git.oblomov.eu Git - linux-2.6/blob - drivers/char/rocket.c

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