x86: hpet: provide separate functions to stop and start the counter
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / char / rocket.c
blobf59fc5cea0673546fa03b0395a8d12b6f7872ff4
1 /*
2 * RocketPort device driver for Linux
4 * Written by Theodore Ts'o, 1995, 1996, 1997, 1998, 1999, 2000.
5 *
6 * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2003 by Comtrol, Inc.
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of the
11 * License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 * Kernel Synchronization:
26 * This driver has 2 kernel control paths - exception handlers (calls into the driver
27 * from user mode) and the timer bottom half (tasklet). This is a polled driver, interrupts
28 * are not used.
30 * Critical data:
31 * - rp_table[], accessed through passed "info" pointers, is a global (static) array of
32 * serial port state information and the xmit_buf circular buffer. Protected by
33 * a per port spinlock.
34 * - xmit_flags[], an array of ints indexed by line (port) number, indicating that there
35 * is data to be transmitted. Protected by atomic bit operations.
36 * - rp_num_ports, int indicating number of open ports, protected by atomic operations.
38 * rp_write() and rp_write_char() functions use a per port semaphore to protect against
39 * simultaneous access to the same port by more than one process.
42 /****** Defines ******/
43 #define ROCKET_PARANOIA_CHECK
44 #define ROCKET_DISABLE_SIMUSAGE
46 #undef ROCKET_SOFT_FLOW
47 #undef ROCKET_DEBUG_OPEN
48 #undef ROCKET_DEBUG_INTR
49 #undef ROCKET_DEBUG_WRITE
50 #undef ROCKET_DEBUG_FLOW
51 #undef ROCKET_DEBUG_THROTTLE
52 #undef ROCKET_DEBUG_WAIT_UNTIL_SENT
53 #undef ROCKET_DEBUG_RECEIVE
54 #undef ROCKET_DEBUG_HANGUP
55 #undef REV_PCI_ORDER
56 #undef ROCKET_DEBUG_IO
58 #define POLL_PERIOD HZ/100 /* Polling period .01 seconds (10ms) */
60 /****** Kernel includes ******/
62 #include <linux/module.h>
63 #include <linux/errno.h>
64 #include <linux/major.h>
65 #include <linux/kernel.h>
66 #include <linux/signal.h>
67 #include <linux/slab.h>
68 #include <linux/mm.h>
69 #include <linux/sched.h>
70 #include <linux/timer.h>
71 #include <linux/interrupt.h>
72 #include <linux/tty.h>
73 #include <linux/tty_driver.h>
74 #include <linux/tty_flip.h>
75 #include <linux/serial.h>
76 #include <linux/string.h>
77 #include <linux/fcntl.h>
78 #include <linux/ptrace.h>
79 #include <linux/mutex.h>
80 #include <linux/ioport.h>
81 #include <linux/delay.h>
82 #include <linux/completion.h>
83 #include <linux/wait.h>
84 #include <linux/pci.h>
85 #include <linux/uaccess.h>
86 #include <asm/atomic.h>
87 #include <asm/unaligned.h>
88 #include <linux/bitops.h>
89 #include <linux/spinlock.h>
90 #include <linux/init.h>
92 /****** RocketPort includes ******/
94 #include "rocket_int.h"
95 #include "rocket.h"
97 #define ROCKET_VERSION "2.09"
98 #define ROCKET_DATE "12-June-2003"
100 /****** RocketPort Local Variables ******/
102 static void rp_do_poll(unsigned long dummy);
104 static struct tty_driver *rocket_driver;
106 static struct rocket_version driver_version = {
107 ROCKET_VERSION, ROCKET_DATE
110 static struct r_port *rp_table[MAX_RP_PORTS]; /* The main repository of serial port state information. */
111 static unsigned int xmit_flags[NUM_BOARDS]; /* Bit significant, indicates port had data to transmit. */
112 /* eg. Bit 0 indicates port 0 has xmit data, ... */
113 static atomic_t rp_num_ports_open; /* Number of serial ports open */
114 static DEFINE_TIMER(rocket_timer, rp_do_poll, 0, 0);
116 static unsigned long board1; /* ISA addresses, retrieved from rocketport.conf */
117 static unsigned long board2;
118 static unsigned long board3;
119 static unsigned long board4;
120 static unsigned long controller;
121 static int support_low_speed;
122 static unsigned long modem1;
123 static unsigned long modem2;
124 static unsigned long modem3;
125 static unsigned long modem4;
126 static unsigned long pc104_1[8];
127 static unsigned long pc104_2[8];
128 static unsigned long pc104_3[8];
129 static unsigned long pc104_4[8];
130 static unsigned long *pc104[4] = { pc104_1, pc104_2, pc104_3, pc104_4 };
132 static int rp_baud_base[NUM_BOARDS]; /* Board config info (Someday make a per-board structure) */
133 static unsigned long rcktpt_io_addr[NUM_BOARDS];
134 static int rcktpt_type[NUM_BOARDS];
135 static int is_PCI[NUM_BOARDS];
136 static rocketModel_t rocketModel[NUM_BOARDS];
137 static int max_board;
138 static const struct tty_port_operations rocket_port_ops;
141 * The following arrays define the interrupt bits corresponding to each AIOP.
142 * These bits are different between the ISA and regular PCI boards and the
143 * Universal PCI boards.
146 static Word_t aiop_intr_bits[AIOP_CTL_SIZE] = {
147 AIOP_INTR_BIT_0,
148 AIOP_INTR_BIT_1,
149 AIOP_INTR_BIT_2,
150 AIOP_INTR_BIT_3
153 static Word_t upci_aiop_intr_bits[AIOP_CTL_SIZE] = {
154 UPCI_AIOP_INTR_BIT_0,
155 UPCI_AIOP_INTR_BIT_1,
156 UPCI_AIOP_INTR_BIT_2,
157 UPCI_AIOP_INTR_BIT_3
160 static Byte_t RData[RDATASIZE] = {
161 0x00, 0x09, 0xf6, 0x82,
162 0x02, 0x09, 0x86, 0xfb,
163 0x04, 0x09, 0x00, 0x0a,
164 0x06, 0x09, 0x01, 0x0a,
165 0x08, 0x09, 0x8a, 0x13,
166 0x0a, 0x09, 0xc5, 0x11,
167 0x0c, 0x09, 0x86, 0x85,
168 0x0e, 0x09, 0x20, 0x0a,
169 0x10, 0x09, 0x21, 0x0a,
170 0x12, 0x09, 0x41, 0xff,
171 0x14, 0x09, 0x82, 0x00,
172 0x16, 0x09, 0x82, 0x7b,
173 0x18, 0x09, 0x8a, 0x7d,
174 0x1a, 0x09, 0x88, 0x81,
175 0x1c, 0x09, 0x86, 0x7a,
176 0x1e, 0x09, 0x84, 0x81,
177 0x20, 0x09, 0x82, 0x7c,
178 0x22, 0x09, 0x0a, 0x0a
181 static Byte_t RRegData[RREGDATASIZE] = {
182 0x00, 0x09, 0xf6, 0x82, /* 00: Stop Rx processor */
183 0x08, 0x09, 0x8a, 0x13, /* 04: Tx software flow control */
184 0x0a, 0x09, 0xc5, 0x11, /* 08: XON char */
185 0x0c, 0x09, 0x86, 0x85, /* 0c: XANY */
186 0x12, 0x09, 0x41, 0xff, /* 10: Rx mask char */
187 0x14, 0x09, 0x82, 0x00, /* 14: Compare/Ignore #0 */
188 0x16, 0x09, 0x82, 0x7b, /* 18: Compare #1 */
189 0x18, 0x09, 0x8a, 0x7d, /* 1c: Compare #2 */
190 0x1a, 0x09, 0x88, 0x81, /* 20: Interrupt #1 */
191 0x1c, 0x09, 0x86, 0x7a, /* 24: Ignore/Replace #1 */
192 0x1e, 0x09, 0x84, 0x81, /* 28: Interrupt #2 */
193 0x20, 0x09, 0x82, 0x7c, /* 2c: Ignore/Replace #2 */
194 0x22, 0x09, 0x0a, 0x0a /* 30: Rx FIFO Enable */
197 static CONTROLLER_T sController[CTL_SIZE] = {
198 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
199 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
200 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
201 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
202 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
203 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
204 {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
205 {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}}
208 static Byte_t sBitMapClrTbl[8] = {
209 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f
212 static Byte_t sBitMapSetTbl[8] = {
213 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
216 static int sClockPrescale = 0x14;
219 * Line number is the ttySIx number (x), the Minor number. We
220 * assign them sequentially, starting at zero. The following
221 * array keeps track of the line number assigned to a given board/aiop/channel.
223 static unsigned char lineNumbers[MAX_RP_PORTS];
224 static unsigned long nextLineNumber;
226 /***** RocketPort Static Prototypes *********/
227 static int __init init_ISA(int i);
228 static void rp_wait_until_sent(struct tty_struct *tty, int timeout);
229 static void rp_flush_buffer(struct tty_struct *tty);
230 static void rmSpeakerReset(CONTROLLER_T * CtlP, unsigned long model);
231 static unsigned char GetLineNumber(int ctrl, int aiop, int ch);
232 static unsigned char SetLineNumber(int ctrl, int aiop, int ch);
233 static void rp_start(struct tty_struct *tty);
234 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
235 int ChanNum);
236 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode);
237 static void sFlushRxFIFO(CHANNEL_T * ChP);
238 static void sFlushTxFIFO(CHANNEL_T * ChP);
239 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags);
240 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags);
241 static void sModemReset(CONTROLLER_T * CtlP, int chan, int on);
242 static void sPCIModemReset(CONTROLLER_T * CtlP, int chan, int on);
243 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data);
244 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
245 ByteIO_t * AiopIOList, int AiopIOListSize,
246 WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
247 int PeriodicOnly, int altChanRingIndicator,
248 int UPCIRingInd);
249 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
250 ByteIO_t * AiopIOList, int AiopIOListSize,
251 int IRQNum, Byte_t Frequency, int PeriodicOnly);
252 static int sReadAiopID(ByteIO_t io);
253 static int sReadAiopNumChan(WordIO_t io);
255 MODULE_AUTHOR("Theodore Ts'o");
256 MODULE_DESCRIPTION("Comtrol RocketPort driver");
257 module_param(board1, ulong, 0);
258 MODULE_PARM_DESC(board1, "I/O port for (ISA) board #1");
259 module_param(board2, ulong, 0);
260 MODULE_PARM_DESC(board2, "I/O port for (ISA) board #2");
261 module_param(board3, ulong, 0);
262 MODULE_PARM_DESC(board3, "I/O port for (ISA) board #3");
263 module_param(board4, ulong, 0);
264 MODULE_PARM_DESC(board4, "I/O port for (ISA) board #4");
265 module_param(controller, ulong, 0);
266 MODULE_PARM_DESC(controller, "I/O port for (ISA) rocketport controller");
267 module_param(support_low_speed, bool, 0);
268 MODULE_PARM_DESC(support_low_speed, "1 means support 50 baud, 0 means support 460400 baud");
269 module_param(modem1, ulong, 0);
270 MODULE_PARM_DESC(modem1, "1 means (ISA) board #1 is a RocketModem");
271 module_param(modem2, ulong, 0);
272 MODULE_PARM_DESC(modem2, "1 means (ISA) board #2 is a RocketModem");
273 module_param(modem3, ulong, 0);
274 MODULE_PARM_DESC(modem3, "1 means (ISA) board #3 is a RocketModem");
275 module_param(modem4, ulong, 0);
276 MODULE_PARM_DESC(modem4, "1 means (ISA) board #4 is a RocketModem");
277 module_param_array(pc104_1, ulong, NULL, 0);
278 MODULE_PARM_DESC(pc104_1, "set interface types for ISA(PC104) board #1 (e.g. pc104_1=232,232,485,485,...");
279 module_param_array(pc104_2, ulong, NULL, 0);
280 MODULE_PARM_DESC(pc104_2, "set interface types for ISA(PC104) board #2 (e.g. pc104_2=232,232,485,485,...");
281 module_param_array(pc104_3, ulong, NULL, 0);
282 MODULE_PARM_DESC(pc104_3, "set interface types for ISA(PC104) board #3 (e.g. pc104_3=232,232,485,485,...");
283 module_param_array(pc104_4, ulong, NULL, 0);
284 MODULE_PARM_DESC(pc104_4, "set interface types for ISA(PC104) board #4 (e.g. pc104_4=232,232,485,485,...");
286 static int rp_init(void);
287 static void rp_cleanup_module(void);
289 module_init(rp_init);
290 module_exit(rp_cleanup_module);
293 MODULE_LICENSE("Dual BSD/GPL");
295 /*************************************************************************/
296 /* Module code starts here */
298 static inline int rocket_paranoia_check(struct r_port *info,
299 const char *routine)
301 #ifdef ROCKET_PARANOIA_CHECK
302 if (!info)
303 return 1;
304 if (info->magic != RPORT_MAGIC) {
305 printk(KERN_WARNING "Warning: bad magic number for rocketport "
306 "struct in %s\n", routine);
307 return 1;
309 #endif
310 return 0;
314 /* Serial port receive data function. Called (from timer poll) when an AIOPIC signals
315 * that receive data is present on a serial port. Pulls data from FIFO, moves it into the
316 * tty layer.
318 static void rp_do_receive(struct r_port *info,
319 struct tty_struct *tty,
320 CHANNEL_t * cp, unsigned int ChanStatus)
322 unsigned int CharNStat;
323 int ToRecv, wRecv, space;
324 unsigned char *cbuf;
326 ToRecv = sGetRxCnt(cp);
327 #ifdef ROCKET_DEBUG_INTR
328 printk(KERN_INFO "rp_do_receive(%d)...\n", ToRecv);
329 #endif
330 if (ToRecv == 0)
331 return;
334 * if status indicates there are errored characters in the
335 * FIFO, then enter status mode (a word in FIFO holds
336 * character and status).
338 if (ChanStatus & (RXFOVERFL | RXBREAK | RXFRAME | RXPARITY)) {
339 if (!(ChanStatus & STATMODE)) {
340 #ifdef ROCKET_DEBUG_RECEIVE
341 printk(KERN_INFO "Entering STATMODE...\n");
342 #endif
343 ChanStatus |= STATMODE;
344 sEnRxStatusMode(cp);
349 * if we previously entered status mode, then read down the
350 * FIFO one word at a time, pulling apart the character and
351 * the status. Update error counters depending on status
353 if (ChanStatus & STATMODE) {
354 #ifdef ROCKET_DEBUG_RECEIVE
355 printk(KERN_INFO "Ignore %x, read %x...\n",
356 info->ignore_status_mask, info->read_status_mask);
357 #endif
358 while (ToRecv) {
359 char flag;
361 CharNStat = sInW(sGetTxRxDataIO(cp));
362 #ifdef ROCKET_DEBUG_RECEIVE
363 printk(KERN_INFO "%x...\n", CharNStat);
364 #endif
365 if (CharNStat & STMBREAKH)
366 CharNStat &= ~(STMFRAMEH | STMPARITYH);
367 if (CharNStat & info->ignore_status_mask) {
368 ToRecv--;
369 continue;
371 CharNStat &= info->read_status_mask;
372 if (CharNStat & STMBREAKH)
373 flag = TTY_BREAK;
374 else if (CharNStat & STMPARITYH)
375 flag = TTY_PARITY;
376 else if (CharNStat & STMFRAMEH)
377 flag = TTY_FRAME;
378 else if (CharNStat & STMRCVROVRH)
379 flag = TTY_OVERRUN;
380 else
381 flag = TTY_NORMAL;
382 tty_insert_flip_char(tty, CharNStat & 0xff, flag);
383 ToRecv--;
387 * after we've emptied the FIFO in status mode, turn
388 * status mode back off
390 if (sGetRxCnt(cp) == 0) {
391 #ifdef ROCKET_DEBUG_RECEIVE
392 printk(KERN_INFO "Status mode off.\n");
393 #endif
394 sDisRxStatusMode(cp);
396 } else {
398 * we aren't in status mode, so read down the FIFO two
399 * characters at time by doing repeated word IO
400 * transfer.
402 space = tty_prepare_flip_string(tty, &cbuf, ToRecv);
403 if (space < ToRecv) {
404 #ifdef ROCKET_DEBUG_RECEIVE
405 printk(KERN_INFO "rp_do_receive:insufficient space ToRecv=%d space=%d\n", ToRecv, space);
406 #endif
407 if (space <= 0)
408 return;
409 ToRecv = space;
411 wRecv = ToRecv >> 1;
412 if (wRecv)
413 sInStrW(sGetTxRxDataIO(cp), (unsigned short *) cbuf, wRecv);
414 if (ToRecv & 1)
415 cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
417 /* Push the data up to the tty layer */
418 tty_flip_buffer_push(tty);
422 * Serial port transmit data function. Called from the timer polling loop as a
423 * result of a bit set in xmit_flags[], indicating data (from the tty layer) is ready
424 * to be sent out the serial port. Data is buffered in rp_table[line].xmit_buf, it is
425 * moved to the port's xmit FIFO. *info is critical data, protected by spinlocks.
427 static void rp_do_transmit(struct r_port *info)
429 int c;
430 CHANNEL_t *cp = &info->channel;
431 struct tty_struct *tty;
432 unsigned long flags;
434 #ifdef ROCKET_DEBUG_INTR
435 printk(KERN_DEBUG "%s\n", __func__);
436 #endif
437 if (!info)
438 return;
439 tty = tty_port_tty_get(&info->port);
441 if (tty == NULL) {
442 printk(KERN_WARNING "rp: WARNING %s called with tty==NULL\n", __func__);
443 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
444 return;
447 spin_lock_irqsave(&info->slock, flags);
448 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
450 /* Loop sending data to FIFO until done or FIFO full */
451 while (1) {
452 if (tty->stopped || tty->hw_stopped)
453 break;
454 c = min(info->xmit_fifo_room, info->xmit_cnt);
455 c = min(c, XMIT_BUF_SIZE - info->xmit_tail);
456 if (c <= 0 || info->xmit_fifo_room <= 0)
457 break;
458 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) (info->xmit_buf + info->xmit_tail), c / 2);
459 if (c & 1)
460 sOutB(sGetTxRxDataIO(cp), info->xmit_buf[info->xmit_tail + c - 1]);
461 info->xmit_tail += c;
462 info->xmit_tail &= XMIT_BUF_SIZE - 1;
463 info->xmit_cnt -= c;
464 info->xmit_fifo_room -= c;
465 #ifdef ROCKET_DEBUG_INTR
466 printk(KERN_INFO "tx %d chars...\n", c);
467 #endif
470 if (info->xmit_cnt == 0)
471 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
473 if (info->xmit_cnt < WAKEUP_CHARS) {
474 tty_wakeup(tty);
475 #ifdef ROCKETPORT_HAVE_POLL_WAIT
476 wake_up_interruptible(&tty->poll_wait);
477 #endif
480 spin_unlock_irqrestore(&info->slock, flags);
481 tty_kref_put(tty);
483 #ifdef ROCKET_DEBUG_INTR
484 printk(KERN_DEBUG "(%d,%d,%d,%d)...\n", info->xmit_cnt, info->xmit_head,
485 info->xmit_tail, info->xmit_fifo_room);
486 #endif
490 * Called when a serial port signals it has read data in it's RX FIFO.
491 * It checks what interrupts are pending and services them, including
492 * receiving serial data.
494 static void rp_handle_port(struct r_port *info)
496 CHANNEL_t *cp;
497 struct tty_struct *tty;
498 unsigned int IntMask, ChanStatus;
500 if (!info)
501 return;
503 if ((info->port.flags & ASYNC_INITIALIZED) == 0) {
504 printk(KERN_WARNING "rp: WARNING: rp_handle_port called with "
505 "info->flags & NOT_INIT\n");
506 return;
508 tty = tty_port_tty_get(&info->port);
509 if (!tty) {
510 printk(KERN_WARNING "rp: WARNING: rp_handle_port called with "
511 "tty==NULL\n");
512 return;
514 cp = &info->channel;
516 IntMask = sGetChanIntID(cp) & info->intmask;
517 #ifdef ROCKET_DEBUG_INTR
518 printk(KERN_INFO "rp_interrupt %02x...\n", IntMask);
519 #endif
520 ChanStatus = sGetChanStatus(cp);
521 if (IntMask & RXF_TRIG) { /* Rx FIFO trigger level */
522 rp_do_receive(info, tty, cp, ChanStatus);
524 if (IntMask & DELTA_CD) { /* CD change */
525 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_INTR) || defined(ROCKET_DEBUG_HANGUP))
526 printk(KERN_INFO "ttyR%d CD now %s...\n", info->line,
527 (ChanStatus & CD_ACT) ? "on" : "off");
528 #endif
529 if (!(ChanStatus & CD_ACT) && info->cd_status) {
530 #ifdef ROCKET_DEBUG_HANGUP
531 printk(KERN_INFO "CD drop, calling hangup.\n");
532 #endif
533 tty_hangup(tty);
535 info->cd_status = (ChanStatus & CD_ACT) ? 1 : 0;
536 wake_up_interruptible(&info->port.open_wait);
538 #ifdef ROCKET_DEBUG_INTR
539 if (IntMask & DELTA_CTS) { /* CTS change */
540 printk(KERN_INFO "CTS change...\n");
542 if (IntMask & DELTA_DSR) { /* DSR change */
543 printk(KERN_INFO "DSR change...\n");
545 #endif
546 tty_kref_put(tty);
550 * The top level polling routine. Repeats every 1/100 HZ (10ms).
552 static void rp_do_poll(unsigned long dummy)
554 CONTROLLER_t *ctlp;
555 int ctrl, aiop, ch, line;
556 unsigned int xmitmask, i;
557 unsigned int CtlMask;
558 unsigned char AiopMask;
559 Word_t bit;
561 /* Walk through all the boards (ctrl's) */
562 for (ctrl = 0; ctrl < max_board; ctrl++) {
563 if (rcktpt_io_addr[ctrl] <= 0)
564 continue;
566 /* Get a ptr to the board's control struct */
567 ctlp = sCtlNumToCtlPtr(ctrl);
569 /* Get the interrupt status from the board */
570 #ifdef CONFIG_PCI
571 if (ctlp->BusType == isPCI)
572 CtlMask = sPCIGetControllerIntStatus(ctlp);
573 else
574 #endif
575 CtlMask = sGetControllerIntStatus(ctlp);
577 /* Check if any AIOP read bits are set */
578 for (aiop = 0; CtlMask; aiop++) {
579 bit = ctlp->AiopIntrBits[aiop];
580 if (CtlMask & bit) {
581 CtlMask &= ~bit;
582 AiopMask = sGetAiopIntStatus(ctlp, aiop);
584 /* Check if any port read bits are set */
585 for (ch = 0; AiopMask; AiopMask >>= 1, ch++) {
586 if (AiopMask & 1) {
588 /* Get the line number (/dev/ttyRx number). */
589 /* Read the data from the port. */
590 line = GetLineNumber(ctrl, aiop, ch);
591 rp_handle_port(rp_table[line]);
597 xmitmask = xmit_flags[ctrl];
600 * xmit_flags contains bit-significant flags, indicating there is data
601 * to xmit on the port. Bit 0 is port 0 on this board, bit 1 is port
602 * 1, ... (32 total possible). The variable i has the aiop and ch
603 * numbers encoded in it (port 0-7 are aiop0, 8-15 are aiop1, etc).
605 if (xmitmask) {
606 for (i = 0; i < rocketModel[ctrl].numPorts; i++) {
607 if (xmitmask & (1 << i)) {
608 aiop = (i & 0x18) >> 3;
609 ch = i & 0x07;
610 line = GetLineNumber(ctrl, aiop, ch);
611 rp_do_transmit(rp_table[line]);
618 * Reset the timer so we get called at the next clock tick (10ms).
620 if (atomic_read(&rp_num_ports_open))
621 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
625 * Initializes the r_port structure for a port, as well as enabling the port on
626 * the board.
627 * Inputs: board, aiop, chan numbers
629 static void init_r_port(int board, int aiop, int chan, struct pci_dev *pci_dev)
631 unsigned rocketMode;
632 struct r_port *info;
633 int line;
634 CONTROLLER_T *ctlp;
636 /* Get the next available line number */
637 line = SetLineNumber(board, aiop, chan);
639 ctlp = sCtlNumToCtlPtr(board);
641 /* Get a r_port struct for the port, fill it in and save it globally, indexed by line number */
642 info = kzalloc(sizeof (struct r_port), GFP_KERNEL);
643 if (!info) {
644 printk(KERN_ERR "Couldn't allocate info struct for line #%d\n",
645 line);
646 return;
649 info->magic = RPORT_MAGIC;
650 info->line = line;
651 info->ctlp = ctlp;
652 info->board = board;
653 info->aiop = aiop;
654 info->chan = chan;
655 tty_port_init(&info->port);
656 info->port.ops = &rocket_port_ops;
657 init_completion(&info->close_wait);
658 info->flags &= ~ROCKET_MODE_MASK;
659 switch (pc104[board][line]) {
660 case 422:
661 info->flags |= ROCKET_MODE_RS422;
662 break;
663 case 485:
664 info->flags |= ROCKET_MODE_RS485;
665 break;
666 case 232:
667 default:
668 info->flags |= ROCKET_MODE_RS232;
669 break;
672 info->intmask = RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR;
673 if (sInitChan(ctlp, &info->channel, aiop, chan) == 0) {
674 printk(KERN_ERR "RocketPort sInitChan(%d, %d, %d) failed!\n",
675 board, aiop, chan);
676 kfree(info);
677 return;
680 rocketMode = info->flags & ROCKET_MODE_MASK;
682 if ((info->flags & ROCKET_RTS_TOGGLE) || (rocketMode == ROCKET_MODE_RS485))
683 sEnRTSToggle(&info->channel);
684 else
685 sDisRTSToggle(&info->channel);
687 if (ctlp->boardType == ROCKET_TYPE_PC104) {
688 switch (rocketMode) {
689 case ROCKET_MODE_RS485:
690 sSetInterfaceMode(&info->channel, InterfaceModeRS485);
691 break;
692 case ROCKET_MODE_RS422:
693 sSetInterfaceMode(&info->channel, InterfaceModeRS422);
694 break;
695 case ROCKET_MODE_RS232:
696 default:
697 if (info->flags & ROCKET_RTS_TOGGLE)
698 sSetInterfaceMode(&info->channel, InterfaceModeRS232T);
699 else
700 sSetInterfaceMode(&info->channel, InterfaceModeRS232);
701 break;
704 spin_lock_init(&info->slock);
705 mutex_init(&info->write_mtx);
706 rp_table[line] = info;
707 tty_register_device(rocket_driver, line, pci_dev ? &pci_dev->dev :
708 NULL);
712 * Configures a rocketport port according to its termio settings. Called from
713 * user mode into the driver (exception handler). *info CD manipulation is spinlock protected.
715 static void configure_r_port(struct tty_struct *tty, struct r_port *info,
716 struct ktermios *old_termios)
718 unsigned cflag;
719 unsigned long flags;
720 unsigned rocketMode;
721 int bits, baud, divisor;
722 CHANNEL_t *cp;
723 struct ktermios *t = tty->termios;
725 cp = &info->channel;
726 cflag = t->c_cflag;
728 /* Byte size and parity */
729 if ((cflag & CSIZE) == CS8) {
730 sSetData8(cp);
731 bits = 10;
732 } else {
733 sSetData7(cp);
734 bits = 9;
736 if (cflag & CSTOPB) {
737 sSetStop2(cp);
738 bits++;
739 } else {
740 sSetStop1(cp);
743 if (cflag & PARENB) {
744 sEnParity(cp);
745 bits++;
746 if (cflag & PARODD) {
747 sSetOddParity(cp);
748 } else {
749 sSetEvenParity(cp);
751 } else {
752 sDisParity(cp);
755 /* baud rate */
756 baud = tty_get_baud_rate(tty);
757 if (!baud)
758 baud = 9600;
759 divisor = ((rp_baud_base[info->board] + (baud >> 1)) / baud) - 1;
760 if ((divisor >= 8192 || divisor < 0) && old_termios) {
761 baud = tty_termios_baud_rate(old_termios);
762 if (!baud)
763 baud = 9600;
764 divisor = (rp_baud_base[info->board] / baud) - 1;
766 if (divisor >= 8192 || divisor < 0) {
767 baud = 9600;
768 divisor = (rp_baud_base[info->board] / baud) - 1;
770 info->cps = baud / bits;
771 sSetBaud(cp, divisor);
773 /* FIXME: Should really back compute a baud rate from the divisor */
774 tty_encode_baud_rate(tty, baud, baud);
776 if (cflag & CRTSCTS) {
777 info->intmask |= DELTA_CTS;
778 sEnCTSFlowCtl(cp);
779 } else {
780 info->intmask &= ~DELTA_CTS;
781 sDisCTSFlowCtl(cp);
783 if (cflag & CLOCAL) {
784 info->intmask &= ~DELTA_CD;
785 } else {
786 spin_lock_irqsave(&info->slock, flags);
787 if (sGetChanStatus(cp) & CD_ACT)
788 info->cd_status = 1;
789 else
790 info->cd_status = 0;
791 info->intmask |= DELTA_CD;
792 spin_unlock_irqrestore(&info->slock, flags);
796 * Handle software flow control in the board
798 #ifdef ROCKET_SOFT_FLOW
799 if (I_IXON(tty)) {
800 sEnTxSoftFlowCtl(cp);
801 if (I_IXANY(tty)) {
802 sEnIXANY(cp);
803 } else {
804 sDisIXANY(cp);
806 sSetTxXONChar(cp, START_CHAR(tty));
807 sSetTxXOFFChar(cp, STOP_CHAR(tty));
808 } else {
809 sDisTxSoftFlowCtl(cp);
810 sDisIXANY(cp);
811 sClrTxXOFF(cp);
813 #endif
816 * Set up ignore/read mask words
818 info->read_status_mask = STMRCVROVRH | 0xFF;
819 if (I_INPCK(tty))
820 info->read_status_mask |= STMFRAMEH | STMPARITYH;
821 if (I_BRKINT(tty) || I_PARMRK(tty))
822 info->read_status_mask |= STMBREAKH;
825 * Characters to ignore
827 info->ignore_status_mask = 0;
828 if (I_IGNPAR(tty))
829 info->ignore_status_mask |= STMFRAMEH | STMPARITYH;
830 if (I_IGNBRK(tty)) {
831 info->ignore_status_mask |= STMBREAKH;
833 * If we're ignoring parity and break indicators,
834 * ignore overruns too. (For real raw support).
836 if (I_IGNPAR(tty))
837 info->ignore_status_mask |= STMRCVROVRH;
840 rocketMode = info->flags & ROCKET_MODE_MASK;
842 if ((info->flags & ROCKET_RTS_TOGGLE)
843 || (rocketMode == ROCKET_MODE_RS485))
844 sEnRTSToggle(cp);
845 else
846 sDisRTSToggle(cp);
848 sSetRTS(&info->channel);
850 if (cp->CtlP->boardType == ROCKET_TYPE_PC104) {
851 switch (rocketMode) {
852 case ROCKET_MODE_RS485:
853 sSetInterfaceMode(cp, InterfaceModeRS485);
854 break;
855 case ROCKET_MODE_RS422:
856 sSetInterfaceMode(cp, InterfaceModeRS422);
857 break;
858 case ROCKET_MODE_RS232:
859 default:
860 if (info->flags & ROCKET_RTS_TOGGLE)
861 sSetInterfaceMode(cp, InterfaceModeRS232T);
862 else
863 sSetInterfaceMode(cp, InterfaceModeRS232);
864 break;
869 static int carrier_raised(struct tty_port *port)
871 struct r_port *info = container_of(port, struct r_port, port);
872 return (sGetChanStatusLo(&info->channel) & CD_ACT) ? 1 : 0;
875 static void raise_dtr_rts(struct tty_port *port)
877 struct r_port *info = container_of(port, struct r_port, port);
878 sSetDTR(&info->channel);
879 sSetRTS(&info->channel);
883 * Exception handler that opens a serial port. Creates xmit_buf storage, fills in
884 * port's r_port struct. Initializes the port hardware.
886 static int rp_open(struct tty_struct *tty, struct file *filp)
888 struct r_port *info;
889 struct tty_port *port;
890 int line = 0, retval;
891 CHANNEL_t *cp;
892 unsigned long page;
894 line = tty->index;
895 if (line < 0 || line >= MAX_RP_PORTS || ((info = rp_table[line]) == NULL))
896 return -ENXIO;
897 port = &info->port;
899 page = __get_free_page(GFP_KERNEL);
900 if (!page)
901 return -ENOMEM;
903 if (port->flags & ASYNC_CLOSING) {
904 retval = wait_for_completion_interruptible(&info->close_wait);
905 free_page(page);
906 if (retval)
907 return retval;
908 return ((port->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
912 * We must not sleep from here until the port is marked fully in use.
914 if (info->xmit_buf)
915 free_page(page);
916 else
917 info->xmit_buf = (unsigned char *) page;
919 tty->driver_data = info;
920 tty_port_tty_set(port, tty);
922 if (port->count++ == 0) {
923 atomic_inc(&rp_num_ports_open);
925 #ifdef ROCKET_DEBUG_OPEN
926 printk(KERN_INFO "rocket mod++ = %d...\n",
927 atomic_read(&rp_num_ports_open));
928 #endif
930 #ifdef ROCKET_DEBUG_OPEN
931 printk(KERN_INFO "rp_open ttyR%d, count=%d\n", info->line, info->port.count);
932 #endif
935 * Info->count is now 1; so it's safe to sleep now.
937 if (!test_bit(ASYNC_INITIALIZED, &port->flags)) {
938 cp = &info->channel;
939 sSetRxTrigger(cp, TRIG_1);
940 if (sGetChanStatus(cp) & CD_ACT)
941 info->cd_status = 1;
942 else
943 info->cd_status = 0;
944 sDisRxStatusMode(cp);
945 sFlushRxFIFO(cp);
946 sFlushTxFIFO(cp);
948 sEnInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
949 sSetRxTrigger(cp, TRIG_1);
951 sGetChanStatus(cp);
952 sDisRxStatusMode(cp);
953 sClrTxXOFF(cp);
955 sDisCTSFlowCtl(cp);
956 sDisTxSoftFlowCtl(cp);
958 sEnRxFIFO(cp);
959 sEnTransmit(cp);
961 set_bit(ASYNC_INITIALIZED, &info->port.flags);
964 * Set up the tty->alt_speed kludge
966 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
967 tty->alt_speed = 57600;
968 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
969 tty->alt_speed = 115200;
970 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
971 tty->alt_speed = 230400;
972 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
973 tty->alt_speed = 460800;
975 configure_r_port(tty, info, NULL);
976 if (tty->termios->c_cflag & CBAUD) {
977 sSetDTR(cp);
978 sSetRTS(cp);
981 /* Starts (or resets) the maint polling loop */
982 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
984 retval = tty_port_block_til_ready(port, tty, filp);
985 if (retval) {
986 #ifdef ROCKET_DEBUG_OPEN
987 printk(KERN_INFO "rp_open returning after block_til_ready with %d\n", retval);
988 #endif
989 return retval;
991 return 0;
995 * Exception handler that closes a serial port. info->port.count is considered critical.
997 static void rp_close(struct tty_struct *tty, struct file *filp)
999 struct r_port *info = tty->driver_data;
1000 struct tty_port *port = &info->port;
1001 int timeout;
1002 CHANNEL_t *cp;
1004 if (rocket_paranoia_check(info, "rp_close"))
1005 return;
1007 #ifdef ROCKET_DEBUG_OPEN
1008 printk(KERN_INFO "rp_close ttyR%d, count = %d\n", info->line, info->port.count);
1009 #endif
1011 if (tty_port_close_start(port, tty, filp) == 0)
1012 return;
1014 cp = &info->channel;
1016 * Before we drop DTR, make sure the UART transmitter
1017 * has completely drained; this is especially
1018 * important if there is a transmit FIFO!
1020 timeout = (sGetTxCnt(cp) + 1) * HZ / info->cps;
1021 if (timeout == 0)
1022 timeout = 1;
1023 rp_wait_until_sent(tty, timeout);
1024 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1026 sDisTransmit(cp);
1027 sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1028 sDisCTSFlowCtl(cp);
1029 sDisTxSoftFlowCtl(cp);
1030 sClrTxXOFF(cp);
1031 sFlushRxFIFO(cp);
1032 sFlushTxFIFO(cp);
1033 sClrRTS(cp);
1034 if (C_HUPCL(tty))
1035 sClrDTR(cp);
1037 rp_flush_buffer(tty);
1039 tty_ldisc_flush(tty);
1041 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1043 /* We can't yet use tty_port_close_end as the buffer handling in this
1044 driver is a bit different to the usual */
1046 if (port->blocked_open) {
1047 if (port->close_delay) {
1048 msleep_interruptible(jiffies_to_msecs(port->close_delay));
1050 wake_up_interruptible(&port->open_wait);
1051 } else {
1052 if (info->xmit_buf) {
1053 free_page((unsigned long) info->xmit_buf);
1054 info->xmit_buf = NULL;
1057 info->port.flags &= ~(ASYNC_INITIALIZED | ASYNC_CLOSING | ASYNC_NORMAL_ACTIVE);
1058 tty->closing = 0;
1059 tty_port_tty_set(port, NULL);
1060 wake_up_interruptible(&port->close_wait);
1061 complete_all(&info->close_wait);
1062 atomic_dec(&rp_num_ports_open);
1064 #ifdef ROCKET_DEBUG_OPEN
1065 printk(KERN_INFO "rocket mod-- = %d...\n",
1066 atomic_read(&rp_num_ports_open));
1067 printk(KERN_INFO "rp_close ttyR%d complete shutdown\n", info->line);
1068 #endif
1072 static void rp_set_termios(struct tty_struct *tty,
1073 struct ktermios *old_termios)
1075 struct r_port *info = tty->driver_data;
1076 CHANNEL_t *cp;
1077 unsigned cflag;
1079 if (rocket_paranoia_check(info, "rp_set_termios"))
1080 return;
1082 cflag = tty->termios->c_cflag;
1085 * This driver doesn't support CS5 or CS6
1087 if (((cflag & CSIZE) == CS5) || ((cflag & CSIZE) == CS6))
1088 tty->termios->c_cflag =
1089 ((cflag & ~CSIZE) | (old_termios->c_cflag & CSIZE));
1090 /* Or CMSPAR */
1091 tty->termios->c_cflag &= ~CMSPAR;
1093 configure_r_port(tty, info, old_termios);
1095 cp = &info->channel;
1097 /* Handle transition to B0 status */
1098 if ((old_termios->c_cflag & CBAUD) && !(tty->termios->c_cflag & CBAUD)) {
1099 sClrDTR(cp);
1100 sClrRTS(cp);
1103 /* Handle transition away from B0 status */
1104 if (!(old_termios->c_cflag & CBAUD) && (tty->termios->c_cflag & CBAUD)) {
1105 if (!tty->hw_stopped || !(tty->termios->c_cflag & CRTSCTS))
1106 sSetRTS(cp);
1107 sSetDTR(cp);
1110 if ((old_termios->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) {
1111 tty->hw_stopped = 0;
1112 rp_start(tty);
1116 static int rp_break(struct tty_struct *tty, int break_state)
1118 struct r_port *info = tty->driver_data;
1119 unsigned long flags;
1121 if (rocket_paranoia_check(info, "rp_break"))
1122 return -EINVAL;
1124 spin_lock_irqsave(&info->slock, flags);
1125 if (break_state == -1)
1126 sSendBreak(&info->channel);
1127 else
1128 sClrBreak(&info->channel);
1129 spin_unlock_irqrestore(&info->slock, flags);
1130 return 0;
1134 * sGetChanRI used to be a macro in rocket_int.h. When the functionality for
1135 * the UPCI boards was added, it was decided to make this a function because
1136 * the macro was getting too complicated. All cases except the first one
1137 * (UPCIRingInd) are taken directly from the original macro.
1139 static int sGetChanRI(CHANNEL_T * ChP)
1141 CONTROLLER_t *CtlP = ChP->CtlP;
1142 int ChanNum = ChP->ChanNum;
1143 int RingInd = 0;
1145 if (CtlP->UPCIRingInd)
1146 RingInd = !(sInB(CtlP->UPCIRingInd) & sBitMapSetTbl[ChanNum]);
1147 else if (CtlP->AltChanRingIndicator)
1148 RingInd = sInB((ByteIO_t) (ChP->ChanStat + 8)) & DSR_ACT;
1149 else if (CtlP->boardType == ROCKET_TYPE_PC104)
1150 RingInd = !(sInB(CtlP->AiopIO[3]) & sBitMapSetTbl[ChanNum]);
1152 return RingInd;
1155 /********************************************************************************************/
1156 /* Here are the routines used by rp_ioctl. These are all called from exception handlers. */
1159 * Returns the state of the serial modem control lines. These next 2 functions
1160 * are the way kernel versions > 2.5 handle modem control lines rather than IOCTLs.
1162 static int rp_tiocmget(struct tty_struct *tty, struct file *file)
1164 struct r_port *info = tty->driver_data;
1165 unsigned int control, result, ChanStatus;
1167 ChanStatus = sGetChanStatusLo(&info->channel);
1168 control = info->channel.TxControl[3];
1169 result = ((control & SET_RTS) ? TIOCM_RTS : 0) |
1170 ((control & SET_DTR) ? TIOCM_DTR : 0) |
1171 ((ChanStatus & CD_ACT) ? TIOCM_CAR : 0) |
1172 (sGetChanRI(&info->channel) ? TIOCM_RNG : 0) |
1173 ((ChanStatus & DSR_ACT) ? TIOCM_DSR : 0) |
1174 ((ChanStatus & CTS_ACT) ? TIOCM_CTS : 0);
1176 return result;
1180 * Sets the modem control lines
1182 static int rp_tiocmset(struct tty_struct *tty, struct file *file,
1183 unsigned int set, unsigned int clear)
1185 struct r_port *info = tty->driver_data;
1187 if (set & TIOCM_RTS)
1188 info->channel.TxControl[3] |= SET_RTS;
1189 if (set & TIOCM_DTR)
1190 info->channel.TxControl[3] |= SET_DTR;
1191 if (clear & TIOCM_RTS)
1192 info->channel.TxControl[3] &= ~SET_RTS;
1193 if (clear & TIOCM_DTR)
1194 info->channel.TxControl[3] &= ~SET_DTR;
1196 out32(info->channel.IndexAddr, info->channel.TxControl);
1197 return 0;
1200 static int get_config(struct r_port *info, struct rocket_config __user *retinfo)
1202 struct rocket_config tmp;
1204 if (!retinfo)
1205 return -EFAULT;
1206 memset(&tmp, 0, sizeof (tmp));
1207 tmp.line = info->line;
1208 tmp.flags = info->flags;
1209 tmp.close_delay = info->port.close_delay;
1210 tmp.closing_wait = info->port.closing_wait;
1211 tmp.port = rcktpt_io_addr[(info->line >> 5) & 3];
1213 if (copy_to_user(retinfo, &tmp, sizeof (*retinfo)))
1214 return -EFAULT;
1215 return 0;
1218 static int set_config(struct tty_struct *tty, struct r_port *info,
1219 struct rocket_config __user *new_info)
1221 struct rocket_config new_serial;
1223 if (copy_from_user(&new_serial, new_info, sizeof (new_serial)))
1224 return -EFAULT;
1226 if (!capable(CAP_SYS_ADMIN))
1228 if ((new_serial.flags & ~ROCKET_USR_MASK) != (info->flags & ~ROCKET_USR_MASK))
1229 return -EPERM;
1230 info->flags = ((info->flags & ~ROCKET_USR_MASK) | (new_serial.flags & ROCKET_USR_MASK));
1231 configure_r_port(tty, info, NULL);
1232 return 0;
1235 info->flags = ((info->flags & ~ROCKET_FLAGS) | (new_serial.flags & ROCKET_FLAGS));
1236 info->port.close_delay = new_serial.close_delay;
1237 info->port.closing_wait = new_serial.closing_wait;
1239 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1240 tty->alt_speed = 57600;
1241 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1242 tty->alt_speed = 115200;
1243 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1244 tty->alt_speed = 230400;
1245 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1246 tty->alt_speed = 460800;
1248 configure_r_port(tty, info, NULL);
1249 return 0;
1253 * This function fills in a rocket_ports struct with information
1254 * about what boards/ports are in the system. This info is passed
1255 * to user space. See setrocket.c where the info is used to create
1256 * the /dev/ttyRx ports.
1258 static int get_ports(struct r_port *info, struct rocket_ports __user *retports)
1260 struct rocket_ports tmp;
1261 int board;
1263 if (!retports)
1264 return -EFAULT;
1265 memset(&tmp, 0, sizeof (tmp));
1266 tmp.tty_major = rocket_driver->major;
1268 for (board = 0; board < 4; board++) {
1269 tmp.rocketModel[board].model = rocketModel[board].model;
1270 strcpy(tmp.rocketModel[board].modelString, rocketModel[board].modelString);
1271 tmp.rocketModel[board].numPorts = rocketModel[board].numPorts;
1272 tmp.rocketModel[board].loadrm2 = rocketModel[board].loadrm2;
1273 tmp.rocketModel[board].startingPortNumber = rocketModel[board].startingPortNumber;
1275 if (copy_to_user(retports, &tmp, sizeof (*retports)))
1276 return -EFAULT;
1277 return 0;
1280 static int reset_rm2(struct r_port *info, void __user *arg)
1282 int reset;
1284 if (!capable(CAP_SYS_ADMIN))
1285 return -EPERM;
1287 if (copy_from_user(&reset, arg, sizeof (int)))
1288 return -EFAULT;
1289 if (reset)
1290 reset = 1;
1292 if (rcktpt_type[info->board] != ROCKET_TYPE_MODEMII &&
1293 rcktpt_type[info->board] != ROCKET_TYPE_MODEMIII)
1294 return -EINVAL;
1296 if (info->ctlp->BusType == isISA)
1297 sModemReset(info->ctlp, info->chan, reset);
1298 else
1299 sPCIModemReset(info->ctlp, info->chan, reset);
1301 return 0;
1304 static int get_version(struct r_port *info, struct rocket_version __user *retvers)
1306 if (copy_to_user(retvers, &driver_version, sizeof (*retvers)))
1307 return -EFAULT;
1308 return 0;
1311 /* IOCTL call handler into the driver */
1312 static int rp_ioctl(struct tty_struct *tty, struct file *file,
1313 unsigned int cmd, unsigned long arg)
1315 struct r_port *info = tty->driver_data;
1316 void __user *argp = (void __user *)arg;
1317 int ret = 0;
1319 if (cmd != RCKP_GET_PORTS && rocket_paranoia_check(info, "rp_ioctl"))
1320 return -ENXIO;
1322 lock_kernel();
1324 switch (cmd) {
1325 case RCKP_GET_STRUCT:
1326 if (copy_to_user(argp, info, sizeof (struct r_port)))
1327 ret = -EFAULT;
1328 break;
1329 case RCKP_GET_CONFIG:
1330 ret = get_config(info, argp);
1331 break;
1332 case RCKP_SET_CONFIG:
1333 ret = set_config(tty, info, argp);
1334 break;
1335 case RCKP_GET_PORTS:
1336 ret = get_ports(info, argp);
1337 break;
1338 case RCKP_RESET_RM2:
1339 ret = reset_rm2(info, argp);
1340 break;
1341 case RCKP_GET_VERSION:
1342 ret = get_version(info, argp);
1343 break;
1344 default:
1345 ret = -ENOIOCTLCMD;
1347 unlock_kernel();
1348 return ret;
1351 static void rp_send_xchar(struct tty_struct *tty, char ch)
1353 struct r_port *info = tty->driver_data;
1354 CHANNEL_t *cp;
1356 if (rocket_paranoia_check(info, "rp_send_xchar"))
1357 return;
1359 cp = &info->channel;
1360 if (sGetTxCnt(cp))
1361 sWriteTxPrioByte(cp, ch);
1362 else
1363 sWriteTxByte(sGetTxRxDataIO(cp), ch);
1366 static void rp_throttle(struct tty_struct *tty)
1368 struct r_port *info = tty->driver_data;
1369 CHANNEL_t *cp;
1371 #ifdef ROCKET_DEBUG_THROTTLE
1372 printk(KERN_INFO "throttle %s: %d....\n", tty->name,
1373 tty->ldisc.chars_in_buffer(tty));
1374 #endif
1376 if (rocket_paranoia_check(info, "rp_throttle"))
1377 return;
1379 cp = &info->channel;
1380 if (I_IXOFF(tty))
1381 rp_send_xchar(tty, STOP_CHAR(tty));
1383 sClrRTS(&info->channel);
1386 static void rp_unthrottle(struct tty_struct *tty)
1388 struct r_port *info = tty->driver_data;
1389 CHANNEL_t *cp;
1390 #ifdef ROCKET_DEBUG_THROTTLE
1391 printk(KERN_INFO "unthrottle %s: %d....\n", tty->name,
1392 tty->ldisc.chars_in_buffer(tty));
1393 #endif
1395 if (rocket_paranoia_check(info, "rp_throttle"))
1396 return;
1398 cp = &info->channel;
1399 if (I_IXOFF(tty))
1400 rp_send_xchar(tty, START_CHAR(tty));
1402 sSetRTS(&info->channel);
1406 * ------------------------------------------------------------
1407 * rp_stop() and rp_start()
1409 * This routines are called before setting or resetting tty->stopped.
1410 * They enable or disable transmitter interrupts, as necessary.
1411 * ------------------------------------------------------------
1413 static void rp_stop(struct tty_struct *tty)
1415 struct r_port *info = tty->driver_data;
1417 #ifdef ROCKET_DEBUG_FLOW
1418 printk(KERN_INFO "stop %s: %d %d....\n", tty->name,
1419 info->xmit_cnt, info->xmit_fifo_room);
1420 #endif
1422 if (rocket_paranoia_check(info, "rp_stop"))
1423 return;
1425 if (sGetTxCnt(&info->channel))
1426 sDisTransmit(&info->channel);
1429 static void rp_start(struct tty_struct *tty)
1431 struct r_port *info = tty->driver_data;
1433 #ifdef ROCKET_DEBUG_FLOW
1434 printk(KERN_INFO "start %s: %d %d....\n", tty->name,
1435 info->xmit_cnt, info->xmit_fifo_room);
1436 #endif
1438 if (rocket_paranoia_check(info, "rp_stop"))
1439 return;
1441 sEnTransmit(&info->channel);
1442 set_bit((info->aiop * 8) + info->chan,
1443 (void *) &xmit_flags[info->board]);
1447 * rp_wait_until_sent() --- wait until the transmitter is empty
1449 static void rp_wait_until_sent(struct tty_struct *tty, int timeout)
1451 struct r_port *info = tty->driver_data;
1452 CHANNEL_t *cp;
1453 unsigned long orig_jiffies;
1454 int check_time, exit_time;
1455 int txcnt;
1457 if (rocket_paranoia_check(info, "rp_wait_until_sent"))
1458 return;
1460 cp = &info->channel;
1462 orig_jiffies = jiffies;
1463 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1464 printk(KERN_INFO "In RP_wait_until_sent(%d) (jiff=%lu)...\n", timeout,
1465 jiffies);
1466 printk(KERN_INFO "cps=%d...\n", info->cps);
1467 #endif
1468 lock_kernel();
1469 while (1) {
1470 txcnt = sGetTxCnt(cp);
1471 if (!txcnt) {
1472 if (sGetChanStatusLo(cp) & TXSHRMT)
1473 break;
1474 check_time = (HZ / info->cps) / 5;
1475 } else {
1476 check_time = HZ * txcnt / info->cps;
1478 if (timeout) {
1479 exit_time = orig_jiffies + timeout - jiffies;
1480 if (exit_time <= 0)
1481 break;
1482 if (exit_time < check_time)
1483 check_time = exit_time;
1485 if (check_time == 0)
1486 check_time = 1;
1487 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1488 printk(KERN_INFO "txcnt = %d (jiff=%lu,check=%d)...\n", txcnt,
1489 jiffies, check_time);
1490 #endif
1491 msleep_interruptible(jiffies_to_msecs(check_time));
1492 if (signal_pending(current))
1493 break;
1495 __set_current_state(TASK_RUNNING);
1496 unlock_kernel();
1497 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1498 printk(KERN_INFO "txcnt = %d (jiff=%lu)...done\n", txcnt, jiffies);
1499 #endif
1503 * rp_hangup() --- called by tty_hangup() when a hangup is signaled.
1505 static void rp_hangup(struct tty_struct *tty)
1507 CHANNEL_t *cp;
1508 struct r_port *info = tty->driver_data;
1510 if (rocket_paranoia_check(info, "rp_hangup"))
1511 return;
1513 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_HANGUP))
1514 printk(KERN_INFO "rp_hangup of ttyR%d...\n", info->line);
1515 #endif
1516 rp_flush_buffer(tty);
1517 if (info->port.flags & ASYNC_CLOSING)
1518 return;
1519 if (info->port.count)
1520 atomic_dec(&rp_num_ports_open);
1521 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1523 tty_port_hangup(&info->port);
1525 cp = &info->channel;
1526 sDisRxFIFO(cp);
1527 sDisTransmit(cp);
1528 sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1529 sDisCTSFlowCtl(cp);
1530 sDisTxSoftFlowCtl(cp);
1531 sClrTxXOFF(cp);
1532 info->port.flags &= ~ASYNC_INITIALIZED;
1534 wake_up_interruptible(&info->port.open_wait);
1538 * Exception handler - write char routine. The RocketPort driver uses a
1539 * double-buffering strategy, with the twist that if the in-memory CPU
1540 * buffer is empty, and there's space in the transmit FIFO, the
1541 * writing routines will write directly to transmit FIFO.
1542 * Write buffer and counters protected by spinlocks
1544 static int rp_put_char(struct tty_struct *tty, unsigned char ch)
1546 struct r_port *info = tty->driver_data;
1547 CHANNEL_t *cp;
1548 unsigned long flags;
1550 if (rocket_paranoia_check(info, "rp_put_char"))
1551 return 0;
1554 * Grab the port write mutex, locking out other processes that try to
1555 * write to this port
1557 mutex_lock(&info->write_mtx);
1559 #ifdef ROCKET_DEBUG_WRITE
1560 printk(KERN_INFO "rp_put_char %c...\n", ch);
1561 #endif
1563 spin_lock_irqsave(&info->slock, flags);
1564 cp = &info->channel;
1566 if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room == 0)
1567 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1569 if (tty->stopped || tty->hw_stopped || info->xmit_fifo_room == 0 || info->xmit_cnt != 0) {
1570 info->xmit_buf[info->xmit_head++] = ch;
1571 info->xmit_head &= XMIT_BUF_SIZE - 1;
1572 info->xmit_cnt++;
1573 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1574 } else {
1575 sOutB(sGetTxRxDataIO(cp), ch);
1576 info->xmit_fifo_room--;
1578 spin_unlock_irqrestore(&info->slock, flags);
1579 mutex_unlock(&info->write_mtx);
1580 return 1;
1584 * Exception handler - write routine, called when user app writes to the device.
1585 * A per port write mutex is used to protect from another process writing to
1586 * this port at the same time. This other process could be running on the other CPU
1587 * or get control of the CPU if the copy_from_user() blocks due to a page fault (swapped out).
1588 * Spinlocks protect the info xmit members.
1590 static int rp_write(struct tty_struct *tty,
1591 const unsigned char *buf, int count)
1593 struct r_port *info = tty->driver_data;
1594 CHANNEL_t *cp;
1595 const unsigned char *b;
1596 int c, retval = 0;
1597 unsigned long flags;
1599 if (count <= 0 || rocket_paranoia_check(info, "rp_write"))
1600 return 0;
1602 if (mutex_lock_interruptible(&info->write_mtx))
1603 return -ERESTARTSYS;
1605 #ifdef ROCKET_DEBUG_WRITE
1606 printk(KERN_INFO "rp_write %d chars...\n", count);
1607 #endif
1608 cp = &info->channel;
1610 if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room < count)
1611 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1614 * If the write queue for the port is empty, and there is FIFO space, stuff bytes
1615 * into FIFO. Use the write queue for temp storage.
1617 if (!tty->stopped && !tty->hw_stopped && info->xmit_cnt == 0 && info->xmit_fifo_room > 0) {
1618 c = min(count, info->xmit_fifo_room);
1619 b = buf;
1621 /* Push data into FIFO, 2 bytes at a time */
1622 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) b, c / 2);
1624 /* If there is a byte remaining, write it */
1625 if (c & 1)
1626 sOutB(sGetTxRxDataIO(cp), b[c - 1]);
1628 retval += c;
1629 buf += c;
1630 count -= c;
1632 spin_lock_irqsave(&info->slock, flags);
1633 info->xmit_fifo_room -= c;
1634 spin_unlock_irqrestore(&info->slock, flags);
1637 /* If count is zero, we wrote it all and are done */
1638 if (!count)
1639 goto end;
1641 /* Write remaining data into the port's xmit_buf */
1642 while (1) {
1643 /* Hung up ? */
1644 if (!test_bit(ASYNC_NORMAL_ACTIVE, &info->port.flags))
1645 goto end;
1646 c = min(count, XMIT_BUF_SIZE - info->xmit_cnt - 1);
1647 c = min(c, XMIT_BUF_SIZE - info->xmit_head);
1648 if (c <= 0)
1649 break;
1651 b = buf;
1652 memcpy(info->xmit_buf + info->xmit_head, b, c);
1654 spin_lock_irqsave(&info->slock, flags);
1655 info->xmit_head =
1656 (info->xmit_head + c) & (XMIT_BUF_SIZE - 1);
1657 info->xmit_cnt += c;
1658 spin_unlock_irqrestore(&info->slock, flags);
1660 buf += c;
1661 count -= c;
1662 retval += c;
1665 if ((retval > 0) && !tty->stopped && !tty->hw_stopped)
1666 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1668 end:
1669 if (info->xmit_cnt < WAKEUP_CHARS) {
1670 tty_wakeup(tty);
1671 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1672 wake_up_interruptible(&tty->poll_wait);
1673 #endif
1675 mutex_unlock(&info->write_mtx);
1676 return retval;
1680 * Return the number of characters that can be sent. We estimate
1681 * only using the in-memory transmit buffer only, and ignore the
1682 * potential space in the transmit FIFO.
1684 static int rp_write_room(struct tty_struct *tty)
1686 struct r_port *info = tty->driver_data;
1687 int ret;
1689 if (rocket_paranoia_check(info, "rp_write_room"))
1690 return 0;
1692 ret = XMIT_BUF_SIZE - info->xmit_cnt - 1;
1693 if (ret < 0)
1694 ret = 0;
1695 #ifdef ROCKET_DEBUG_WRITE
1696 printk(KERN_INFO "rp_write_room returns %d...\n", ret);
1697 #endif
1698 return ret;
1702 * Return the number of characters in the buffer. Again, this only
1703 * counts those characters in the in-memory transmit buffer.
1705 static int rp_chars_in_buffer(struct tty_struct *tty)
1707 struct r_port *info = tty->driver_data;
1708 CHANNEL_t *cp;
1710 if (rocket_paranoia_check(info, "rp_chars_in_buffer"))
1711 return 0;
1713 cp = &info->channel;
1715 #ifdef ROCKET_DEBUG_WRITE
1716 printk(KERN_INFO "rp_chars_in_buffer returns %d...\n", info->xmit_cnt);
1717 #endif
1718 return info->xmit_cnt;
1722 * Flushes the TX fifo for a port, deletes data in the xmit_buf stored in the
1723 * r_port struct for the port. Note that spinlock are used to protect info members,
1724 * do not call this function if the spinlock is already held.
1726 static void rp_flush_buffer(struct tty_struct *tty)
1728 struct r_port *info = tty->driver_data;
1729 CHANNEL_t *cp;
1730 unsigned long flags;
1732 if (rocket_paranoia_check(info, "rp_flush_buffer"))
1733 return;
1735 spin_lock_irqsave(&info->slock, flags);
1736 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1737 spin_unlock_irqrestore(&info->slock, flags);
1739 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1740 wake_up_interruptible(&tty->poll_wait);
1741 #endif
1742 tty_wakeup(tty);
1744 cp = &info->channel;
1745 sFlushTxFIFO(cp);
1748 #ifdef CONFIG_PCI
1750 static struct pci_device_id __devinitdata rocket_pci_ids[] = {
1751 { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_ANY_ID) },
1754 MODULE_DEVICE_TABLE(pci, rocket_pci_ids);
1757 * Called when a PCI card is found. Retrieves and stores model information,
1758 * init's aiopic and serial port hardware.
1759 * Inputs: i is the board number (0-n)
1761 static __init int register_PCI(int i, struct pci_dev *dev)
1763 int num_aiops, aiop, max_num_aiops, num_chan, chan;
1764 unsigned int aiopio[MAX_AIOPS_PER_BOARD];
1765 char *str, *board_type;
1766 CONTROLLER_t *ctlp;
1768 int fast_clock = 0;
1769 int altChanRingIndicator = 0;
1770 int ports_per_aiop = 8;
1771 WordIO_t ConfigIO = 0;
1772 ByteIO_t UPCIRingInd = 0;
1774 if (!dev || pci_enable_device(dev))
1775 return 0;
1777 rcktpt_io_addr[i] = pci_resource_start(dev, 0);
1779 rcktpt_type[i] = ROCKET_TYPE_NORMAL;
1780 rocketModel[i].loadrm2 = 0;
1781 rocketModel[i].startingPortNumber = nextLineNumber;
1783 /* Depending on the model, set up some config variables */
1784 switch (dev->device) {
1785 case PCI_DEVICE_ID_RP4QUAD:
1786 str = "Quadcable";
1787 max_num_aiops = 1;
1788 ports_per_aiop = 4;
1789 rocketModel[i].model = MODEL_RP4QUAD;
1790 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/quad cable");
1791 rocketModel[i].numPorts = 4;
1792 break;
1793 case PCI_DEVICE_ID_RP8OCTA:
1794 str = "Octacable";
1795 max_num_aiops = 1;
1796 rocketModel[i].model = MODEL_RP8OCTA;
1797 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/octa cable");
1798 rocketModel[i].numPorts = 8;
1799 break;
1800 case PCI_DEVICE_ID_URP8OCTA:
1801 str = "Octacable";
1802 max_num_aiops = 1;
1803 rocketModel[i].model = MODEL_UPCI_RP8OCTA;
1804 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/octa cable");
1805 rocketModel[i].numPorts = 8;
1806 break;
1807 case PCI_DEVICE_ID_RP8INTF:
1808 str = "8";
1809 max_num_aiops = 1;
1810 rocketModel[i].model = MODEL_RP8INTF;
1811 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/external I/F");
1812 rocketModel[i].numPorts = 8;
1813 break;
1814 case PCI_DEVICE_ID_URP8INTF:
1815 str = "8";
1816 max_num_aiops = 1;
1817 rocketModel[i].model = MODEL_UPCI_RP8INTF;
1818 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/external I/F");
1819 rocketModel[i].numPorts = 8;
1820 break;
1821 case PCI_DEVICE_ID_RP8J:
1822 str = "8J";
1823 max_num_aiops = 1;
1824 rocketModel[i].model = MODEL_RP8J;
1825 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/RJ11 connectors");
1826 rocketModel[i].numPorts = 8;
1827 break;
1828 case PCI_DEVICE_ID_RP4J:
1829 str = "4J";
1830 max_num_aiops = 1;
1831 ports_per_aiop = 4;
1832 rocketModel[i].model = MODEL_RP4J;
1833 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/RJ45 connectors");
1834 rocketModel[i].numPorts = 4;
1835 break;
1836 case PCI_DEVICE_ID_RP8SNI:
1837 str = "8 (DB78 Custom)";
1838 max_num_aiops = 1;
1839 rocketModel[i].model = MODEL_RP8SNI;
1840 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/ custom DB78");
1841 rocketModel[i].numPorts = 8;
1842 break;
1843 case PCI_DEVICE_ID_RP16SNI:
1844 str = "16 (DB78 Custom)";
1845 max_num_aiops = 2;
1846 rocketModel[i].model = MODEL_RP16SNI;
1847 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/ custom DB78");
1848 rocketModel[i].numPorts = 16;
1849 break;
1850 case PCI_DEVICE_ID_RP16INTF:
1851 str = "16";
1852 max_num_aiops = 2;
1853 rocketModel[i].model = MODEL_RP16INTF;
1854 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/external I/F");
1855 rocketModel[i].numPorts = 16;
1856 break;
1857 case PCI_DEVICE_ID_URP16INTF:
1858 str = "16";
1859 max_num_aiops = 2;
1860 rocketModel[i].model = MODEL_UPCI_RP16INTF;
1861 strcpy(rocketModel[i].modelString, "RocketPort UPCI 16 port w/external I/F");
1862 rocketModel[i].numPorts = 16;
1863 break;
1864 case PCI_DEVICE_ID_CRP16INTF:
1865 str = "16";
1866 max_num_aiops = 2;
1867 rocketModel[i].model = MODEL_CPCI_RP16INTF;
1868 strcpy(rocketModel[i].modelString, "RocketPort Compact PCI 16 port w/external I/F");
1869 rocketModel[i].numPorts = 16;
1870 break;
1871 case PCI_DEVICE_ID_RP32INTF:
1872 str = "32";
1873 max_num_aiops = 4;
1874 rocketModel[i].model = MODEL_RP32INTF;
1875 strcpy(rocketModel[i].modelString, "RocketPort 32 port w/external I/F");
1876 rocketModel[i].numPorts = 32;
1877 break;
1878 case PCI_DEVICE_ID_URP32INTF:
1879 str = "32";
1880 max_num_aiops = 4;
1881 rocketModel[i].model = MODEL_UPCI_RP32INTF;
1882 strcpy(rocketModel[i].modelString, "RocketPort UPCI 32 port w/external I/F");
1883 rocketModel[i].numPorts = 32;
1884 break;
1885 case PCI_DEVICE_ID_RPP4:
1886 str = "Plus Quadcable";
1887 max_num_aiops = 1;
1888 ports_per_aiop = 4;
1889 altChanRingIndicator++;
1890 fast_clock++;
1891 rocketModel[i].model = MODEL_RPP4;
1892 strcpy(rocketModel[i].modelString, "RocketPort Plus 4 port");
1893 rocketModel[i].numPorts = 4;
1894 break;
1895 case PCI_DEVICE_ID_RPP8:
1896 str = "Plus Octacable";
1897 max_num_aiops = 2;
1898 ports_per_aiop = 4;
1899 altChanRingIndicator++;
1900 fast_clock++;
1901 rocketModel[i].model = MODEL_RPP8;
1902 strcpy(rocketModel[i].modelString, "RocketPort Plus 8 port");
1903 rocketModel[i].numPorts = 8;
1904 break;
1905 case PCI_DEVICE_ID_RP2_232:
1906 str = "Plus 2 (RS-232)";
1907 max_num_aiops = 1;
1908 ports_per_aiop = 2;
1909 altChanRingIndicator++;
1910 fast_clock++;
1911 rocketModel[i].model = MODEL_RP2_232;
1912 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS232");
1913 rocketModel[i].numPorts = 2;
1914 break;
1915 case PCI_DEVICE_ID_RP2_422:
1916 str = "Plus 2 (RS-422)";
1917 max_num_aiops = 1;
1918 ports_per_aiop = 2;
1919 altChanRingIndicator++;
1920 fast_clock++;
1921 rocketModel[i].model = MODEL_RP2_422;
1922 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS422");
1923 rocketModel[i].numPorts = 2;
1924 break;
1925 case PCI_DEVICE_ID_RP6M:
1927 max_num_aiops = 1;
1928 ports_per_aiop = 6;
1929 str = "6-port";
1931 /* If revision is 1, the rocketmodem flash must be loaded.
1932 * If it is 2 it is a "socketed" version. */
1933 if (dev->revision == 1) {
1934 rcktpt_type[i] = ROCKET_TYPE_MODEMII;
1935 rocketModel[i].loadrm2 = 1;
1936 } else {
1937 rcktpt_type[i] = ROCKET_TYPE_MODEM;
1940 rocketModel[i].model = MODEL_RP6M;
1941 strcpy(rocketModel[i].modelString, "RocketModem 6 port");
1942 rocketModel[i].numPorts = 6;
1943 break;
1944 case PCI_DEVICE_ID_RP4M:
1945 max_num_aiops = 1;
1946 ports_per_aiop = 4;
1947 str = "4-port";
1948 if (dev->revision == 1) {
1949 rcktpt_type[i] = ROCKET_TYPE_MODEMII;
1950 rocketModel[i].loadrm2 = 1;
1951 } else {
1952 rcktpt_type[i] = ROCKET_TYPE_MODEM;
1955 rocketModel[i].model = MODEL_RP4M;
1956 strcpy(rocketModel[i].modelString, "RocketModem 4 port");
1957 rocketModel[i].numPorts = 4;
1958 break;
1959 default:
1960 str = "(unknown/unsupported)";
1961 max_num_aiops = 0;
1962 break;
1966 * Check for UPCI boards.
1969 switch (dev->device) {
1970 case PCI_DEVICE_ID_URP32INTF:
1971 case PCI_DEVICE_ID_URP8INTF:
1972 case PCI_DEVICE_ID_URP16INTF:
1973 case PCI_DEVICE_ID_CRP16INTF:
1974 case PCI_DEVICE_ID_URP8OCTA:
1975 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
1976 ConfigIO = pci_resource_start(dev, 1);
1977 if (dev->device == PCI_DEVICE_ID_URP8OCTA) {
1978 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
1981 * Check for octa or quad cable.
1983 if (!
1984 (sInW(ConfigIO + _PCI_9030_GPIO_CTRL) &
1985 PCI_GPIO_CTRL_8PORT)) {
1986 str = "Quadcable";
1987 ports_per_aiop = 4;
1988 rocketModel[i].numPorts = 4;
1991 break;
1992 case PCI_DEVICE_ID_UPCI_RM3_8PORT:
1993 str = "8 ports";
1994 max_num_aiops = 1;
1995 rocketModel[i].model = MODEL_UPCI_RM3_8PORT;
1996 strcpy(rocketModel[i].modelString, "RocketModem III 8 port");
1997 rocketModel[i].numPorts = 8;
1998 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
1999 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2000 ConfigIO = pci_resource_start(dev, 1);
2001 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2002 break;
2003 case PCI_DEVICE_ID_UPCI_RM3_4PORT:
2004 str = "4 ports";
2005 max_num_aiops = 1;
2006 rocketModel[i].model = MODEL_UPCI_RM3_4PORT;
2007 strcpy(rocketModel[i].modelString, "RocketModem III 4 port");
2008 rocketModel[i].numPorts = 4;
2009 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2010 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2011 ConfigIO = pci_resource_start(dev, 1);
2012 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2013 break;
2014 default:
2015 break;
2018 switch (rcktpt_type[i]) {
2019 case ROCKET_TYPE_MODEM:
2020 board_type = "RocketModem";
2021 break;
2022 case ROCKET_TYPE_MODEMII:
2023 board_type = "RocketModem II";
2024 break;
2025 case ROCKET_TYPE_MODEMIII:
2026 board_type = "RocketModem III";
2027 break;
2028 default:
2029 board_type = "RocketPort";
2030 break;
2033 if (fast_clock) {
2034 sClockPrescale = 0x12; /* mod 2 (divide by 3) */
2035 rp_baud_base[i] = 921600;
2036 } else {
2038 * If support_low_speed is set, use the slow clock
2039 * prescale, which supports 50 bps
2041 if (support_low_speed) {
2042 /* mod 9 (divide by 10) prescale */
2043 sClockPrescale = 0x19;
2044 rp_baud_base[i] = 230400;
2045 } else {
2046 /* mod 4 (devide by 5) prescale */
2047 sClockPrescale = 0x14;
2048 rp_baud_base[i] = 460800;
2052 for (aiop = 0; aiop < max_num_aiops; aiop++)
2053 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x40);
2054 ctlp = sCtlNumToCtlPtr(i);
2055 num_aiops = sPCIInitController(ctlp, i, aiopio, max_num_aiops, ConfigIO, 0, FREQ_DIS, 0, altChanRingIndicator, UPCIRingInd);
2056 for (aiop = 0; aiop < max_num_aiops; aiop++)
2057 ctlp->AiopNumChan[aiop] = ports_per_aiop;
2059 dev_info(&dev->dev, "comtrol PCI controller #%d found at "
2060 "address %04lx, %d AIOP(s) (%s), creating ttyR%d - %ld\n",
2061 i, rcktpt_io_addr[i], num_aiops, rocketModel[i].modelString,
2062 rocketModel[i].startingPortNumber,
2063 rocketModel[i].startingPortNumber + rocketModel[i].numPorts-1);
2065 if (num_aiops <= 0) {
2066 rcktpt_io_addr[i] = 0;
2067 return (0);
2069 is_PCI[i] = 1;
2071 /* Reset the AIOPIC, init the serial ports */
2072 for (aiop = 0; aiop < num_aiops; aiop++) {
2073 sResetAiopByNum(ctlp, aiop);
2074 num_chan = ports_per_aiop;
2075 for (chan = 0; chan < num_chan; chan++)
2076 init_r_port(i, aiop, chan, dev);
2079 /* Rocket modems must be reset */
2080 if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) ||
2081 (rcktpt_type[i] == ROCKET_TYPE_MODEMII) ||
2082 (rcktpt_type[i] == ROCKET_TYPE_MODEMIII)) {
2083 num_chan = ports_per_aiop;
2084 for (chan = 0; chan < num_chan; chan++)
2085 sPCIModemReset(ctlp, chan, 1);
2086 msleep(500);
2087 for (chan = 0; chan < num_chan; chan++)
2088 sPCIModemReset(ctlp, chan, 0);
2089 msleep(500);
2090 rmSpeakerReset(ctlp, rocketModel[i].model);
2092 return (1);
2096 * Probes for PCI cards, inits them if found
2097 * Input: board_found = number of ISA boards already found, or the
2098 * starting board number
2099 * Returns: Number of PCI boards found
2101 static int __init init_PCI(int boards_found)
2103 struct pci_dev *dev = NULL;
2104 int count = 0;
2106 /* Work through the PCI device list, pulling out ours */
2107 while ((dev = pci_get_device(PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {
2108 if (register_PCI(count + boards_found, dev))
2109 count++;
2111 return (count);
2114 #endif /* CONFIG_PCI */
2117 * Probes for ISA cards
2118 * Input: i = the board number to look for
2119 * Returns: 1 if board found, 0 else
2121 static int __init init_ISA(int i)
2123 int num_aiops, num_chan = 0, total_num_chan = 0;
2124 int aiop, chan;
2125 unsigned int aiopio[MAX_AIOPS_PER_BOARD];
2126 CONTROLLER_t *ctlp;
2127 char *type_string;
2129 /* If io_addr is zero, no board configured */
2130 if (rcktpt_io_addr[i] == 0)
2131 return (0);
2133 /* Reserve the IO region */
2134 if (!request_region(rcktpt_io_addr[i], 64, "Comtrol RocketPort")) {
2135 printk(KERN_ERR "Unable to reserve IO region for configured "
2136 "ISA RocketPort at address 0x%lx, board not "
2137 "installed...\n", rcktpt_io_addr[i]);
2138 rcktpt_io_addr[i] = 0;
2139 return (0);
2142 ctlp = sCtlNumToCtlPtr(i);
2144 ctlp->boardType = rcktpt_type[i];
2146 switch (rcktpt_type[i]) {
2147 case ROCKET_TYPE_PC104:
2148 type_string = "(PC104)";
2149 break;
2150 case ROCKET_TYPE_MODEM:
2151 type_string = "(RocketModem)";
2152 break;
2153 case ROCKET_TYPE_MODEMII:
2154 type_string = "(RocketModem II)";
2155 break;
2156 default:
2157 type_string = "";
2158 break;
2162 * If support_low_speed is set, use the slow clock prescale,
2163 * which supports 50 bps
2165 if (support_low_speed) {
2166 sClockPrescale = 0x19; /* mod 9 (divide by 10) prescale */
2167 rp_baud_base[i] = 230400;
2168 } else {
2169 sClockPrescale = 0x14; /* mod 4 (devide by 5) prescale */
2170 rp_baud_base[i] = 460800;
2173 for (aiop = 0; aiop < MAX_AIOPS_PER_BOARD; aiop++)
2174 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x400);
2176 num_aiops = sInitController(ctlp, i, controller + (i * 0x400), aiopio, MAX_AIOPS_PER_BOARD, 0, FREQ_DIS, 0);
2178 if (ctlp->boardType == ROCKET_TYPE_PC104) {
2179 sEnAiop(ctlp, 2); /* only one AIOPIC, but these */
2180 sEnAiop(ctlp, 3); /* CSels used for other stuff */
2183 /* If something went wrong initing the AIOP's release the ISA IO memory */
2184 if (num_aiops <= 0) {
2185 release_region(rcktpt_io_addr[i], 64);
2186 rcktpt_io_addr[i] = 0;
2187 return (0);
2190 rocketModel[i].startingPortNumber = nextLineNumber;
2192 for (aiop = 0; aiop < num_aiops; aiop++) {
2193 sResetAiopByNum(ctlp, aiop);
2194 sEnAiop(ctlp, aiop);
2195 num_chan = sGetAiopNumChan(ctlp, aiop);
2196 total_num_chan += num_chan;
2197 for (chan = 0; chan < num_chan; chan++)
2198 init_r_port(i, aiop, chan, NULL);
2200 is_PCI[i] = 0;
2201 if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) || (rcktpt_type[i] == ROCKET_TYPE_MODEMII)) {
2202 num_chan = sGetAiopNumChan(ctlp, 0);
2203 total_num_chan = num_chan;
2204 for (chan = 0; chan < num_chan; chan++)
2205 sModemReset(ctlp, chan, 1);
2206 msleep(500);
2207 for (chan = 0; chan < num_chan; chan++)
2208 sModemReset(ctlp, chan, 0);
2209 msleep(500);
2210 strcpy(rocketModel[i].modelString, "RocketModem ISA");
2211 } else {
2212 strcpy(rocketModel[i].modelString, "RocketPort ISA");
2214 rocketModel[i].numPorts = total_num_chan;
2215 rocketModel[i].model = MODEL_ISA;
2217 printk(KERN_INFO "RocketPort ISA card #%d found at 0x%lx - %d AIOPs %s\n",
2218 i, rcktpt_io_addr[i], num_aiops, type_string);
2220 printk(KERN_INFO "Installing %s, creating /dev/ttyR%d - %ld\n",
2221 rocketModel[i].modelString,
2222 rocketModel[i].startingPortNumber,
2223 rocketModel[i].startingPortNumber +
2224 rocketModel[i].numPorts - 1);
2226 return (1);
2229 static const struct tty_operations rocket_ops = {
2230 .open = rp_open,
2231 .close = rp_close,
2232 .write = rp_write,
2233 .put_char = rp_put_char,
2234 .write_room = rp_write_room,
2235 .chars_in_buffer = rp_chars_in_buffer,
2236 .flush_buffer = rp_flush_buffer,
2237 .ioctl = rp_ioctl,
2238 .throttle = rp_throttle,
2239 .unthrottle = rp_unthrottle,
2240 .set_termios = rp_set_termios,
2241 .stop = rp_stop,
2242 .start = rp_start,
2243 .hangup = rp_hangup,
2244 .break_ctl = rp_break,
2245 .send_xchar = rp_send_xchar,
2246 .wait_until_sent = rp_wait_until_sent,
2247 .tiocmget = rp_tiocmget,
2248 .tiocmset = rp_tiocmset,
2251 static const struct tty_port_operations rocket_port_ops = {
2252 .carrier_raised = carrier_raised,
2253 .raise_dtr_rts = raise_dtr_rts,
2257 * The module "startup" routine; it's run when the module is loaded.
2259 static int __init rp_init(void)
2261 int ret = -ENOMEM, pci_boards_found, isa_boards_found, i;
2263 printk(KERN_INFO "RocketPort device driver module, version %s, %s\n",
2264 ROCKET_VERSION, ROCKET_DATE);
2266 rocket_driver = alloc_tty_driver(MAX_RP_PORTS);
2267 if (!rocket_driver)
2268 goto err;
2271 * If board 1 is non-zero, there is at least one ISA configured. If controller is
2272 * zero, use the default controller IO address of board1 + 0x40.
2274 if (board1) {
2275 if (controller == 0)
2276 controller = board1 + 0x40;
2277 } else {
2278 controller = 0; /* Used as a flag, meaning no ISA boards */
2281 /* If an ISA card is configured, reserve the 4 byte IO space for the Mudbac controller */
2282 if (controller && (!request_region(controller, 4, "Comtrol RocketPort"))) {
2283 printk(KERN_ERR "Unable to reserve IO region for first "
2284 "configured ISA RocketPort controller 0x%lx. "
2285 "Driver exiting\n", controller);
2286 ret = -EBUSY;
2287 goto err_tty;
2290 /* Store ISA variable retrieved from command line or .conf file. */
2291 rcktpt_io_addr[0] = board1;
2292 rcktpt_io_addr[1] = board2;
2293 rcktpt_io_addr[2] = board3;
2294 rcktpt_io_addr[3] = board4;
2296 rcktpt_type[0] = modem1 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2297 rcktpt_type[0] = pc104_1[0] ? ROCKET_TYPE_PC104 : rcktpt_type[0];
2298 rcktpt_type[1] = modem2 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2299 rcktpt_type[1] = pc104_2[0] ? ROCKET_TYPE_PC104 : rcktpt_type[1];
2300 rcktpt_type[2] = modem3 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2301 rcktpt_type[2] = pc104_3[0] ? ROCKET_TYPE_PC104 : rcktpt_type[2];
2302 rcktpt_type[3] = modem4 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2303 rcktpt_type[3] = pc104_4[0] ? ROCKET_TYPE_PC104 : rcktpt_type[3];
2306 * Set up the tty driver structure and then register this
2307 * driver with the tty layer.
2310 rocket_driver->owner = THIS_MODULE;
2311 rocket_driver->flags = TTY_DRIVER_DYNAMIC_DEV;
2312 rocket_driver->name = "ttyR";
2313 rocket_driver->driver_name = "Comtrol RocketPort";
2314 rocket_driver->major = TTY_ROCKET_MAJOR;
2315 rocket_driver->minor_start = 0;
2316 rocket_driver->type = TTY_DRIVER_TYPE_SERIAL;
2317 rocket_driver->subtype = SERIAL_TYPE_NORMAL;
2318 rocket_driver->init_termios = tty_std_termios;
2319 rocket_driver->init_termios.c_cflag =
2320 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2321 rocket_driver->init_termios.c_ispeed = 9600;
2322 rocket_driver->init_termios.c_ospeed = 9600;
2323 #ifdef ROCKET_SOFT_FLOW
2324 rocket_driver->flags |= TTY_DRIVER_REAL_RAW;
2325 #endif
2326 tty_set_operations(rocket_driver, &rocket_ops);
2328 ret = tty_register_driver(rocket_driver);
2329 if (ret < 0) {
2330 printk(KERN_ERR "Couldn't install tty RocketPort driver\n");
2331 goto err_tty;
2334 #ifdef ROCKET_DEBUG_OPEN
2335 printk(KERN_INFO "RocketPort driver is major %d\n", rocket_driver.major);
2336 #endif
2339 * OK, let's probe each of the controllers looking for boards. Any boards found
2340 * will be initialized here.
2342 isa_boards_found = 0;
2343 pci_boards_found = 0;
2345 for (i = 0; i < NUM_BOARDS; i++) {
2346 if (init_ISA(i))
2347 isa_boards_found++;
2350 #ifdef CONFIG_PCI
2351 if (isa_boards_found < NUM_BOARDS)
2352 pci_boards_found = init_PCI(isa_boards_found);
2353 #endif
2355 max_board = pci_boards_found + isa_boards_found;
2357 if (max_board == 0) {
2358 printk(KERN_ERR "No rocketport ports found; unloading driver\n");
2359 ret = -ENXIO;
2360 goto err_ttyu;
2363 return 0;
2364 err_ttyu:
2365 tty_unregister_driver(rocket_driver);
2366 err_tty:
2367 put_tty_driver(rocket_driver);
2368 err:
2369 return ret;
2373 static void rp_cleanup_module(void)
2375 int retval;
2376 int i;
2378 del_timer_sync(&rocket_timer);
2380 retval = tty_unregister_driver(rocket_driver);
2381 if (retval)
2382 printk(KERN_ERR "Error %d while trying to unregister "
2383 "rocketport driver\n", -retval);
2385 for (i = 0; i < MAX_RP_PORTS; i++)
2386 if (rp_table[i]) {
2387 tty_unregister_device(rocket_driver, i);
2388 kfree(rp_table[i]);
2391 put_tty_driver(rocket_driver);
2393 for (i = 0; i < NUM_BOARDS; i++) {
2394 if (rcktpt_io_addr[i] <= 0 || is_PCI[i])
2395 continue;
2396 release_region(rcktpt_io_addr[i], 64);
2398 if (controller)
2399 release_region(controller, 4);
2402 /***************************************************************************
2403 Function: sInitController
2404 Purpose: Initialization of controller global registers and controller
2405 structure.
2406 Call: sInitController(CtlP,CtlNum,MudbacIO,AiopIOList,AiopIOListSize,
2407 IRQNum,Frequency,PeriodicOnly)
2408 CONTROLLER_T *CtlP; Ptr to controller structure
2409 int CtlNum; Controller number
2410 ByteIO_t MudbacIO; Mudbac base I/O address.
2411 ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2412 This list must be in the order the AIOPs will be found on the
2413 controller. Once an AIOP in the list is not found, it is
2414 assumed that there are no more AIOPs on the controller.
2415 int AiopIOListSize; Number of addresses in AiopIOList
2416 int IRQNum; Interrupt Request number. Can be any of the following:
2417 0: Disable global interrupts
2418 3: IRQ 3
2419 4: IRQ 4
2420 5: IRQ 5
2421 9: IRQ 9
2422 10: IRQ 10
2423 11: IRQ 11
2424 12: IRQ 12
2425 15: IRQ 15
2426 Byte_t Frequency: A flag identifying the frequency
2427 of the periodic interrupt, can be any one of the following:
2428 FREQ_DIS - periodic interrupt disabled
2429 FREQ_137HZ - 137 Hertz
2430 FREQ_69HZ - 69 Hertz
2431 FREQ_34HZ - 34 Hertz
2432 FREQ_17HZ - 17 Hertz
2433 FREQ_9HZ - 9 Hertz
2434 FREQ_4HZ - 4 Hertz
2435 If IRQNum is set to 0 the Frequency parameter is
2436 overidden, it is forced to a value of FREQ_DIS.
2437 int PeriodicOnly: 1 if all interrupts except the periodic
2438 interrupt are to be blocked.
2439 0 is both the periodic interrupt and
2440 other channel interrupts are allowed.
2441 If IRQNum is set to 0 the PeriodicOnly parameter is
2442 overidden, it is forced to a value of 0.
2443 Return: int: Number of AIOPs on the controller, or CTLID_NULL if controller
2444 initialization failed.
2446 Comments:
2447 If periodic interrupts are to be disabled but AIOP interrupts
2448 are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2450 If interrupts are to be completely disabled set IRQNum to 0.
2452 Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2453 invalid combination.
2455 This function performs initialization of global interrupt modes,
2456 but it does not actually enable global interrupts. To enable
2457 and disable global interrupts use functions sEnGlobalInt() and
2458 sDisGlobalInt(). Enabling of global interrupts is normally not
2459 done until all other initializations are complete.
2461 Even if interrupts are globally enabled, they must also be
2462 individually enabled for each channel that is to generate
2463 interrupts.
2465 Warnings: No range checking on any of the parameters is done.
2467 No context switches are allowed while executing this function.
2469 After this function all AIOPs on the controller are disabled,
2470 they can be enabled with sEnAiop().
2472 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
2473 ByteIO_t * AiopIOList, int AiopIOListSize,
2474 int IRQNum, Byte_t Frequency, int PeriodicOnly)
2476 int i;
2477 ByteIO_t io;
2478 int done;
2480 CtlP->AiopIntrBits = aiop_intr_bits;
2481 CtlP->AltChanRingIndicator = 0;
2482 CtlP->CtlNum = CtlNum;
2483 CtlP->CtlID = CTLID_0001; /* controller release 1 */
2484 CtlP->BusType = isISA;
2485 CtlP->MBaseIO = MudbacIO;
2486 CtlP->MReg1IO = MudbacIO + 1;
2487 CtlP->MReg2IO = MudbacIO + 2;
2488 CtlP->MReg3IO = MudbacIO + 3;
2489 #if 1
2490 CtlP->MReg2 = 0; /* interrupt disable */
2491 CtlP->MReg3 = 0; /* no periodic interrupts */
2492 #else
2493 if (sIRQMap[IRQNum] == 0) { /* interrupts globally disabled */
2494 CtlP->MReg2 = 0; /* interrupt disable */
2495 CtlP->MReg3 = 0; /* no periodic interrupts */
2496 } else {
2497 CtlP->MReg2 = sIRQMap[IRQNum]; /* set IRQ number */
2498 CtlP->MReg3 = Frequency; /* set frequency */
2499 if (PeriodicOnly) { /* periodic interrupt only */
2500 CtlP->MReg3 |= PERIODIC_ONLY;
2503 #endif
2504 sOutB(CtlP->MReg2IO, CtlP->MReg2);
2505 sOutB(CtlP->MReg3IO, CtlP->MReg3);
2506 sControllerEOI(CtlP); /* clear EOI if warm init */
2507 /* Init AIOPs */
2508 CtlP->NumAiop = 0;
2509 for (i = done = 0; i < AiopIOListSize; i++) {
2510 io = AiopIOList[i];
2511 CtlP->AiopIO[i] = (WordIO_t) io;
2512 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2513 sOutB(CtlP->MReg2IO, CtlP->MReg2 | (i & 0x03)); /* AIOP index */
2514 sOutB(MudbacIO, (Byte_t) (io >> 6)); /* set up AIOP I/O in MUDBAC */
2515 if (done)
2516 continue;
2517 sEnAiop(CtlP, i); /* enable the AIOP */
2518 CtlP->AiopID[i] = sReadAiopID(io); /* read AIOP ID */
2519 if (CtlP->AiopID[i] == AIOPID_NULL) /* if AIOP does not exist */
2520 done = 1; /* done looking for AIOPs */
2521 else {
2522 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2523 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE); /* clock prescaler */
2524 sOutB(io + _INDX_DATA, sClockPrescale);
2525 CtlP->NumAiop++; /* bump count of AIOPs */
2527 sDisAiop(CtlP, i); /* disable AIOP */
2530 if (CtlP->NumAiop == 0)
2531 return (-1);
2532 else
2533 return (CtlP->NumAiop);
2536 /***************************************************************************
2537 Function: sPCIInitController
2538 Purpose: Initialization of controller global registers and controller
2539 structure.
2540 Call: sPCIInitController(CtlP,CtlNum,AiopIOList,AiopIOListSize,
2541 IRQNum,Frequency,PeriodicOnly)
2542 CONTROLLER_T *CtlP; Ptr to controller structure
2543 int CtlNum; Controller number
2544 ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2545 This list must be in the order the AIOPs will be found on the
2546 controller. Once an AIOP in the list is not found, it is
2547 assumed that there are no more AIOPs on the controller.
2548 int AiopIOListSize; Number of addresses in AiopIOList
2549 int IRQNum; Interrupt Request number. Can be any of the following:
2550 0: Disable global interrupts
2551 3: IRQ 3
2552 4: IRQ 4
2553 5: IRQ 5
2554 9: IRQ 9
2555 10: IRQ 10
2556 11: IRQ 11
2557 12: IRQ 12
2558 15: IRQ 15
2559 Byte_t Frequency: A flag identifying the frequency
2560 of the periodic interrupt, can be any one of the following:
2561 FREQ_DIS - periodic interrupt disabled
2562 FREQ_137HZ - 137 Hertz
2563 FREQ_69HZ - 69 Hertz
2564 FREQ_34HZ - 34 Hertz
2565 FREQ_17HZ - 17 Hertz
2566 FREQ_9HZ - 9 Hertz
2567 FREQ_4HZ - 4 Hertz
2568 If IRQNum is set to 0 the Frequency parameter is
2569 overidden, it is forced to a value of FREQ_DIS.
2570 int PeriodicOnly: 1 if all interrupts except the periodic
2571 interrupt are to be blocked.
2572 0 is both the periodic interrupt and
2573 other channel interrupts are allowed.
2574 If IRQNum is set to 0 the PeriodicOnly parameter is
2575 overidden, it is forced to a value of 0.
2576 Return: int: Number of AIOPs on the controller, or CTLID_NULL if controller
2577 initialization failed.
2579 Comments:
2580 If periodic interrupts are to be disabled but AIOP interrupts
2581 are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2583 If interrupts are to be completely disabled set IRQNum to 0.
2585 Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2586 invalid combination.
2588 This function performs initialization of global interrupt modes,
2589 but it does not actually enable global interrupts. To enable
2590 and disable global interrupts use functions sEnGlobalInt() and
2591 sDisGlobalInt(). Enabling of global interrupts is normally not
2592 done until all other initializations are complete.
2594 Even if interrupts are globally enabled, they must also be
2595 individually enabled for each channel that is to generate
2596 interrupts.
2598 Warnings: No range checking on any of the parameters is done.
2600 No context switches are allowed while executing this function.
2602 After this function all AIOPs on the controller are disabled,
2603 they can be enabled with sEnAiop().
2605 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
2606 ByteIO_t * AiopIOList, int AiopIOListSize,
2607 WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
2608 int PeriodicOnly, int altChanRingIndicator,
2609 int UPCIRingInd)
2611 int i;
2612 ByteIO_t io;
2614 CtlP->AltChanRingIndicator = altChanRingIndicator;
2615 CtlP->UPCIRingInd = UPCIRingInd;
2616 CtlP->CtlNum = CtlNum;
2617 CtlP->CtlID = CTLID_0001; /* controller release 1 */
2618 CtlP->BusType = isPCI; /* controller release 1 */
2620 if (ConfigIO) {
2621 CtlP->isUPCI = 1;
2622 CtlP->PCIIO = ConfigIO + _PCI_9030_INT_CTRL;
2623 CtlP->PCIIO2 = ConfigIO + _PCI_9030_GPIO_CTRL;
2624 CtlP->AiopIntrBits = upci_aiop_intr_bits;
2625 } else {
2626 CtlP->isUPCI = 0;
2627 CtlP->PCIIO =
2628 (WordIO_t) ((ByteIO_t) AiopIOList[0] + _PCI_INT_FUNC);
2629 CtlP->AiopIntrBits = aiop_intr_bits;
2632 sPCIControllerEOI(CtlP); /* clear EOI if warm init */
2633 /* Init AIOPs */
2634 CtlP->NumAiop = 0;
2635 for (i = 0; i < AiopIOListSize; i++) {
2636 io = AiopIOList[i];
2637 CtlP->AiopIO[i] = (WordIO_t) io;
2638 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2640 CtlP->AiopID[i] = sReadAiopID(io); /* read AIOP ID */
2641 if (CtlP->AiopID[i] == AIOPID_NULL) /* if AIOP does not exist */
2642 break; /* done looking for AIOPs */
2644 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2645 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE); /* clock prescaler */
2646 sOutB(io + _INDX_DATA, sClockPrescale);
2647 CtlP->NumAiop++; /* bump count of AIOPs */
2650 if (CtlP->NumAiop == 0)
2651 return (-1);
2652 else
2653 return (CtlP->NumAiop);
2656 /***************************************************************************
2657 Function: sReadAiopID
2658 Purpose: Read the AIOP idenfication number directly from an AIOP.
2659 Call: sReadAiopID(io)
2660 ByteIO_t io: AIOP base I/O address
2661 Return: int: Flag AIOPID_XXXX if a valid AIOP is found, where X
2662 is replace by an identifying number.
2663 Flag AIOPID_NULL if no valid AIOP is found
2664 Warnings: No context switches are allowed while executing this function.
2667 static int sReadAiopID(ByteIO_t io)
2669 Byte_t AiopID; /* ID byte from AIOP */
2671 sOutB(io + _CMD_REG, RESET_ALL); /* reset AIOP */
2672 sOutB(io + _CMD_REG, 0x0);
2673 AiopID = sInW(io + _CHN_STAT0) & 0x07;
2674 if (AiopID == 0x06)
2675 return (1);
2676 else /* AIOP does not exist */
2677 return (-1);
2680 /***************************************************************************
2681 Function: sReadAiopNumChan
2682 Purpose: Read the number of channels available in an AIOP directly from
2683 an AIOP.
2684 Call: sReadAiopNumChan(io)
2685 WordIO_t io: AIOP base I/O address
2686 Return: int: The number of channels available
2687 Comments: The number of channels is determined by write/reads from identical
2688 offsets within the SRAM address spaces for channels 0 and 4.
2689 If the channel 4 space is mirrored to channel 0 it is a 4 channel
2690 AIOP, otherwise it is an 8 channel.
2691 Warnings: No context switches are allowed while executing this function.
2693 static int sReadAiopNumChan(WordIO_t io)
2695 Word_t x;
2696 static Byte_t R[4] = { 0x00, 0x00, 0x34, 0x12 };
2698 /* write to chan 0 SRAM */
2699 out32((DWordIO_t) io + _INDX_ADDR, R);
2700 sOutW(io + _INDX_ADDR, 0); /* read from SRAM, chan 0 */
2701 x = sInW(io + _INDX_DATA);
2702 sOutW(io + _INDX_ADDR, 0x4000); /* read from SRAM, chan 4 */
2703 if (x != sInW(io + _INDX_DATA)) /* if different must be 8 chan */
2704 return (8);
2705 else
2706 return (4);
2709 /***************************************************************************
2710 Function: sInitChan
2711 Purpose: Initialization of a channel and channel structure
2712 Call: sInitChan(CtlP,ChP,AiopNum,ChanNum)
2713 CONTROLLER_T *CtlP; Ptr to controller structure
2714 CHANNEL_T *ChP; Ptr to channel structure
2715 int AiopNum; AIOP number within controller
2716 int ChanNum; Channel number within AIOP
2717 Return: int: 1 if initialization succeeded, 0 if it fails because channel
2718 number exceeds number of channels available in AIOP.
2719 Comments: This function must be called before a channel can be used.
2720 Warnings: No range checking on any of the parameters is done.
2722 No context switches are allowed while executing this function.
2724 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
2725 int ChanNum)
2727 int i;
2728 WordIO_t AiopIO;
2729 WordIO_t ChIOOff;
2730 Byte_t *ChR;
2731 Word_t ChOff;
2732 static Byte_t R[4];
2733 int brd9600;
2735 if (ChanNum >= CtlP->AiopNumChan[AiopNum])
2736 return 0; /* exceeds num chans in AIOP */
2738 /* Channel, AIOP, and controller identifiers */
2739 ChP->CtlP = CtlP;
2740 ChP->ChanID = CtlP->AiopID[AiopNum];
2741 ChP->AiopNum = AiopNum;
2742 ChP->ChanNum = ChanNum;
2744 /* Global direct addresses */
2745 AiopIO = CtlP->AiopIO[AiopNum];
2746 ChP->Cmd = (ByteIO_t) AiopIO + _CMD_REG;
2747 ChP->IntChan = (ByteIO_t) AiopIO + _INT_CHAN;
2748 ChP->IntMask = (ByteIO_t) AiopIO + _INT_MASK;
2749 ChP->IndexAddr = (DWordIO_t) AiopIO + _INDX_ADDR;
2750 ChP->IndexData = AiopIO + _INDX_DATA;
2752 /* Channel direct addresses */
2753 ChIOOff = AiopIO + ChP->ChanNum * 2;
2754 ChP->TxRxData = ChIOOff + _TD0;
2755 ChP->ChanStat = ChIOOff + _CHN_STAT0;
2756 ChP->TxRxCount = ChIOOff + _FIFO_CNT0;
2757 ChP->IntID = (ByteIO_t) AiopIO + ChP->ChanNum + _INT_ID0;
2759 /* Initialize the channel from the RData array */
2760 for (i = 0; i < RDATASIZE; i += 4) {
2761 R[0] = RData[i];
2762 R[1] = RData[i + 1] + 0x10 * ChanNum;
2763 R[2] = RData[i + 2];
2764 R[3] = RData[i + 3];
2765 out32(ChP->IndexAddr, R);
2768 ChR = ChP->R;
2769 for (i = 0; i < RREGDATASIZE; i += 4) {
2770 ChR[i] = RRegData[i];
2771 ChR[i + 1] = RRegData[i + 1] + 0x10 * ChanNum;
2772 ChR[i + 2] = RRegData[i + 2];
2773 ChR[i + 3] = RRegData[i + 3];
2776 /* Indexed registers */
2777 ChOff = (Word_t) ChanNum *0x1000;
2779 if (sClockPrescale == 0x14)
2780 brd9600 = 47;
2781 else
2782 brd9600 = 23;
2784 ChP->BaudDiv[0] = (Byte_t) (ChOff + _BAUD);
2785 ChP->BaudDiv[1] = (Byte_t) ((ChOff + _BAUD) >> 8);
2786 ChP->BaudDiv[2] = (Byte_t) brd9600;
2787 ChP->BaudDiv[3] = (Byte_t) (brd9600 >> 8);
2788 out32(ChP->IndexAddr, ChP->BaudDiv);
2790 ChP->TxControl[0] = (Byte_t) (ChOff + _TX_CTRL);
2791 ChP->TxControl[1] = (Byte_t) ((ChOff + _TX_CTRL) >> 8);
2792 ChP->TxControl[2] = 0;
2793 ChP->TxControl[3] = 0;
2794 out32(ChP->IndexAddr, ChP->TxControl);
2796 ChP->RxControl[0] = (Byte_t) (ChOff + _RX_CTRL);
2797 ChP->RxControl[1] = (Byte_t) ((ChOff + _RX_CTRL) >> 8);
2798 ChP->RxControl[2] = 0;
2799 ChP->RxControl[3] = 0;
2800 out32(ChP->IndexAddr, ChP->RxControl);
2802 ChP->TxEnables[0] = (Byte_t) (ChOff + _TX_ENBLS);
2803 ChP->TxEnables[1] = (Byte_t) ((ChOff + _TX_ENBLS) >> 8);
2804 ChP->TxEnables[2] = 0;
2805 ChP->TxEnables[3] = 0;
2806 out32(ChP->IndexAddr, ChP->TxEnables);
2808 ChP->TxCompare[0] = (Byte_t) (ChOff + _TXCMP1);
2809 ChP->TxCompare[1] = (Byte_t) ((ChOff + _TXCMP1) >> 8);
2810 ChP->TxCompare[2] = 0;
2811 ChP->TxCompare[3] = 0;
2812 out32(ChP->IndexAddr, ChP->TxCompare);
2814 ChP->TxReplace1[0] = (Byte_t) (ChOff + _TXREP1B1);
2815 ChP->TxReplace1[1] = (Byte_t) ((ChOff + _TXREP1B1) >> 8);
2816 ChP->TxReplace1[2] = 0;
2817 ChP->TxReplace1[3] = 0;
2818 out32(ChP->IndexAddr, ChP->TxReplace1);
2820 ChP->TxReplace2[0] = (Byte_t) (ChOff + _TXREP2);
2821 ChP->TxReplace2[1] = (Byte_t) ((ChOff + _TXREP2) >> 8);
2822 ChP->TxReplace2[2] = 0;
2823 ChP->TxReplace2[3] = 0;
2824 out32(ChP->IndexAddr, ChP->TxReplace2);
2826 ChP->TxFIFOPtrs = ChOff + _TXF_OUTP;
2827 ChP->TxFIFO = ChOff + _TX_FIFO;
2829 sOutB(ChP->Cmd, (Byte_t) ChanNum | RESTXFCNT); /* apply reset Tx FIFO count */
2830 sOutB(ChP->Cmd, (Byte_t) ChanNum); /* remove reset Tx FIFO count */
2831 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs); /* clear Tx in/out ptrs */
2832 sOutW(ChP->IndexData, 0);
2833 ChP->RxFIFOPtrs = ChOff + _RXF_OUTP;
2834 ChP->RxFIFO = ChOff + _RX_FIFO;
2836 sOutB(ChP->Cmd, (Byte_t) ChanNum | RESRXFCNT); /* apply reset Rx FIFO count */
2837 sOutB(ChP->Cmd, (Byte_t) ChanNum); /* remove reset Rx FIFO count */
2838 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs); /* clear Rx out ptr */
2839 sOutW(ChP->IndexData, 0);
2840 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2); /* clear Rx in ptr */
2841 sOutW(ChP->IndexData, 0);
2842 ChP->TxPrioCnt = ChOff + _TXP_CNT;
2843 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioCnt);
2844 sOutB(ChP->IndexData, 0);
2845 ChP->TxPrioPtr = ChOff + _TXP_PNTR;
2846 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioPtr);
2847 sOutB(ChP->IndexData, 0);
2848 ChP->TxPrioBuf = ChOff + _TXP_BUF;
2849 sEnRxProcessor(ChP); /* start the Rx processor */
2851 return 1;
2854 /***************************************************************************
2855 Function: sStopRxProcessor
2856 Purpose: Stop the receive processor from processing a channel.
2857 Call: sStopRxProcessor(ChP)
2858 CHANNEL_T *ChP; Ptr to channel structure
2860 Comments: The receive processor can be started again with sStartRxProcessor().
2861 This function causes the receive processor to skip over the
2862 stopped channel. It does not stop it from processing other channels.
2864 Warnings: No context switches are allowed while executing this function.
2866 Do not leave the receive processor stopped for more than one
2867 character time.
2869 After calling this function a delay of 4 uS is required to ensure
2870 that the receive processor is no longer processing this channel.
2872 static void sStopRxProcessor(CHANNEL_T * ChP)
2874 Byte_t R[4];
2876 R[0] = ChP->R[0];
2877 R[1] = ChP->R[1];
2878 R[2] = 0x0a;
2879 R[3] = ChP->R[3];
2880 out32(ChP->IndexAddr, R);
2883 /***************************************************************************
2884 Function: sFlushRxFIFO
2885 Purpose: Flush the Rx FIFO
2886 Call: sFlushRxFIFO(ChP)
2887 CHANNEL_T *ChP; Ptr to channel structure
2888 Return: void
2889 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
2890 while it is being flushed the receive processor is stopped
2891 and the transmitter is disabled. After these operations a
2892 4 uS delay is done before clearing the pointers to allow
2893 the receive processor to stop. These items are handled inside
2894 this function.
2895 Warnings: No context switches are allowed while executing this function.
2897 static void sFlushRxFIFO(CHANNEL_T * ChP)
2899 int i;
2900 Byte_t Ch; /* channel number within AIOP */
2901 int RxFIFOEnabled; /* 1 if Rx FIFO enabled */
2903 if (sGetRxCnt(ChP) == 0) /* Rx FIFO empty */
2904 return; /* don't need to flush */
2906 RxFIFOEnabled = 0;
2907 if (ChP->R[0x32] == 0x08) { /* Rx FIFO is enabled */
2908 RxFIFOEnabled = 1;
2909 sDisRxFIFO(ChP); /* disable it */
2910 for (i = 0; i < 2000 / 200; i++) /* delay 2 uS to allow proc to disable FIFO */
2911 sInB(ChP->IntChan); /* depends on bus i/o timing */
2913 sGetChanStatus(ChP); /* clear any pending Rx errors in chan stat */
2914 Ch = (Byte_t) sGetChanNum(ChP);
2915 sOutB(ChP->Cmd, Ch | RESRXFCNT); /* apply reset Rx FIFO count */
2916 sOutB(ChP->Cmd, Ch); /* remove reset Rx FIFO count */
2917 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs); /* clear Rx out ptr */
2918 sOutW(ChP->IndexData, 0);
2919 sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2); /* clear Rx in ptr */
2920 sOutW(ChP->IndexData, 0);
2921 if (RxFIFOEnabled)
2922 sEnRxFIFO(ChP); /* enable Rx FIFO */
2925 /***************************************************************************
2926 Function: sFlushTxFIFO
2927 Purpose: Flush the Tx FIFO
2928 Call: sFlushTxFIFO(ChP)
2929 CHANNEL_T *ChP; Ptr to channel structure
2930 Return: void
2931 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
2932 while it is being flushed the receive processor is stopped
2933 and the transmitter is disabled. After these operations a
2934 4 uS delay is done before clearing the pointers to allow
2935 the receive processor to stop. These items are handled inside
2936 this function.
2937 Warnings: No context switches are allowed while executing this function.
2939 static void sFlushTxFIFO(CHANNEL_T * ChP)
2941 int i;
2942 Byte_t Ch; /* channel number within AIOP */
2943 int TxEnabled; /* 1 if transmitter enabled */
2945 if (sGetTxCnt(ChP) == 0) /* Tx FIFO empty */
2946 return; /* don't need to flush */
2948 TxEnabled = 0;
2949 if (ChP->TxControl[3] & TX_ENABLE) {
2950 TxEnabled = 1;
2951 sDisTransmit(ChP); /* disable transmitter */
2953 sStopRxProcessor(ChP); /* stop Rx processor */
2954 for (i = 0; i < 4000 / 200; i++) /* delay 4 uS to allow proc to stop */
2955 sInB(ChP->IntChan); /* depends on bus i/o timing */
2956 Ch = (Byte_t) sGetChanNum(ChP);
2957 sOutB(ChP->Cmd, Ch | RESTXFCNT); /* apply reset Tx FIFO count */
2958 sOutB(ChP->Cmd, Ch); /* remove reset Tx FIFO count */
2959 sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs); /* clear Tx in/out ptrs */
2960 sOutW(ChP->IndexData, 0);
2961 if (TxEnabled)
2962 sEnTransmit(ChP); /* enable transmitter */
2963 sStartRxProcessor(ChP); /* restart Rx processor */
2966 /***************************************************************************
2967 Function: sWriteTxPrioByte
2968 Purpose: Write a byte of priority transmit data to a channel
2969 Call: sWriteTxPrioByte(ChP,Data)
2970 CHANNEL_T *ChP; Ptr to channel structure
2971 Byte_t Data; The transmit data byte
2973 Return: int: 1 if the bytes is successfully written, otherwise 0.
2975 Comments: The priority byte is transmitted before any data in the Tx FIFO.
2977 Warnings: No context switches are allowed while executing this function.
2979 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data)
2981 Byte_t DWBuf[4]; /* buffer for double word writes */
2982 Word_t *WordPtr; /* must be far because Win SS != DS */
2983 register DWordIO_t IndexAddr;
2985 if (sGetTxCnt(ChP) > 1) { /* write it to Tx priority buffer */
2986 IndexAddr = ChP->IndexAddr;
2987 sOutW((WordIO_t) IndexAddr, ChP->TxPrioCnt); /* get priority buffer status */
2988 if (sInB((ByteIO_t) ChP->IndexData) & PRI_PEND) /* priority buffer busy */
2989 return (0); /* nothing sent */
2991 WordPtr = (Word_t *) (&DWBuf[0]);
2992 *WordPtr = ChP->TxPrioBuf; /* data byte address */
2994 DWBuf[2] = Data; /* data byte value */
2995 out32(IndexAddr, DWBuf); /* write it out */
2997 *WordPtr = ChP->TxPrioCnt; /* Tx priority count address */
2999 DWBuf[2] = PRI_PEND + 1; /* indicate 1 byte pending */
3000 DWBuf[3] = 0; /* priority buffer pointer */
3001 out32(IndexAddr, DWBuf); /* write it out */
3002 } else { /* write it to Tx FIFO */
3004 sWriteTxByte(sGetTxRxDataIO(ChP), Data);
3006 return (1); /* 1 byte sent */
3009 /***************************************************************************
3010 Function: sEnInterrupts
3011 Purpose: Enable one or more interrupts for a channel
3012 Call: sEnInterrupts(ChP,Flags)
3013 CHANNEL_T *ChP; Ptr to channel structure
3014 Word_t Flags: Interrupt enable flags, can be any combination
3015 of the following flags:
3016 TXINT_EN: Interrupt on Tx FIFO empty
3017 RXINT_EN: Interrupt on Rx FIFO at trigger level (see
3018 sSetRxTrigger())
3019 SRCINT_EN: Interrupt on SRC (Special Rx Condition)
3020 MCINT_EN: Interrupt on modem input change
3021 CHANINT_EN: Allow channel interrupt signal to the AIOP's
3022 Interrupt Channel Register.
3023 Return: void
3024 Comments: If an interrupt enable flag is set in Flags, that interrupt will be
3025 enabled. If an interrupt enable flag is not set in Flags, that
3026 interrupt will not be changed. Interrupts can be disabled with
3027 function sDisInterrupts().
3029 This function sets the appropriate bit for the channel in the AIOP's
3030 Interrupt Mask Register if the CHANINT_EN flag is set. This allows
3031 this channel's bit to be set in the AIOP's Interrupt Channel Register.
3033 Interrupts must also be globally enabled before channel interrupts
3034 will be passed on to the host. This is done with function
3035 sEnGlobalInt().
3037 In some cases it may be desirable to disable interrupts globally but
3038 enable channel interrupts. This would allow the global interrupt
3039 status register to be used to determine which AIOPs need service.
3041 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags)
3043 Byte_t Mask; /* Interrupt Mask Register */
3045 ChP->RxControl[2] |=
3046 ((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3048 out32(ChP->IndexAddr, ChP->RxControl);
3050 ChP->TxControl[2] |= ((Byte_t) Flags & TXINT_EN);
3052 out32(ChP->IndexAddr, ChP->TxControl);
3054 if (Flags & CHANINT_EN) {
3055 Mask = sInB(ChP->IntMask) | sBitMapSetTbl[ChP->ChanNum];
3056 sOutB(ChP->IntMask, Mask);
3060 /***************************************************************************
3061 Function: sDisInterrupts
3062 Purpose: Disable one or more interrupts for a channel
3063 Call: sDisInterrupts(ChP,Flags)
3064 CHANNEL_T *ChP; Ptr to channel structure
3065 Word_t Flags: Interrupt flags, can be any combination
3066 of the following flags:
3067 TXINT_EN: Interrupt on Tx FIFO empty
3068 RXINT_EN: Interrupt on Rx FIFO at trigger level (see
3069 sSetRxTrigger())
3070 SRCINT_EN: Interrupt on SRC (Special Rx Condition)
3071 MCINT_EN: Interrupt on modem input change
3072 CHANINT_EN: Disable channel interrupt signal to the
3073 AIOP's Interrupt Channel Register.
3074 Return: void
3075 Comments: If an interrupt flag is set in Flags, that interrupt will be
3076 disabled. If an interrupt flag is not set in Flags, that
3077 interrupt will not be changed. Interrupts can be enabled with
3078 function sEnInterrupts().
3080 This function clears the appropriate bit for the channel in the AIOP's
3081 Interrupt Mask Register if the CHANINT_EN flag is set. This blocks
3082 this channel's bit from being set in the AIOP's Interrupt Channel
3083 Register.
3085 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags)
3087 Byte_t Mask; /* Interrupt Mask Register */
3089 ChP->RxControl[2] &=
3090 ~((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3091 out32(ChP->IndexAddr, ChP->RxControl);
3092 ChP->TxControl[2] &= ~((Byte_t) Flags & TXINT_EN);
3093 out32(ChP->IndexAddr, ChP->TxControl);
3095 if (Flags & CHANINT_EN) {
3096 Mask = sInB(ChP->IntMask) & sBitMapClrTbl[ChP->ChanNum];
3097 sOutB(ChP->IntMask, Mask);
3101 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode)
3103 sOutB(ChP->CtlP->AiopIO[2], (mode & 0x18) | ChP->ChanNum);
3107 * Not an official SSCI function, but how to reset RocketModems.
3108 * ISA bus version
3110 static void sModemReset(CONTROLLER_T * CtlP, int chan, int on)
3112 ByteIO_t addr;
3113 Byte_t val;
3115 addr = CtlP->AiopIO[0] + 0x400;
3116 val = sInB(CtlP->MReg3IO);
3117 /* if AIOP[1] is not enabled, enable it */
3118 if ((val & 2) == 0) {
3119 val = sInB(CtlP->MReg2IO);
3120 sOutB(CtlP->MReg2IO, (val & 0xfc) | (1 & 0x03));
3121 sOutB(CtlP->MBaseIO, (unsigned char) (addr >> 6));
3124 sEnAiop(CtlP, 1);
3125 if (!on)
3126 addr += 8;
3127 sOutB(addr + chan, 0); /* apply or remove reset */
3128 sDisAiop(CtlP, 1);
3132 * Not an official SSCI function, but how to reset RocketModems.
3133 * PCI bus version
3135 static void sPCIModemReset(CONTROLLER_T * CtlP, int chan, int on)
3137 ByteIO_t addr;
3139 addr = CtlP->AiopIO[0] + 0x40; /* 2nd AIOP */
3140 if (!on)
3141 addr += 8;
3142 sOutB(addr + chan, 0); /* apply or remove reset */
3145 /* Resets the speaker controller on RocketModem II and III devices */
3146 static void rmSpeakerReset(CONTROLLER_T * CtlP, unsigned long model)
3148 ByteIO_t addr;
3150 /* RocketModem II speaker control is at the 8th port location of offset 0x40 */
3151 if ((model == MODEL_RP4M) || (model == MODEL_RP6M)) {
3152 addr = CtlP->AiopIO[0] + 0x4F;
3153 sOutB(addr, 0);
3156 /* RocketModem III speaker control is at the 1st port location of offset 0x80 */
3157 if ((model == MODEL_UPCI_RM3_8PORT)
3158 || (model == MODEL_UPCI_RM3_4PORT)) {
3159 addr = CtlP->AiopIO[0] + 0x88;
3160 sOutB(addr, 0);
3164 /* Returns the line number given the controller (board), aiop and channel number */
3165 static unsigned char GetLineNumber(int ctrl, int aiop, int ch)
3167 return lineNumbers[(ctrl << 5) | (aiop << 3) | ch];
3171 * Stores the line number associated with a given controller (board), aiop
3172 * and channel number.
3173 * Returns: The line number assigned
3175 static unsigned char SetLineNumber(int ctrl, int aiop, int ch)
3177 lineNumbers[(ctrl << 5) | (aiop << 3) | ch] = nextLineNumber++;
3178 return (nextLineNumber - 1);