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