drivers/char/rocket portability fixes
[sfrench/cifs-2.6.git] / drivers / char / rocket.c
1 /*
2  * RocketPort device driver for Linux
3  *
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.
12  * 
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.
17  * 
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.
21  */
22
23 /*
24  * Kernel Synchronization:
25  *
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.
29  *
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.
37  * 
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.
40  */
41
42 /****** Defines ******/
43 #define ROCKET_PARANOIA_CHECK
44 #define ROCKET_DISABLE_SIMUSAGE
45
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
57
58 #define POLL_PERIOD HZ/100      /*  Polling period .01 seconds (10ms) */
59
60 /****** Kernel includes ******/
61
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/string.h>
76 #include <linux/fcntl.h>
77 #include <linux/ptrace.h>
78 #include <linux/mutex.h>
79 #include <linux/ioport.h>
80 #include <linux/delay.h>
81 #include <linux/completion.h>
82 #include <linux/wait.h>
83 #include <linux/pci.h>
84 #include <asm/uaccess.h>
85 #include <asm/atomic.h>
86 #include <asm/unaligned.h>
87 #include <linux/bitops.h>
88 #include <linux/spinlock.h>
89 #include <linux/init.h>
90
91 /****** RocketPort includes ******/
92
93 #include "rocket_int.h"
94 #include "rocket.h"
95
96 #define ROCKET_VERSION "2.09"
97 #define ROCKET_DATE "12-June-2003"
98
99 /****** RocketPort Local Variables ******/
100
101 static void rp_do_poll(unsigned long dummy);
102
103 static struct tty_driver *rocket_driver;
104
105 static struct rocket_version driver_version = { 
106         ROCKET_VERSION, ROCKET_DATE
107 };
108
109 static struct r_port *rp_table[MAX_RP_PORTS];          /*  The main repository of serial port state information. */
110 static unsigned int xmit_flags[NUM_BOARDS];            /*  Bit significant, indicates port had data to transmit. */
111                                                        /*  eg.  Bit 0 indicates port 0 has xmit data, ...        */
112 static atomic_t rp_num_ports_open;                     /*  Number of serial ports open                           */
113 static DEFINE_TIMER(rocket_timer, rp_do_poll, 0, 0);
114
115 static unsigned long board1;                           /* ISA addresses, retrieved from rocketport.conf          */
116 static unsigned long board2;
117 static unsigned long board3;
118 static unsigned long board4;
119 static unsigned long controller;
120 static int support_low_speed;
121 static unsigned long modem1;
122 static unsigned long modem2;
123 static unsigned long modem3;
124 static unsigned long modem4;
125 static unsigned long pc104_1[8];
126 static unsigned long pc104_2[8];
127 static unsigned long pc104_3[8];
128 static unsigned long pc104_4[8];
129 static unsigned long *pc104[4] = { pc104_1, pc104_2, pc104_3, pc104_4 };
130
131 static int rp_baud_base[NUM_BOARDS];                   /*  Board config info (Someday make a per-board structure)  */
132 static unsigned long rcktpt_io_addr[NUM_BOARDS];
133 static int rcktpt_type[NUM_BOARDS];
134 static int is_PCI[NUM_BOARDS];
135 static rocketModel_t rocketModel[NUM_BOARDS];
136 static int max_board;
137
138 /*
139  * The following arrays define the interrupt bits corresponding to each AIOP.
140  * These bits are different between the ISA and regular PCI boards and the
141  * Universal PCI boards.
142  */
143
144 static Word_t aiop_intr_bits[AIOP_CTL_SIZE] = {
145         AIOP_INTR_BIT_0,
146         AIOP_INTR_BIT_1,
147         AIOP_INTR_BIT_2,
148         AIOP_INTR_BIT_3
149 };
150
151 static Word_t upci_aiop_intr_bits[AIOP_CTL_SIZE] = {
152         UPCI_AIOP_INTR_BIT_0,
153         UPCI_AIOP_INTR_BIT_1,
154         UPCI_AIOP_INTR_BIT_2,
155         UPCI_AIOP_INTR_BIT_3
156 };
157
158 static Byte_t RData[RDATASIZE] = {
159         0x00, 0x09, 0xf6, 0x82,
160         0x02, 0x09, 0x86, 0xfb,
161         0x04, 0x09, 0x00, 0x0a,
162         0x06, 0x09, 0x01, 0x0a,
163         0x08, 0x09, 0x8a, 0x13,
164         0x0a, 0x09, 0xc5, 0x11,
165         0x0c, 0x09, 0x86, 0x85,
166         0x0e, 0x09, 0x20, 0x0a,
167         0x10, 0x09, 0x21, 0x0a,
168         0x12, 0x09, 0x41, 0xff,
169         0x14, 0x09, 0x82, 0x00,
170         0x16, 0x09, 0x82, 0x7b,
171         0x18, 0x09, 0x8a, 0x7d,
172         0x1a, 0x09, 0x88, 0x81,
173         0x1c, 0x09, 0x86, 0x7a,
174         0x1e, 0x09, 0x84, 0x81,
175         0x20, 0x09, 0x82, 0x7c,
176         0x22, 0x09, 0x0a, 0x0a
177 };
178
179 static Byte_t RRegData[RREGDATASIZE] = {
180         0x00, 0x09, 0xf6, 0x82, /* 00: Stop Rx processor */
181         0x08, 0x09, 0x8a, 0x13, /* 04: Tx software flow control */
182         0x0a, 0x09, 0xc5, 0x11, /* 08: XON char */
183         0x0c, 0x09, 0x86, 0x85, /* 0c: XANY */
184         0x12, 0x09, 0x41, 0xff, /* 10: Rx mask char */
185         0x14, 0x09, 0x82, 0x00, /* 14: Compare/Ignore #0 */
186         0x16, 0x09, 0x82, 0x7b, /* 18: Compare #1 */
187         0x18, 0x09, 0x8a, 0x7d, /* 1c: Compare #2 */
188         0x1a, 0x09, 0x88, 0x81, /* 20: Interrupt #1 */
189         0x1c, 0x09, 0x86, 0x7a, /* 24: Ignore/Replace #1 */
190         0x1e, 0x09, 0x84, 0x81, /* 28: Interrupt #2 */
191         0x20, 0x09, 0x82, 0x7c, /* 2c: Ignore/Replace #2 */
192         0x22, 0x09, 0x0a, 0x0a  /* 30: Rx FIFO Enable */
193 };
194
195 static CONTROLLER_T sController[CTL_SIZE] = {
196         {-1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0, 0},
197          {0, 0, 0, 0}, {-1, -1, -1, -1}, {0, 0, 0, 0}},
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 };
205
206 static Byte_t sBitMapClrTbl[8] = {
207         0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f
208 };
209
210 static Byte_t sBitMapSetTbl[8] = {
211         0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
212 };
213
214 static int sClockPrescale = 0x14;
215
216 /*
217  *  Line number is the ttySIx number (x), the Minor number.  We 
218  *  assign them sequentially, starting at zero.  The following 
219  *  array keeps track of the line number assigned to a given board/aiop/channel.
220  */
221 static unsigned char lineNumbers[MAX_RP_PORTS];
222 static unsigned long nextLineNumber;
223
224 /*****  RocketPort Static Prototypes   *********/
225 static int __init init_ISA(int i);
226 static void rp_wait_until_sent(struct tty_struct *tty, int timeout);
227 static void rp_flush_buffer(struct tty_struct *tty);
228 static void rmSpeakerReset(CONTROLLER_T * CtlP, unsigned long model);
229 static unsigned char GetLineNumber(int ctrl, int aiop, int ch);
230 static unsigned char SetLineNumber(int ctrl, int aiop, int ch);
231 static void rp_start(struct tty_struct *tty);
232 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
233                      int ChanNum);
234 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode);
235 static void sFlushRxFIFO(CHANNEL_T * ChP);
236 static void sFlushTxFIFO(CHANNEL_T * ChP);
237 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags);
238 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags);
239 static void sModemReset(CONTROLLER_T * CtlP, int chan, int on);
240 static void sPCIModemReset(CONTROLLER_T * CtlP, int chan, int on);
241 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data);
242 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
243                               ByteIO_t * AiopIOList, int AiopIOListSize,
244                               WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
245                               int PeriodicOnly, int altChanRingIndicator,
246                               int UPCIRingInd);
247 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
248                            ByteIO_t * AiopIOList, int AiopIOListSize,
249                            int IRQNum, Byte_t Frequency, int PeriodicOnly);
250 static int sReadAiopID(ByteIO_t io);
251 static int sReadAiopNumChan(WordIO_t io);
252
253 MODULE_AUTHOR("Theodore Ts'o");
254 MODULE_DESCRIPTION("Comtrol RocketPort driver");
255 module_param(board1, ulong, 0);
256 MODULE_PARM_DESC(board1, "I/O port for (ISA) board #1");
257 module_param(board2, ulong, 0);
258 MODULE_PARM_DESC(board2, "I/O port for (ISA) board #2");
259 module_param(board3, ulong, 0);
260 MODULE_PARM_DESC(board3, "I/O port for (ISA) board #3");
261 module_param(board4, ulong, 0);
262 MODULE_PARM_DESC(board4, "I/O port for (ISA) board #4");
263 module_param(controller, ulong, 0);
264 MODULE_PARM_DESC(controller, "I/O port for (ISA) rocketport controller");
265 module_param(support_low_speed, bool, 0);
266 MODULE_PARM_DESC(support_low_speed, "1 means support 50 baud, 0 means support 460400 baud");
267 module_param(modem1, ulong, 0);
268 MODULE_PARM_DESC(modem1, "1 means (ISA) board #1 is a RocketModem");
269 module_param(modem2, ulong, 0);
270 MODULE_PARM_DESC(modem2, "1 means (ISA) board #2 is a RocketModem");
271 module_param(modem3, ulong, 0);
272 MODULE_PARM_DESC(modem3, "1 means (ISA) board #3 is a RocketModem");
273 module_param(modem4, ulong, 0);
274 MODULE_PARM_DESC(modem4, "1 means (ISA) board #4 is a RocketModem");
275 module_param_array(pc104_1, ulong, NULL, 0);
276 MODULE_PARM_DESC(pc104_1, "set interface types for ISA(PC104) board #1 (e.g. pc104_1=232,232,485,485,...");
277 module_param_array(pc104_2, ulong, NULL, 0);
278 MODULE_PARM_DESC(pc104_2, "set interface types for ISA(PC104) board #2 (e.g. pc104_2=232,232,485,485,...");
279 module_param_array(pc104_3, ulong, NULL, 0);
280 MODULE_PARM_DESC(pc104_3, "set interface types for ISA(PC104) board #3 (e.g. pc104_3=232,232,485,485,...");
281 module_param_array(pc104_4, ulong, NULL, 0);
282 MODULE_PARM_DESC(pc104_4, "set interface types for ISA(PC104) board #4 (e.g. pc104_4=232,232,485,485,...");
283
284 static int rp_init(void);
285 static void rp_cleanup_module(void);
286
287 module_init(rp_init);
288 module_exit(rp_cleanup_module);
289
290
291 MODULE_LICENSE("Dual BSD/GPL");
292
293 /*************************************************************************/
294 /*                     Module code starts here                           */
295
296 static inline int rocket_paranoia_check(struct r_port *info,
297                                         const char *routine)
298 {
299 #ifdef ROCKET_PARANOIA_CHECK
300         if (!info)
301                 return 1;
302         if (info->magic != RPORT_MAGIC) {
303                 printk(KERN_WARNING "Warning: bad magic number for rocketport "
304                                 "struct in %s\n", routine);
305                 return 1;
306         }
307 #endif
308         return 0;
309 }
310
311
312 /*  Serial port receive data function.  Called (from timer poll) when an AIOPIC signals 
313  *  that receive data is present on a serial port.  Pulls data from FIFO, moves it into the 
314  *  tty layer.  
315  */
316 static void rp_do_receive(struct r_port *info,
317                           struct tty_struct *tty,
318                           CHANNEL_t * cp, unsigned int ChanStatus)
319 {
320         unsigned int CharNStat;
321         int ToRecv, wRecv, space;
322         unsigned char *cbuf;
323
324         ToRecv = sGetRxCnt(cp);
325 #ifdef ROCKET_DEBUG_INTR
326         printk(KERN_INFO "rp_do_receive(%d)...\n", ToRecv);
327 #endif
328         if (ToRecv == 0)
329                 return;
330
331         /*
332          * if status indicates there are errored characters in the
333          * FIFO, then enter status mode (a word in FIFO holds
334          * character and status).
335          */
336         if (ChanStatus & (RXFOVERFL | RXBREAK | RXFRAME | RXPARITY)) {
337                 if (!(ChanStatus & STATMODE)) {
338 #ifdef ROCKET_DEBUG_RECEIVE
339                         printk(KERN_INFO "Entering STATMODE...\n");
340 #endif
341                         ChanStatus |= STATMODE;
342                         sEnRxStatusMode(cp);
343                 }
344         }
345
346         /* 
347          * if we previously entered status mode, then read down the
348          * FIFO one word at a time, pulling apart the character and
349          * the status.  Update error counters depending on status
350          */
351         if (ChanStatus & STATMODE) {
352 #ifdef ROCKET_DEBUG_RECEIVE
353                 printk(KERN_INFO "Ignore %x, read %x...\n",
354                         info->ignore_status_mask, info->read_status_mask);
355 #endif
356                 while (ToRecv) {
357                         char flag;
358
359                         CharNStat = sInW(sGetTxRxDataIO(cp));
360 #ifdef ROCKET_DEBUG_RECEIVE
361                         printk(KERN_INFO "%x...\n", CharNStat);
362 #endif
363                         if (CharNStat & STMBREAKH)
364                                 CharNStat &= ~(STMFRAMEH | STMPARITYH);
365                         if (CharNStat & info->ignore_status_mask) {
366                                 ToRecv--;
367                                 continue;
368                         }
369                         CharNStat &= info->read_status_mask;
370                         if (CharNStat & STMBREAKH)
371                                 flag = TTY_BREAK;
372                         else if (CharNStat & STMPARITYH)
373                                 flag = TTY_PARITY;
374                         else if (CharNStat & STMFRAMEH)
375                                 flag = TTY_FRAME;
376                         else if (CharNStat & STMRCVROVRH)
377                                 flag = TTY_OVERRUN;
378                         else
379                                 flag = TTY_NORMAL;
380                         tty_insert_flip_char(tty, CharNStat & 0xff, flag);
381                         ToRecv--;
382                 }
383
384                 /*
385                  * after we've emptied the FIFO in status mode, turn
386                  * status mode back off
387                  */
388                 if (sGetRxCnt(cp) == 0) {
389 #ifdef ROCKET_DEBUG_RECEIVE
390                         printk(KERN_INFO "Status mode off.\n");
391 #endif
392                         sDisRxStatusMode(cp);
393                 }
394         } else {
395                 /*
396                  * we aren't in status mode, so read down the FIFO two
397                  * characters at time by doing repeated word IO
398                  * transfer.
399                  */
400                 space = tty_prepare_flip_string(tty, &cbuf, ToRecv);
401                 if (space < ToRecv) {
402 #ifdef ROCKET_DEBUG_RECEIVE
403                         printk(KERN_INFO "rp_do_receive:insufficient space ToRecv=%d space=%d\n", ToRecv, space);
404 #endif
405                         if (space <= 0)
406                                 return;
407                         ToRecv = space;
408                 }
409                 wRecv = ToRecv >> 1;
410                 if (wRecv)
411                         sInStrW(sGetTxRxDataIO(cp), (unsigned short *) cbuf, wRecv);
412                 if (ToRecv & 1)
413                         cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
414         }
415         /*  Push the data up to the tty layer */
416         tty_flip_buffer_push(tty);
417 }
418
419 /*
420  *  Serial port transmit data function.  Called from the timer polling loop as a 
421  *  result of a bit set in xmit_flags[], indicating data (from the tty layer) is ready
422  *  to be sent out the serial port.  Data is buffered in rp_table[line].xmit_buf, it is 
423  *  moved to the port's xmit FIFO.  *info is critical data, protected by spinlocks.
424  */
425 static void rp_do_transmit(struct r_port *info)
426 {
427         int c;
428         CHANNEL_t *cp = &info->channel;
429         struct tty_struct *tty;
430         unsigned long flags;
431
432 #ifdef ROCKET_DEBUG_INTR
433         printk(KERN_DEBUG "%s\n", __func__);
434 #endif
435         if (!info)
436                 return;
437         if (!info->tty) {
438                 printk(KERN_WARNING "rp: WARNING %s called with "
439                                 "info->tty==NULL\n", __func__);
440                 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
441                 return;
442         }
443
444         spin_lock_irqsave(&info->slock, flags);
445         tty = info->tty;
446         info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
447
448         /*  Loop sending data to FIFO until done or FIFO full */
449         while (1) {
450                 if (tty->stopped || tty->hw_stopped)
451                         break;
452                 c = min(info->xmit_fifo_room, min(info->xmit_cnt, XMIT_BUF_SIZE - info->xmit_tail));
453                 if (c <= 0 || info->xmit_fifo_room <= 0)
454                         break;
455                 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) (info->xmit_buf + info->xmit_tail), c / 2);
456                 if (c & 1)
457                         sOutB(sGetTxRxDataIO(cp), info->xmit_buf[info->xmit_tail + c - 1]);
458                 info->xmit_tail += c;
459                 info->xmit_tail &= XMIT_BUF_SIZE - 1;
460                 info->xmit_cnt -= c;
461                 info->xmit_fifo_room -= c;
462 #ifdef ROCKET_DEBUG_INTR
463                 printk(KERN_INFO "tx %d chars...\n", c);
464 #endif
465         }
466
467         if (info->xmit_cnt == 0)
468                 clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
469
470         if (info->xmit_cnt < WAKEUP_CHARS) {
471                 tty_wakeup(tty);
472 #ifdef ROCKETPORT_HAVE_POLL_WAIT
473                 wake_up_interruptible(&tty->poll_wait);
474 #endif
475         }
476
477         spin_unlock_irqrestore(&info->slock, flags);
478
479 #ifdef ROCKET_DEBUG_INTR
480         printk(KERN_DEBUG "(%d,%d,%d,%d)...\n", info->xmit_cnt, info->xmit_head,
481                info->xmit_tail, info->xmit_fifo_room);
482 #endif
483 }
484
485 /*
486  *  Called when a serial port signals it has read data in it's RX FIFO.
487  *  It checks what interrupts are pending and services them, including
488  *  receiving serial data.  
489  */
490 static void rp_handle_port(struct r_port *info)
491 {
492         CHANNEL_t *cp;
493         struct tty_struct *tty;
494         unsigned int IntMask, ChanStatus;
495
496         if (!info)
497                 return;
498
499         if ((info->flags & ROCKET_INITIALIZED) == 0) {
500                 printk(KERN_WARNING "rp: WARNING: rp_handle_port called with "
501                                 "info->flags & NOT_INIT\n");
502                 return;
503         }
504         if (!info->tty) {
505                 printk(KERN_WARNING "rp: WARNING: rp_handle_port called with "
506                                 "info->tty==NULL\n");
507                 return;
508         }
509         cp = &info->channel;
510         tty = info->tty;
511
512         IntMask = sGetChanIntID(cp) & info->intmask;
513 #ifdef ROCKET_DEBUG_INTR
514         printk(KERN_INFO "rp_interrupt %02x...\n", IntMask);
515 #endif
516         ChanStatus = sGetChanStatus(cp);
517         if (IntMask & RXF_TRIG) {       /* Rx FIFO trigger level */
518                 rp_do_receive(info, tty, cp, ChanStatus);
519         }
520         if (IntMask & DELTA_CD) {       /* CD change  */
521 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_INTR) || defined(ROCKET_DEBUG_HANGUP))
522                 printk(KERN_INFO "ttyR%d CD now %s...\n", info->line,
523                        (ChanStatus & CD_ACT) ? "on" : "off");
524 #endif
525                 if (!(ChanStatus & CD_ACT) && info->cd_status) {
526 #ifdef ROCKET_DEBUG_HANGUP
527                         printk(KERN_INFO "CD drop, calling hangup.\n");
528 #endif
529                         tty_hangup(tty);
530                 }
531                 info->cd_status = (ChanStatus & CD_ACT) ? 1 : 0;
532                 wake_up_interruptible(&info->open_wait);
533         }
534 #ifdef ROCKET_DEBUG_INTR
535         if (IntMask & DELTA_CTS) {      /* CTS change */
536                 printk(KERN_INFO "CTS change...\n");
537         }
538         if (IntMask & DELTA_DSR) {      /* DSR change */
539                 printk(KERN_INFO "DSR change...\n");
540         }
541 #endif
542 }
543
544 /*
545  *  The top level polling routine.  Repeats every 1/100 HZ (10ms).
546  */
547 static void rp_do_poll(unsigned long dummy)
548 {
549         CONTROLLER_t *ctlp;
550         int ctrl, aiop, ch, line;
551         unsigned int xmitmask, i;
552         unsigned int CtlMask;
553         unsigned char AiopMask;
554         Word_t bit;
555
556         /*  Walk through all the boards (ctrl's) */
557         for (ctrl = 0; ctrl < max_board; ctrl++) {
558                 if (rcktpt_io_addr[ctrl] <= 0)
559                         continue;
560
561                 /*  Get a ptr to the board's control struct */
562                 ctlp = sCtlNumToCtlPtr(ctrl);
563
564                 /*  Get the interrupt status from the board */
565 #ifdef CONFIG_PCI
566                 if (ctlp->BusType == isPCI)
567                         CtlMask = sPCIGetControllerIntStatus(ctlp);
568                 else
569 #endif
570                         CtlMask = sGetControllerIntStatus(ctlp);
571
572                 /*  Check if any AIOP read bits are set */
573                 for (aiop = 0; CtlMask; aiop++) {
574                         bit = ctlp->AiopIntrBits[aiop];
575                         if (CtlMask & bit) {
576                                 CtlMask &= ~bit;
577                                 AiopMask = sGetAiopIntStatus(ctlp, aiop);
578
579                                 /*  Check if any port read bits are set */
580                                 for (ch = 0; AiopMask;  AiopMask >>= 1, ch++) {
581                                         if (AiopMask & 1) {
582
583                                                 /*  Get the line number (/dev/ttyRx number). */
584                                                 /*  Read the data from the port. */
585                                                 line = GetLineNumber(ctrl, aiop, ch);
586                                                 rp_handle_port(rp_table[line]);
587                                         }
588                                 }
589                         }
590                 }
591
592                 xmitmask = xmit_flags[ctrl];
593
594                 /*
595                  *  xmit_flags contains bit-significant flags, indicating there is data
596                  *  to xmit on the port. Bit 0 is port 0 on this board, bit 1 is port 
597                  *  1, ... (32 total possible).  The variable i has the aiop and ch 
598                  *  numbers encoded in it (port 0-7 are aiop0, 8-15 are aiop1, etc).
599                  */
600                 if (xmitmask) {
601                         for (i = 0; i < rocketModel[ctrl].numPorts; i++) {
602                                 if (xmitmask & (1 << i)) {
603                                         aiop = (i & 0x18) >> 3;
604                                         ch = i & 0x07;
605                                         line = GetLineNumber(ctrl, aiop, ch);
606                                         rp_do_transmit(rp_table[line]);
607                                 }
608                         }
609                 }
610         }
611
612         /*
613          * Reset the timer so we get called at the next clock tick (10ms).
614          */
615         if (atomic_read(&rp_num_ports_open))
616                 mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
617 }
618
619 /*
620  *  Initializes the r_port structure for a port, as well as enabling the port on 
621  *  the board.  
622  *  Inputs:  board, aiop, chan numbers
623  */
624 static void init_r_port(int board, int aiop, int chan, struct pci_dev *pci_dev)
625 {
626         unsigned rocketMode;
627         struct r_port *info;
628         int line;
629         CONTROLLER_T *ctlp;
630
631         /*  Get the next available line number */
632         line = SetLineNumber(board, aiop, chan);
633
634         ctlp = sCtlNumToCtlPtr(board);
635
636         /*  Get a r_port struct for the port, fill it in and save it globally, indexed by line number */
637         info = kzalloc(sizeof (struct r_port), GFP_KERNEL);
638         if (!info) {
639                 printk(KERN_ERR "Couldn't allocate info struct for line #%d\n",
640                                 line);
641                 return;
642         }
643
644         info->magic = RPORT_MAGIC;
645         info->line = line;
646         info->ctlp = ctlp;
647         info->board = board;
648         info->aiop = aiop;
649         info->chan = chan;
650         info->closing_wait = 3000;
651         info->close_delay = 50;
652         init_waitqueue_head(&info->open_wait);
653         init_completion(&info->close_wait);
654         info->flags &= ~ROCKET_MODE_MASK;
655         switch (pc104[board][line]) {
656         case 422:
657                 info->flags |= ROCKET_MODE_RS422;
658                 break;
659         case 485:
660                 info->flags |= ROCKET_MODE_RS485;
661                 break;
662         case 232:
663         default:
664                 info->flags |= ROCKET_MODE_RS232;
665                 break;
666         }
667
668         info->intmask = RXF_TRIG | TXFIFO_MT | SRC_INT | DELTA_CD | DELTA_CTS | DELTA_DSR;
669         if (sInitChan(ctlp, &info->channel, aiop, chan) == 0) {
670                 printk(KERN_ERR "RocketPort sInitChan(%d, %d, %d) failed!\n",
671                                 board, aiop, chan);
672                 kfree(info);
673                 return;
674         }
675
676         rocketMode = info->flags & ROCKET_MODE_MASK;
677
678         if ((info->flags & ROCKET_RTS_TOGGLE) || (rocketMode == ROCKET_MODE_RS485))
679                 sEnRTSToggle(&info->channel);
680         else
681                 sDisRTSToggle(&info->channel);
682
683         if (ctlp->boardType == ROCKET_TYPE_PC104) {
684                 switch (rocketMode) {
685                 case ROCKET_MODE_RS485:
686                         sSetInterfaceMode(&info->channel, InterfaceModeRS485);
687                         break;
688                 case ROCKET_MODE_RS422:
689                         sSetInterfaceMode(&info->channel, InterfaceModeRS422);
690                         break;
691                 case ROCKET_MODE_RS232:
692                 default:
693                         if (info->flags & ROCKET_RTS_TOGGLE)
694                                 sSetInterfaceMode(&info->channel, InterfaceModeRS232T);
695                         else
696                                 sSetInterfaceMode(&info->channel, InterfaceModeRS232);
697                         break;
698                 }
699         }
700         spin_lock_init(&info->slock);
701         mutex_init(&info->write_mtx);
702         rp_table[line] = info;
703         tty_register_device(rocket_driver, line, pci_dev ? &pci_dev->dev :
704                         NULL);
705 }
706
707 /*
708  *  Configures a rocketport port according to its termio settings.  Called from 
709  *  user mode into the driver (exception handler).  *info CD manipulation is spinlock protected.
710  */
711 static void configure_r_port(struct r_port *info,
712                              struct ktermios *old_termios)
713 {
714         unsigned cflag;
715         unsigned long flags;
716         unsigned rocketMode;
717         int bits, baud, divisor;
718         CHANNEL_t *cp;
719         struct ktermios *t = info->tty->termios;
720
721         cp = &info->channel;
722         cflag = t->c_cflag;
723
724         /* Byte size and parity */
725         if ((cflag & CSIZE) == CS8) {
726                 sSetData8(cp);
727                 bits = 10;
728         } else {
729                 sSetData7(cp);
730                 bits = 9;
731         }
732         if (cflag & CSTOPB) {
733                 sSetStop2(cp);
734                 bits++;
735         } else {
736                 sSetStop1(cp);
737         }
738
739         if (cflag & PARENB) {
740                 sEnParity(cp);
741                 bits++;
742                 if (cflag & PARODD) {
743                         sSetOddParity(cp);
744                 } else {
745                         sSetEvenParity(cp);
746                 }
747         } else {
748                 sDisParity(cp);
749         }
750
751         /* baud rate */
752         baud = tty_get_baud_rate(info->tty);
753         if (!baud)
754                 baud = 9600;
755         divisor = ((rp_baud_base[info->board] + (baud >> 1)) / baud) - 1;
756         if ((divisor >= 8192 || divisor < 0) && old_termios) {
757                 baud = tty_termios_baud_rate(old_termios);
758                 if (!baud)
759                         baud = 9600;
760                 divisor = (rp_baud_base[info->board] / baud) - 1;
761         }
762         if (divisor >= 8192 || divisor < 0) {
763                 baud = 9600;
764                 divisor = (rp_baud_base[info->board] / baud) - 1;
765         }
766         info->cps = baud / bits;
767         sSetBaud(cp, divisor);
768
769         /* FIXME: Should really back compute a baud rate from the divisor */
770         tty_encode_baud_rate(info->tty, baud, baud);
771
772         if (cflag & CRTSCTS) {
773                 info->intmask |= DELTA_CTS;
774                 sEnCTSFlowCtl(cp);
775         } else {
776                 info->intmask &= ~DELTA_CTS;
777                 sDisCTSFlowCtl(cp);
778         }
779         if (cflag & CLOCAL) {
780                 info->intmask &= ~DELTA_CD;
781         } else {
782                 spin_lock_irqsave(&info->slock, flags);
783                 if (sGetChanStatus(cp) & CD_ACT)
784                         info->cd_status = 1;
785                 else
786                         info->cd_status = 0;
787                 info->intmask |= DELTA_CD;
788                 spin_unlock_irqrestore(&info->slock, flags);
789         }
790
791         /*
792          * Handle software flow control in the board
793          */
794 #ifdef ROCKET_SOFT_FLOW
795         if (I_IXON(info->tty)) {
796                 sEnTxSoftFlowCtl(cp);
797                 if (I_IXANY(info->tty)) {
798                         sEnIXANY(cp);
799                 } else {
800                         sDisIXANY(cp);
801                 }
802                 sSetTxXONChar(cp, START_CHAR(info->tty));
803                 sSetTxXOFFChar(cp, STOP_CHAR(info->tty));
804         } else {
805                 sDisTxSoftFlowCtl(cp);
806                 sDisIXANY(cp);
807                 sClrTxXOFF(cp);
808         }
809 #endif
810
811         /*
812          * Set up ignore/read mask words
813          */
814         info->read_status_mask = STMRCVROVRH | 0xFF;
815         if (I_INPCK(info->tty))
816                 info->read_status_mask |= STMFRAMEH | STMPARITYH;
817         if (I_BRKINT(info->tty) || I_PARMRK(info->tty))
818                 info->read_status_mask |= STMBREAKH;
819
820         /*
821          * Characters to ignore
822          */
823         info->ignore_status_mask = 0;
824         if (I_IGNPAR(info->tty))
825                 info->ignore_status_mask |= STMFRAMEH | STMPARITYH;
826         if (I_IGNBRK(info->tty)) {
827                 info->ignore_status_mask |= STMBREAKH;
828                 /*
829                  * If we're ignoring parity and break indicators,
830                  * ignore overruns too.  (For real raw support).
831                  */
832                 if (I_IGNPAR(info->tty))
833                         info->ignore_status_mask |= STMRCVROVRH;
834         }
835
836         rocketMode = info->flags & ROCKET_MODE_MASK;
837
838         if ((info->flags & ROCKET_RTS_TOGGLE)
839             || (rocketMode == ROCKET_MODE_RS485))
840                 sEnRTSToggle(cp);
841         else
842                 sDisRTSToggle(cp);
843
844         sSetRTS(&info->channel);
845
846         if (cp->CtlP->boardType == ROCKET_TYPE_PC104) {
847                 switch (rocketMode) {
848                 case ROCKET_MODE_RS485:
849                         sSetInterfaceMode(cp, InterfaceModeRS485);
850                         break;
851                 case ROCKET_MODE_RS422:
852                         sSetInterfaceMode(cp, InterfaceModeRS422);
853                         break;
854                 case ROCKET_MODE_RS232:
855                 default:
856                         if (info->flags & ROCKET_RTS_TOGGLE)
857                                 sSetInterfaceMode(cp, InterfaceModeRS232T);
858                         else
859                                 sSetInterfaceMode(cp, InterfaceModeRS232);
860                         break;
861                 }
862         }
863 }
864
865 /*  info->count is considered critical, protected by spinlocks.  */
866 static int block_til_ready(struct tty_struct *tty, struct file *filp,
867                            struct r_port *info)
868 {
869         DECLARE_WAITQUEUE(wait, current);
870         int retval;
871         int do_clocal = 0, extra_count = 0;
872         unsigned long flags;
873
874         /*
875          * If the device is in the middle of being closed, then block
876          * until it's done, and then try again.
877          */
878         if (tty_hung_up_p(filp))
879                 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
880         if (info->flags & ROCKET_CLOSING) {
881                 if (wait_for_completion_interruptible(&info->close_wait))
882                         return -ERESTARTSYS;
883                 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
884         }
885
886         /*
887          * If non-blocking mode is set, or the port is not enabled,
888          * then make the check up front and then exit.
889          */
890         if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
891                 info->flags |= ROCKET_NORMAL_ACTIVE;
892                 return 0;
893         }
894         if (tty->termios->c_cflag & CLOCAL)
895                 do_clocal = 1;
896
897         /*
898          * Block waiting for the carrier detect and the line to become free.  While we are in
899          * this loop, info->count is dropped by one, so that rp_close() knows when to free things.  
900          * We restore it upon exit, either normal or abnormal.
901          */
902         retval = 0;
903         add_wait_queue(&info->open_wait, &wait);
904 #ifdef ROCKET_DEBUG_OPEN
905         printk(KERN_INFO "block_til_ready before block: ttyR%d, count = %d\n", info->line, info->count);
906 #endif
907         spin_lock_irqsave(&info->slock, flags);
908
909 #ifdef ROCKET_DISABLE_SIMUSAGE
910         info->flags |= ROCKET_NORMAL_ACTIVE;
911 #else
912         if (!tty_hung_up_p(filp)) {
913                 extra_count = 1;
914                 info->count--;
915         }
916 #endif
917         info->blocked_open++;
918
919         spin_unlock_irqrestore(&info->slock, flags);
920
921         while (1) {
922                 if (tty->termios->c_cflag & CBAUD) {
923                         sSetDTR(&info->channel);
924                         sSetRTS(&info->channel);
925                 }
926                 set_current_state(TASK_INTERRUPTIBLE);
927                 if (tty_hung_up_p(filp) || !(info->flags & ROCKET_INITIALIZED)) {
928                         if (info->flags & ROCKET_HUP_NOTIFY)
929                                 retval = -EAGAIN;
930                         else
931                                 retval = -ERESTARTSYS;
932                         break;
933                 }
934                 if (!(info->flags & ROCKET_CLOSING) && (do_clocal || (sGetChanStatusLo(&info->channel) & CD_ACT)))
935                         break;
936                 if (signal_pending(current)) {
937                         retval = -ERESTARTSYS;
938                         break;
939                 }
940 #ifdef ROCKET_DEBUG_OPEN
941                 printk(KERN_INFO "block_til_ready blocking: ttyR%d, count = %d, flags=0x%0x\n",
942                      info->line, info->count, info->flags);
943 #endif
944                 schedule();     /*  Don't hold spinlock here, will hang PC */
945         }
946         __set_current_state(TASK_RUNNING);
947         remove_wait_queue(&info->open_wait, &wait);
948
949         spin_lock_irqsave(&info->slock, flags);
950
951         if (extra_count)
952                 info->count++;
953         info->blocked_open--;
954
955         spin_unlock_irqrestore(&info->slock, flags);
956
957 #ifdef ROCKET_DEBUG_OPEN
958         printk(KERN_INFO "block_til_ready after blocking: ttyR%d, count = %d\n",
959                info->line, info->count);
960 #endif
961         if (retval)
962                 return retval;
963         info->flags |= ROCKET_NORMAL_ACTIVE;
964         return 0;
965 }
966
967 /*
968  *  Exception handler that opens a serial port.  Creates xmit_buf storage, fills in 
969  *  port's r_port struct.  Initializes the port hardware.  
970  */
971 static int rp_open(struct tty_struct *tty, struct file *filp)
972 {
973         struct r_port *info;
974         int line = 0, retval;
975         CHANNEL_t *cp;
976         unsigned long page;
977
978         line = tty->index;
979         if ((line < 0) || (line >= MAX_RP_PORTS) || ((info = rp_table[line]) == NULL))
980                 return -ENXIO;
981
982         page = __get_free_page(GFP_KERNEL);
983         if (!page)
984                 return -ENOMEM;
985
986         if (info->flags & ROCKET_CLOSING) {
987                 retval = wait_for_completion_interruptible(&info->close_wait);
988                 free_page(page);
989                 if (retval)
990                         return retval;
991                 return ((info->flags & ROCKET_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
992         }
993
994         /*
995          * We must not sleep from here until the port is marked fully in use.
996          */
997         if (info->xmit_buf)
998                 free_page(page);
999         else
1000                 info->xmit_buf = (unsigned char *) page;
1001
1002         tty->driver_data = info;
1003         info->tty = tty;
1004
1005         if (info->count++ == 0) {
1006                 atomic_inc(&rp_num_ports_open);
1007
1008 #ifdef ROCKET_DEBUG_OPEN
1009                 printk(KERN_INFO "rocket mod++ = %d...\n",
1010                                 atomic_read(&rp_num_ports_open));
1011 #endif
1012         }
1013 #ifdef ROCKET_DEBUG_OPEN
1014         printk(KERN_INFO "rp_open ttyR%d, count=%d\n", info->line, info->count);
1015 #endif
1016
1017         /*
1018          * Info->count is now 1; so it's safe to sleep now.
1019          */
1020         if ((info->flags & ROCKET_INITIALIZED) == 0) {
1021                 cp = &info->channel;
1022                 sSetRxTrigger(cp, TRIG_1);
1023                 if (sGetChanStatus(cp) & CD_ACT)
1024                         info->cd_status = 1;
1025                 else
1026                         info->cd_status = 0;
1027                 sDisRxStatusMode(cp);
1028                 sFlushRxFIFO(cp);
1029                 sFlushTxFIFO(cp);
1030
1031                 sEnInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1032                 sSetRxTrigger(cp, TRIG_1);
1033
1034                 sGetChanStatus(cp);
1035                 sDisRxStatusMode(cp);
1036                 sClrTxXOFF(cp);
1037
1038                 sDisCTSFlowCtl(cp);
1039                 sDisTxSoftFlowCtl(cp);
1040
1041                 sEnRxFIFO(cp);
1042                 sEnTransmit(cp);
1043
1044                 info->flags |= ROCKET_INITIALIZED;
1045
1046                 /*
1047                  * Set up the tty->alt_speed kludge
1048                  */
1049                 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1050                         info->tty->alt_speed = 57600;
1051                 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1052                         info->tty->alt_speed = 115200;
1053                 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1054                         info->tty->alt_speed = 230400;
1055                 if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1056                         info->tty->alt_speed = 460800;
1057
1058                 configure_r_port(info, NULL);
1059                 if (tty->termios->c_cflag & CBAUD) {
1060                         sSetDTR(cp);
1061                         sSetRTS(cp);
1062                 }
1063         }
1064         /*  Starts (or resets) the maint polling loop */
1065         mod_timer(&rocket_timer, jiffies + POLL_PERIOD);
1066
1067         retval = block_til_ready(tty, filp, info);
1068         if (retval) {
1069 #ifdef ROCKET_DEBUG_OPEN
1070                 printk(KERN_INFO "rp_open returning after block_til_ready with %d\n", retval);
1071 #endif
1072                 return retval;
1073         }
1074         return 0;
1075 }
1076
1077 /*
1078  *  Exception handler that closes a serial port. info->count is considered critical. 
1079  */
1080 static void rp_close(struct tty_struct *tty, struct file *filp)
1081 {
1082         struct r_port *info = (struct r_port *) tty->driver_data;
1083         unsigned long flags;
1084         int timeout;
1085         CHANNEL_t *cp;
1086         
1087         if (rocket_paranoia_check(info, "rp_close"))
1088                 return;
1089
1090 #ifdef ROCKET_DEBUG_OPEN
1091         printk(KERN_INFO "rp_close ttyR%d, count = %d\n", info->line, info->count);
1092 #endif
1093
1094         if (tty_hung_up_p(filp))
1095                 return;
1096         spin_lock_irqsave(&info->slock, flags);
1097
1098         if ((tty->count == 1) && (info->count != 1)) {
1099                 /*
1100                  * Uh, oh.  tty->count is 1, which means that the tty
1101                  * structure will be freed.  Info->count should always
1102                  * be one in these conditions.  If it's greater than
1103                  * one, we've got real problems, since it means the
1104                  * serial port won't be shutdown.
1105                  */
1106                 printk(KERN_WARNING "rp_close: bad serial port count; "
1107                         "tty->count is 1, info->count is %d\n", info->count);
1108                 info->count = 1;
1109         }
1110         if (--info->count < 0) {
1111                 printk(KERN_WARNING "rp_close: bad serial port count for "
1112                                 "ttyR%d: %d\n", info->line, info->count);
1113                 info->count = 0;
1114         }
1115         if (info->count) {
1116                 spin_unlock_irqrestore(&info->slock, flags);
1117                 return;
1118         }
1119         info->flags |= ROCKET_CLOSING;
1120         spin_unlock_irqrestore(&info->slock, flags);
1121
1122         cp = &info->channel;
1123
1124         /*
1125          * Notify the line discpline to only process XON/XOFF characters
1126          */
1127         tty->closing = 1;
1128
1129         /*
1130          * If transmission was throttled by the application request,
1131          * just flush the xmit buffer.
1132          */
1133         if (tty->flow_stopped)
1134                 rp_flush_buffer(tty);
1135
1136         /*
1137          * Wait for the transmit buffer to clear
1138          */
1139         if (info->closing_wait != ROCKET_CLOSING_WAIT_NONE)
1140                 tty_wait_until_sent(tty, info->closing_wait);
1141         /*
1142          * Before we drop DTR, make sure the UART transmitter
1143          * has completely drained; this is especially
1144          * important if there is a transmit FIFO!
1145          */
1146         timeout = (sGetTxCnt(cp) + 1) * HZ / info->cps;
1147         if (timeout == 0)
1148                 timeout = 1;
1149         rp_wait_until_sent(tty, timeout);
1150         clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1151
1152         sDisTransmit(cp);
1153         sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1154         sDisCTSFlowCtl(cp);
1155         sDisTxSoftFlowCtl(cp);
1156         sClrTxXOFF(cp);
1157         sFlushRxFIFO(cp);
1158         sFlushTxFIFO(cp);
1159         sClrRTS(cp);
1160         if (C_HUPCL(tty))
1161                 sClrDTR(cp);
1162
1163         rp_flush_buffer(tty);
1164                 
1165         tty_ldisc_flush(tty);
1166
1167         clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1168
1169         if (info->blocked_open) {
1170                 if (info->close_delay) {
1171                         msleep_interruptible(jiffies_to_msecs(info->close_delay));
1172                 }
1173                 wake_up_interruptible(&info->open_wait);
1174         } else {
1175                 if (info->xmit_buf) {
1176                         free_page((unsigned long) info->xmit_buf);
1177                         info->xmit_buf = NULL;
1178                 }
1179         }
1180         info->flags &= ~(ROCKET_INITIALIZED | ROCKET_CLOSING | ROCKET_NORMAL_ACTIVE);
1181         tty->closing = 0;
1182         complete_all(&info->close_wait);
1183         atomic_dec(&rp_num_ports_open);
1184
1185 #ifdef ROCKET_DEBUG_OPEN
1186         printk(KERN_INFO "rocket mod-- = %d...\n",
1187                         atomic_read(&rp_num_ports_open));
1188         printk(KERN_INFO "rp_close ttyR%d complete shutdown\n", info->line);
1189 #endif
1190
1191 }
1192
1193 static void rp_set_termios(struct tty_struct *tty,
1194                            struct ktermios *old_termios)
1195 {
1196         struct r_port *info = (struct r_port *) tty->driver_data;
1197         CHANNEL_t *cp;
1198         unsigned cflag;
1199
1200         if (rocket_paranoia_check(info, "rp_set_termios"))
1201                 return;
1202
1203         cflag = tty->termios->c_cflag;
1204
1205         /*
1206          * This driver doesn't support CS5 or CS6
1207          */
1208         if (((cflag & CSIZE) == CS5) || ((cflag & CSIZE) == CS6))
1209                 tty->termios->c_cflag =
1210                     ((cflag & ~CSIZE) | (old_termios->c_cflag & CSIZE));
1211         /* Or CMSPAR */
1212         tty->termios->c_cflag &= ~CMSPAR;
1213
1214         configure_r_port(info, old_termios);
1215
1216         cp = &info->channel;
1217
1218         /* Handle transition to B0 status */
1219         if ((old_termios->c_cflag & CBAUD) && !(tty->termios->c_cflag & CBAUD)) {
1220                 sClrDTR(cp);
1221                 sClrRTS(cp);
1222         }
1223
1224         /* Handle transition away from B0 status */
1225         if (!(old_termios->c_cflag & CBAUD) && (tty->termios->c_cflag & CBAUD)) {
1226                 if (!tty->hw_stopped || !(tty->termios->c_cflag & CRTSCTS))
1227                         sSetRTS(cp);
1228                 sSetDTR(cp);
1229         }
1230
1231         if ((old_termios->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) {
1232                 tty->hw_stopped = 0;
1233                 rp_start(tty);
1234         }
1235 }
1236
1237 static void rp_break(struct tty_struct *tty, int break_state)
1238 {
1239         struct r_port *info = (struct r_port *) tty->driver_data;
1240         unsigned long flags;
1241
1242         if (rocket_paranoia_check(info, "rp_break"))
1243                 return;
1244
1245         spin_lock_irqsave(&info->slock, flags);
1246         if (break_state == -1)
1247                 sSendBreak(&info->channel);
1248         else
1249                 sClrBreak(&info->channel);
1250         spin_unlock_irqrestore(&info->slock, flags);
1251 }
1252
1253 /*
1254  * sGetChanRI used to be a macro in rocket_int.h. When the functionality for
1255  * the UPCI boards was added, it was decided to make this a function because
1256  * the macro was getting too complicated. All cases except the first one
1257  * (UPCIRingInd) are taken directly from the original macro.
1258  */
1259 static int sGetChanRI(CHANNEL_T * ChP)
1260 {
1261         CONTROLLER_t *CtlP = ChP->CtlP;
1262         int ChanNum = ChP->ChanNum;
1263         int RingInd = 0;
1264
1265         if (CtlP->UPCIRingInd)
1266                 RingInd = !(sInB(CtlP->UPCIRingInd) & sBitMapSetTbl[ChanNum]);
1267         else if (CtlP->AltChanRingIndicator)
1268                 RingInd = sInB((ByteIO_t) (ChP->ChanStat + 8)) & DSR_ACT;
1269         else if (CtlP->boardType == ROCKET_TYPE_PC104)
1270                 RingInd = !(sInB(CtlP->AiopIO[3]) & sBitMapSetTbl[ChanNum]);
1271
1272         return RingInd;
1273 }
1274
1275 /********************************************************************************************/
1276 /*  Here are the routines used by rp_ioctl.  These are all called from exception handlers.  */
1277
1278 /*
1279  *  Returns the state of the serial modem control lines.  These next 2 functions 
1280  *  are the way kernel versions > 2.5 handle modem control lines rather than IOCTLs.
1281  */
1282 static int rp_tiocmget(struct tty_struct *tty, struct file *file)
1283 {
1284         struct r_port *info = (struct r_port *)tty->driver_data;
1285         unsigned int control, result, ChanStatus;
1286
1287         ChanStatus = sGetChanStatusLo(&info->channel);
1288         control = info->channel.TxControl[3];
1289         result = ((control & SET_RTS) ? TIOCM_RTS : 0) | 
1290                 ((control & SET_DTR) ?  TIOCM_DTR : 0) |
1291                 ((ChanStatus & CD_ACT) ? TIOCM_CAR : 0) |
1292                 (sGetChanRI(&info->channel) ? TIOCM_RNG : 0) |
1293                 ((ChanStatus & DSR_ACT) ? TIOCM_DSR : 0) |
1294                 ((ChanStatus & CTS_ACT) ? TIOCM_CTS : 0);
1295
1296         return result;
1297 }
1298
1299 /* 
1300  *  Sets the modem control lines
1301  */
1302 static int rp_tiocmset(struct tty_struct *tty, struct file *file,
1303                     unsigned int set, unsigned int clear)
1304 {
1305         struct r_port *info = (struct r_port *)tty->driver_data;
1306
1307         if (set & TIOCM_RTS)
1308                 info->channel.TxControl[3] |= SET_RTS;
1309         if (set & TIOCM_DTR)
1310                 info->channel.TxControl[3] |= SET_DTR;
1311         if (clear & TIOCM_RTS)
1312                 info->channel.TxControl[3] &= ~SET_RTS;
1313         if (clear & TIOCM_DTR)
1314                 info->channel.TxControl[3] &= ~SET_DTR;
1315
1316         out32(info->channel.IndexAddr, info->channel.TxControl);
1317         return 0;
1318 }
1319
1320 static int get_config(struct r_port *info, struct rocket_config __user *retinfo)
1321 {
1322         struct rocket_config tmp;
1323
1324         if (!retinfo)
1325                 return -EFAULT;
1326         memset(&tmp, 0, sizeof (tmp));
1327         tmp.line = info->line;
1328         tmp.flags = info->flags;
1329         tmp.close_delay = info->close_delay;
1330         tmp.closing_wait = info->closing_wait;
1331         tmp.port = rcktpt_io_addr[(info->line >> 5) & 3];
1332
1333         if (copy_to_user(retinfo, &tmp, sizeof (*retinfo)))
1334                 return -EFAULT;
1335         return 0;
1336 }
1337
1338 static int set_config(struct r_port *info, struct rocket_config __user *new_info)
1339 {
1340         struct rocket_config new_serial;
1341
1342         if (copy_from_user(&new_serial, new_info, sizeof (new_serial)))
1343                 return -EFAULT;
1344
1345         if (!capable(CAP_SYS_ADMIN))
1346         {
1347                 if ((new_serial.flags & ~ROCKET_USR_MASK) != (info->flags & ~ROCKET_USR_MASK))
1348                         return -EPERM;
1349                 info->flags = ((info->flags & ~ROCKET_USR_MASK) | (new_serial.flags & ROCKET_USR_MASK));
1350                 configure_r_port(info, NULL);
1351                 return 0;
1352         }
1353
1354         info->flags = ((info->flags & ~ROCKET_FLAGS) | (new_serial.flags & ROCKET_FLAGS));
1355         info->close_delay = new_serial.close_delay;
1356         info->closing_wait = new_serial.closing_wait;
1357
1358         if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_HI)
1359                 info->tty->alt_speed = 57600;
1360         if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_VHI)
1361                 info->tty->alt_speed = 115200;
1362         if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_SHI)
1363                 info->tty->alt_speed = 230400;
1364         if ((info->flags & ROCKET_SPD_MASK) == ROCKET_SPD_WARP)
1365                 info->tty->alt_speed = 460800;
1366
1367         configure_r_port(info, NULL);
1368         return 0;
1369 }
1370
1371 /*
1372  *  This function fills in a rocket_ports struct with information
1373  *  about what boards/ports are in the system.  This info is passed
1374  *  to user space.  See setrocket.c where the info is used to create
1375  *  the /dev/ttyRx ports.
1376  */
1377 static int get_ports(struct r_port *info, struct rocket_ports __user *retports)
1378 {
1379         struct rocket_ports tmp;
1380         int board;
1381
1382         if (!retports)
1383                 return -EFAULT;
1384         memset(&tmp, 0, sizeof (tmp));
1385         tmp.tty_major = rocket_driver->major;
1386
1387         for (board = 0; board < 4; board++) {
1388                 tmp.rocketModel[board].model = rocketModel[board].model;
1389                 strcpy(tmp.rocketModel[board].modelString, rocketModel[board].modelString);
1390                 tmp.rocketModel[board].numPorts = rocketModel[board].numPorts;
1391                 tmp.rocketModel[board].loadrm2 = rocketModel[board].loadrm2;
1392                 tmp.rocketModel[board].startingPortNumber = rocketModel[board].startingPortNumber;
1393         }
1394         if (copy_to_user(retports, &tmp, sizeof (*retports)))
1395                 return -EFAULT;
1396         return 0;
1397 }
1398
1399 static int reset_rm2(struct r_port *info, void __user *arg)
1400 {
1401         int reset;
1402
1403         if (!capable(CAP_SYS_ADMIN))
1404                 return -EPERM;
1405
1406         if (copy_from_user(&reset, arg, sizeof (int)))
1407                 return -EFAULT;
1408         if (reset)
1409                 reset = 1;
1410
1411         if (rcktpt_type[info->board] != ROCKET_TYPE_MODEMII &&
1412             rcktpt_type[info->board] != ROCKET_TYPE_MODEMIII)
1413                 return -EINVAL;
1414
1415         if (info->ctlp->BusType == isISA)
1416                 sModemReset(info->ctlp, info->chan, reset);
1417         else
1418                 sPCIModemReset(info->ctlp, info->chan, reset);
1419
1420         return 0;
1421 }
1422
1423 static int get_version(struct r_port *info, struct rocket_version __user *retvers)
1424 {
1425         if (copy_to_user(retvers, &driver_version, sizeof (*retvers)))
1426                 return -EFAULT;
1427         return 0;
1428 }
1429
1430 /*  IOCTL call handler into the driver */
1431 static int rp_ioctl(struct tty_struct *tty, struct file *file,
1432                     unsigned int cmd, unsigned long arg)
1433 {
1434         struct r_port *info = (struct r_port *) tty->driver_data;
1435         void __user *argp = (void __user *)arg;
1436
1437         if (cmd != RCKP_GET_PORTS && rocket_paranoia_check(info, "rp_ioctl"))
1438                 return -ENXIO;
1439
1440         switch (cmd) {
1441         case RCKP_GET_STRUCT:
1442                 if (copy_to_user(argp, info, sizeof (struct r_port)))
1443                         return -EFAULT;
1444                 return 0;
1445         case RCKP_GET_CONFIG:
1446                 return get_config(info, argp);
1447         case RCKP_SET_CONFIG:
1448                 return set_config(info, argp);
1449         case RCKP_GET_PORTS:
1450                 return get_ports(info, argp);
1451         case RCKP_RESET_RM2:
1452                 return reset_rm2(info, argp);
1453         case RCKP_GET_VERSION:
1454                 return get_version(info, argp);
1455         default:
1456                 return -ENOIOCTLCMD;
1457         }
1458         return 0;
1459 }
1460
1461 static void rp_send_xchar(struct tty_struct *tty, char ch)
1462 {
1463         struct r_port *info = (struct r_port *) tty->driver_data;
1464         CHANNEL_t *cp;
1465
1466         if (rocket_paranoia_check(info, "rp_send_xchar"))
1467                 return;
1468
1469         cp = &info->channel;
1470         if (sGetTxCnt(cp))
1471                 sWriteTxPrioByte(cp, ch);
1472         else
1473                 sWriteTxByte(sGetTxRxDataIO(cp), ch);
1474 }
1475
1476 static void rp_throttle(struct tty_struct *tty)
1477 {
1478         struct r_port *info = (struct r_port *) tty->driver_data;
1479         CHANNEL_t *cp;
1480
1481 #ifdef ROCKET_DEBUG_THROTTLE
1482         printk(KERN_INFO "throttle %s: %d....\n", tty->name,
1483                tty->ldisc.chars_in_buffer(tty));
1484 #endif
1485
1486         if (rocket_paranoia_check(info, "rp_throttle"))
1487                 return;
1488
1489         cp = &info->channel;
1490         if (I_IXOFF(tty))
1491                 rp_send_xchar(tty, STOP_CHAR(tty));
1492
1493         sClrRTS(&info->channel);
1494 }
1495
1496 static void rp_unthrottle(struct tty_struct *tty)
1497 {
1498         struct r_port *info = (struct r_port *) tty->driver_data;
1499         CHANNEL_t *cp;
1500 #ifdef ROCKET_DEBUG_THROTTLE
1501         printk(KERN_INFO "unthrottle %s: %d....\n", tty->name,
1502                tty->ldisc.chars_in_buffer(tty));
1503 #endif
1504
1505         if (rocket_paranoia_check(info, "rp_throttle"))
1506                 return;
1507
1508         cp = &info->channel;
1509         if (I_IXOFF(tty))
1510                 rp_send_xchar(tty, START_CHAR(tty));
1511
1512         sSetRTS(&info->channel);
1513 }
1514
1515 /*
1516  * ------------------------------------------------------------
1517  * rp_stop() and rp_start()
1518  *
1519  * This routines are called before setting or resetting tty->stopped.
1520  * They enable or disable transmitter interrupts, as necessary.
1521  * ------------------------------------------------------------
1522  */
1523 static void rp_stop(struct tty_struct *tty)
1524 {
1525         struct r_port *info = (struct r_port *) tty->driver_data;
1526
1527 #ifdef ROCKET_DEBUG_FLOW
1528         printk(KERN_INFO "stop %s: %d %d....\n", tty->name,
1529                info->xmit_cnt, info->xmit_fifo_room);
1530 #endif
1531
1532         if (rocket_paranoia_check(info, "rp_stop"))
1533                 return;
1534
1535         if (sGetTxCnt(&info->channel))
1536                 sDisTransmit(&info->channel);
1537 }
1538
1539 static void rp_start(struct tty_struct *tty)
1540 {
1541         struct r_port *info = (struct r_port *) tty->driver_data;
1542
1543 #ifdef ROCKET_DEBUG_FLOW
1544         printk(KERN_INFO "start %s: %d %d....\n", tty->name,
1545                info->xmit_cnt, info->xmit_fifo_room);
1546 #endif
1547
1548         if (rocket_paranoia_check(info, "rp_stop"))
1549                 return;
1550
1551         sEnTransmit(&info->channel);
1552         set_bit((info->aiop * 8) + info->chan,
1553                 (void *) &xmit_flags[info->board]);
1554 }
1555
1556 /*
1557  * rp_wait_until_sent() --- wait until the transmitter is empty
1558  */
1559 static void rp_wait_until_sent(struct tty_struct *tty, int timeout)
1560 {
1561         struct r_port *info = (struct r_port *) tty->driver_data;
1562         CHANNEL_t *cp;
1563         unsigned long orig_jiffies;
1564         int check_time, exit_time;
1565         int txcnt;
1566
1567         if (rocket_paranoia_check(info, "rp_wait_until_sent"))
1568                 return;
1569
1570         cp = &info->channel;
1571
1572         orig_jiffies = jiffies;
1573 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1574         printk(KERN_INFO "In RP_wait_until_sent(%d) (jiff=%lu)...\n", timeout,
1575                jiffies);
1576         printk(KERN_INFO "cps=%d...\n", info->cps);
1577 #endif
1578         while (1) {
1579                 txcnt = sGetTxCnt(cp);
1580                 if (!txcnt) {
1581                         if (sGetChanStatusLo(cp) & TXSHRMT)
1582                                 break;
1583                         check_time = (HZ / info->cps) / 5;
1584                 } else {
1585                         check_time = HZ * txcnt / info->cps;
1586                 }
1587                 if (timeout) {
1588                         exit_time = orig_jiffies + timeout - jiffies;
1589                         if (exit_time <= 0)
1590                                 break;
1591                         if (exit_time < check_time)
1592                                 check_time = exit_time;
1593                 }
1594                 if (check_time == 0)
1595                         check_time = 1;
1596 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1597                 printk(KERN_INFO "txcnt = %d (jiff=%lu,check=%d)...\n", txcnt,
1598                                 jiffies, check_time);
1599 #endif
1600                 msleep_interruptible(jiffies_to_msecs(check_time));
1601                 if (signal_pending(current))
1602                         break;
1603         }
1604         __set_current_state(TASK_RUNNING);
1605 #ifdef ROCKET_DEBUG_WAIT_UNTIL_SENT
1606         printk(KERN_INFO "txcnt = %d (jiff=%lu)...done\n", txcnt, jiffies);
1607 #endif
1608 }
1609
1610 /*
1611  * rp_hangup() --- called by tty_hangup() when a hangup is signaled.
1612  */
1613 static void rp_hangup(struct tty_struct *tty)
1614 {
1615         CHANNEL_t *cp;
1616         struct r_port *info = (struct r_port *) tty->driver_data;
1617
1618         if (rocket_paranoia_check(info, "rp_hangup"))
1619                 return;
1620
1621 #if (defined(ROCKET_DEBUG_OPEN) || defined(ROCKET_DEBUG_HANGUP))
1622         printk(KERN_INFO "rp_hangup of ttyR%d...\n", info->line);
1623 #endif
1624         rp_flush_buffer(tty);
1625         if (info->flags & ROCKET_CLOSING)
1626                 return;
1627         if (info->count) 
1628                 atomic_dec(&rp_num_ports_open);
1629         clear_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1630
1631         info->count = 0;
1632         info->flags &= ~ROCKET_NORMAL_ACTIVE;
1633         info->tty = NULL;
1634
1635         cp = &info->channel;
1636         sDisRxFIFO(cp);
1637         sDisTransmit(cp);
1638         sDisInterrupts(cp, (TXINT_EN | MCINT_EN | RXINT_EN | SRCINT_EN | CHANINT_EN));
1639         sDisCTSFlowCtl(cp);
1640         sDisTxSoftFlowCtl(cp);
1641         sClrTxXOFF(cp);
1642         info->flags &= ~ROCKET_INITIALIZED;
1643
1644         wake_up_interruptible(&info->open_wait);
1645 }
1646
1647 /*
1648  *  Exception handler - write char routine.  The RocketPort driver uses a
1649  *  double-buffering strategy, with the twist that if the in-memory CPU
1650  *  buffer is empty, and there's space in the transmit FIFO, the
1651  *  writing routines will write directly to transmit FIFO.
1652  *  Write buffer and counters protected by spinlocks
1653  */
1654 static void rp_put_char(struct tty_struct *tty, unsigned char ch)
1655 {
1656         struct r_port *info = (struct r_port *) tty->driver_data;
1657         CHANNEL_t *cp;
1658         unsigned long flags;
1659
1660         if (rocket_paranoia_check(info, "rp_put_char"))
1661                 return;
1662
1663         /*
1664          * Grab the port write mutex, locking out other processes that try to
1665          * write to this port
1666          */
1667         mutex_lock(&info->write_mtx);
1668
1669 #ifdef ROCKET_DEBUG_WRITE
1670         printk(KERN_INFO "rp_put_char %c...\n", ch);
1671 #endif
1672
1673         spin_lock_irqsave(&info->slock, flags);
1674         cp = &info->channel;
1675
1676         if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room == 0)
1677                 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1678
1679         if (tty->stopped || tty->hw_stopped || info->xmit_fifo_room == 0 || info->xmit_cnt != 0) {
1680                 info->xmit_buf[info->xmit_head++] = ch;
1681                 info->xmit_head &= XMIT_BUF_SIZE - 1;
1682                 info->xmit_cnt++;
1683                 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1684         } else {
1685                 sOutB(sGetTxRxDataIO(cp), ch);
1686                 info->xmit_fifo_room--;
1687         }
1688         spin_unlock_irqrestore(&info->slock, flags);
1689         mutex_unlock(&info->write_mtx);
1690 }
1691
1692 /*
1693  *  Exception handler - write routine, called when user app writes to the device.
1694  *  A per port write mutex is used to protect from another process writing to
1695  *  this port at the same time.  This other process could be running on the other CPU
1696  *  or get control of the CPU if the copy_from_user() blocks due to a page fault (swapped out). 
1697  *  Spinlocks protect the info xmit members.
1698  */
1699 static int rp_write(struct tty_struct *tty,
1700                     const unsigned char *buf, int count)
1701 {
1702         struct r_port *info = (struct r_port *) tty->driver_data;
1703         CHANNEL_t *cp;
1704         const unsigned char *b;
1705         int c, retval = 0;
1706         unsigned long flags;
1707
1708         if (count <= 0 || rocket_paranoia_check(info, "rp_write"))
1709                 return 0;
1710
1711         if (mutex_lock_interruptible(&info->write_mtx))
1712                 return -ERESTARTSYS;
1713
1714 #ifdef ROCKET_DEBUG_WRITE
1715         printk(KERN_INFO "rp_write %d chars...\n", count);
1716 #endif
1717         cp = &info->channel;
1718
1719         if (!tty->stopped && !tty->hw_stopped && info->xmit_fifo_room < count)
1720                 info->xmit_fifo_room = TXFIFO_SIZE - sGetTxCnt(cp);
1721
1722         /*
1723          *  If the write queue for the port is empty, and there is FIFO space, stuff bytes 
1724          *  into FIFO.  Use the write queue for temp storage.
1725          */
1726         if (!tty->stopped && !tty->hw_stopped && info->xmit_cnt == 0 && info->xmit_fifo_room > 0) {
1727                 c = min(count, info->xmit_fifo_room);
1728                 b = buf;
1729
1730                 /*  Push data into FIFO, 2 bytes at a time */
1731                 sOutStrW(sGetTxRxDataIO(cp), (unsigned short *) b, c / 2);
1732
1733                 /*  If there is a byte remaining, write it */
1734                 if (c & 1)
1735                         sOutB(sGetTxRxDataIO(cp), b[c - 1]);
1736
1737                 retval += c;
1738                 buf += c;
1739                 count -= c;
1740
1741                 spin_lock_irqsave(&info->slock, flags);
1742                 info->xmit_fifo_room -= c;
1743                 spin_unlock_irqrestore(&info->slock, flags);
1744         }
1745
1746         /* If count is zero, we wrote it all and are done */
1747         if (!count)
1748                 goto end;
1749
1750         /*  Write remaining data into the port's xmit_buf */
1751         while (1) {
1752                 if (!info->tty) /*   Seemingly obligatory check... */
1753                         goto end;
1754
1755                 c = min(count, min(XMIT_BUF_SIZE - info->xmit_cnt - 1, XMIT_BUF_SIZE - info->xmit_head));
1756                 if (c <= 0)
1757                         break;
1758
1759                 b = buf;
1760                 memcpy(info->xmit_buf + info->xmit_head, b, c);
1761
1762                 spin_lock_irqsave(&info->slock, flags);
1763                 info->xmit_head =
1764                     (info->xmit_head + c) & (XMIT_BUF_SIZE - 1);
1765                 info->xmit_cnt += c;
1766                 spin_unlock_irqrestore(&info->slock, flags);
1767
1768                 buf += c;
1769                 count -= c;
1770                 retval += c;
1771         }
1772
1773         if ((retval > 0) && !tty->stopped && !tty->hw_stopped)
1774                 set_bit((info->aiop * 8) + info->chan, (void *) &xmit_flags[info->board]);
1775         
1776 end:
1777         if (info->xmit_cnt < WAKEUP_CHARS) {
1778                 tty_wakeup(tty);
1779 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1780                 wake_up_interruptible(&tty->poll_wait);
1781 #endif
1782         }
1783         mutex_unlock(&info->write_mtx);
1784         return retval;
1785 }
1786
1787 /*
1788  * Return the number of characters that can be sent.  We estimate
1789  * only using the in-memory transmit buffer only, and ignore the
1790  * potential space in the transmit FIFO.
1791  */
1792 static int rp_write_room(struct tty_struct *tty)
1793 {
1794         struct r_port *info = (struct r_port *) tty->driver_data;
1795         int ret;
1796
1797         if (rocket_paranoia_check(info, "rp_write_room"))
1798                 return 0;
1799
1800         ret = XMIT_BUF_SIZE - info->xmit_cnt - 1;
1801         if (ret < 0)
1802                 ret = 0;
1803 #ifdef ROCKET_DEBUG_WRITE
1804         printk(KERN_INFO "rp_write_room returns %d...\n", ret);
1805 #endif
1806         return ret;
1807 }
1808
1809 /*
1810  * Return the number of characters in the buffer.  Again, this only
1811  * counts those characters in the in-memory transmit buffer.
1812  */
1813 static int rp_chars_in_buffer(struct tty_struct *tty)
1814 {
1815         struct r_port *info = (struct r_port *) tty->driver_data;
1816         CHANNEL_t *cp;
1817
1818         if (rocket_paranoia_check(info, "rp_chars_in_buffer"))
1819                 return 0;
1820
1821         cp = &info->channel;
1822
1823 #ifdef ROCKET_DEBUG_WRITE
1824         printk(KERN_INFO "rp_chars_in_buffer returns %d...\n", info->xmit_cnt);
1825 #endif
1826         return info->xmit_cnt;
1827 }
1828
1829 /*
1830  *  Flushes the TX fifo for a port, deletes data in the xmit_buf stored in the
1831  *  r_port struct for the port.  Note that spinlock are used to protect info members,
1832  *  do not call this function if the spinlock is already held.
1833  */
1834 static void rp_flush_buffer(struct tty_struct *tty)
1835 {
1836         struct r_port *info = (struct r_port *) tty->driver_data;
1837         CHANNEL_t *cp;
1838         unsigned long flags;
1839
1840         if (rocket_paranoia_check(info, "rp_flush_buffer"))
1841                 return;
1842
1843         spin_lock_irqsave(&info->slock, flags);
1844         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1845         spin_unlock_irqrestore(&info->slock, flags);
1846
1847 #ifdef ROCKETPORT_HAVE_POLL_WAIT
1848         wake_up_interruptible(&tty->poll_wait);
1849 #endif
1850         tty_wakeup(tty);
1851
1852         cp = &info->channel;
1853         sFlushTxFIFO(cp);
1854 }
1855
1856 #ifdef CONFIG_PCI
1857
1858 static struct pci_device_id __devinitdata rocket_pci_ids[] = {
1859         { PCI_DEVICE(PCI_VENDOR_ID_RP, PCI_ANY_ID) },
1860         { }
1861 };
1862 MODULE_DEVICE_TABLE(pci, rocket_pci_ids);
1863
1864 /*
1865  *  Called when a PCI card is found.  Retrieves and stores model information,
1866  *  init's aiopic and serial port hardware.
1867  *  Inputs:  i is the board number (0-n)
1868  */
1869 static __init int register_PCI(int i, struct pci_dev *dev)
1870 {
1871         int num_aiops, aiop, max_num_aiops, num_chan, chan;
1872         unsigned int aiopio[MAX_AIOPS_PER_BOARD];
1873         char *str, *board_type;
1874         CONTROLLER_t *ctlp;
1875
1876         int fast_clock = 0;
1877         int altChanRingIndicator = 0;
1878         int ports_per_aiop = 8;
1879         WordIO_t ConfigIO = 0;
1880         ByteIO_t UPCIRingInd = 0;
1881
1882         if (!dev || pci_enable_device(dev))
1883                 return 0;
1884
1885         rcktpt_io_addr[i] = pci_resource_start(dev, 0);
1886
1887         rcktpt_type[i] = ROCKET_TYPE_NORMAL;
1888         rocketModel[i].loadrm2 = 0;
1889         rocketModel[i].startingPortNumber = nextLineNumber;
1890
1891         /*  Depending on the model, set up some config variables */
1892         switch (dev->device) {
1893         case PCI_DEVICE_ID_RP4QUAD:
1894                 str = "Quadcable";
1895                 max_num_aiops = 1;
1896                 ports_per_aiop = 4;
1897                 rocketModel[i].model = MODEL_RP4QUAD;
1898                 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/quad cable");
1899                 rocketModel[i].numPorts = 4;
1900                 break;
1901         case PCI_DEVICE_ID_RP8OCTA:
1902                 str = "Octacable";
1903                 max_num_aiops = 1;
1904                 rocketModel[i].model = MODEL_RP8OCTA;
1905                 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/octa cable");
1906                 rocketModel[i].numPorts = 8;
1907                 break;
1908         case PCI_DEVICE_ID_URP8OCTA:
1909                 str = "Octacable";
1910                 max_num_aiops = 1;
1911                 rocketModel[i].model = MODEL_UPCI_RP8OCTA;
1912                 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/octa cable");
1913                 rocketModel[i].numPorts = 8;
1914                 break;
1915         case PCI_DEVICE_ID_RP8INTF:
1916                 str = "8";
1917                 max_num_aiops = 1;
1918                 rocketModel[i].model = MODEL_RP8INTF;
1919                 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/external I/F");
1920                 rocketModel[i].numPorts = 8;
1921                 break;
1922         case PCI_DEVICE_ID_URP8INTF:
1923                 str = "8";
1924                 max_num_aiops = 1;
1925                 rocketModel[i].model = MODEL_UPCI_RP8INTF;
1926                 strcpy(rocketModel[i].modelString, "RocketPort UPCI 8 port w/external I/F");
1927                 rocketModel[i].numPorts = 8;
1928                 break;
1929         case PCI_DEVICE_ID_RP8J:
1930                 str = "8J";
1931                 max_num_aiops = 1;
1932                 rocketModel[i].model = MODEL_RP8J;
1933                 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/RJ11 connectors");
1934                 rocketModel[i].numPorts = 8;
1935                 break;
1936         case PCI_DEVICE_ID_RP4J:
1937                 str = "4J";
1938                 max_num_aiops = 1;
1939                 ports_per_aiop = 4;
1940                 rocketModel[i].model = MODEL_RP4J;
1941                 strcpy(rocketModel[i].modelString, "RocketPort 4 port w/RJ45 connectors");
1942                 rocketModel[i].numPorts = 4;
1943                 break;
1944         case PCI_DEVICE_ID_RP8SNI:
1945                 str = "8 (DB78 Custom)";
1946                 max_num_aiops = 1;
1947                 rocketModel[i].model = MODEL_RP8SNI;
1948                 strcpy(rocketModel[i].modelString, "RocketPort 8 port w/ custom DB78");
1949                 rocketModel[i].numPorts = 8;
1950                 break;
1951         case PCI_DEVICE_ID_RP16SNI:
1952                 str = "16 (DB78 Custom)";
1953                 max_num_aiops = 2;
1954                 rocketModel[i].model = MODEL_RP16SNI;
1955                 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/ custom DB78");
1956                 rocketModel[i].numPorts = 16;
1957                 break;
1958         case PCI_DEVICE_ID_RP16INTF:
1959                 str = "16";
1960                 max_num_aiops = 2;
1961                 rocketModel[i].model = MODEL_RP16INTF;
1962                 strcpy(rocketModel[i].modelString, "RocketPort 16 port w/external I/F");
1963                 rocketModel[i].numPorts = 16;
1964                 break;
1965         case PCI_DEVICE_ID_URP16INTF:
1966                 str = "16";
1967                 max_num_aiops = 2;
1968                 rocketModel[i].model = MODEL_UPCI_RP16INTF;
1969                 strcpy(rocketModel[i].modelString, "RocketPort UPCI 16 port w/external I/F");
1970                 rocketModel[i].numPorts = 16;
1971                 break;
1972         case PCI_DEVICE_ID_CRP16INTF:
1973                 str = "16";
1974                 max_num_aiops = 2;
1975                 rocketModel[i].model = MODEL_CPCI_RP16INTF;
1976                 strcpy(rocketModel[i].modelString, "RocketPort Compact PCI 16 port w/external I/F");
1977                 rocketModel[i].numPorts = 16;
1978                 break;
1979         case PCI_DEVICE_ID_RP32INTF:
1980                 str = "32";
1981                 max_num_aiops = 4;
1982                 rocketModel[i].model = MODEL_RP32INTF;
1983                 strcpy(rocketModel[i].modelString, "RocketPort 32 port w/external I/F");
1984                 rocketModel[i].numPorts = 32;
1985                 break;
1986         case PCI_DEVICE_ID_URP32INTF:
1987                 str = "32";
1988                 max_num_aiops = 4;
1989                 rocketModel[i].model = MODEL_UPCI_RP32INTF;
1990                 strcpy(rocketModel[i].modelString, "RocketPort UPCI 32 port w/external I/F");
1991                 rocketModel[i].numPorts = 32;
1992                 break;
1993         case PCI_DEVICE_ID_RPP4:
1994                 str = "Plus Quadcable";
1995                 max_num_aiops = 1;
1996                 ports_per_aiop = 4;
1997                 altChanRingIndicator++;
1998                 fast_clock++;
1999                 rocketModel[i].model = MODEL_RPP4;
2000                 strcpy(rocketModel[i].modelString, "RocketPort Plus 4 port");
2001                 rocketModel[i].numPorts = 4;
2002                 break;
2003         case PCI_DEVICE_ID_RPP8:
2004                 str = "Plus Octacable";
2005                 max_num_aiops = 2;
2006                 ports_per_aiop = 4;
2007                 altChanRingIndicator++;
2008                 fast_clock++;
2009                 rocketModel[i].model = MODEL_RPP8;
2010                 strcpy(rocketModel[i].modelString, "RocketPort Plus 8 port");
2011                 rocketModel[i].numPorts = 8;
2012                 break;
2013         case PCI_DEVICE_ID_RP2_232:
2014                 str = "Plus 2 (RS-232)";
2015                 max_num_aiops = 1;
2016                 ports_per_aiop = 2;
2017                 altChanRingIndicator++;
2018                 fast_clock++;
2019                 rocketModel[i].model = MODEL_RP2_232;
2020                 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS232");
2021                 rocketModel[i].numPorts = 2;
2022                 break;
2023         case PCI_DEVICE_ID_RP2_422:
2024                 str = "Plus 2 (RS-422)";
2025                 max_num_aiops = 1;
2026                 ports_per_aiop = 2;
2027                 altChanRingIndicator++;
2028                 fast_clock++;
2029                 rocketModel[i].model = MODEL_RP2_422;
2030                 strcpy(rocketModel[i].modelString, "RocketPort Plus 2 port RS422");
2031                 rocketModel[i].numPorts = 2;
2032                 break;
2033         case PCI_DEVICE_ID_RP6M:
2034
2035                 max_num_aiops = 1;
2036                 ports_per_aiop = 6;
2037                 str = "6-port";
2038
2039                 /*  If revision is 1, the rocketmodem flash must be loaded.
2040                  *  If it is 2 it is a "socketed" version. */
2041                 if (dev->revision == 1) {
2042                         rcktpt_type[i] = ROCKET_TYPE_MODEMII;
2043                         rocketModel[i].loadrm2 = 1;
2044                 } else {
2045                         rcktpt_type[i] = ROCKET_TYPE_MODEM;
2046                 }
2047
2048                 rocketModel[i].model = MODEL_RP6M;
2049                 strcpy(rocketModel[i].modelString, "RocketModem 6 port");
2050                 rocketModel[i].numPorts = 6;
2051                 break;
2052         case PCI_DEVICE_ID_RP4M:
2053                 max_num_aiops = 1;
2054                 ports_per_aiop = 4;
2055                 str = "4-port";
2056                 if (dev->revision == 1) {
2057                         rcktpt_type[i] = ROCKET_TYPE_MODEMII;
2058                         rocketModel[i].loadrm2 = 1;
2059                 } else {
2060                         rcktpt_type[i] = ROCKET_TYPE_MODEM;
2061                 }
2062
2063                 rocketModel[i].model = MODEL_RP4M;
2064                 strcpy(rocketModel[i].modelString, "RocketModem 4 port");
2065                 rocketModel[i].numPorts = 4;
2066                 break;
2067         default:
2068                 str = "(unknown/unsupported)";
2069                 max_num_aiops = 0;
2070                 break;
2071         }
2072
2073         /*
2074          * Check for UPCI boards.
2075          */
2076
2077         switch (dev->device) {
2078         case PCI_DEVICE_ID_URP32INTF:
2079         case PCI_DEVICE_ID_URP8INTF:
2080         case PCI_DEVICE_ID_URP16INTF:
2081         case PCI_DEVICE_ID_CRP16INTF:
2082         case PCI_DEVICE_ID_URP8OCTA:
2083                 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2084                 ConfigIO = pci_resource_start(dev, 1);
2085                 if (dev->device == PCI_DEVICE_ID_URP8OCTA) {
2086                         UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2087
2088                         /*
2089                          * Check for octa or quad cable.
2090                          */
2091                         if (!
2092                             (sInW(ConfigIO + _PCI_9030_GPIO_CTRL) &
2093                              PCI_GPIO_CTRL_8PORT)) {
2094                                 str = "Quadcable";
2095                                 ports_per_aiop = 4;
2096                                 rocketModel[i].numPorts = 4;
2097                         }
2098                 }
2099                 break;
2100         case PCI_DEVICE_ID_UPCI_RM3_8PORT:
2101                 str = "8 ports";
2102                 max_num_aiops = 1;
2103                 rocketModel[i].model = MODEL_UPCI_RM3_8PORT;
2104                 strcpy(rocketModel[i].modelString, "RocketModem III 8 port");
2105                 rocketModel[i].numPorts = 8;
2106                 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2107                 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2108                 ConfigIO = pci_resource_start(dev, 1);
2109                 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2110                 break;
2111         case PCI_DEVICE_ID_UPCI_RM3_4PORT:
2112                 str = "4 ports";
2113                 max_num_aiops = 1;
2114                 rocketModel[i].model = MODEL_UPCI_RM3_4PORT;
2115                 strcpy(rocketModel[i].modelString, "RocketModem III 4 port");
2116                 rocketModel[i].numPorts = 4;
2117                 rcktpt_io_addr[i] = pci_resource_start(dev, 2);
2118                 UPCIRingInd = rcktpt_io_addr[i] + _PCI_9030_RING_IND;
2119                 ConfigIO = pci_resource_start(dev, 1);
2120                 rcktpt_type[i] = ROCKET_TYPE_MODEMIII;
2121                 break;
2122         default:
2123                 break;
2124         }
2125
2126         switch (rcktpt_type[i]) {
2127         case ROCKET_TYPE_MODEM:
2128                 board_type = "RocketModem";
2129                 break;
2130         case ROCKET_TYPE_MODEMII:
2131                 board_type = "RocketModem II";
2132                 break;
2133         case ROCKET_TYPE_MODEMIII:
2134                 board_type = "RocketModem III";
2135                 break;
2136         default:
2137                 board_type = "RocketPort";
2138                 break;
2139         }
2140
2141         if (fast_clock) {
2142                 sClockPrescale = 0x12;  /* mod 2 (divide by 3) */
2143                 rp_baud_base[i] = 921600;
2144         } else {
2145                 /*
2146                  * If support_low_speed is set, use the slow clock
2147                  * prescale, which supports 50 bps
2148                  */
2149                 if (support_low_speed) {
2150                         /* mod 9 (divide by 10) prescale */
2151                         sClockPrescale = 0x19;
2152                         rp_baud_base[i] = 230400;
2153                 } else {
2154                         /* mod 4 (devide by 5) prescale */
2155                         sClockPrescale = 0x14;
2156                         rp_baud_base[i] = 460800;
2157                 }
2158         }
2159
2160         for (aiop = 0; aiop < max_num_aiops; aiop++)
2161                 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x40);
2162         ctlp = sCtlNumToCtlPtr(i);
2163         num_aiops = sPCIInitController(ctlp, i, aiopio, max_num_aiops, ConfigIO, 0, FREQ_DIS, 0, altChanRingIndicator, UPCIRingInd);
2164         for (aiop = 0; aiop < max_num_aiops; aiop++)
2165                 ctlp->AiopNumChan[aiop] = ports_per_aiop;
2166
2167         dev_info(&dev->dev, "comtrol PCI controller #%d found at "
2168                 "address %04lx, %d AIOP(s) (%s), creating ttyR%d - %ld\n",
2169                 i, rcktpt_io_addr[i], num_aiops, rocketModel[i].modelString,
2170                 rocketModel[i].startingPortNumber,
2171                 rocketModel[i].startingPortNumber + rocketModel[i].numPorts-1);
2172
2173         if (num_aiops <= 0) {
2174                 rcktpt_io_addr[i] = 0;
2175                 return (0);
2176         }
2177         is_PCI[i] = 1;
2178
2179         /*  Reset the AIOPIC, init the serial ports */
2180         for (aiop = 0; aiop < num_aiops; aiop++) {
2181                 sResetAiopByNum(ctlp, aiop);
2182                 num_chan = ports_per_aiop;
2183                 for (chan = 0; chan < num_chan; chan++)
2184                         init_r_port(i, aiop, chan, dev);
2185         }
2186
2187         /*  Rocket modems must be reset */
2188         if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) ||
2189             (rcktpt_type[i] == ROCKET_TYPE_MODEMII) ||
2190             (rcktpt_type[i] == ROCKET_TYPE_MODEMIII)) {
2191                 num_chan = ports_per_aiop;
2192                 for (chan = 0; chan < num_chan; chan++)
2193                         sPCIModemReset(ctlp, chan, 1);
2194                 msleep(500);
2195                 for (chan = 0; chan < num_chan; chan++)
2196                         sPCIModemReset(ctlp, chan, 0);
2197                 msleep(500);
2198                 rmSpeakerReset(ctlp, rocketModel[i].model);
2199         }
2200         return (1);
2201 }
2202
2203 /*
2204  *  Probes for PCI cards, inits them if found
2205  *  Input:   board_found = number of ISA boards already found, or the
2206  *           starting board number
2207  *  Returns: Number of PCI boards found
2208  */
2209 static int __init init_PCI(int boards_found)
2210 {
2211         struct pci_dev *dev = NULL;
2212         int count = 0;
2213
2214         /*  Work through the PCI device list, pulling out ours */
2215         while ((dev = pci_get_device(PCI_VENDOR_ID_RP, PCI_ANY_ID, dev))) {
2216                 if (register_PCI(count + boards_found, dev))
2217                         count++;
2218         }
2219         return (count);
2220 }
2221
2222 #endif                          /* CONFIG_PCI */
2223
2224 /*
2225  *  Probes for ISA cards
2226  *  Input:   i = the board number to look for
2227  *  Returns: 1 if board found, 0 else
2228  */
2229 static int __init init_ISA(int i)
2230 {
2231         int num_aiops, num_chan = 0, total_num_chan = 0;
2232         int aiop, chan;
2233         unsigned int aiopio[MAX_AIOPS_PER_BOARD];
2234         CONTROLLER_t *ctlp;
2235         char *type_string;
2236
2237         /*  If io_addr is zero, no board configured */
2238         if (rcktpt_io_addr[i] == 0)
2239                 return (0);
2240
2241         /*  Reserve the IO region */
2242         if (!request_region(rcktpt_io_addr[i], 64, "Comtrol RocketPort")) {
2243                 printk(KERN_ERR "Unable to reserve IO region for configured "
2244                                 "ISA RocketPort at address 0x%lx, board not "
2245                                 "installed...\n", rcktpt_io_addr[i]);
2246                 rcktpt_io_addr[i] = 0;
2247                 return (0);
2248         }
2249
2250         ctlp = sCtlNumToCtlPtr(i);
2251
2252         ctlp->boardType = rcktpt_type[i];
2253
2254         switch (rcktpt_type[i]) {
2255         case ROCKET_TYPE_PC104:
2256                 type_string = "(PC104)";
2257                 break;
2258         case ROCKET_TYPE_MODEM:
2259                 type_string = "(RocketModem)";
2260                 break;
2261         case ROCKET_TYPE_MODEMII:
2262                 type_string = "(RocketModem II)";
2263                 break;
2264         default:
2265                 type_string = "";
2266                 break;
2267         }
2268
2269         /*
2270          * If support_low_speed is set, use the slow clock prescale,
2271          * which supports 50 bps
2272          */
2273         if (support_low_speed) {
2274                 sClockPrescale = 0x19;  /* mod 9 (divide by 10) prescale */
2275                 rp_baud_base[i] = 230400;
2276         } else {
2277                 sClockPrescale = 0x14;  /* mod 4 (devide by 5) prescale */
2278                 rp_baud_base[i] = 460800;
2279         }
2280
2281         for (aiop = 0; aiop < MAX_AIOPS_PER_BOARD; aiop++)
2282                 aiopio[aiop] = rcktpt_io_addr[i] + (aiop * 0x400);
2283
2284         num_aiops = sInitController(ctlp, i, controller + (i * 0x400), aiopio,  MAX_AIOPS_PER_BOARD, 0, FREQ_DIS, 0);
2285
2286         if (ctlp->boardType == ROCKET_TYPE_PC104) {
2287                 sEnAiop(ctlp, 2);       /* only one AIOPIC, but these */
2288                 sEnAiop(ctlp, 3);       /* CSels used for other stuff */
2289         }
2290
2291         /*  If something went wrong initing the AIOP's release the ISA IO memory */
2292         if (num_aiops <= 0) {
2293                 release_region(rcktpt_io_addr[i], 64);
2294                 rcktpt_io_addr[i] = 0;
2295                 return (0);
2296         }
2297   
2298         rocketModel[i].startingPortNumber = nextLineNumber;
2299
2300         for (aiop = 0; aiop < num_aiops; aiop++) {
2301                 sResetAiopByNum(ctlp, aiop);
2302                 sEnAiop(ctlp, aiop);
2303                 num_chan = sGetAiopNumChan(ctlp, aiop);
2304                 total_num_chan += num_chan;
2305                 for (chan = 0; chan < num_chan; chan++)
2306                         init_r_port(i, aiop, chan, NULL);
2307         }
2308         is_PCI[i] = 0;
2309         if ((rcktpt_type[i] == ROCKET_TYPE_MODEM) || (rcktpt_type[i] == ROCKET_TYPE_MODEMII)) {
2310                 num_chan = sGetAiopNumChan(ctlp, 0);
2311                 total_num_chan = num_chan;
2312                 for (chan = 0; chan < num_chan; chan++)
2313                         sModemReset(ctlp, chan, 1);
2314                 msleep(500);
2315                 for (chan = 0; chan < num_chan; chan++)
2316                         sModemReset(ctlp, chan, 0);
2317                 msleep(500);
2318                 strcpy(rocketModel[i].modelString, "RocketModem ISA");
2319         } else {
2320                 strcpy(rocketModel[i].modelString, "RocketPort ISA");
2321         }
2322         rocketModel[i].numPorts = total_num_chan;
2323         rocketModel[i].model = MODEL_ISA;
2324
2325         printk(KERN_INFO "RocketPort ISA card #%d found at 0x%lx - %d AIOPs %s\n", 
2326                i, rcktpt_io_addr[i], num_aiops, type_string);
2327
2328         printk(KERN_INFO "Installing %s, creating /dev/ttyR%d - %ld\n",
2329                rocketModel[i].modelString,
2330                rocketModel[i].startingPortNumber,
2331                rocketModel[i].startingPortNumber +
2332                rocketModel[i].numPorts - 1);
2333
2334         return (1);
2335 }
2336
2337 static const struct tty_operations rocket_ops = {
2338         .open = rp_open,
2339         .close = rp_close,
2340         .write = rp_write,
2341         .put_char = rp_put_char,
2342         .write_room = rp_write_room,
2343         .chars_in_buffer = rp_chars_in_buffer,
2344         .flush_buffer = rp_flush_buffer,
2345         .ioctl = rp_ioctl,
2346         .throttle = rp_throttle,
2347         .unthrottle = rp_unthrottle,
2348         .set_termios = rp_set_termios,
2349         .stop = rp_stop,
2350         .start = rp_start,
2351         .hangup = rp_hangup,
2352         .break_ctl = rp_break,
2353         .send_xchar = rp_send_xchar,
2354         .wait_until_sent = rp_wait_until_sent,
2355         .tiocmget = rp_tiocmget,
2356         .tiocmset = rp_tiocmset,
2357 };
2358
2359 /*
2360  * The module "startup" routine; it's run when the module is loaded.
2361  */
2362 static int __init rp_init(void)
2363 {
2364         int ret = -ENOMEM, pci_boards_found, isa_boards_found, i;
2365
2366         printk(KERN_INFO "RocketPort device driver module, version %s, %s\n",
2367                ROCKET_VERSION, ROCKET_DATE);
2368
2369         rocket_driver = alloc_tty_driver(MAX_RP_PORTS);
2370         if (!rocket_driver)
2371                 goto err;
2372
2373         /*
2374          *  If board 1 is non-zero, there is at least one ISA configured.  If controller is 
2375          *  zero, use the default controller IO address of board1 + 0x40.
2376          */
2377         if (board1) {
2378                 if (controller == 0)
2379                         controller = board1 + 0x40;
2380         } else {
2381                 controller = 0;  /*  Used as a flag, meaning no ISA boards */
2382         }
2383
2384         /*  If an ISA card is configured, reserve the 4 byte IO space for the Mudbac controller */
2385         if (controller && (!request_region(controller, 4, "Comtrol RocketPort"))) {
2386                 printk(KERN_ERR "Unable to reserve IO region for first "
2387                         "configured ISA RocketPort controller 0x%lx.  "
2388                         "Driver exiting\n", controller);
2389                 ret = -EBUSY;
2390                 goto err_tty;
2391         }
2392
2393         /*  Store ISA variable retrieved from command line or .conf file. */
2394         rcktpt_io_addr[0] = board1;
2395         rcktpt_io_addr[1] = board2;
2396         rcktpt_io_addr[2] = board3;
2397         rcktpt_io_addr[3] = board4;
2398
2399         rcktpt_type[0] = modem1 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2400         rcktpt_type[0] = pc104_1[0] ? ROCKET_TYPE_PC104 : rcktpt_type[0];
2401         rcktpt_type[1] = modem2 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2402         rcktpt_type[1] = pc104_2[0] ? ROCKET_TYPE_PC104 : rcktpt_type[1];
2403         rcktpt_type[2] = modem3 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2404         rcktpt_type[2] = pc104_3[0] ? ROCKET_TYPE_PC104 : rcktpt_type[2];
2405         rcktpt_type[3] = modem4 ? ROCKET_TYPE_MODEM : ROCKET_TYPE_NORMAL;
2406         rcktpt_type[3] = pc104_4[0] ? ROCKET_TYPE_PC104 : rcktpt_type[3];
2407
2408         /*
2409          * Set up the tty driver structure and then register this
2410          * driver with the tty layer.
2411          */
2412
2413         rocket_driver->owner = THIS_MODULE;
2414         rocket_driver->flags = TTY_DRIVER_DYNAMIC_DEV;
2415         rocket_driver->name = "ttyR";
2416         rocket_driver->driver_name = "Comtrol RocketPort";
2417         rocket_driver->major = TTY_ROCKET_MAJOR;
2418         rocket_driver->minor_start = 0;
2419         rocket_driver->type = TTY_DRIVER_TYPE_SERIAL;
2420         rocket_driver->subtype = SERIAL_TYPE_NORMAL;
2421         rocket_driver->init_termios = tty_std_termios;
2422         rocket_driver->init_termios.c_cflag =
2423             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2424         rocket_driver->init_termios.c_ispeed = 9600;
2425         rocket_driver->init_termios.c_ospeed = 9600;
2426 #ifdef ROCKET_SOFT_FLOW
2427         rocket_driver->flags |= TTY_DRIVER_REAL_RAW;
2428 #endif
2429         tty_set_operations(rocket_driver, &rocket_ops);
2430
2431         ret = tty_register_driver(rocket_driver);
2432         if (ret < 0) {
2433                 printk(KERN_ERR "Couldn't install tty RocketPort driver\n");
2434                 goto err_tty;
2435         }
2436
2437 #ifdef ROCKET_DEBUG_OPEN
2438         printk(KERN_INFO "RocketPort driver is major %d\n", rocket_driver.major);
2439 #endif
2440
2441         /*
2442          *  OK, let's probe each of the controllers looking for boards.  Any boards found
2443          *  will be initialized here.
2444          */
2445         isa_boards_found = 0;
2446         pci_boards_found = 0;
2447
2448         for (i = 0; i < NUM_BOARDS; i++) {
2449                 if (init_ISA(i))
2450                         isa_boards_found++;
2451         }
2452
2453 #ifdef CONFIG_PCI
2454         if (isa_boards_found < NUM_BOARDS)
2455                 pci_boards_found = init_PCI(isa_boards_found);
2456 #endif
2457
2458         max_board = pci_boards_found + isa_boards_found;
2459
2460         if (max_board == 0) {
2461                 printk(KERN_ERR "No rocketport ports found; unloading driver\n");
2462                 ret = -ENXIO;
2463                 goto err_ttyu;
2464         }
2465
2466         return 0;
2467 err_ttyu:
2468         tty_unregister_driver(rocket_driver);
2469 err_tty:
2470         put_tty_driver(rocket_driver);
2471 err:
2472         return ret;
2473 }
2474
2475
2476 static void rp_cleanup_module(void)
2477 {
2478         int retval;
2479         int i;
2480
2481         del_timer_sync(&rocket_timer);
2482
2483         retval = tty_unregister_driver(rocket_driver);
2484         if (retval)
2485                 printk(KERN_ERR "Error %d while trying to unregister "
2486                        "rocketport driver\n", -retval);
2487
2488         for (i = 0; i < MAX_RP_PORTS; i++)
2489                 if (rp_table[i]) {
2490                         tty_unregister_device(rocket_driver, i);
2491                         kfree(rp_table[i]);
2492                 }
2493
2494         put_tty_driver(rocket_driver);
2495
2496         for (i = 0; i < NUM_BOARDS; i++) {
2497                 if (rcktpt_io_addr[i] <= 0 || is_PCI[i])
2498                         continue;
2499                 release_region(rcktpt_io_addr[i], 64);
2500         }
2501         if (controller)
2502                 release_region(controller, 4);
2503 }
2504
2505 /***************************************************************************
2506 Function: sInitController
2507 Purpose:  Initialization of controller global registers and controller
2508           structure.
2509 Call:     sInitController(CtlP,CtlNum,MudbacIO,AiopIOList,AiopIOListSize,
2510                           IRQNum,Frequency,PeriodicOnly)
2511           CONTROLLER_T *CtlP; Ptr to controller structure
2512           int CtlNum; Controller number
2513           ByteIO_t MudbacIO; Mudbac base I/O address.
2514           ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2515              This list must be in the order the AIOPs will be found on the
2516              controller.  Once an AIOP in the list is not found, it is
2517              assumed that there are no more AIOPs on the controller.
2518           int AiopIOListSize; Number of addresses in AiopIOList
2519           int IRQNum; Interrupt Request number.  Can be any of the following:
2520                          0: Disable global interrupts
2521                          3: IRQ 3
2522                          4: IRQ 4
2523                          5: IRQ 5
2524                          9: IRQ 9
2525                          10: IRQ 10
2526                          11: IRQ 11
2527                          12: IRQ 12
2528                          15: IRQ 15
2529           Byte_t Frequency: A flag identifying the frequency
2530                    of the periodic interrupt, can be any one of the following:
2531                       FREQ_DIS - periodic interrupt disabled
2532                       FREQ_137HZ - 137 Hertz
2533                       FREQ_69HZ - 69 Hertz
2534                       FREQ_34HZ - 34 Hertz
2535                       FREQ_17HZ - 17 Hertz
2536                       FREQ_9HZ - 9 Hertz
2537                       FREQ_4HZ - 4 Hertz
2538                    If IRQNum is set to 0 the Frequency parameter is
2539                    overidden, it is forced to a value of FREQ_DIS.
2540           int PeriodicOnly: 1 if all interrupts except the periodic
2541                                interrupt are to be blocked.
2542                             0 is both the periodic interrupt and
2543                                other channel interrupts are allowed.
2544                             If IRQNum is set to 0 the PeriodicOnly parameter is
2545                                overidden, it is forced to a value of 0.
2546 Return:   int: Number of AIOPs on the controller, or CTLID_NULL if controller
2547                initialization failed.
2548
2549 Comments:
2550           If periodic interrupts are to be disabled but AIOP interrupts
2551           are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2552
2553           If interrupts are to be completely disabled set IRQNum to 0.
2554
2555           Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2556           invalid combination.
2557
2558           This function performs initialization of global interrupt modes,
2559           but it does not actually enable global interrupts.  To enable
2560           and disable global interrupts use functions sEnGlobalInt() and
2561           sDisGlobalInt().  Enabling of global interrupts is normally not
2562           done until all other initializations are complete.
2563
2564           Even if interrupts are globally enabled, they must also be
2565           individually enabled for each channel that is to generate
2566           interrupts.
2567
2568 Warnings: No range checking on any of the parameters is done.
2569
2570           No context switches are allowed while executing this function.
2571
2572           After this function all AIOPs on the controller are disabled,
2573           they can be enabled with sEnAiop().
2574 */
2575 static int sInitController(CONTROLLER_T * CtlP, int CtlNum, ByteIO_t MudbacIO,
2576                            ByteIO_t * AiopIOList, int AiopIOListSize,
2577                            int IRQNum, Byte_t Frequency, int PeriodicOnly)
2578 {
2579         int i;
2580         ByteIO_t io;
2581         int done;
2582
2583         CtlP->AiopIntrBits = aiop_intr_bits;
2584         CtlP->AltChanRingIndicator = 0;
2585         CtlP->CtlNum = CtlNum;
2586         CtlP->CtlID = CTLID_0001;       /* controller release 1 */
2587         CtlP->BusType = isISA;
2588         CtlP->MBaseIO = MudbacIO;
2589         CtlP->MReg1IO = MudbacIO + 1;
2590         CtlP->MReg2IO = MudbacIO + 2;
2591         CtlP->MReg3IO = MudbacIO + 3;
2592 #if 1
2593         CtlP->MReg2 = 0;        /* interrupt disable */
2594         CtlP->MReg3 = 0;        /* no periodic interrupts */
2595 #else
2596         if (sIRQMap[IRQNum] == 0) {     /* interrupts globally disabled */
2597                 CtlP->MReg2 = 0;        /* interrupt disable */
2598                 CtlP->MReg3 = 0;        /* no periodic interrupts */
2599         } else {
2600                 CtlP->MReg2 = sIRQMap[IRQNum];  /* set IRQ number */
2601                 CtlP->MReg3 = Frequency;        /* set frequency */
2602                 if (PeriodicOnly) {     /* periodic interrupt only */
2603                         CtlP->MReg3 |= PERIODIC_ONLY;
2604                 }
2605         }
2606 #endif
2607         sOutB(CtlP->MReg2IO, CtlP->MReg2);
2608         sOutB(CtlP->MReg3IO, CtlP->MReg3);
2609         sControllerEOI(CtlP);   /* clear EOI if warm init */
2610         /* Init AIOPs */
2611         CtlP->NumAiop = 0;
2612         for (i = done = 0; i < AiopIOListSize; i++) {
2613                 io = AiopIOList[i];
2614                 CtlP->AiopIO[i] = (WordIO_t) io;
2615                 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2616                 sOutB(CtlP->MReg2IO, CtlP->MReg2 | (i & 0x03)); /* AIOP index */
2617                 sOutB(MudbacIO, (Byte_t) (io >> 6));    /* set up AIOP I/O in MUDBAC */
2618                 if (done)
2619                         continue;
2620                 sEnAiop(CtlP, i);       /* enable the AIOP */
2621                 CtlP->AiopID[i] = sReadAiopID(io);      /* read AIOP ID */
2622                 if (CtlP->AiopID[i] == AIOPID_NULL)     /* if AIOP does not exist */
2623                         done = 1;       /* done looking for AIOPs */
2624                 else {
2625                         CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2626                         sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE);    /* clock prescaler */
2627                         sOutB(io + _INDX_DATA, sClockPrescale);
2628                         CtlP->NumAiop++;        /* bump count of AIOPs */
2629                 }
2630                 sDisAiop(CtlP, i);      /* disable AIOP */
2631         }
2632
2633         if (CtlP->NumAiop == 0)
2634                 return (-1);
2635         else
2636                 return (CtlP->NumAiop);
2637 }
2638
2639 /***************************************************************************
2640 Function: sPCIInitController
2641 Purpose:  Initialization of controller global registers and controller
2642           structure.
2643 Call:     sPCIInitController(CtlP,CtlNum,AiopIOList,AiopIOListSize,
2644                           IRQNum,Frequency,PeriodicOnly)
2645           CONTROLLER_T *CtlP; Ptr to controller structure
2646           int CtlNum; Controller number
2647           ByteIO_t *AiopIOList; List of I/O addresses for each AIOP.
2648              This list must be in the order the AIOPs will be found on the
2649              controller.  Once an AIOP in the list is not found, it is
2650              assumed that there are no more AIOPs on the controller.
2651           int AiopIOListSize; Number of addresses in AiopIOList
2652           int IRQNum; Interrupt Request number.  Can be any of the following:
2653                          0: Disable global interrupts
2654                          3: IRQ 3
2655                          4: IRQ 4
2656                          5: IRQ 5
2657                          9: IRQ 9
2658                          10: IRQ 10
2659                          11: IRQ 11
2660                          12: IRQ 12
2661                          15: IRQ 15
2662           Byte_t Frequency: A flag identifying the frequency
2663                    of the periodic interrupt, can be any one of the following:
2664                       FREQ_DIS - periodic interrupt disabled
2665                       FREQ_137HZ - 137 Hertz
2666                       FREQ_69HZ - 69 Hertz
2667                       FREQ_34HZ - 34 Hertz
2668                       FREQ_17HZ - 17 Hertz
2669                       FREQ_9HZ - 9 Hertz
2670                       FREQ_4HZ - 4 Hertz
2671                    If IRQNum is set to 0 the Frequency parameter is
2672                    overidden, it is forced to a value of FREQ_DIS.
2673           int PeriodicOnly: 1 if all interrupts except the periodic
2674                                interrupt are to be blocked.
2675                             0 is both the periodic interrupt and
2676                                other channel interrupts are allowed.
2677                             If IRQNum is set to 0 the PeriodicOnly parameter is
2678                                overidden, it is forced to a value of 0.
2679 Return:   int: Number of AIOPs on the controller, or CTLID_NULL if controller
2680                initialization failed.
2681
2682 Comments:
2683           If periodic interrupts are to be disabled but AIOP interrupts
2684           are allowed, set Frequency to FREQ_DIS and PeriodicOnly to 0.
2685
2686           If interrupts are to be completely disabled set IRQNum to 0.
2687
2688           Setting Frequency to FREQ_DIS and PeriodicOnly to 1 is an
2689           invalid combination.
2690
2691           This function performs initialization of global interrupt modes,
2692           but it does not actually enable global interrupts.  To enable
2693           and disable global interrupts use functions sEnGlobalInt() and
2694           sDisGlobalInt().  Enabling of global interrupts is normally not
2695           done until all other initializations are complete.
2696
2697           Even if interrupts are globally enabled, they must also be
2698           individually enabled for each channel that is to generate
2699           interrupts.
2700
2701 Warnings: No range checking on any of the parameters is done.
2702
2703           No context switches are allowed while executing this function.
2704
2705           After this function all AIOPs on the controller are disabled,
2706           they can be enabled with sEnAiop().
2707 */
2708 static int sPCIInitController(CONTROLLER_T * CtlP, int CtlNum,
2709                               ByteIO_t * AiopIOList, int AiopIOListSize,
2710                               WordIO_t ConfigIO, int IRQNum, Byte_t Frequency,
2711                               int PeriodicOnly, int altChanRingIndicator,
2712                               int UPCIRingInd)
2713 {
2714         int i;
2715         ByteIO_t io;
2716
2717         CtlP->AltChanRingIndicator = altChanRingIndicator;
2718         CtlP->UPCIRingInd = UPCIRingInd;
2719         CtlP->CtlNum = CtlNum;
2720         CtlP->CtlID = CTLID_0001;       /* controller release 1 */
2721         CtlP->BusType = isPCI;  /* controller release 1 */
2722
2723         if (ConfigIO) {
2724                 CtlP->isUPCI = 1;
2725                 CtlP->PCIIO = ConfigIO + _PCI_9030_INT_CTRL;
2726                 CtlP->PCIIO2 = ConfigIO + _PCI_9030_GPIO_CTRL;
2727                 CtlP->AiopIntrBits = upci_aiop_intr_bits;
2728         } else {
2729                 CtlP->isUPCI = 0;
2730                 CtlP->PCIIO =
2731                     (WordIO_t) ((ByteIO_t) AiopIOList[0] + _PCI_INT_FUNC);
2732                 CtlP->AiopIntrBits = aiop_intr_bits;
2733         }
2734
2735         sPCIControllerEOI(CtlP);        /* clear EOI if warm init */
2736         /* Init AIOPs */
2737         CtlP->NumAiop = 0;
2738         for (i = 0; i < AiopIOListSize; i++) {
2739                 io = AiopIOList[i];
2740                 CtlP->AiopIO[i] = (WordIO_t) io;
2741                 CtlP->AiopIntChanIO[i] = io + _INT_CHAN;
2742
2743                 CtlP->AiopID[i] = sReadAiopID(io);      /* read AIOP ID */
2744                 if (CtlP->AiopID[i] == AIOPID_NULL)     /* if AIOP does not exist */
2745                         break;  /* done looking for AIOPs */
2746
2747                 CtlP->AiopNumChan[i] = sReadAiopNumChan((WordIO_t) io); /* num channels in AIOP */
2748                 sOutW((WordIO_t) io + _INDX_ADDR, _CLK_PRE);    /* clock prescaler */
2749                 sOutB(io + _INDX_DATA, sClockPrescale);
2750                 CtlP->NumAiop++;        /* bump count of AIOPs */
2751         }
2752
2753         if (CtlP->NumAiop == 0)
2754                 return (-1);
2755         else
2756                 return (CtlP->NumAiop);
2757 }
2758
2759 /***************************************************************************
2760 Function: sReadAiopID
2761 Purpose:  Read the AIOP idenfication number directly from an AIOP.
2762 Call:     sReadAiopID(io)
2763           ByteIO_t io: AIOP base I/O address
2764 Return:   int: Flag AIOPID_XXXX if a valid AIOP is found, where X
2765                  is replace by an identifying number.
2766           Flag AIOPID_NULL if no valid AIOP is found
2767 Warnings: No context switches are allowed while executing this function.
2768
2769 */
2770 static int sReadAiopID(ByteIO_t io)
2771 {
2772         Byte_t AiopID;          /* ID byte from AIOP */
2773
2774         sOutB(io + _CMD_REG, RESET_ALL);        /* reset AIOP */
2775         sOutB(io + _CMD_REG, 0x0);
2776         AiopID = sInW(io + _CHN_STAT0) & 0x07;
2777         if (AiopID == 0x06)
2778                 return (1);
2779         else                    /* AIOP does not exist */
2780                 return (-1);
2781 }
2782
2783 /***************************************************************************
2784 Function: sReadAiopNumChan
2785 Purpose:  Read the number of channels available in an AIOP directly from
2786           an AIOP.
2787 Call:     sReadAiopNumChan(io)
2788           WordIO_t io: AIOP base I/O address
2789 Return:   int: The number of channels available
2790 Comments: The number of channels is determined by write/reads from identical
2791           offsets within the SRAM address spaces for channels 0 and 4.
2792           If the channel 4 space is mirrored to channel 0 it is a 4 channel
2793           AIOP, otherwise it is an 8 channel.
2794 Warnings: No context switches are allowed while executing this function.
2795 */
2796 static int sReadAiopNumChan(WordIO_t io)
2797 {
2798         Word_t x;
2799         static Byte_t R[4] = { 0x00, 0x00, 0x34, 0x12 };
2800
2801         /* write to chan 0 SRAM */
2802         out32((DWordIO_t) io + _INDX_ADDR, R);
2803         sOutW(io + _INDX_ADDR, 0);      /* read from SRAM, chan 0 */
2804         x = sInW(io + _INDX_DATA);
2805         sOutW(io + _INDX_ADDR, 0x4000); /* read from SRAM, chan 4 */
2806         if (x != sInW(io + _INDX_DATA)) /* if different must be 8 chan */
2807                 return (8);
2808         else
2809                 return (4);
2810 }
2811
2812 /***************************************************************************
2813 Function: sInitChan
2814 Purpose:  Initialization of a channel and channel structure
2815 Call:     sInitChan(CtlP,ChP,AiopNum,ChanNum)
2816           CONTROLLER_T *CtlP; Ptr to controller structure
2817           CHANNEL_T *ChP; Ptr to channel structure
2818           int AiopNum; AIOP number within controller
2819           int ChanNum; Channel number within AIOP
2820 Return:   int: 1 if initialization succeeded, 0 if it fails because channel
2821                number exceeds number of channels available in AIOP.
2822 Comments: This function must be called before a channel can be used.
2823 Warnings: No range checking on any of the parameters is done.
2824
2825           No context switches are allowed while executing this function.
2826 */
2827 static int sInitChan(CONTROLLER_T * CtlP, CHANNEL_T * ChP, int AiopNum,
2828                      int ChanNum)
2829 {
2830         int i;
2831         WordIO_t AiopIO;
2832         WordIO_t ChIOOff;
2833         Byte_t *ChR;
2834         Word_t ChOff;
2835         static Byte_t R[4];
2836         int brd9600;
2837
2838         if (ChanNum >= CtlP->AiopNumChan[AiopNum])
2839                 return 0;       /* exceeds num chans in AIOP */
2840
2841         /* Channel, AIOP, and controller identifiers */
2842         ChP->CtlP = CtlP;
2843         ChP->ChanID = CtlP->AiopID[AiopNum];
2844         ChP->AiopNum = AiopNum;
2845         ChP->ChanNum = ChanNum;
2846
2847         /* Global direct addresses */
2848         AiopIO = CtlP->AiopIO[AiopNum];
2849         ChP->Cmd = (ByteIO_t) AiopIO + _CMD_REG;
2850         ChP->IntChan = (ByteIO_t) AiopIO + _INT_CHAN;
2851         ChP->IntMask = (ByteIO_t) AiopIO + _INT_MASK;
2852         ChP->IndexAddr = (DWordIO_t) AiopIO + _INDX_ADDR;
2853         ChP->IndexData = AiopIO + _INDX_DATA;
2854
2855         /* Channel direct addresses */
2856         ChIOOff = AiopIO + ChP->ChanNum * 2;
2857         ChP->TxRxData = ChIOOff + _TD0;
2858         ChP->ChanStat = ChIOOff + _CHN_STAT0;
2859         ChP->TxRxCount = ChIOOff + _FIFO_CNT0;
2860         ChP->IntID = (ByteIO_t) AiopIO + ChP->ChanNum + _INT_ID0;
2861
2862         /* Initialize the channel from the RData array */
2863         for (i = 0; i < RDATASIZE; i += 4) {
2864                 R[0] = RData[i];
2865                 R[1] = RData[i + 1] + 0x10 * ChanNum;
2866                 R[2] = RData[i + 2];
2867                 R[3] = RData[i + 3];
2868                 out32(ChP->IndexAddr, R);
2869         }
2870
2871         ChR = ChP->R;
2872         for (i = 0; i < RREGDATASIZE; i += 4) {
2873                 ChR[i] = RRegData[i];
2874                 ChR[i + 1] = RRegData[i + 1] + 0x10 * ChanNum;
2875                 ChR[i + 2] = RRegData[i + 2];
2876                 ChR[i + 3] = RRegData[i + 3];
2877         }
2878
2879         /* Indexed registers */
2880         ChOff = (Word_t) ChanNum *0x1000;
2881
2882         if (sClockPrescale == 0x14)
2883                 brd9600 = 47;
2884         else
2885                 brd9600 = 23;
2886
2887         ChP->BaudDiv[0] = (Byte_t) (ChOff + _BAUD);
2888         ChP->BaudDiv[1] = (Byte_t) ((ChOff + _BAUD) >> 8);
2889         ChP->BaudDiv[2] = (Byte_t) brd9600;
2890         ChP->BaudDiv[3] = (Byte_t) (brd9600 >> 8);
2891         out32(ChP->IndexAddr, ChP->BaudDiv);
2892
2893         ChP->TxControl[0] = (Byte_t) (ChOff + _TX_CTRL);
2894         ChP->TxControl[1] = (Byte_t) ((ChOff + _TX_CTRL) >> 8);
2895         ChP->TxControl[2] = 0;
2896         ChP->TxControl[3] = 0;
2897         out32(ChP->IndexAddr, ChP->TxControl);
2898
2899         ChP->RxControl[0] = (Byte_t) (ChOff + _RX_CTRL);
2900         ChP->RxControl[1] = (Byte_t) ((ChOff + _RX_CTRL) >> 8);
2901         ChP->RxControl[2] = 0;
2902         ChP->RxControl[3] = 0;
2903         out32(ChP->IndexAddr, ChP->RxControl);
2904
2905         ChP->TxEnables[0] = (Byte_t) (ChOff + _TX_ENBLS);
2906         ChP->TxEnables[1] = (Byte_t) ((ChOff + _TX_ENBLS) >> 8);
2907         ChP->TxEnables[2] = 0;
2908         ChP->TxEnables[3] = 0;
2909         out32(ChP->IndexAddr, ChP->TxEnables);
2910
2911         ChP->TxCompare[0] = (Byte_t) (ChOff + _TXCMP1);
2912         ChP->TxCompare[1] = (Byte_t) ((ChOff + _TXCMP1) >> 8);
2913         ChP->TxCompare[2] = 0;
2914         ChP->TxCompare[3] = 0;
2915         out32(ChP->IndexAddr, ChP->TxCompare);
2916
2917         ChP->TxReplace1[0] = (Byte_t) (ChOff + _TXREP1B1);
2918         ChP->TxReplace1[1] = (Byte_t) ((ChOff + _TXREP1B1) >> 8);
2919         ChP->TxReplace1[2] = 0;
2920         ChP->TxReplace1[3] = 0;
2921         out32(ChP->IndexAddr, ChP->TxReplace1);
2922
2923         ChP->TxReplace2[0] = (Byte_t) (ChOff + _TXREP2);
2924         ChP->TxReplace2[1] = (Byte_t) ((ChOff + _TXREP2) >> 8);
2925         ChP->TxReplace2[2] = 0;
2926         ChP->TxReplace2[3] = 0;
2927         out32(ChP->IndexAddr, ChP->TxReplace2);
2928
2929         ChP->TxFIFOPtrs = ChOff + _TXF_OUTP;
2930         ChP->TxFIFO = ChOff + _TX_FIFO;
2931
2932         sOutB(ChP->Cmd, (Byte_t) ChanNum | RESTXFCNT);  /* apply reset Tx FIFO count */
2933         sOutB(ChP->Cmd, (Byte_t) ChanNum);      /* remove reset Tx FIFO count */
2934         sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs);      /* clear Tx in/out ptrs */
2935         sOutW(ChP->IndexData, 0);
2936         ChP->RxFIFOPtrs = ChOff + _RXF_OUTP;
2937         ChP->RxFIFO = ChOff + _RX_FIFO;
2938
2939         sOutB(ChP->Cmd, (Byte_t) ChanNum | RESRXFCNT);  /* apply reset Rx FIFO count */
2940         sOutB(ChP->Cmd, (Byte_t) ChanNum);      /* remove reset Rx FIFO count */
2941         sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs);      /* clear Rx out ptr */
2942         sOutW(ChP->IndexData, 0);
2943         sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2);  /* clear Rx in ptr */
2944         sOutW(ChP->IndexData, 0);
2945         ChP->TxPrioCnt = ChOff + _TXP_CNT;
2946         sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioCnt);
2947         sOutB(ChP->IndexData, 0);
2948         ChP->TxPrioPtr = ChOff + _TXP_PNTR;
2949         sOutW((WordIO_t) ChP->IndexAddr, ChP->TxPrioPtr);
2950         sOutB(ChP->IndexData, 0);
2951         ChP->TxPrioBuf = ChOff + _TXP_BUF;
2952         sEnRxProcessor(ChP);    /* start the Rx processor */
2953
2954         return 1;
2955 }
2956
2957 /***************************************************************************
2958 Function: sStopRxProcessor
2959 Purpose:  Stop the receive processor from processing a channel.
2960 Call:     sStopRxProcessor(ChP)
2961           CHANNEL_T *ChP; Ptr to channel structure
2962
2963 Comments: The receive processor can be started again with sStartRxProcessor().
2964           This function causes the receive processor to skip over the
2965           stopped channel.  It does not stop it from processing other channels.
2966
2967 Warnings: No context switches are allowed while executing this function.
2968
2969           Do not leave the receive processor stopped for more than one
2970           character time.
2971
2972           After calling this function a delay of 4 uS is required to ensure
2973           that the receive processor is no longer processing this channel.
2974 */
2975 static void sStopRxProcessor(CHANNEL_T * ChP)
2976 {
2977         Byte_t R[4];
2978
2979         R[0] = ChP->R[0];
2980         R[1] = ChP->R[1];
2981         R[2] = 0x0a;
2982         R[3] = ChP->R[3];
2983         out32(ChP->IndexAddr, R);
2984 }
2985
2986 /***************************************************************************
2987 Function: sFlushRxFIFO
2988 Purpose:  Flush the Rx FIFO
2989 Call:     sFlushRxFIFO(ChP)
2990           CHANNEL_T *ChP; Ptr to channel structure
2991 Return:   void
2992 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
2993           while it is being flushed the receive processor is stopped
2994           and the transmitter is disabled.  After these operations a
2995           4 uS delay is done before clearing the pointers to allow
2996           the receive processor to stop.  These items are handled inside
2997           this function.
2998 Warnings: No context switches are allowed while executing this function.
2999 */
3000 static void sFlushRxFIFO(CHANNEL_T * ChP)
3001 {
3002         int i;
3003         Byte_t Ch;              /* channel number within AIOP */
3004         int RxFIFOEnabled;      /* 1 if Rx FIFO enabled */
3005
3006         if (sGetRxCnt(ChP) == 0)        /* Rx FIFO empty */
3007                 return;         /* don't need to flush */
3008
3009         RxFIFOEnabled = 0;
3010         if (ChP->R[0x32] == 0x08) {     /* Rx FIFO is enabled */
3011                 RxFIFOEnabled = 1;
3012                 sDisRxFIFO(ChP);        /* disable it */
3013                 for (i = 0; i < 2000 / 200; i++)        /* delay 2 uS to allow proc to disable FIFO */
3014                         sInB(ChP->IntChan);     /* depends on bus i/o timing */
3015         }
3016         sGetChanStatus(ChP);    /* clear any pending Rx errors in chan stat */
3017         Ch = (Byte_t) sGetChanNum(ChP);
3018         sOutB(ChP->Cmd, Ch | RESRXFCNT);        /* apply reset Rx FIFO count */
3019         sOutB(ChP->Cmd, Ch);    /* remove reset Rx FIFO count */
3020         sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs);      /* clear Rx out ptr */
3021         sOutW(ChP->IndexData, 0);
3022         sOutW((WordIO_t) ChP->IndexAddr, ChP->RxFIFOPtrs + 2);  /* clear Rx in ptr */
3023         sOutW(ChP->IndexData, 0);
3024         if (RxFIFOEnabled)
3025                 sEnRxFIFO(ChP); /* enable Rx FIFO */
3026 }
3027
3028 /***************************************************************************
3029 Function: sFlushTxFIFO
3030 Purpose:  Flush the Tx FIFO
3031 Call:     sFlushTxFIFO(ChP)
3032           CHANNEL_T *ChP; Ptr to channel structure
3033 Return:   void
3034 Comments: To prevent data from being enqueued or dequeued in the Tx FIFO
3035           while it is being flushed the receive processor is stopped
3036           and the transmitter is disabled.  After these operations a
3037           4 uS delay is done before clearing the pointers to allow
3038           the receive processor to stop.  These items are handled inside
3039           this function.
3040 Warnings: No context switches are allowed while executing this function.
3041 */
3042 static void sFlushTxFIFO(CHANNEL_T * ChP)
3043 {
3044         int i;
3045         Byte_t Ch;              /* channel number within AIOP */
3046         int TxEnabled;          /* 1 if transmitter enabled */
3047
3048         if (sGetTxCnt(ChP) == 0)        /* Tx FIFO empty */
3049                 return;         /* don't need to flush */
3050
3051         TxEnabled = 0;
3052         if (ChP->TxControl[3] & TX_ENABLE) {
3053                 TxEnabled = 1;
3054                 sDisTransmit(ChP);      /* disable transmitter */
3055         }
3056         sStopRxProcessor(ChP);  /* stop Rx processor */
3057         for (i = 0; i < 4000 / 200; i++)        /* delay 4 uS to allow proc to stop */
3058                 sInB(ChP->IntChan);     /* depends on bus i/o timing */
3059         Ch = (Byte_t) sGetChanNum(ChP);
3060         sOutB(ChP->Cmd, Ch | RESTXFCNT);        /* apply reset Tx FIFO count */
3061         sOutB(ChP->Cmd, Ch);    /* remove reset Tx FIFO count */
3062         sOutW((WordIO_t) ChP->IndexAddr, ChP->TxFIFOPtrs);      /* clear Tx in/out ptrs */
3063         sOutW(ChP->IndexData, 0);
3064         if (TxEnabled)
3065                 sEnTransmit(ChP);       /* enable transmitter */
3066         sStartRxProcessor(ChP); /* restart Rx processor */
3067 }
3068
3069 /***************************************************************************
3070 Function: sWriteTxPrioByte
3071 Purpose:  Write a byte of priority transmit data to a channel
3072 Call:     sWriteTxPrioByte(ChP,Data)
3073           CHANNEL_T *ChP; Ptr to channel structure
3074           Byte_t Data; The transmit data byte
3075
3076 Return:   int: 1 if the bytes is successfully written, otherwise 0.
3077
3078 Comments: The priority byte is transmitted before any data in the Tx FIFO.
3079
3080 Warnings: No context switches are allowed while executing this function.
3081 */
3082 static int sWriteTxPrioByte(CHANNEL_T * ChP, Byte_t Data)
3083 {
3084         Byte_t DWBuf[4];        /* buffer for double word writes */
3085         Word_t *WordPtr;        /* must be far because Win SS != DS */
3086         register DWordIO_t IndexAddr;
3087
3088         if (sGetTxCnt(ChP) > 1) {       /* write it to Tx priority buffer */
3089                 IndexAddr = ChP->IndexAddr;
3090                 sOutW((WordIO_t) IndexAddr, ChP->TxPrioCnt);    /* get priority buffer status */
3091                 if (sInB((ByteIO_t) ChP->IndexData) & PRI_PEND) /* priority buffer busy */
3092                         return (0);     /* nothing sent */
3093
3094                 WordPtr = (Word_t *) (&DWBuf[0]);
3095                 *WordPtr = ChP->TxPrioBuf;      /* data byte address */
3096
3097                 DWBuf[2] = Data;        /* data byte value */
3098                 out32(IndexAddr, DWBuf);        /* write it out */
3099
3100                 *WordPtr = ChP->TxPrioCnt;      /* Tx priority count address */
3101
3102                 DWBuf[2] = PRI_PEND + 1;        /* indicate 1 byte pending */
3103                 DWBuf[3] = 0;   /* priority buffer pointer */
3104                 out32(IndexAddr, DWBuf);        /* write it out */
3105         } else {                /* write it to Tx FIFO */
3106
3107                 sWriteTxByte(sGetTxRxDataIO(ChP), Data);
3108         }
3109         return (1);             /* 1 byte sent */
3110 }
3111
3112 /***************************************************************************
3113 Function: sEnInterrupts
3114 Purpose:  Enable one or more interrupts for a channel
3115 Call:     sEnInterrupts(ChP,Flags)
3116           CHANNEL_T *ChP; Ptr to channel structure
3117           Word_t Flags: Interrupt enable flags, can be any combination
3118              of the following flags:
3119                 TXINT_EN:   Interrupt on Tx FIFO empty
3120                 RXINT_EN:   Interrupt on Rx FIFO at trigger level (see
3121                             sSetRxTrigger())
3122                 SRCINT_EN:  Interrupt on SRC (Special Rx Condition)
3123                 MCINT_EN:   Interrupt on modem input change
3124                 CHANINT_EN: Allow channel interrupt signal to the AIOP's
3125                             Interrupt Channel Register.
3126 Return:   void
3127 Comments: If an interrupt enable flag is set in Flags, that interrupt will be
3128           enabled.  If an interrupt enable flag is not set in Flags, that
3129           interrupt will not be changed.  Interrupts can be disabled with
3130           function sDisInterrupts().
3131
3132           This function sets the appropriate bit for the channel in the AIOP's
3133           Interrupt Mask Register if the CHANINT_EN flag is set.  This allows
3134           this channel's bit to be set in the AIOP's Interrupt Channel Register.
3135
3136           Interrupts must also be globally enabled before channel interrupts
3137           will be passed on to the host.  This is done with function
3138           sEnGlobalInt().
3139
3140           In some cases it may be desirable to disable interrupts globally but
3141           enable channel interrupts.  This would allow the global interrupt
3142           status register to be used to determine which AIOPs need service.
3143 */
3144 static void sEnInterrupts(CHANNEL_T * ChP, Word_t Flags)
3145 {
3146         Byte_t Mask;            /* Interrupt Mask Register */
3147
3148         ChP->RxControl[2] |=
3149             ((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3150
3151         out32(ChP->IndexAddr, ChP->RxControl);
3152
3153         ChP->TxControl[2] |= ((Byte_t) Flags & TXINT_EN);
3154
3155         out32(ChP->IndexAddr, ChP->TxControl);
3156
3157         if (Flags & CHANINT_EN) {
3158                 Mask = sInB(ChP->IntMask) | sBitMapSetTbl[ChP->ChanNum];
3159                 sOutB(ChP->IntMask, Mask);
3160         }
3161 }
3162
3163 /***************************************************************************
3164 Function: sDisInterrupts
3165 Purpose:  Disable one or more interrupts for a channel
3166 Call:     sDisInterrupts(ChP,Flags)
3167           CHANNEL_T *ChP; Ptr to channel structure
3168           Word_t Flags: Interrupt flags, can be any combination
3169              of the following flags:
3170                 TXINT_EN:   Interrupt on Tx FIFO empty
3171                 RXINT_EN:   Interrupt on Rx FIFO at trigger level (see
3172                             sSetRxTrigger())
3173                 SRCINT_EN:  Interrupt on SRC (Special Rx Condition)
3174                 MCINT_EN:   Interrupt on modem input change
3175                 CHANINT_EN: Disable channel interrupt signal to the
3176                             AIOP's Interrupt Channel Register.
3177 Return:   void
3178 Comments: If an interrupt flag is set in Flags, that interrupt will be
3179           disabled.  If an interrupt flag is not set in Flags, that
3180           interrupt will not be changed.  Interrupts can be enabled with
3181           function sEnInterrupts().
3182
3183           This function clears the appropriate bit for the channel in the AIOP's
3184           Interrupt Mask Register if the CHANINT_EN flag is set.  This blocks
3185           this channel's bit from being set in the AIOP's Interrupt Channel
3186           Register.
3187 */
3188 static void sDisInterrupts(CHANNEL_T * ChP, Word_t Flags)
3189 {
3190         Byte_t Mask;            /* Interrupt Mask Register */
3191
3192         ChP->RxControl[2] &=
3193             ~((Byte_t) Flags & (RXINT_EN | SRCINT_EN | MCINT_EN));
3194         out32(ChP->IndexAddr, ChP->RxControl);
3195         ChP->TxControl[2] &= ~((Byte_t) Flags & TXINT_EN);
3196         out32(ChP->IndexAddr, ChP->TxControl);
3197
3198         if (Flags & CHANINT_EN) {
3199                 Mask = sInB(ChP->IntMask) & sBitMapClrTbl[ChP->ChanNum];
3200                 sOutB(ChP->IntMask, Mask);
3201         }
3202 }
3203
3204 static void sSetInterfaceMode(CHANNEL_T * ChP, Byte_t mode)
3205 {
3206 &n