2 * Copyright (c) Comtrol Corporation <support@comtrol.com>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted prodived that the follwoing conditions
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.
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
32 * $FreeBSD: src/sys/dev/rp/rpreg.h,v 1.4.2.1 2002/06/18 03:11:46 obrien Exp $
33 * $DragonFly: src/sys/dev/serial/rp/rpreg.h,v 1.3 2004/05/19 22:52:49 dillon Exp $
37 * Begin OS-specific defines - rpreg.h - for RocketPort FreeBSD
40 typedef unsigned char Byte_t;
41 typedef unsigned int ByteIO_t;
43 typedef unsigned int Word_t;
44 typedef unsigned int WordIO_t;
46 typedef unsigned long DWord_t;
47 typedef unsigned int DWordIO_t;
49 #define rp_readio(size, ctlp, rid, offset) \
50 (bus_space_read_##size(rman_get_bustag(ctlp->io[rid]), rman_get_bushandle(ctlp->io[rid]), offset))
51 #define rp_readmultiio(size, ctlp, rid, offset, addr, count) \
52 (bus_space_read_multi_##size(rman_get_bustag(ctlp->io[rid]), rman_get_bushandle(ctlp->io[rid]), offset, addr, count))
53 #define rp_writeio(size, ctlp, rid, offset, data) \
54 (bus_space_write_##size(rman_get_bustag(ctlp->io[rid]), rman_get_bushandle(ctlp->io[rid]), offset, data))
55 #define rp_writemultiio(size, ctlp, rid, offset, addr, count) \
56 (bus_space_write_multi_##size(rman_get_bustag(ctlp->io[rid]), rman_get_bushandle(ctlp->io[rid]), offset, addr, count))
58 #define rp_readio1(ctlp, rid, offset) rp_readio(1, ctlp, rid, offset)
59 #define rp_readio2(ctlp, rid, offset) rp_readio(2, ctlp, rid, offset)
60 #define rp_readio4(ctlp, rid, offset) rp_readio(4, ctlp, rid, offset)
61 #define rp_writeio1(ctlp, rid, offset, data) rp_writeio(1, ctlp, rid, offset, data)
62 #define rp_writeio2(ctlp, rid, offset, data) rp_writeio(2, ctlp, rid, offset, data)
63 #define rp_writeio4(ctlp, rid, offset, data) rp_writeio(4, ctlp, rid, offset, data)
64 #define rp_readmultiio1(ctlp, rid, offset, addr, count) rp_readmultiio(1, ctlp, rid, offset, addr, count)
65 #define rp_readmultiio2(ctlp, rid, offset, addr, count) rp_readmultiio(2, ctlp, rid, offset, addr, count)
66 #define rp_readmultiio4(ctlp, rid, offset, addr, count) rp_readmultiio(4, ctlp, rid, offset, addr, count)
67 #define rp_writemultiio1(ctlp, rid, offset, addr, count) rp_writemultiio(1, ctlp, rid, offset, addr, count)
68 #define rp_writemultiio2(ctlp, rid, offset, addr, count) rp_writemultiio(2, ctlp, rid, offset, addr, count)
69 #define rp_writemultiio4(ctlp, rid, offset, addr, count) rp_writemultiio(4, ctlp, rid, offset, addr, count)
71 #define rp_readaiop1(ctlp, aiop, offset) \
72 (rp_readio1((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset)))
73 #define rp_readaiop2(ctlp, aiop, offset) \
74 (rp_readio2((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset)))
75 #define rp_readaiop4(ctlp, aiop, offset) \
76 (rp_readio4((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset)))
77 #define rp_readmultiaiop1(ctlp, aiop, offset, addr, count) \
78 (rp_readmultiio1((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), addr, count))
79 #define rp_readmultiaiop2(ctlp, aiop, offset, addr, count) \
80 (rp_readmultiio2((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), addr, count))
81 #define rp_readmultiaiop4(ctlp, aiop, offset, addr, count) \
82 (rp_readmultiio4((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), addr, count))
83 #define rp_writeaiop1(ctlp, aiop, offset, data) \
84 (rp_writeio1((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), data))
85 #define rp_writeaiop2(ctlp, aiop, offset, data) \
86 (rp_writeio2((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), data))
87 #define rp_writeaiop4(ctlp, aiop, offset, data) \
88 (rp_writeio4((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), data))
89 #define rp_writemultiaiop1(ctlp, aiop, offset, addr, count) \
90 (rp_writemultiio1((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), addr, count))
91 #define rp_writemultiaiop2(ctlp, aiop, offset, addr, count) \
92 (rp_writemultiio2((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), addr, count))
93 #define rp_writemultiaiop4(ctlp, aiop, offset, addr, count) \
94 (rp_writemultiio4((ctlp), (ctlp)->aiop2rid(aiop, offset), (ctlp)->aiop2off(aiop, offset), addr, count))
96 #define rp_readch1(chp, offset) \
97 (rp_readaiop1((chp)->CtlP, (chp)->AiopNum, offset))
98 #define rp_readch2(chp, offset) \
99 (rp_readaiop2((chp)->CtlP, (chp)->AiopNum, offset))
100 #define rp_readch4(chp, offset) \
101 (rp_readaiop4((chp)->CtlP, (chp)->AiopNum, offset))
102 #define rp_readmultich1(chp, offset, addr, count) \
103 (rp_readmultiaiop1((chp)->CtlP, (chp)->AiopNum, offset, addr, count))
104 #define rp_readmultich2(chp, offset, addr, count) \
105 (rp_readmultiaiop2((chp)->CtlP, (chp)->AiopNum, offset, addr, count))
106 #define rp_readmultich4(chp, offset, addr, count) \
107 (rp_readmultiaiop4((chp)->CtlP, (chp)->AiopNum, offset, addr, count))
108 #define rp_writech1(chp, offset, data) \
109 (rp_writeaiop1((chp)->CtlP, (chp)->AiopNum, offset, data))
110 #define rp_writech2(chp, offset, data) \
111 (rp_writeaiop2((chp)->CtlP, (chp)->AiopNum, offset, data))
112 #define rp_writech4(chp, offset, data) \
113 (rp_writeaiop4((chp)->CtlP, (chp)->AiopNum, offset, data))
114 #define rp_writemultich1(chp, offset, addr, count) \
115 (rp_writemultiaiop1((chp)->CtlP, (chp)->AiopNum, offset, addr, count))
116 #define rp_writemultich2(chp, offset, addr, count) \
117 (rp_writemultiaiop2((chp)->CtlP, (chp)->AiopNum, offset, addr, count))
118 #define rp_writemultich4(chp, offset, addr, count) \
119 (rp_writemultiaiop4((chp)->CtlP, (chp)->AiopNum, offset, addr, count))
122 * End of OS-specific defines
128 #define AIOP_CTL_SIZE 4
129 #define CHAN_AIOP_SIZE 8
130 #define MAX_PORTS_PER_AIOP 8
131 #define MAX_AIOPS_PER_BOARD 4
132 #define MAX_PORTS_PER_BOARD 32
134 /* Controller ID numbers */
135 #define CTLID_NULL -1 /* no controller exists */
136 #define CTLID_0001 0x0001 /* controller release 1 */
138 /* AIOP ID numbers, identifies AIOP type implementing channel */
139 #define AIOPID_NULL -1 /* no AIOP or channel exists */
140 #define AIOPID_0001 0x0001 /* AIOP release 1 */
142 #define NULLDEV -1 /* identifies non-existant device */
143 #define NULLCTL -1 /* identifies non-existant controller */
144 #define NULLAIOP -1 /* identifies non-existant AIOP */
145 #define NULLCHAN -1 /* identifies non-existant channel */
147 /************************************************************************
148 Global Register Offsets - Direct Access - Fixed values
149 ************************************************************************/
151 #define _CMD_REG 0x38 /* Command Register 8 Write */
152 #define _INT_CHAN 0x39 /* Interrupt Channel Register 8 Read */
153 #define _INT_MASK 0x3A /* Interrupt Mask Register 8 Read / Write */
154 #define _UNUSED 0x3B /* Unused 8 */
155 #define _INDX_ADDR 0x3C /* Index Register Address 16 Write */
156 #define _INDX_DATA 0x3E /* Index Register Data 8/16 Read / Write */
158 /************************************************************************
159 Channel Register Offsets for 1st channel in AIOP - Direct Access
160 ************************************************************************/
161 #define _TD0 0x00 /* Transmit Data 16 Write */
162 #define _RD0 0x00 /* Receive Data 16 Read */
163 #define _CHN_STAT0 0x20 /* Channel Status 8/16 Read / Write */
164 #define _FIFO_CNT0 0x10 /* Transmit/Receive FIFO Count 16 Read */
165 #define _INT_ID0 0x30 /* Interrupt Identification 8 Read */
167 /************************************************************************
168 Tx Control Register Offsets - Indexed - External - Fixed
169 ************************************************************************/
170 #define _TX_ENBLS 0x980 /* Tx Processor Enables Register 8 Read / Write */
171 #define _TXCMP1 0x988 /* Transmit Compare Value #1 8 Read / Write */
172 #define _TXCMP2 0x989 /* Transmit Compare Value #2 8 Read / Write */
173 #define _TXREP1B1 0x98A /* Tx Replace Value #1 - Byte 1 8 Read / Write */
174 #define _TXREP1B2 0x98B /* Tx Replace Value #1 - Byte 2 8 Read / Write */
175 #define _TXREP2 0x98C /* Transmit Replace Value #2 8 Read / Write */
177 /************************************************************************
179 ************************************************************************/
180 #define RXFIFO_DATA 0x5f
181 #define RXFIFO_OUT 0x5c
182 #define RXFIFO_EN 0x08
183 #define RXFIFO_DIS 0xa7
185 /************************************************************************
186 Memory Controller Register Offsets - Indexed - External - Fixed
187 ************************************************************************/
188 #define _RX_FIFO 0x000 /* Rx FIFO */
189 #define _TX_FIFO 0x800 /* Tx FIFO */
190 #define _RXF_OUTP 0x990 /* Rx FIFO OUT pointer 16 Read / Write */
191 #define _RXF_INP 0x992 /* Rx FIFO IN pointer 16 Read / Write */
192 #define _TXF_OUTP 0x994 /* Tx FIFO OUT pointer 8 Read / Write */
193 #define _TXF_INP 0x995 /* Tx FIFO IN pointer 8 Read / Write */
194 #define _TXP_CNT 0x996 /* Tx Priority Count 8 Read / Write */
195 #define _TXP_PNTR 0x997 /* Tx Priority Pointer 8 Read / Write */
197 #define PRI_PEND 0x80 /* Priority data pending (bit7, Tx pri cnt) */
198 #define TXFIFO_SIZE 255 /* size of Tx FIFO */
199 #define RXFIFO_SIZE 1023 /* size of Rx FIFO */
201 /************************************************************************
202 Tx Priority Buffer - Indexed - External - Fixed
203 ************************************************************************/
204 #define _TXP_BUF 0x9C0 /* Tx Priority Buffer 32 Bytes Read / Write */
205 #define TXP_SIZE 0x20 /* 32 bytes */
207 /************************************************************************
208 Channel Register Offsets - Indexed - Internal - Fixed
209 ************************************************************************/
211 #define _TX_CTRL 0xFF0 /* Transmit Control 16 Write */
212 #define _RX_CTRL 0xFF2 /* Receive Control 8 Write */
213 #define _BAUD 0xFF4 /* Baud Rate 16 Write */
214 #define _CLK_PRE 0xFF6 /* Clock Prescaler 8 Write */
216 #define CLOCK_PRESC 0x19 /* mod 9 (divide by 10) prescale */
242 #define STMBREAK 0x08 /* BREAK */
243 #define STMFRAME 0x04 /* framing error */
244 #define STMRCVROVR 0x02 /* receiver over run error */
245 #define STMPARITY 0x01 /* parity error */
246 #define STMERROR (STMBREAK | STMFRAME | STMPARITY)
247 #define STMBREAKH 0x800 /* BREAK */
248 #define STMFRAMEH 0x400 /* framing error */
249 #define STMRCVROVRH 0x200 /* receiver over run error */
250 #define STMPARITYH 0x100 /* parity error */
251 #define STMERRORH (STMBREAKH | STMFRAMEH | STMPARITYH)
253 #define CTS_ACT 0x20 /* CTS input asserted */
254 #define DSR_ACT 0x10 /* DSR input asserted */
255 #define CD_ACT 0x08 /* CD input asserted */
256 #define TXFIFOMT 0x04 /* Tx FIFO is empty */
257 #define TXSHRMT 0x02 /* Tx shift register is empty */
258 #define RDA 0x01 /* Rx data available */
259 #define DRAINED (TXFIFOMT | TXSHRMT) /* indicates Tx is drained */
261 #define STATMODE 0x8000 /* status mode enable bit */
262 #define RXFOVERFL 0x2000 /* receive FIFO overflow */
263 #define RX2MATCH 0x1000 /* receive compare byte 2 match */
264 #define RX1MATCH 0x0800 /* receive compare byte 1 match */
265 #define RXBREAK 0x0400 /* received BREAK */
266 #define RXFRAME 0x0200 /* received framing error */
267 #define RXPARITY 0x0100 /* received parity error */
268 #define STATERROR (RXBREAK | RXFRAME | RXPARITY)
270 #define CTSFC_EN 0x80 /* CTS flow control enable bit */
271 #define RTSTOG_EN 0x40 /* RTS toggle enable bit */
272 #define TXINT_EN 0x10 /* transmit interrupt enable */
273 #define STOP2 0x08 /* enable 2 stop bits (0 = 1 stop) */
274 #define PARITY_EN 0x04 /* enable parity (0 = no parity) */
275 #define EVEN_PAR 0x02 /* even parity (0 = odd parity) */
276 #define DATA8BIT 0x01 /* 8 bit data (0 = 7 bit data) */
278 #define SETBREAK 0x10 /* send break condition (must clear) */
279 #define LOCALLOOP 0x08 /* local loopback set for test */
280 #define SET_DTR 0x04 /* assert DTR */
281 #define SET_RTS 0x02 /* assert RTS */
282 #define TX_ENABLE 0x01 /* enable transmitter */
284 #define RTSFC_EN 0x40 /* RTS flow control enable */
285 #define RXPROC_EN 0x20 /* receive processor enable */
286 #define TRIG_NO 0x00 /* Rx FIFO trigger level 0 (no trigger) */
287 #define TRIG_1 0x08 /* trigger level 1 char */
288 #define TRIG_1_2 0x10 /* trigger level 1/2 */
289 #define TRIG_7_8 0x18 /* trigger level 7/8 */
290 #define TRIG_MASK 0x18 /* trigger level mask */
291 #define SRCINT_EN 0x04 /* special Rx condition interrupt enable */
292 #define RXINT_EN 0x02 /* Rx interrupt enable */
293 #define MCINT_EN 0x01 /* modem change interrupt enable */
295 #define RXF_TRIG 0x20 /* Rx FIFO trigger level interrupt */
296 #define TXFIFO_MT 0x10 /* Tx FIFO empty interrupt */
297 #define SRC_INT 0x08 /* special receive condition interrupt */
298 #define DELTA_CD 0x04 /* CD change interrupt */
299 #define DELTA_CTS 0x02 /* CTS change interrupt */
300 #define DELTA_DSR 0x01 /* DSR change interrupt */
302 #define REP1W2_EN 0x10 /* replace byte 1 with 2 bytes enable */
303 #define IGN2_EN 0x08 /* ignore byte 2 enable */
304 #define IGN1_EN 0x04 /* ignore byte 1 enable */
305 #define COMP2_EN 0x02 /* compare byte 2 enable */
306 #define COMP1_EN 0x01 /* compare byte 1 enable */
308 #define RESET_ALL 0x80 /* reset AIOP (all channels) */
309 #define TXOVERIDE 0x40 /* Transmit software off override */
310 #define RESETUART 0x20 /* reset channel's UART */
311 #define RESTXFCNT 0x10 /* reset channel's Tx FIFO count register */
312 #define RESRXFCNT 0x08 /* reset channel's Rx FIFO count register */
314 #define INTSTAT0 0x01 /* AIOP 0 interrupt status */
315 #define INTSTAT1 0x02 /* AIOP 1 interrupt status */
316 #define INTSTAT2 0x04 /* AIOP 2 interrupt status */
317 #define INTSTAT3 0x08 /* AIOP 3 interrupt status */
319 #define INTR_EN 0x08 /* allow interrupts to host */
320 #define INT_STROB 0x04 /* strobe and clear interrupt line (EOI) */
322 #define CHAN3_EN 0x08 /* enable AIOP 3 */
323 #define CHAN2_EN 0x04 /* enable AIOP 2 */
324 #define CHAN1_EN 0x02 /* enable AIOP 1 */
325 #define CHAN0_EN 0x01 /* enable AIOP 0 */
326 #define FREQ_DIS 0x00
327 #define FREQ_274HZ 0x60
328 #define FREQ_137HZ 0x50
329 #define FREQ_69HZ 0x40
330 #define FREQ_34HZ 0x30
331 #define FREQ_17HZ 0x20
332 #define FREQ_9HZ 0x10
333 #define PERIODIC_ONLY 0x80 /* only PERIODIC interrupt */
335 #define CHANINT_EN 0x0100 /* flags to enable/disable channel ints */
338 #define RREGDATASIZE 52
348 struct CONTROLLER_str;
351 /* The types of bus-specific methods */
352 typedef int rp_aiop2rid_t(int, int);
353 typedef int rp_aiop2off_t(int, int);
354 typedef unsigned char rp_ctlmask_t(struct CONTROLLER_str *);
356 /* Controller level information structure */
357 struct CONTROLLER_str
361 int AiopID[AIOP_CTL_SIZE];
362 int AiopNumChan[AIOP_CTL_SIZE];
364 /* Device and resource management */
365 device_t dev; /* device */
366 int io_num; /* Number of IO resources */
367 int *io_rid; /* IO resource IDs */
368 struct resource **io; /* IO resources */
370 struct rp_port *rp; /* port */
371 struct tty *tty; /* tty */
373 /* Bus-specific properties */
376 /* Bus-specific methods */
377 rp_aiop2rid_t *aiop2rid; /* (aiop, offset) -> rid */
378 rp_aiop2off_t *aiop2off; /* (aiop, offset) -> off */
379 rp_ctlmask_t *ctlmask; /* Int status */
381 typedef struct CONTROLLER_str CONTROLLER_T;
382 typedef CONTROLLER_T CONTROLLER_t;
384 /* Channel level information structure */
400 Byte_t R[RREGDATASIZE];
407 Byte_t TxReplace1[4];
408 Byte_t TxReplace2[4];
411 typedef struct CHANNEL_str CHANNEL_T;
412 typedef CHANNEL_T CHANNEL_t;
413 typedef CHANNEL_T * CHANPTR_T;
415 #define CHNOFF_TXRXDATA(chp) ((chp)->ChanNum * 2 + _TD0)
416 #define CHNOFF_CHANSTAT(chp) ((chp)->ChanNum * 2 + _CHN_STAT0)
417 #define CHNOFF_TXRXCOUNT(chp) ((chp)->ChanNum * 2 + _FIFO_CNT0)
418 #define CHNOFF_INTID(chp) ((chp)->ChanNum + _INT_ID0)
420 /***************************************************************************
422 Purpose: Stop sending a transmit BREAK signal
424 CHANNEL_T *ChP; Ptr to channel structure
426 #define sClrBreak(ChP) \
428 (ChP)->TxControl[3] &= ~SETBREAK; \
429 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
432 /***************************************************************************
434 Purpose: Clr the DTR output
436 CHANNEL_T *ChP; Ptr to channel structure
438 #define sClrDTR(ChP) \
440 (ChP)->TxControl[3] &= ~SET_DTR; \
441 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
444 /***************************************************************************
446 Purpose: Clr the RTS output
448 CHANNEL_T *ChP; Ptr to channel structure
450 #define sClrRTS(ChP) \
452 (ChP)->TxControl[3] &= ~SET_RTS; \
453 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
456 /***************************************************************************
458 Purpose: Clear any existing transmit software flow control off condition
459 Call: sClrTxXOFF(ChP)
460 CHANNEL_T *ChP; Ptr to channel structure
462 #define sClrTxXOFF(ChP) \
464 rp_writech1(ChP,_CMD_REG,TXOVERIDE | (Byte_t)(ChP)->ChanNum); \
465 rp_writech1(ChP,_CMD_REG,(Byte_t)(ChP)->ChanNum); \
468 /***************************************************************************
469 Function: sDisCTSFlowCtl
470 Purpose: Disable output flow control using CTS
471 Call: sDisCTSFlowCtl(ChP)
472 CHANNEL_T *ChP; Ptr to channel structure
474 #define sDisCTSFlowCtl(ChP) \
476 (ChP)->TxControl[2] &= ~CTSFC_EN; \
477 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
480 /***************************************************************************
482 Purpose: Disable parity
483 Call: sDisParity(ChP)
484 CHANNEL_T *ChP; Ptr to channel structure
485 Comments: Function sSetParity() can be used in place of functions sEnParity(),
486 sDisParity(), sSetOddParity(), and sSetEvenParity().
488 #define sDisParity(ChP) \
490 (ChP)->TxControl[2] &= ~PARITY_EN; \
491 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
494 /***************************************************************************
496 Purpose: Disable Rx FIFO
497 Call: sDisRxFIFO(ChP)
498 CHANNEL_T *ChP; Ptr to channel structure
500 #define sDisRxFIFO(ChP) \
502 (ChP)->R[0x32] = 0x0a; \
503 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->R[0x30]); \
506 /***************************************************************************
507 Function: sDisRxStatusMode
508 Purpose: Disable the Rx status mode
509 Call: sDisRxStatusMode(ChP)
510 CHANNEL_T *ChP; Ptr to channel structure
511 Comments: This takes the channel out of the receive status mode. All
512 subsequent reads of receive data using sReadRxWord() will return
515 #define sDisRxStatusMode(ChP) rp_writech2(ChP,CHNOFF_CHANSTAT(ChP),0)
517 /***************************************************************************
518 Function: sDisTransmit
519 Purpose: Disable transmit
520 Call: sDisTransmit(ChP)
521 CHANNEL_T *ChP; Ptr to channel structure
522 This disables movement of Tx data from the Tx FIFO into the 1 byte
523 Tx buffer. Therefore there could be up to a 2 byte latency
524 between the time sDisTransmit() is called and the transmit buffer
525 and transmit shift register going completely empty.
527 #define sDisTransmit(ChP) \
529 (ChP)->TxControl[3] &= ~TX_ENABLE; \
530 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
533 /***************************************************************************
534 Function: sDisTxSoftFlowCtl
535 Purpose: Disable Tx Software Flow Control
536 Call: sDisTxSoftFlowCtl(ChP)
537 CHANNEL_T *ChP; Ptr to channel structure
539 #define sDisTxSoftFlowCtl(ChP) \
541 (ChP)->R[0x06] = 0x8a; \
542 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->R[0x04]); \
545 /***************************************************************************
546 Function: sEnCTSFlowCtl
547 Purpose: Enable output flow control using CTS
548 Call: sEnCTSFlowCtl(ChP)
549 CHANNEL_T *ChP; Ptr to channel structure
551 #define sEnCTSFlowCtl(ChP) \
553 (ChP)->TxControl[2] |= CTSFC_EN; \
554 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
557 /***************************************************************************
559 Purpose: Enable parity
561 CHANNEL_T *ChP; Ptr to channel structure
562 Comments: Function sSetParity() can be used in place of functions sEnParity(),
563 sDisParity(), sSetOddParity(), and sSetEvenParity().
565 Warnings: Before enabling parity odd or even parity should be chosen using
566 functions sSetOddParity() or sSetEvenParity().
568 #define sEnParity(ChP) \
570 (ChP)->TxControl[2] |= PARITY_EN; \
571 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
574 /***************************************************************************
575 Function: sEnRTSFlowCtl
578 #define sEnRTSFlowCtl(ChP) \
580 (ChP)->TxControl[2] &= ~RTSTOG_EN; \
581 (ChP)->TxControl[3] &= ~SET_RTS; \
582 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
583 (ChP)->RxControl[2] |= RTSFC_EN; \
584 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->RxControl[0]); \
587 /***************************************************************************
588 Function: sDisRTSFlowCtl
591 #define sDisRTSFlowCtl(ChP) \
593 (ChP)->RxControl[2] &= ~RTSFC_EN; \
594 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->RxControl[0]); \
597 /***************************************************************************
599 Purpose: Enable Rx FIFO
601 CHANNEL_T *ChP; Ptr to channel structure
603 #define sEnRxFIFO(ChP) \
605 (ChP)->R[0x32] = 0x08; \
606 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->R[0x30]); \
609 /***************************************************************************
610 Function: sEnRxProcessor
611 Purpose: Enable the receive processor
612 Call: sEnRxProcessor(ChP)
613 CHANNEL_T *ChP; Ptr to channel structure
614 Comments: This function is used to start the receive processor. When
615 the channel is in the reset state the receive processor is not
616 running. This is done to prevent the receive processor from
617 executing invalid microcode instructions prior to the
618 downloading of the microcode.
620 Warnings: This function must be called after valid microcode has been
621 downloaded to the AIOP, and it must not be called before the
622 microcode has been downloaded.
624 #define sEnRxProcessor(ChP) \
626 (ChP)->RxControl[2] |= RXPROC_EN; \
627 rp_writech2(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->RxControl[0]); \
630 /***************************************************************************
631 Function: sEnRxStatusMode
632 Purpose: Enable the Rx status mode
633 Call: sEnRxStatusMode(ChP)
634 CHANNEL_T *ChP; Ptr to channel structure
635 Comments: This places the channel in the receive status mode. All subsequent
636 reads of receive data using sReadRxWord() will return a data byte
637 in the low word and a status byte in the high word.
640 #define sEnRxStatusMode(ChP) rp_writech2(ChP,CHNOFF_CHANSTAT(ChP),STATMODE)
642 /***************************************************************************
643 Function: sEnTransmit
644 Purpose: Enable transmit
645 Call: sEnTransmit(ChP)
646 CHANNEL_T *ChP; Ptr to channel structure
648 #define sEnTransmit(ChP) \
650 (ChP)->TxControl[3] |= TX_ENABLE; \
651 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
654 /***************************************************************************
655 Function: sGetAiopIntStatus
656 Purpose: Get the AIOP interrupt status
657 Call: sGetAiopIntStatus(CtlP,AiopNum)
658 CONTROLLER_T *CtlP; Ptr to controller structure
659 int AiopNum; AIOP number
660 Return: Byte_t: The AIOP interrupt status. Bits 0 through 7
661 represent channels 0 through 7 respectively. If a
662 bit is set that channel is interrupting.
664 #define sGetAiopIntStatus(CtlP,AIOPNUM) rp_readaiop1(CtlP,AIOPNUM,_INT_CHAN)
666 /***************************************************************************
667 Function: sGetAiopNumChan
668 Purpose: Get the number of channels supported by an AIOP
669 Call: sGetAiopNumChan(CtlP,AiopNum)
670 CONTROLLER_T *CtlP; Ptr to controller structure
671 int AiopNum; AIOP number
672 Return: int: The number of channels supported by the AIOP
674 #define sGetAiopNumChan(CtlP,AIOPNUM) CtlP->AiopNumChan[AIOPNUM]
676 /***************************************************************************
677 Function: sGetChanIntID
678 Purpose: Get a channel's interrupt identification byte
679 Call: sGetChanIntID(ChP)
680 CHANNEL_T *ChP; Ptr to channel structure
681 Return: Byte_t: The channel interrupt ID. Can be any
682 combination of the following flags:
683 RXF_TRIG: Rx FIFO trigger level interrupt
684 TXFIFO_MT: Tx FIFO empty interrupt
685 SRC_INT: Special receive condition interrupt
686 DELTA_CD: CD change interrupt
687 DELTA_CTS: CTS change interrupt
688 DELTA_DSR: DSR change interrupt
690 #define sGetChanIntID(ChP) (rp_readch1(ChP,(ChP)->ChanNum+_INT_ID0) & (RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR))
692 /***************************************************************************
693 Function: sGetChanNum
694 Purpose: Get the number of a channel within an AIOP
695 Call: sGetChanNum(ChP)
696 CHANNEL_T *ChP; Ptr to channel structure
697 Return: int: Channel number within AIOP, or NULLCHAN if channel does
700 #define sGetChanNum(ChP) (ChP)->ChanNum
702 /***************************************************************************
703 Function: sGetChanStatus
704 Purpose: Get the channel status
705 Call: sGetChanStatus(ChP)
706 CHANNEL_T *ChP; Ptr to channel structure
707 Return: Word_t: The channel status. Can be any combination of
710 CTS_ACT: CTS input asserted
711 DSR_ACT: DSR input asserted
712 CD_ACT: CD input asserted
713 TXFIFOMT: Tx FIFO is empty
714 TXSHRMT: Tx shift register is empty
715 RDA: Rx data available
718 STATMODE: status mode enable bit
719 RXFOVERFL: receive FIFO overflow
720 RX2MATCH: receive compare byte 2 match
721 RX1MATCH: receive compare byte 1 match
722 RXBREAK: received BREAK
723 RXFRAME: received framing error
724 RXPARITY: received parity error
725 Warnings: This function will clear the high byte flags in the Channel
728 #define sGetChanStatus(ChP) rp_readch2(ChP,CHNOFF_CHANSTAT(ChP))
730 /***************************************************************************
731 Function: sGetChanStatusLo
732 Purpose: Get the low byte only of the channel status
733 Call: sGetChanStatusLo(ChP)
734 CHANNEL_T *ChP; Ptr to channel structure
735 Return: Byte_t: The channel status low byte. Can be any combination
736 of the following flags:
737 CTS_ACT: CTS input asserted
738 DSR_ACT: DSR input asserted
739 CD_ACT: CD input asserted
740 TXFIFOMT: Tx FIFO is empty
741 TXSHRMT: Tx shift register is empty
742 RDA: Rx data available
744 #define sGetChanStatusLo(ChP) rp_readch1(ChP,CHNOFF_CHANSTAT(ChP))
746 /***************************************************************************
748 Purpose: Get the number of data bytes in the Rx FIFO
750 CHANNEL_T *ChP; Ptr to channel structure
751 Return: int: The number of data bytes in the Rx FIFO.
752 Comments: Byte read of count register is required to obtain Rx count.
755 #define sGetRxCnt(ChP) rp_readch2(ChP,CHNOFF_TXRXCOUNT(ChP))
757 /***************************************************************************
759 Purpose: Get the number of data bytes in the Tx FIFO
761 CHANNEL_T *ChP; Ptr to channel structure
762 Return: Byte_t: The number of data bytes in the Tx FIFO.
763 Comments: Byte read of count register is required to obtain Tx count.
766 #define sGetTxCnt(ChP) rp_readch1(ChP,CHNOFF_TXRXCOUNT(ChP))
768 /*****************************************************************************
769 Function: sGetTxRxDataIO
770 Purpose: Get the offset of a channel's TxRx Data register
771 Call: sGetTxRxDataIO(ChP)
772 CHANNEL_T *ChP; Ptr to channel structure
773 Return: WordIO_t: offset of a channel's TxRx Data register
775 #define sGetTxRxDataIO(ChP) CHNOFF_TXRXDATA(ChP)
777 /***************************************************************************
778 Function: sInitChanDefaults
779 Purpose: Initialize a channel structure to its default state.
780 Call: sInitChanDefaults(ChP)
781 CHANNEL_T *ChP; Ptr to the channel structure
782 Comments: This function must be called once for every channel structure
783 that exists before any other SSCI calls can be made.
786 #define sInitChanDefaults(ChP) \
788 (ChP)->CtlP = NULL; \
789 (ChP)->AiopNum = NULLAIOP; \
790 (ChP)->ChanID = AIOPID_NULL; \
791 (ChP)->ChanNum = NULLCHAN; \
794 /***************************************************************************
795 Function: sResetAiopByNum
796 Purpose: Reset the AIOP by number
797 Call: sResetAiopByNum(CTLP,AIOPNUM)
798 CONTROLLER_T CTLP; Ptr to controller structure
801 #define sResetAiopByNum(CTLP,AIOPNUM) \
803 rp_writeaiop1(CTLP,AIOPNUM,_CMD_REG,RESET_ALL); \
804 rp_writeaiop1(CTLP,AIOPNUM,_CMD_REG,0x0); \
807 /***************************************************************************
809 Purpose: Send a transmit BREAK signal
810 Call: sSendBreak(ChP)
811 CHANNEL_T *ChP; Ptr to channel structure
813 #define sSendBreak(ChP) \
815 (ChP)->TxControl[3] |= SETBREAK; \
816 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
819 /***************************************************************************
821 Purpose: Set baud rate
822 Call: sSetBaud(ChP,Divisor)
823 CHANNEL_T *ChP; Ptr to channel structure
824 Word_t Divisor; 16 bit baud rate divisor for channel
826 #define sSetBaud(ChP,DIVISOR) \
828 (ChP)->BaudDiv[2] = (Byte_t)(DIVISOR); \
829 (ChP)->BaudDiv[3] = (Byte_t)((DIVISOR) >> 8); \
830 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->BaudDiv[0]); \
833 /***************************************************************************
835 Purpose: Set data bits to 7
837 CHANNEL_T *ChP; Ptr to channel structure
839 #define sSetData7(ChP) \
841 (ChP)->TxControl[2] &= ~DATA8BIT; \
842 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
845 /***************************************************************************
847 Purpose: Set data bits to 8
849 CHANNEL_T *ChP; Ptr to channel structure
851 #define sSetData8(ChP) \
853 (ChP)->TxControl[2] |= DATA8BIT; \
854 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
857 /***************************************************************************
859 Purpose: Set the DTR output
861 CHANNEL_T *ChP; Ptr to channel structure
863 #define sSetDTR(ChP) \
865 (ChP)->TxControl[3] |= SET_DTR; \
866 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
869 /***************************************************************************
870 Function: sSetEvenParity
871 Purpose: Set even parity
872 Call: sSetEvenParity(ChP)
873 CHANNEL_T *ChP; Ptr to channel structure
874 Comments: Function sSetParity() can be used in place of functions sEnParity(),
875 sDisParity(), sSetOddParity(), and sSetEvenParity().
877 Warnings: This function has no effect unless parity is enabled with function
880 #define sSetEvenParity(ChP) \
882 (ChP)->TxControl[2] |= EVEN_PAR; \
883 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
886 /***************************************************************************
887 Function: sSetOddParity
888 Purpose: Set odd parity
889 Call: sSetOddParity(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().
894 Warnings: This function has no effect unless parity is enabled with function
897 #define sSetOddParity(ChP) \
899 (ChP)->TxControl[2] &= ~EVEN_PAR; \
900 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
903 /***************************************************************************
905 Purpose: Set the RTS output
907 CHANNEL_T *ChP; Ptr to channel structure
909 #define sSetRTS(ChP) \
911 (ChP)->TxControl[3] |= SET_RTS; \
912 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
915 /***************************************************************************
916 Function: sSetRxTrigger
917 Purpose: Set the Rx FIFO trigger level
918 Call: sSetRxProcessor(ChP,Level)
919 CHANNEL_T *ChP; Ptr to channel structure
920 Byte_t Level; Number of characters in Rx FIFO at which the
921 interrupt will be generated. Can be any of the following flags:
924 TRIG_1: 1 character in FIFO
925 TRIG_1_2: FIFO 1/2 full
926 TRIG_7_8: FIFO 7/8 full
927 Comments: An interrupt will be generated when the trigger level is reached
928 only if function sEnInterrupt() has been called with flag
929 RXINT_EN set. The RXF_TRIG flag in the Interrupt Idenfification
930 register will be set whenever the trigger level is reached
931 regardless of the setting of RXINT_EN.
934 #define sSetRxTrigger(ChP,LEVEL) \
936 (ChP)->RxControl[2] &= ~TRIG_MASK; \
937 (ChP)->RxControl[2] |= LEVEL; \
938 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->RxControl[0]); \
941 /***************************************************************************
943 Purpose: Set stop bits to 1
945 CHANNEL_T *ChP; Ptr to channel structure
947 #define sSetStop1(ChP) \
949 (ChP)->TxControl[2] &= ~STOP2; \
950 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
953 /***************************************************************************
955 Purpose: Set stop bits to 2
957 CHANNEL_T *ChP; Ptr to channel structure
959 #define sSetStop2(ChP) \
961 (ChP)->TxControl[2] |= STOP2; \
962 rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->TxControl[0]); \
965 /***************************************************************************
966 Function: sStartRxProcessor
967 Purpose: Start a channel's receive processor
968 Call: sStartRxProcessor(ChP)
969 CHANNEL_T *ChP; Ptr to channel structure
970 Comments: This function is used to start a Rx processor after it was
971 stopped with sStopRxProcessor() or sStopSWInFlowCtl(). It
972 will restart both the Rx processor and software input flow control.
975 #define sStartRxProcessor(ChP) rp_writech4(ChP,_INDX_ADDR,*(DWord_t *)&(ChP)->R[0])
977 /***************************************************************************
978 Function: sWriteTxByte
979 Purpose: Write a transmit data byte to a channel.
980 CHANNEL_T *ChP; Ptr to channel structure
981 ByteIO_t io: Channel transmit register I/O address. This can
982 be obtained with sGetTxRxDataIO().
983 Byte_t Data; The transmit data byte.
984 Warnings: This function writes the data byte without checking to see if
985 sMaxTxSize is exceeded in the Tx FIFO.
987 #define sWriteTxByte(ChP,IO,DATA) rp_writech1(ChP,IO,DATA)
989 int sReadAiopID(CONTROLLER_T *CtlP, int aiop);
990 int sReadAiopNumChan(CONTROLLER_T *CtlP, int aiop);
991 int sInitChan( CONTROLLER_T *CtlP,
995 Byte_t sGetRxErrStatus(CHANNEL_T *ChP);
996 void sStopRxProcessor(CHANNEL_T *ChP);
997 void sStopSWInFlowCtl(CHANNEL_T *ChP);
998 void sFlushRxFIFO(CHANNEL_T *ChP);
999 void sFlushTxFIFO(CHANNEL_T *ChP);
1000 int sWriteTxPrioByte(CHANNEL_T *ChP, Byte_t Data);
1001 void sEnInterrupts(CHANNEL_T *ChP,Word_t Flags);
1002 void sDisInterrupts(CHANNEL_T *ChP,Word_t Flags);
1003 int rp_attachcommon(CONTROLLER_T *ctlp, int num_aiops, int num_ports);
1004 void rp_releaseresource(CONTROLLER_t *ctlp);
1007 extern Byte_t R[RDATASIZE];
1008 extern CONTROLLER_T sController[CTL_SIZE];
1009 extern Byte_t sIRQMap[16];
1011 extern Byte_t rp_sBitMapClrTbl[8];
1012 extern Byte_t rp_sBitMapSetTbl[8];