FreeBSD/Linux Kernel Cross Reference
sys/i386/isa/rpreg.h
1 /*
2 * Copyright (c) Comtrol Corporation <support@comtrol.com>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted prodived that the follwoing conditions
7 * are met.
8 * 1. Redistributions of source code must retain the above copyright
9 * notive, this list of conditions and the following disclainer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials prodided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Comtrol Corporation.
16 * 4. The name of Comtrol Corporation may not be used to endorse or
17 * promote products derived from this software without specific
18 * prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY COMTROL CORPORATION ``AS IS'' AND ANY
21 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL COMTROL CORPORATION BE LIABLE FOR
24 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, LIFE OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 /*
34 * Begin OS-specific defines - rpreg.h - for RocketPort FreeBSD
35 */
36
37 typedef unsigned char Byte_t;
38 typedef unsigned int ByteIO_t;
39
40 typedef unsigned int Word_t;
41 typedef unsigned int WordIO_t;
42
43 typedef unsigned long DWord_t;
44 typedef unsigned int DWordIO_t;
45
46 #define sOutB(a, b) outb(a, b)
47 #define sOutW(a, b) outw(a, b)
48 #define sOutDW(a, b) outl(a, b)
49 #define sInB(a) (inb(a))
50 #define sInW(a) (inw(a))
51 #define sOutStrW(port, addr, count) outsw(port, addr, count)
52 #define sInStrW(port, addr, count) insw(port, addr, count)
53
54 /*
55 * End of OS-specific defines
56 */
57
58 #define ROCKET_H
59
60 #define CTL_SIZE 4
61 #define AIOP_CTL_SIZE 4
62 #define CHAN_AIOP_SIZE 8
63 #define MAX_PORTS_PER_AIOP 8
64 #define MAX_AIOPS_PER_BOARD 4
65 #define MAX_PORTS_PER_BOARD 32
66
67 /* Bus Type ID */
68 #define isISA 0
69 #define isPCI 1
70 #define isMC 2
71
72 /* Controller ID numbers */
73 #define CTLID_NULL -1 /* no controller exists */
74 #define CTLID_0001 0x0001 /* controller release 1 */
75
76 /* PCI IDs */
77 #define RP_VENDOR_ID 0x11FE
78 #define RP_DEVICE_ID_8OCTA 0x0001
79 #define RP_DEVICE_ID_8INTF 0x0002
80 #define RP_DEVICE_ID_16INTF 0x0003
81 #define RP_DEVICE_ID_32INTF 0x0004
82
83 /* AIOP ID numbers, identifies AIOP type implementing channel */
84 #define AIOPID_NULL -1 /* no AIOP or channel exists */
85 #define AIOPID_0001 0x0001 /* AIOP release 1 */
86
87 #define NULLDEV -1 /* identifies non-existant device */
88 #define NULLCTL -1 /* identifies non-existant controller */
89 #define NULLCTLPTR (CONTROLLER_T *)0 /* identifies non-existant controller */
90 #define NULLAIOP -1 /* identifies non-existant AIOP */
91 #define NULLCHAN -1 /* identifies non-existant channel */
92
93 /************************************************************************
94 Global Register Offsets - Direct Access - Fixed values
95 ************************************************************************/
96
97 #define _CMD_REG 0x38 /* Command Register 8 Write */
98 #define _INT_CHAN 0x39 /* Interrupt Channel Register 8 Read */
99 #define _INT_MASK 0x3A /* Interrupt Mask Register 8 Read / Write */
100 #define _UNUSED 0x3B /* Unused 8 */
101 #define _INDX_ADDR 0x3C /* Index Register Address 16 Write */
102 #define _INDX_DATA 0x3E /* Index Register Data 8/16 Read / Write */
103
104 /************************************************************************
105 Channel Register Offsets for 1st channel in AIOP - Direct Access
106 ************************************************************************/
107 #define _TD0 0x00 /* Transmit Data 16 Write */
108 #define _RD0 0x00 /* Receive Data 16 Read */
109 #define _CHN_STAT0 0x20 /* Channel Status 8/16 Read / Write */
110 #define _FIFO_CNT0 0x10 /* Transmit/Receive FIFO Count 16 Read */
111 #define _INT_ID0 0x30 /* Interrupt Identification 8 Read */
112
113 /************************************************************************
114 Tx Control Register Offsets - Indexed - External - Fixed
115 ************************************************************************/
116 #define _TX_ENBLS 0x980 /* Tx Processor Enables Register 8 Read / Write */
117 #define _TXCMP1 0x988 /* Transmit Compare Value #1 8 Read / Write */
118 #define _TXCMP2 0x989 /* Transmit Compare Value #2 8 Read / Write */
119 #define _TXREP1B1 0x98A /* Tx Replace Value #1 - Byte 1 8 Read / Write */
120 #define _TXREP1B2 0x98B /* Tx Replace Value #1 - Byte 2 8 Read / Write */
121 #define _TXREP2 0x98C /* Transmit Replace Value #2 8 Read / Write */
122
123 /************************************************************************
124 Receive FIFO
125 ************************************************************************/
126 #define RXFIFO_DATA 0x5f
127 #define RXFIFO_OUT 0x5c
128 #define RXFIFO_EN 0x08
129 #define RXFIFO_DIS 0xa7
130
131 /************************************************************************
132 Memory Controller Register Offsets - Indexed - External - Fixed
133 ************************************************************************/
134 #define _RX_FIFO 0x000 /* Rx FIFO */
135 #define _TX_FIFO 0x800 /* Tx FIFO */
136 #define _RXF_OUTP 0x990 /* Rx FIFO OUT pointer 16 Read / Write */
137 #define _RXF_INP 0x992 /* Rx FIFO IN pointer 16 Read / Write */
138 #define _TXF_OUTP 0x994 /* Tx FIFO OUT pointer 8 Read / Write */
139 #define _TXF_INP 0x995 /* Tx FIFO IN pointer 8 Read / Write */
140 #define _TXP_CNT 0x996 /* Tx Priority Count 8 Read / Write */
141 #define _TXP_PNTR 0x997 /* Tx Priority Pointer 8 Read / Write */
142
143 #define PRI_PEND 0x80 /* Priority data pending (bit7, Tx pri cnt) */
144 #define TXFIFO_SIZE 255 /* size of Tx FIFO */
145 #define RXFIFO_SIZE 1023 /* size of Rx FIFO */
146
147 /************************************************************************
148 Tx Priority Buffer - Indexed - External - Fixed
149 ************************************************************************/
150 #define _TXP_BUF 0x9C0 /* Tx Priority Buffer 32 Bytes Read / Write */
151 #define TXP_SIZE 0x20 /* 32 bytes */
152
153 /************************************************************************
154 Channel Register Offsets - Indexed - Internal - Fixed
155 ************************************************************************/
156
157 #define _TX_CTRL 0xFF0 /* Transmit Control 16 Write */
158 #define _RX_CTRL 0xFF2 /* Receive Control 8 Write */
159 #define _BAUD 0xFF4 /* Baud Rate 16 Write */
160 #define _CLK_PRE 0xFF6 /* Clock Prescaler 8 Write */
161
162 #define CLOCK_PRESC 0x19 /* mod 9 (divide by 10) prescale */
163
164 #define BRD50 4607
165 #define BRD75 3071
166 #define BRD110 2094
167 #define BRD134 1712
168 #define BRD150 1535
169 #define BRD200 1151
170 #define BRD300 767
171 #define BRD600 383
172 #define BRD1200 191
173 #define BRD1800 127
174 #define BRD2000 114
175 #define BRD2400 95
176 #define BRD3600 64
177 #define BRD4800 47
178 #define BRD7200 31
179 #define BRD9600 23
180 #define BRD14400 15
181 #define BRD19200 11
182 #define BRD38400 5
183 #define BRD57600 3
184 #define BRD76800 2
185 #define BRD115200 1
186 #define BRD230400 0
187
188 #define STMBREAK 0x08 /* BREAK */
189 #define STMFRAME 0x04 /* framing error */
190 #define STMRCVROVR 0x02 /* receiver over run error */
191 #define STMPARITY 0x01 /* parity error */
192 #define STMERROR (STMBREAK | STMFRAME | STMPARITY)
193 #define STMBREAKH 0x800 /* BREAK */
194 #define STMFRAMEH 0x400 /* framing error */
195 #define STMRCVROVRH 0x200 /* receiver over run error */
196 #define STMPARITYH 0x100 /* parity error */
197 #define STMERRORH (STMBREAKH | STMFRAMEH | STMPARITYH)
198
199 #define CTS_ACT 0x20 /* CTS input asserted */
200 #define DSR_ACT 0x10 /* DSR input asserted */
201 #define CD_ACT 0x08 /* CD input asserted */
202 #define TXFIFOMT 0x04 /* Tx FIFO is empty */
203 #define TXSHRMT 0x02 /* Tx shift register is empty */
204 #define RDA 0x01 /* Rx data available */
205 #define DRAINED (TXFIFOMT | TXSHRMT) /* indicates Tx is drained */
206
207 #define STATMODE 0x8000 /* status mode enable bit */
208 #define RXFOVERFL 0x2000 /* receive FIFO overflow */
209 #define RX2MATCH 0x1000 /* receive compare byte 2 match */
210 #define RX1MATCH 0x0800 /* receive compare byte 1 match */
211 #define RXBREAK 0x0400 /* received BREAK */
212 #define RXFRAME 0x0200 /* received framing error */
213 #define RXPARITY 0x0100 /* received parity error */
214 #define STATERROR (RXBREAK | RXFRAME | RXPARITY)
215
216 #define CTSFC_EN 0x80 /* CTS flow control enable bit */
217 #define RTSTOG_EN 0x40 /* RTS toggle enable bit */
218 #define TXINT_EN 0x10 /* transmit interrupt enable */
219 #define STOP2 0x08 /* enable 2 stop bits (0 = 1 stop) */
220 #define PARITY_EN 0x04 /* enable parity (0 = no parity) */
221 #define EVEN_PAR 0x02 /* even parity (0 = odd parity) */
222 #define DATA8BIT 0x01 /* 8 bit data (0 = 7 bit data) */
223
224 #define SETBREAK 0x10 /* send break condition (must clear) */
225 #define LOCALLOOP 0x08 /* local loopback set for test */
226 #define SET_DTR 0x04 /* assert DTR */
227 #define SET_RTS 0x02 /* assert RTS */
228 #define TX_ENABLE 0x01 /* enable transmitter */
229
230 #define RTSFC_EN 0x40 /* RTS flow control enable */
231 #define RXPROC_EN 0x20 /* receive processor enable */
232 #define TRIG_NO 0x00 /* Rx FIFO trigger level 0 (no trigger) */
233 #define TRIG_1 0x08 /* trigger level 1 char */
234 #define TRIG_1_2 0x10 /* trigger level 1/2 */
235 #define TRIG_7_8 0x18 /* trigger level 7/8 */
236 #define TRIG_MASK 0x18 /* trigger level mask */
237 #define SRCINT_EN 0x04 /* special Rx condition interrupt enable */
238 #define RXINT_EN 0x02 /* Rx interrupt enable */
239 #define MCINT_EN 0x01 /* modem change interrupt enable */
240
241 #define RXF_TRIG 0x20 /* Rx FIFO trigger level interrupt */
242 #define TXFIFO_MT 0x10 /* Tx FIFO empty interrupt */
243 #define SRC_INT 0x08 /* special receive condition interrupt */
244 #define DELTA_CD 0x04 /* CD change interrupt */
245 #define DELTA_CTS 0x02 /* CTS change interrupt */
246 #define DELTA_DSR 0x01 /* DSR change interrupt */
247
248 #define REP1W2_EN 0x10 /* replace byte 1 with 2 bytes enable */
249 #define IGN2_EN 0x08 /* ignore byte 2 enable */
250 #define IGN1_EN 0x04 /* ignore byte 1 enable */
251 #define COMP2_EN 0x02 /* compare byte 2 enable */
252 #define COMP1_EN 0x01 /* compare byte 1 enable */
253
254 #define RESET_ALL 0x80 /* reset AIOP (all channels) */
255 #define TXOVERIDE 0x40 /* Transmit software off override */
256 #define RESETUART 0x20 /* reset channel's UART */
257 #define RESTXFCNT 0x10 /* reset channel's Tx FIFO count register */
258 #define RESRXFCNT 0x08 /* reset channel's Rx FIFO count register */
259
260 #define INTSTAT0 0x01 /* AIOP 0 interrupt status */
261 #define INTSTAT1 0x02 /* AIOP 1 interrupt status */
262 #define INTSTAT2 0x04 /* AIOP 2 interrupt status */
263 #define INTSTAT3 0x08 /* AIOP 3 interrupt status */
264
265 #define INTR_EN 0x08 /* allow interrupts to host */
266 #define INT_STROB 0x04 /* strobe and clear interrupt line (EOI) */
267
268 /**************************************************************************
269 MUDBAC remapped for PCI
270 **************************************************************************/
271
272 #define _CFG_INT_PCI 0x40
273 #define _PCI_INT_FUNC 0x3A
274
275 #define PCI_STROB 0x2000
276 #define INTR_EN_PCI 0x0010
277
278 #define CHAN3_EN 0x08 /* enable AIOP 3 */
279 #define CHAN2_EN 0x04 /* enable AIOP 2 */
280 #define CHAN1_EN 0x02 /* enable AIOP 1 */
281 #define CHAN0_EN 0x01 /* enable AIOP 0 */
282 #define FREQ_DIS 0x00
283 #define FREQ_274HZ 0x60
284 #define FREQ_137HZ 0x50
285 #define FREQ_69HZ 0x40
286 #define FREQ_34HZ 0x30
287 #define FREQ_17HZ 0x20
288 #define FREQ_9HZ 0x10
289 #define PERIODIC_ONLY 0x80 /* only PERIODIC interrupt */
290
291 #define CHANINT_EN 0x0100 /* flags to enable/disable channel ints */
292
293 #define RDATASIZE 72
294 #define RREGDATASIZE 52
295
296 /* Controller level information structure */
297 typedef struct
298 {
299 int CtlID;
300 int CtlNum;
301 int BusType;
302 WordIO_t PCIIO;
303 ByteIO_t MBaseIO;
304 ByteIO_t MReg1IO;
305 ByteIO_t MReg2IO;
306 ByteIO_t MReg3IO;
307 Byte_t MReg2;
308 Byte_t MReg3;
309 int NumAiop;
310 WordIO_t AiopIO[AIOP_CTL_SIZE];
311 ByteIO_t AiopIntChanIO[AIOP_CTL_SIZE];
312 int AiopID[AIOP_CTL_SIZE];
313 int AiopNumChan[AIOP_CTL_SIZE];
314 } CONTROLLER_T;
315
316 typedef CONTROLLER_T CONTROLLER_t;
317
318 /* Channel level information structure */
319 typedef struct
320 {
321 CONTROLLER_T *CtlP;
322 int AiopNum;
323 int ChanID;
324 int ChanNum;
325
326 ByteIO_t Cmd;
327 ByteIO_t IntChan;
328 ByteIO_t IntMask;
329 DWordIO_t IndexAddr;
330 WordIO_t IndexData;
331
332 WordIO_t TxRxData;
333 WordIO_t ChanStat;
334 WordIO_t TxRxCount;
335 ByteIO_t IntID;
336
337 Word_t TxFIFO;
338 Word_t TxFIFOPtrs;
339 Word_t RxFIFO;
340 Word_t RxFIFOPtrs;
341 Word_t TxPrioCnt;
342 Word_t TxPrioPtr;
343 Word_t TxPrioBuf;
344
345 Byte_t R[RREGDATASIZE];
346
347 Byte_t BaudDiv[4];
348 Byte_t TxControl[4];
349 Byte_t RxControl[4];
350 Byte_t TxEnables[4];
351 Byte_t TxCompare[4];
352 Byte_t TxReplace1[4];
353 Byte_t TxReplace2[4];
354 } CHANNEL_T;
355
356 typedef CHANNEL_T CHANNEL_t;
357 typedef CHANNEL_T * CHANPTR_T;
358
359 /***************************************************************************
360 Function: sClrBreak
361 Purpose: Stop sending a transmit BREAK signal
362 Call: sClrBreak(ChP)
363 CHANNEL_T *ChP; Ptr to channel structure
364 */
365 #define sClrBreak(ChP) \
366 { \
367 (ChP)->TxControl[3] &= ~SETBREAK; \
368 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
369 }
370
371 /***************************************************************************
372 Function: sClrDTR
373 Purpose: Clr the DTR output
374 Call: sClrDTR(ChP)
375 CHANNEL_T *ChP; Ptr to channel structure
376 */
377 #define sClrDTR(ChP) \
378 { \
379 (ChP)->TxControl[3] &= ~SET_DTR; \
380 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
381 }
382
383 /***************************************************************************
384 Function: sClrRTS
385 Purpose: Clr the RTS output
386 Call: sClrRTS(ChP)
387 CHANNEL_T *ChP; Ptr to channel structure
388 */
389 #define sClrRTS(ChP) \
390 { \
391 (ChP)->TxControl[3] &= ~SET_RTS; \
392 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
393 }
394
395 /***************************************************************************
396 Function: sClrTxXOFF
397 Purpose: Clear any existing transmit software flow control off condition
398 Call: sClrTxXOFF(ChP)
399 CHANNEL_T *ChP; Ptr to channel structure
400 */
401 #define sClrTxXOFF(ChP) \
402 { \
403 sOutB((ChP)->Cmd,TXOVERIDE | (Byte_t)(ChP)->ChanNum); \
404 sOutB((ChP)->Cmd,(Byte_t)(ChP)->ChanNum); \
405 }
406
407 /***************************************************************************
408 Function: sCtlNumToCtlPtr
409 Purpose: Convert a controller number to controller structure pointer
410 Call: sCtlNumToCtlPtr(CtlNum)
411 int CtlNum; Controller number
412 Return: CONTROLLER_T *: Ptr to controller structure
413 */
414 #define sCtlNumToCtlPtr(CTLNUM) &sController[CTLNUM]
415
416 /***************************************************************************
417 Function: sControllerEOI
418 Purpose: Strobe the MUDBAC's End Of Interrupt bit.
419 Call: sControllerEOI(CtlP)
420 CONTROLLER_T *CtlP; Ptr to controller structure
421 */
422 #define sControllerEOI(CTLP) sOutB((CTLP)->MReg2IO,(CTLP)->MReg2 | INT_STROB)
423
424
425 /***************************************************************************
426 Function: sPCIControllerEOI
427 Purpose: Strobe the MUDBAC's End Of Interrupt bit.
428 Call: sPCIControllerEOI(CtlP)
429 CONTROLLER_T *CtlP; Ptr to controller structure
430 */
431 #define sPCIControllerEOI(CTLP) sOutW((CTLP)->PCIIO, PCI_STROB)
432
433 /***************************************************************************
434 Function: sDisAiop
435 Purpose: Disable I/O access to an AIOP
436 Call: sDisAiop(CltP)
437 CONTROLLER_T *CtlP; Ptr to controller structure
438 int AiopNum; Number of AIOP on controller
439 */
440 #define sDisAiop(CTLP,AIOPNUM) \
441 { \
442 (CTLP)->MReg3 &= sBitMapClrTbl[AIOPNUM]; \
443 sOutB((CTLP)->MReg3IO,(CTLP)->MReg3); \
444 }
445
446 /***************************************************************************
447 Function: sDisCTSFlowCtl
448 Purpose: Disable output flow control using CTS
449 Call: sDisCTSFlowCtl(ChP)
450 CHANNEL_T *ChP; Ptr to channel structure
451 */
452 #define sDisCTSFlowCtl(ChP) \
453 { \
454 (ChP)->TxControl[2] &= ~CTSFC_EN; \
455 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
456 }
457
458 /***************************************************************************
459 Function: DisParity
460 Purpose: Disable parity
461 Call: sDisParity(ChP)
462 CHANNEL_T *ChP; Ptr to channel structure
463 Comments: Function sSetParity() can be used in place of functions sEnParity(),
464 sDisParity(), sSetOddParity(), and sSetEvenParity().
465 */
466 #define sDisParity(ChP) \
467 { \
468 (ChP)->TxControl[2] &= ~PARITY_EN; \
469 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
470 }
471
472 /***************************************************************************
473 Function: sDisRxFIFO
474 Purpose: Disable Rx FIFO
475 Call: sDisRxFIFO(ChP)
476 CHANNEL_T *ChP; Ptr to channel structure
477 */
478 #define sDisRxFIFO(ChP) \
479 { \
480 (ChP)->R[0x32] = 0x0a; \
481 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->R[0x30]); \
482 }
483
484 /***************************************************************************
485 Function: sDisRxStatusMode
486 Purpose: Disable the Rx status mode
487 Call: sDisRxStatusMode(ChP)
488 CHANNEL_T *ChP; Ptr to channel structure
489 Comments: This takes the channel out of the receive status mode. All
490 subsequent reads of receive data using sReadRxWord() will return
491 two data bytes.
492 */
493 #define sDisRxStatusMode(ChP) sOutW((ChP)->ChanStat,0)
494
495 /***************************************************************************
496 Function: sDisTransmit
497 Purpose: Disable transmit
498 Call: sDisTransmit(ChP)
499 CHANNEL_T *ChP; Ptr to channel structure
500 This disables movement of Tx data from the Tx FIFO into the 1 byte
501 Tx buffer. Therefore there could be up to a 2 byte latency
502 between the time sDisTransmit() is called and the transmit buffer
503 and transmit shift register going completely empty.
504 */
505 #define sDisTransmit(ChP) \
506 { \
507 (ChP)->TxControl[3] &= ~TX_ENABLE; \
508 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
509 }
510
511 /***************************************************************************
512 Function: sDisTxSoftFlowCtl
513 Purpose: Disable Tx Software Flow Control
514 Call: sDisTxSoftFlowCtl(ChP)
515 CHANNEL_T *ChP; Ptr to channel structure
516 */
517 #define sDisTxSoftFlowCtl(ChP) \
518 { \
519 (ChP)->R[0x06] = 0x8a; \
520 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->R[0x04]); \
521 }
522
523 /***************************************************************************
524 Function: sEnAiop
525 Purpose: Enable I/O access to an AIOP
526 Call: sEnAiop(CltP)
527 CONTROLLER_T *CtlP; Ptr to controller structure
528 int AiopNum; Number of AIOP on controller
529 */
530 #define sEnAiop(CTLP,AIOPNUM) \
531 { \
532 (CTLP)->MReg3 |= sBitMapSetTbl[AIOPNUM]; \
533 sOutB((CTLP)->MReg3IO,(CTLP)->MReg3); \
534 }
535
536 /***************************************************************************
537 Function: sEnCTSFlowCtl
538 Purpose: Enable output flow control using CTS
539 Call: sEnCTSFlowCtl(ChP)
540 CHANNEL_T *ChP; Ptr to channel structure
541 */
542 #define sEnCTSFlowCtl(ChP) \
543 { \
544 (ChP)->TxControl[2] |= CTSFC_EN; \
545 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
546 }
547
548 /***************************************************************************
549 Function: EnParity
550 Purpose: Enable parity
551 Call: sEnParity(ChP)
552 CHANNEL_T *ChP; Ptr to channel structure
553 Comments: Function sSetParity() can be used in place of functions sEnParity(),
554 sDisParity(), sSetOddParity(), and sSetEvenParity().
555
556 Warnings: Before enabling parity odd or even parity should be chosen using
557 functions sSetOddParity() or sSetEvenParity().
558 */
559 #define sEnParity(ChP) \
560 { \
561 (ChP)->TxControl[2] |= PARITY_EN; \
562 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
563 }
564
565 /***************************************************************************
566 Function: sEnRTSFlowCtl
567 Return: void
568 */
569 #define sEnRTSFlowCtl(ChP) \
570 { \
571 (ChP)->TxControl[2] &= ~RTSTOG_EN; \
572 (ChP)->TxControl[3] &= ~SET_RTS; \
573 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
574 (ChP)->RxControl[2] |= RTSFC_EN; \
575 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->RxControl[0]); \
576 }
577
578 /***************************************************************************
579 Function: sDisRTSFlowCtl
580 Return: void
581 */
582 #define sDisRTSFlowCtl(ChP) \
583 { \
584 (ChP)->RxControl[2] &= ~RTSFC_EN; \
585 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->RxControl[0]); \
586 }
587
588 /***************************************************************************
589 Function: sEnRxFIFO
590 Purpose: Enable Rx FIFO
591 Call: sEnRxFIFO(ChP)
592 CHANNEL_T *ChP; Ptr to channel structure
593 */
594 #define sEnRxFIFO(ChP) \
595 { \
596 (ChP)->R[0x32] = 0x08; \
597 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->R[0x30]); \
598 }
599
600 /***************************************************************************
601 Function: sEnRxProcessor
602 Purpose: Enable the receive processor
603 Call: sEnRxProcessor(ChP)
604 CHANNEL_T *ChP; Ptr to channel structure
605 Comments: This function is used to start the receive processor. When
606 the channel is in the reset state the receive processor is not
607 running. This is done to prevent the receive processor from
608 executing invalid microcode instructions prior to the
609 downloading of the microcode.
610
611 Warnings: This function must be called after valid microcode has been
612 downloaded to the AIOP, and it must not be called before the
613 microcode has been downloaded.
614 */
615 #define sEnRxProcessor(ChP) \
616 { \
617 (ChP)->RxControl[2] |= RXPROC_EN; \
618 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->RxControl[0]); \
619 }
620
621 /***************************************************************************
622 Function: sEnRxStatusMode
623 Purpose: Enable the Rx status mode
624 Call: sEnRxStatusMode(ChP)
625 CHANNEL_T *ChP; Ptr to channel structure
626 Comments: This places the channel in the receive status mode. All subsequent
627 reads of receive data using sReadRxWord() will return a data byte
628 in the low word and a status byte in the high word.
629
630 */
631 #define sEnRxStatusMode(ChP) sOutW((ChP)->ChanStat,STATMODE)
632
633 /***************************************************************************
634 Function: sEnTransmit
635 Purpose: Enable transmit
636 Call: sEnTransmit(ChP)
637 CHANNEL_T *ChP; Ptr to channel structure
638 */
639 #define sEnTransmit(ChP) \
640 { \
641 (ChP)->TxControl[3] |= TX_ENABLE; \
642 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
643 }
644
645 /***************************************************************************
646 Function: sGetAiopIntStatus
647 Purpose: Get the AIOP interrupt status
648 Call: sGetAiopIntStatus(CtlP,AiopNum)
649 CONTROLLER_T *CtlP; Ptr to controller structure
650 int AiopNum; AIOP number
651 Return: Byte_t: The AIOP interrupt status. Bits 0 through 7
652 represent channels 0 through 7 respectively. If a
653 bit is set that channel is interrupting.
654 */
655 #define sGetAiopIntStatus(CTLP,AIOPNUM) sInB((CTLP)->AiopIntChanIO[AIOPNUM])
656
657 /***************************************************************************
658 Function: sGetAiopNumChan
659 Purpose: Get the number of channels supported by an AIOP
660 Call: sGetAiopNumChan(CtlP,AiopNum)
661 CONTROLLER_T *CtlP; Ptr to controller structure
662 int AiopNum; AIOP number
663 Return: int: The number of channels supported by the AIOP
664 */
665 #define sGetAiopNumChan(CTLP,AIOPNUM) (CTLP)->AiopNumChan[AIOPNUM]
666
667 /***************************************************************************
668 Function: sGetChanIntID
669 Purpose: Get a channel's interrupt identification byte
670 Call: sGetChanIntID(ChP)
671 CHANNEL_T *ChP; Ptr to channel structure
672 Return: Byte_t: The channel interrupt ID. Can be any
673 combination of the following flags:
674 RXF_TRIG: Rx FIFO trigger level interrupt
675 TXFIFO_MT: Tx FIFO empty interrupt
676 SRC_INT: Special receive condition interrupt
677 DELTA_CD: CD change interrupt
678 DELTA_CTS: CTS change interrupt
679 DELTA_DSR: DSR change interrupt
680 */
681 #define sGetChanIntID(ChP) (sInB((ChP)->IntID) & (RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR))
682
683 /***************************************************************************
684 Function: sGetChanNum
685 Purpose: Get the number of a channel within an AIOP
686 Call: sGetChanNum(ChP)
687 CHANNEL_T *ChP; Ptr to channel structure
688 Return: int: Channel number within AIOP, or NULLCHAN if channel does
689 not exist.
690 */
691 #define sGetChanNum(ChP) (ChP)->ChanNum
692
693 /***************************************************************************
694 Function: sGetChanStatus
695 Purpose: Get the channel status
696 Call: sGetChanStatus(ChP)
697 CHANNEL_T *ChP; Ptr to channel structure
698 Return: Word_t: The channel status. Can be any combination of
699 the following flags:
700 LOW BYTE FLAGS
701 CTS_ACT: CTS input asserted
702 DSR_ACT: DSR input asserted
703 CD_ACT: CD input asserted
704 TXFIFOMT: Tx FIFO is empty
705 TXSHRMT: Tx shift register is empty
706 RDA: Rx data available
707
708 HIGH BYTE FLAGS
709 STATMODE: status mode enable bit
710 RXFOVERFL: receive FIFO overflow
711 RX2MATCH: receive compare byte 2 match
712 RX1MATCH: receive compare byte 1 match
713 RXBREAK: received BREAK
714 RXFRAME: received framing error
715 RXPARITY: received parity error
716 Warnings: This function will clear the high byte flags in the Channel
717 Status Register.
718 */
719 #define sGetChanStatus(ChP) sInW((ChP)->ChanStat)
720
721 /***************************************************************************
722 Function: sGetChanStatusLo
723 Purpose: Get the low byte only of the channel status
724 Call: sGetChanStatusLo(ChP)
725 CHANNEL_T *ChP; Ptr to channel structure
726 Return: Byte_t: The channel status low byte. Can be any combination
727 of the following flags:
728 CTS_ACT: CTS input asserted
729 DSR_ACT: DSR input asserted
730 CD_ACT: CD input asserted
731 TXFIFOMT: Tx FIFO is empty
732 TXSHRMT: Tx shift register is empty
733 RDA: Rx data available
734 */
735 #define sGetChanStatusLo(ChP) sInB((ByteIO_t)(ChP)->ChanStat)
736
737 /***************************************************************************
738 Function: sGetControllerIntStatus
739 Purpose: Get the controller interrupt status
740 Call: sGetControllerIntStatus(CtlP)
741 CONTROLLER_T *CtlP; Ptr to controller structure
742 Return: Byte_t: The controller interrupt status in the lower 4
743 bits. Bits 0 through 3 represent AIOP's 0
744 through 3 respectively. If a bit is set that
745 AIOP is interrupting. Bits 4 through 7 will
746 always be cleared.
747 */
748 #define sGetControllerIntStatus(CTLP) (sInB((CTLP)->MReg1IO) & 0x0f)
749
750 /***************************************************************************
751 Function: sPCIGetControllerIntStatus
752 Purpose: Get the controller interrupt status
753 Call: sPCIGetControllerIntStatus(CtlP)
754 CONTROLLER_T *CtlP; Ptr to controller structure
755 Return: Byte_t: The controller interrupt status in the lower 4
756 bits. Bits 0 through 3 represent AIOP's 0
757 through 3 respectively. If a bit is set that
758 AIOP is interrupting. Bits 4 through 7 will
759 always be cleared.
760 */
761 #define sPCIGetControllerIntStatus(CTLP) ((sInW((CTLP)->PCIIO) >> 8) & 0x1f)
762
763 /***************************************************************************
764 Function: sGetRxCnt
765 Purpose: Get the number of data bytes in the Rx FIFO
766 Call: sGetRxCnt(ChP)
767 CHANNEL_T *ChP; Ptr to channel structure
768 Return: int: The number of data bytes in the Rx FIFO.
769 Comments: Byte read of count register is required to obtain Rx count.
770
771 */
772 #define sGetRxCnt(ChP) sInW((ChP)->TxRxCount)
773
774 /***************************************************************************
775 Function: sGetTxCnt
776 Purpose: Get the number of data bytes in the Tx FIFO
777 Call: sGetTxCnt(ChP)
778 CHANNEL_T *ChP; Ptr to channel structure
779 Return: Byte_t: The number of data bytes in the Tx FIFO.
780 Comments: Byte read of count register is required to obtain Tx count.
781
782 */
783 #define sGetTxCnt(ChP) sInB((ByteIO_t)(ChP)->TxRxCount)
784
785 /*****************************************************************************
786 Function: sGetTxRxDataIO
787 Purpose: Get the I/O address of a channel's TxRx Data register
788 Call: sGetTxRxDataIO(ChP)
789 CHANNEL_T *ChP; Ptr to channel structure
790 Return: WordIO_t: I/O address of a channel's TxRx Data register
791 */
792 #define sGetTxRxDataIO(ChP) (ChP)->TxRxData
793
794 /***************************************************************************
795 Function: sInitChanDefaults
796 Purpose: Initialize a channel structure to its default state.
797 Call: sInitChanDefaults(ChP)
798 CHANNEL_T *ChP; Ptr to the channel structure
799 Comments: This function must be called once for every channel structure
800 that exists before any other SSCI calls can be made.
801
802 */
803 #define sInitChanDefaults(ChP) \
804 { \
805 (ChP)->CtlP = NULLCTLPTR; \
806 (ChP)->AiopNum = NULLAIOP; \
807 (ChP)->ChanID = AIOPID_NULL; \
808 (ChP)->ChanNum = NULLCHAN; \
809 }
810
811 /***************************************************************************
812 Function: sResetAiopByNum
813 Purpose: Reset the AIOP by number
814 Call: sResetAiopByNum(CTLP,AIOPNUM)
815 CONTROLLER_T CTLP; Ptr to controller structure
816 AIOPNUM; AIOP index
817 */
818 #define sResetAiopByNum(CTLP,AIOPNUM) \
819 { \
820 sOutB((CTLP)->AiopIO[(AIOPNUM)]+_CMD_REG,RESET_ALL); \
821 sOutB((CTLP)->AiopIO[(AIOPNUM)]+_CMD_REG,0x0); \
822 }
823
824 /***************************************************************************
825 Function: sSendBreak
826 Purpose: Send a transmit BREAK signal
827 Call: sSendBreak(ChP)
828 CHANNEL_T *ChP; Ptr to channel structure
829 */
830 #define sSendBreak(ChP) \
831 { \
832 (ChP)->TxControl[3] |= SETBREAK; \
833 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
834 }
835
836 /***************************************************************************
837 Function: sSetBaud
838 Purpose: Set baud rate
839 Call: sSetBaud(ChP,Divisor)
840 CHANNEL_T *ChP; Ptr to channel structure
841 Word_t Divisor; 16 bit baud rate divisor for channel
842 */
843 #define sSetBaud(ChP,DIVISOR) \
844 { \
845 (ChP)->BaudDiv[2] = (Byte_t)(DIVISOR); \
846 (ChP)->BaudDiv[3] = (Byte_t)((DIVISOR) >> 8); \
847 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->BaudDiv[0]); \
848 }
849
850 /***************************************************************************
851 Function: sSetData7
852 Purpose: Set data bits to 7
853 Call: sSetData7(ChP)
854 CHANNEL_T *ChP; Ptr to channel structure
855 */
856 #define sSetData7(ChP) \
857 { \
858 (ChP)->TxControl[2] &= ~DATA8BIT; \
859 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
860 }
861
862 /***************************************************************************
863 Function: sSetData8
864 Purpose: Set data bits to 8
865 Call: sSetData8(ChP)
866 CHANNEL_T *ChP; Ptr to channel structure
867 */
868 #define sSetData8(ChP) \
869 { \
870 (ChP)->TxControl[2] |= DATA8BIT; \
871 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
872 }
873
874 /***************************************************************************
875 Function: sSetDTR
876 Purpose: Set the DTR output
877 Call: sSetDTR(ChP)
878 CHANNEL_T *ChP; Ptr to channel structure
879 */
880 #define sSetDTR(ChP) \
881 { \
882 (ChP)->TxControl[3] |= SET_DTR; \
883 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
884 }
885
886 /***************************************************************************
887 Function: sSetEvenParity
888 Purpose: Set even parity
889 Call: sSetEvenParity(ChP)
890 CHANNEL_T *ChP; Ptr to channel structure
891 Comments: Function sSetParity() can be used in place of functions sEnParity(),
892 sDisParity(), sSetOddParity(), and sSetEvenParity().
893
894 Warnings: This function has no effect unless parity is enabled with function
895 sEnParity().
896 */
897 #define sSetEvenParity(ChP) \
898 { \
899 (ChP)->TxControl[2] |= EVEN_PAR; \
900 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
901 }
902
903 /***************************************************************************
904 Function: sSetOddParity
905 Purpose: Set odd parity
906 Call: sSetOddParity(ChP)
907 CHANNEL_T *ChP; Ptr to channel structure
908 Comments: Function sSetParity() can be used in place of functions sEnParity(),
909 sDisParity(), sSetOddParity(), and sSetEvenParity().
910
911 Warnings: This function has no effect unless parity is enabled with function
912 sEnParity().
913 */
914 #define sSetOddParity(ChP) \
915 { \
916 (ChP)->TxControl[2] &= ~EVEN_PAR; \
917 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
918 }
919
920 /***************************************************************************
921 Function: sSetRTS
922 Purpose: Set the RTS output
923 Call: sSetRTS(ChP)
924 CHANNEL_T *ChP; Ptr to channel structure
925 */
926 #define sSetRTS(ChP) \
927 { \
928 (ChP)->TxControl[3] |= SET_RTS; \
929 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
930 }
931
932 /***************************************************************************
933 Function: sSetRxTrigger
934 Purpose: Set the Rx FIFO trigger level
935 Call: sSetRxProcessor(ChP,Level)
936 CHANNEL_T *ChP; Ptr to channel structure
937 Byte_t Level; Number of characters in Rx FIFO at which the
938 interrupt will be generated. Can be any of the following flags:
939
940 TRIG_NO: no trigger
941 TRIG_1: 1 character in FIFO
942 TRIG_1_2: FIFO 1/2 full
943 TRIG_7_8: FIFO 7/8 full
944 Comments: An interrupt will be generated when the trigger level is reached
945 only if function sEnInterrupt() has been called with flag
946 RXINT_EN set. The RXF_TRIG flag in the Interrupt Idenfification
947 register will be set whenever the trigger level is reached
948 regardless of the setting of RXINT_EN.
949
950 */
951 #define sSetRxTrigger(ChP,LEVEL) \
952 { \
953 (ChP)->RxControl[2] &= ~TRIG_MASK; \
954 (ChP)->RxControl[2] |= LEVEL; \
955 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->RxControl[0]); \
956 }
957
958 /***************************************************************************
959 Function: sSetStop1
960 Purpose: Set stop bits to 1
961 Call: sSetStop1(ChP)
962 CHANNEL_T *ChP; Ptr to channel structure
963 */
964 #define sSetStop1(ChP) \
965 { \
966 (ChP)->TxControl[2] &= ~STOP2; \
967 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
968 }
969
970 /***************************************************************************
971 Function: sSetStop2
972 Purpose: Set stop bits to 2
973 Call: sSetStop2(ChP)
974 CHANNEL_T *ChP; Ptr to channel structure
975 */
976 #define sSetStop2(ChP) \
977 { \
978 (ChP)->TxControl[2] |= STOP2; \
979 sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->TxControl[0]); \
980 }
981
982 /***************************************************************************
983 Function: sStartRxProcessor
984 Purpose: Start a channel's receive processor
985 Call: sStartRxProcessor(ChP)
986 CHANNEL_T *ChP; Ptr to channel structure
987 Comments: This function is used to start a Rx processor after it was
988 stopped with sStopRxProcessor() or sStopSWInFlowCtl(). It
989 will restart both the Rx processor and software input flow control.
990
991 */
992 #define sStartRxProcessor(ChP) sOutDW((ChP)->IndexAddr,*(DWord_t *)&(ChP)->R[0])
993
994 /***************************************************************************
995 Function: sWriteTxByte
996 Purpose: Write a transmit data byte to a channel.
997 ByteIO_t io: Channel transmit register I/O address. This can
998 be obtained with sGetTxRxDataIO().
999 Byte_t Data; The transmit data byte.
1000 Warnings: This function writes the data byte without checking to see if
1001 sMaxTxSize is exceeded in the Tx FIFO.
1002 */
1003 #define sWriteTxByte(IO,DATA) sOutB(IO,DATA)
1004
1005 int sInitController( CONTROLLER_T *CtlP,
1006 int CtlNum,
1007 ByteIO_t MudbacIO,
1008 ByteIO_t *AiopIOList,
1009 int AiopIOListSize,
1010 int IRQNum,
1011 Byte_t Frequency,
1012 int PeriodicOnly);
1013
1014 int sPCIInitController( CONTROLLER_T *CtlP,
1015 int CtlNum,
1016 ByteIO_t *AiopIOList,
1017 int AiopIOListSize,
1018 int IRQNum,
1019 Byte_t Frequency,
1020 int PeriodicOnly);
1021
1022 int sReadAiopID(ByteIO_t io);
1023 int sReadAiopNumChan(WordIO_t io);
1024 int sInitChan( CONTROLLER_T *CtlP,
1025 CHANNEL_T *ChP,
1026 int AiopNum,
1027 int ChanNum);
1028 Byte_t sGetRxErrStatus(CHANNEL_T *ChP);
1029 void sStopRxProcessor(CHANNEL_T *ChP);
1030 void sStopSWInFlowCtl(CHANNEL_T *ChP);
1031 void sFlushRxFIFO(CHANNEL_T *ChP);
1032 void sFlushTxFIFO(CHANNEL_T *ChP);
1033 int sWriteTxPrioByte(CHANNEL_T *ChP, Byte_t Data);
1034 void sEnInterrupts(CHANNEL_T *ChP,Word_t Flags);
1035 void sDisInterrupts(CHANNEL_T *ChP,Word_t Flags);
1036
1037 #ifndef ROCKET_C
1038 extern Byte_t R[RDATASIZE];
1039 extern CONTROLLER_T sController[CTL_SIZE];
1040 extern Byte_t sIRQMap[16];
1041 extern Byte_t sBitMapClrTbl[8];
1042 extern Byte_t sBitMapSetTbl[8];
1043 #endif
Cache object: 3981ca0b5371b620322f7129e420a72b
|