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

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