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