drivers/char/specialix.c

   1 /*
   2  *      specialix.c  -- specialix IO8+ multiport serial driver.
   3  *
   4  *      Copyright (C) 1997  Roger Wolff (R.E.Wolff@BitWizard.nl)
   5  *      Copyright (C) 1994-1996  Dmitry Gorodchanin (pgmdsg@ibi.com)
   6  *
   7  *      Specialix pays for the development and support of this driver.
   8  *      Please DO contact io8-linux@specialix.co.uk if you require
   9  *      support. But please read the documentation (specialix.txt)
  10  *      first.
  11  *
  12  *      This driver was developped in the BitWizard linux device
  13  *      driver service. If you require a linux device driver for your
  14  *      product, please contact devices@BitWizard.nl for a quote.
  15  *
  16  *      This code is firmly based on the riscom/8 serial driver,
  17  *      written by Dmitry Gorodchanin. The specialix IO8+ card
  18  *      programming information was obtained from the CL-CD1865 Data
  19  *      Book, and Specialix document number 6200059: IO8+ Hardware
  20  *      Functional Specification.
  21  *
  22  *      This program is free software; you can redistribute it and/or
  23  *      modify it under the terms of the GNU General Public License as
  24  *      published by the Free Software Foundation; either version 2 of
  25  *      the License, or (at your option) any later version.
  26  *
  27  *      This program is distributed in the hope that it will be
  28  *      useful, but WITHOUT ANY WARRANTY; without even the implied
  29  *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  30  *      PURPOSE.  See the GNU General Public License for more details.
  31  *
  32  *      You should have received a copy of the GNU General Public
  33  *      License along with this program; if not, write to the Free
  34  *      Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  35  *      USA.
  36  *
  37  * Revision history:
  38  *
  39  * Revision 1.0:  April 1st 1997.
  40  *                Initial release for alpha testing.
  41  * Revision 1.1:  April 14th 1997.
  42  *                Incorporated Richard Hudsons suggestions,
  43  *                removed some debugging printk's.
  44  * Revision 1.2:  April 15th 1997.
  45  *                Ported to 2.1.x kernels.
  46  * Revision 1.3:  April 17th 1997
  47  *                Backported to 2.0. (Compatibility macros).
  48  * Revision 1.4:  April 18th 1997
  49  *                Fixed DTR/RTS bug that caused the card to indicate
  50  *                "don't send data" to a modem after the password prompt.
  51  *                Fixed bug for premature (fake) interrupts.
  52  * Revision 1.5:  April 19th 1997
  53  *                fixed a minor typo in the header file, cleanup a little.
  54  *                performance warnings are now MAXed at once per minute.
  55  * Revision 1.6:  May 23 1997
  56  *                Changed the specialix=... format to include interrupt.
  57  * Revision 1.7:  May 27 1997
  58  *                Made many more debug printk's a compile time option.
  59  * Revision 1.8:  Jul 1  1997
  60  *                port to linux-2.1.43 kernel.
  61  * Revision 1.9:  Oct 9  1998
  62  *                Added stuff for the IO8+/PCI version.
  63  * Revision 1.10: Oct 22  1999 / Jan 21 2000.
  64  *                Added stuff for setserial.
  65  *                Nicolas Mailhot (Nicolas.Mailhot@email.enst.fr)
  66  *
  67  */
  68
  69 #define VERSION "1.11"
  70
  71
  72 /*
  73  * There is a bunch of documentation about the card, jumpers, config
  74  * settings, restrictions, cables, device names and numbers in
  75  * Documentation/specialix.txt
  76  */
  77
  78 #include <linux/module.h>
  79
  80 #include <linux/io.h>
  81 #include <linux/kernel.h>
  82 #include <linux/sched.h>
  83 #include <linux/ioport.h>
  84 #include <linux/interrupt.h>
  85 #include <linux/errno.h>
  86 #include <linux/tty.h>
  87 #include <linux/tty_flip.h>
  88 #include <linux/mm.h>
  89 #include <linux/serial.h>
  90 #include <linux/fcntl.h>
  91 #include <linux/major.h>
  92 #include <linux/delay.h>
  93 #include <linux/pci.h>
  94 #include <linux/init.h>
  95 #include <linux/uaccess.h>
  96
  97 #include "specialix_io8.h"
  98 #include "cd1865.h"
  99
 100
 101 /*
 102    This driver can spew a whole lot of debugging output at you. If you
 103    need maximum performance, you should disable the DEBUG define. To
 104    aid in debugging in the field, I'm leaving the compile-time debug
 105    features enabled, and disable them "runtime". That allows me to
 106    instruct people with problems to enable debugging without requiring
 107    them to recompile...
 108 */
 109 #define DEBUG
 110
 111 static int sx_debug;
 112 static int sx_rxfifo = SPECIALIX_RXFIFO;
 113 static int sx_rtscts;
 114
 115 #ifdef DEBUG
 116 #define dprintk(f, str...) if (sx_debug & f) printk(str)
 117 #else
 118 #define dprintk(f, str...) /* nothing */
 119 #endif
 120
 121 #define SX_DEBUG_FLOW    0x0001
 122 #define SX_DEBUG_DATA    0x0002
 123 #define SX_DEBUG_PROBE   0x0004
 124 #define SX_DEBUG_CHAN    0x0008
 125 #define SX_DEBUG_INIT    0x0010
 126 #define SX_DEBUG_RX      0x0020
 127 #define SX_DEBUG_TX      0x0040
 128 #define SX_DEBUG_IRQ     0x0080
 129 #define SX_DEBUG_OPEN    0x0100
 130 #define SX_DEBUG_TERMIOS 0x0200
 131 #define SX_DEBUG_SIGNALS 0x0400
 132 #define SX_DEBUG_FIFO    0x0800
 133
 134
 135 #define func_enter() dprintk(SX_DEBUG_FLOW, "io8: enter %s\n", __func__)
 136 #define func_exit()  dprintk(SX_DEBUG_FLOW, "io8: exit  %s\n", __func__)
 137
 138
 139 /* Configurable options: */
 140
 141 /* Am I paranoid or not ? ;-) */
 142 #define SPECIALIX_PARANOIA_CHECK
 143
 144 /*
 145  * The following defines are mostly for testing purposes. But if you need
 146  * some nice reporting in your syslog, you can define them also.
 147  */
 148 #undef SX_REPORT_FIFO
 149 #undef SX_REPORT_OVERRUN
 150
 151
 152
 153
 154 #define SPECIALIX_LEGAL_FLAGS \
 155         (ASYNC_HUP_NOTIFY   | ASYNC_SAK          | ASYNC_SPLIT_TERMIOS   | \
 156          ASYNC_SPD_HI       | ASYNC_SPEED_VHI    | ASYNC_SESSION_LOCKOUT | \
 157          ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
 158
 159 static struct tty_driver *specialix_driver;
 160
 161 static struct specialix_board sx_board[SX_NBOARD] =  {
 162         { 0, SX_IOBASE1,  9, },
 163         { 0, SX_IOBASE2, 11, },
 164         { 0, SX_IOBASE3, 12, },
 165         { 0, SX_IOBASE4, 15, },
 166 };
 167
 168 static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
 169
 170
 171 static int sx_paranoia_check(struct specialix_port const *port,
 172                                     char *name, const char *routine)
 173 {
 174 #ifdef SPECIALIX_PARANOIA_CHECK
 175         static const char *badmagic = KERN_ERR
 176           "sx: Warning: bad specialix port magic number for device %s in %s\n";
 177         static const char *badinfo = KERN_ERR
 178           "sx: Warning: null specialix port for device %s in %s\n";
 179
 180         if (!port) {
 181                 printk(badinfo, name, routine);
 182                 return 1;
 183         }
 184         if (port->magic != SPECIALIX_MAGIC) {
 185                 printk(badmagic, name, routine);
 186                 return 1;
 187         }
 188 #endif
 189         return 0;
 190 }
 191
 192
 193 /*
 194  *
 195  *  Service functions for specialix IO8+ driver.
 196  *
 197  */
 198
 199 /* Get board number from pointer */
 200 static inline int board_No(struct specialix_board *bp)
 201 {
 202         return bp - sx_board;
 203 }
 204
 205
 206 /* Get port number from pointer */
 207 static inline int port_No(struct specialix_port const *port)
 208 {
 209         return SX_PORT(port - sx_port);
 210 }
 211
 212
 213 /* Get pointer to board from pointer to port */
 214 static inline struct specialix_board *port_Board(
 215                                         struct specialix_port const *port)
 216 {
 217         return &sx_board[SX_BOARD(port - sx_port)];
 218 }
 219
 220
 221 /* Input Byte from CL CD186x register */
 222 static inline unsigned char sx_in(struct specialix_board *bp,
 223                                                         unsigned short reg)
 224 {
 225         bp->reg = reg | 0x80;
 226         outb(reg | 0x80, bp->base + SX_ADDR_REG);
 227         return inb(bp->base + SX_DATA_REG);
 228 }
 229
 230
 231 /* Output Byte to CL CD186x register */
 232 static inline void sx_out(struct specialix_board *bp, unsigned short reg,
 233                           unsigned char val)
 234 {
 235         bp->reg = reg | 0x80;
 236         outb(reg | 0x80, bp->base + SX_ADDR_REG);
 237         outb(val, bp->base + SX_DATA_REG);
 238 }
 239
 240
 241 /* Input Byte from CL CD186x register */
 242 static inline unsigned char sx_in_off(struct specialix_board *bp,
 243                                 unsigned short reg)
 244 {
 245         bp->reg = reg;
 246         outb(reg, bp->base + SX_ADDR_REG);
 247         return inb(bp->base + SX_DATA_REG);
 248 }
 249
 250
 251 /* Output Byte to CL CD186x register */
 252 static inline void sx_out_off(struct specialix_board  *bp,
 253                                 unsigned short reg, unsigned char val)
 254 {
 255         bp->reg = reg;
 256         outb(reg, bp->base + SX_ADDR_REG);
 257         outb(val, bp->base + SX_DATA_REG);
 258 }
 259
 260
 261 /* Wait for Channel Command Register ready */
 262 static void sx_wait_CCR(struct specialix_board  *bp)
 263 {
 264         unsigned long delay, flags;
 265         unsigned char ccr;
 266
 267         for (delay = SX_CCR_TIMEOUT; delay; delay--) {
 268                 spin_lock_irqsave(&bp->lock, flags);
 269                 ccr = sx_in(bp, CD186x_CCR);
 270                 spin_unlock_irqrestore(&bp->lock, flags);
 271                 if (!ccr)
 272                         return;
 273                 udelay(1);
 274         }
 275
 276         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 277 }
 278
 279
 280 /* Wait for Channel Command Register ready */
 281 static void sx_wait_CCR_off(struct specialix_board  *bp)
 282 {
 283         unsigned long delay;
 284         unsigned char crr;
 285         unsigned long flags;
 286
 287         for (delay = SX_CCR_TIMEOUT; delay; delay--) {
 288                 spin_lock_irqsave(&bp->lock, flags);
 289                 crr = sx_in_off(bp, CD186x_CCR);
 290                 spin_unlock_irqrestore(&bp->lock, flags);
 291                 if (!crr)
 292                         return;
 293                 udelay(1);
 294         }
 295
 296         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 297 }
 298
 299
 300 /*
 301  *  specialix IO8+ IO range functions.
 302  */
 303
 304 static int sx_request_io_range(struct specialix_board *bp)
 305 {
 306         return request_region(bp->base,
 307                 bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
 308                 "specialix IO8+") == NULL;
 309 }
 310
 311
 312 static void sx_release_io_range(struct specialix_board *bp)
 313 {
 314         release_region(bp->base, bp->flags & SX_BOARD_IS_PCI ?
 315                                         SX_PCI_IO_SPACE : SX_IO_SPACE);
 316 }
 317
 318
 319 /* Set the IRQ using the RTS lines that run to the PAL on the board.... */
 320 static int sx_set_irq(struct specialix_board *bp)
 321 {
 322         int virq;
 323         int i;
 324         unsigned long flags;
 325
 326         if (bp->flags & SX_BOARD_IS_PCI)
 327                 return 1;
 328         switch (bp->irq) {
 329         /* In the same order as in the docs... */
 330         case 15:
 331                 virq = 0;
 332                 break;
 333         case 12:
 334                 virq = 1;
 335                 break;
 336         case 11:
 337                 virq = 2;
 338                 break;
 339         case 9:
 340                 virq = 3;
 341                 break;
 342         default:printk(KERN_ERR
 343                             "Speclialix: cannot set irq to %d.\n", bp->irq);
 344                 return 0;
 345         }
 346         spin_lock_irqsave(&bp->lock, flags);
 347         for (i = 0; i < 2; i++) {
 348                 sx_out(bp, CD186x_CAR, i);
 349                 sx_out(bp, CD186x_MSVRTS, ((virq >> i) & 0x1)? MSVR_RTS:0);
 350         }
 351         spin_unlock_irqrestore(&bp->lock, flags);
 352         return 1;
 353 }
 354
 355
 356 /* Reset and setup CD186x chip */
 357 static int sx_init_CD186x(struct specialix_board  *bp)
 358 {
 359         unsigned long flags;
 360         int scaler;
 361         int rv = 1;
 362
 363         func_enter();
 364         sx_wait_CCR_off(bp);                       /* Wait for CCR ready        */
 365         spin_lock_irqsave(&bp->lock, flags);
 366         sx_out_off(bp, CD186x_CCR, CCR_HARDRESET);      /* Reset CD186x chip          */
 367         spin_unlock_irqrestore(&bp->lock, flags);
 368         msleep(50);                                     /* Delay 0.05 sec            */
 369         spin_lock_irqsave(&bp->lock, flags);
 370         sx_out_off(bp, CD186x_GIVR, SX_ID);             /* Set ID for this chip      */
 371         sx_out_off(bp, CD186x_GICR, 0);                 /* Clear all bits            */
 372         sx_out_off(bp, CD186x_PILR1, SX_ACK_MINT);      /* Prio for modem intr       */
 373         sx_out_off(bp, CD186x_PILR2, SX_ACK_TINT);      /* Prio for transmitter intr */
 374         sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT);      /* Prio for receiver intr    */
 375         /* Set RegAckEn */
 376         sx_out_off(bp, CD186x_SRCR, sx_in(bp, CD186x_SRCR) | SRCR_REGACKEN);
 377
 378         /* Setting up prescaler. We need 4 ticks per 1 ms */
 379         scaler =  SX_OSCFREQ/SPECIALIX_TPS;
 380
 381         sx_out_off(bp, CD186x_PPRH, scaler >> 8);
 382         sx_out_off(bp, CD186x_PPRL, scaler & 0xff);
 383         spin_unlock_irqrestore(&bp->lock, flags);
 384
 385         if (!sx_set_irq(bp)) {
 386                 /* Figure out how to pass this along... */
 387                 printk(KERN_ERR "Cannot set irq to %d.\n", bp->irq);
 388                 rv = 0;
 389         }
 390
 391         func_exit();
 392         return rv;
 393 }
 394
 395
 396 static int read_cross_byte(struct specialix_board *bp, int reg, int bit)
 397 {
 398         int i;
 399         int t;
 400         unsigned long flags;
 401
 402         spin_lock_irqsave(&bp->lock, flags);
 403         for (i = 0, t = 0; i < 8; i++) {
 404                 sx_out_off(bp, CD186x_CAR, i);
 405                 if (sx_in_off(bp, reg) & bit)
 406                         t |= 1 << i;
 407         }
 408         spin_unlock_irqrestore(&bp->lock, flags);
 409
 410         return t;
 411 }
 412
 413
 414 /* Main probing routine, also sets irq. */
 415 static int sx_probe(struct specialix_board *bp)
 416 {
 417         unsigned char val1, val2;
 418         int rev;
 419         int chip;
 420
 421         func_enter();
 422
 423         if (sx_request_io_range(bp)) {
 424                 func_exit();
 425                 return 1;
 426         }
 427
 428         /* Are the I/O ports here ? */
 429         sx_out_off(bp, CD186x_PPRL, 0x5a);
 430         udelay(1);
 431         val1 = sx_in_off(bp, CD186x_PPRL);
 432
 433         sx_out_off(bp, CD186x_PPRL, 0xa5);
 434         udelay(1);
 435         val2 = sx_in_off(bp, CD186x_PPRL);
 436
 437
 438         if (val1 != 0x5a || val2 != 0xa5) {
 439                 printk(KERN_INFO
 440                         "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
 441                                                 board_No(bp), bp->base);
 442                 sx_release_io_range(bp);
 443                 func_exit();
 444                 return 1;
 445         }
 446
 447         /* Check the DSR lines that Specialix uses as board
 448            identification */
 449         val1 = read_cross_byte(bp, CD186x_MSVR, MSVR_DSR);
 450         val2 = read_cross_byte(bp, CD186x_MSVR, MSVR_RTS);
 451         dprintk(SX_DEBUG_INIT,
 452                         "sx%d: DSR lines are: %02x, rts lines are: %02x\n",
 453                                         board_No(bp), val1, val2);
 454
 455         /* They managed to switch the bit order between the docs and
 456            the IO8+ card. The new PCI card now conforms to old docs.
 457            They changed the PCI docs to reflect the situation on the
 458            old card. */
 459         val2 = (bp->flags & SX_BOARD_IS_PCI)?0x4d : 0xb2;
 460         if (val1 != val2) {
 461                 printk(KERN_INFO
 462                   "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
 463                        board_No(bp), val2, bp->base, val1);
 464                 sx_release_io_range(bp);
 465                 func_exit();
 466                 return 1;
 467         }
 468
 469
 470         /* Reset CD186x again  */
 471         if (!sx_init_CD186x(bp)) {
 472                 sx_release_io_range(bp);
 473                 func_exit();
 474                 return 1;
 475         }
 476
 477         sx_request_io_range(bp);
 478         bp->flags |= SX_BOARD_PRESENT;
 479
 480         /* Chip           revcode   pkgtype
 481                           GFRCR     SRCR bit 7
 482            CD180 rev B    0x81      0
 483            CD180 rev C    0x82      0
 484            CD1864 rev A   0x82      1
 485            CD1865 rev A   0x83      1  -- Do not use!!! Does not work.
 486            CD1865 rev B   0x84      1
 487          -- Thanks to Gwen Wang, Cirrus Logic.
 488          */
 489
 490         switch (sx_in_off(bp, CD186x_GFRCR)) {
 491         case 0x82:
 492                 chip = 1864;
 493                 rev = 'A';
 494                 break;
 495         case 0x83:
 496                 chip = 1865;
 497                 rev = 'A';
 498                 break;
 499         case 0x84:
 500                 chip = 1865;
 501                 rev = 'B';
 502                 break;
 503         case 0x85:
 504                 chip = 1865;
 505                 rev = 'C';
 506                 break; /* Does not exist at this time */
 507         default:
 508                 chip = -1;
 509                 rev = 'x';
 510         }
 511
 512         dprintk(SX_DEBUG_INIT, " GFCR = 0x%02x\n", sx_in_off(bp, CD186x_GFRCR));
 513
 514         printk(KERN_INFO
 515     "sx%d: specialix IO8+ board detected at 0x%03x, IRQ %d, CD%d Rev. %c.\n",
 516                                 board_No(bp), bp->base, bp->irq, chip, rev);
 517
 518         func_exit();
 519         return 0;
 520 }
 521
 522 /*
 523  *
 524  *  Interrupt processing routines.
 525  * */
 526
 527 static struct specialix_port *sx_get_port(struct specialix_board *bp,
 528                                                unsigned char const *what)
 529 {
 530         unsigned char channel;
 531         struct specialix_port *port = NULL;
 532
 533         channel = sx_in(bp, CD186x_GICR) >> GICR_CHAN_OFF;
 534         dprintk(SX_DEBUG_CHAN, "channel: %d\n", channel);
 535         if (channel < CD186x_NCH) {
 536                 port = &sx_port[board_No(bp) * SX_NPORT + channel];
 537                 dprintk(SX_DEBUG_CHAN, "port: %d %p flags: 0x%lx\n",
 538                         board_No(bp) * SX_NPORT + channel,  port,
 539                         port->port.flags & ASYNC_INITIALIZED);
 540
 541                 if (port->port.flags & ASYNC_INITIALIZED) {
 542                         dprintk(SX_DEBUG_CHAN, "port: %d %p\n", channel, port);
 543                         func_exit();
 544                         return port;
 545                 }
 546         }
 547         printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
 548                board_No(bp), what, channel);
 549         return NULL;
 550 }
 551
 552
 553 static void sx_receive_exc(struct specialix_board *bp)
 554 {
 555         struct specialix_port *port;
 556         struct tty_struct *tty;
 557         unsigned char status;
 558         unsigned char ch, flag;
 559
 560         func_enter();
 561
 562         port = sx_get_port(bp, "Receive");
 563         if (!port) {
 564                 dprintk(SX_DEBUG_RX, "Hmm, couldn't find port.\n");
 565                 func_exit();
 566                 return;
 567         }
 568         tty = port->port.tty;
 569
 570         status = sx_in(bp, CD186x_RCSR);
 571
 572         dprintk(SX_DEBUG_RX, "status: 0x%x\n", status);
 573         if (status & RCSR_OE) {
 574                 port->overrun++;
 575                 dprintk(SX_DEBUG_FIFO,
 576                         "sx%d: port %d: Overrun. Total %ld overruns.\n",
 577                                 board_No(bp), port_No(port), port->overrun);
 578         }
 579         status &= port->mark_mask;
 580
 581         /* This flip buffer check needs to be below the reading of the
 582            status register to reset the chip's IRQ.... */
 583         if (tty_buffer_request_room(tty, 1) == 0) {
 584                 dprintk(SX_DEBUG_FIFO,
 585                     "sx%d: port %d: Working around flip buffer overflow.\n",
 586                                         board_No(bp), port_No(port));
 587                 func_exit();
 588                 return;
 589         }
 590
 591         ch = sx_in(bp, CD186x_RDR);
 592         if (!status) {
 593                 func_exit();
 594                 return;
 595         }
 596         if (status & RCSR_TOUT) {
 597                 printk(KERN_INFO
 598                     "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
 599                                         board_No(bp), port_No(port));
 600                 func_exit();
 601                 return;
 602
 603         } else if (status & RCSR_BREAK) {
 604                 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
 605                        board_No(bp), port_No(port));
 606                 flag = TTY_BREAK;
 607                 if (port->port.flags & ASYNC_SAK)
 608                         do_SAK(tty);
 609
 610         } else if (status & RCSR_PE)
 611                 flag = TTY_PARITY;
 612
 613         else if (status & RCSR_FE)
 614                 flag = TTY_FRAME;
 615
 616         else if (status & RCSR_OE)
 617                 flag = TTY_OVERRUN;
 618
 619         else
 620                 flag = TTY_NORMAL;
 621
 622         if (tty_insert_flip_char(tty, ch, flag))
 623                 tty_flip_buffer_push(tty);
 624         func_exit();
 625 }
 626
 627
 628 static void sx_receive(struct specialix_board *bp)
 629 {
 630         struct specialix_port *port;
 631         struct tty_struct *tty;
 632         unsigned char count;
 633
 634         func_enter();
 635
 636         port = sx_get_port(bp, "Receive");
 637         if (port == NULL) {
 638                 dprintk(SX_DEBUG_RX, "Hmm, couldn't find port.\n");
 639                 func_exit();
 640                 return;
 641         }
 642         tty = port->port.tty;
 643
 644         count = sx_in(bp, CD186x_RDCR);
 645         dprintk(SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
 646         port->hits[count > 8 ? 9 : count]++;
 647
 648         tty_buffer_request_room(tty, count);
 649
 650         while (count--)
 651                 tty_insert_flip_char(tty, sx_in(bp, CD186x_RDR), TTY_NORMAL);
 652         tty_flip_buffer_push(tty);
 653         func_exit();
 654 }
 655
 656
 657 static void sx_transmit(struct specialix_board *bp)
 658 {
 659         struct specialix_port *port;
 660         struct tty_struct *tty;
 661         unsigned char count;
 662
 663         func_enter();
 664         port = sx_get_port(bp, "Transmit");
 665         if (port == NULL) {
 666                 func_exit();
 667                 return;
 668         }
 669         dprintk(SX_DEBUG_TX, "port: %p\n", port);
 670         tty = port->port.tty;
 671
 672         if (port->IER & IER_TXEMPTY) {
 673                 /* FIFO drained */
 674                 sx_out(bp, CD186x_CAR, port_No(port));
 675                 port->IER &= ~IER_TXEMPTY;
 676                 sx_out(bp, CD186x_IER, port->IER);
 677                 func_exit();
 678                 return;
 679         }
 680
 681         if ((port->xmit_cnt <= 0 && !port->break_length)
 682             || tty->stopped || tty->hw_stopped) {
 683                 sx_out(bp, CD186x_CAR, port_No(port));
 684                 port->IER &= ~IER_TXRDY;
 685                 sx_out(bp, CD186x_IER, port->IER);
 686                 func_exit();
 687                 return;
 688         }
 689
 690         if (port->break_length) {
 691                 if (port->break_length > 0) {
 692                         if (port->COR2 & COR2_ETC) {
 693                                 sx_out(bp, CD186x_TDR, CD186x_C_ESC);
 694                                 sx_out(bp, CD186x_TDR, CD186x_C_SBRK);
 695                                 port->COR2 &= ~COR2_ETC;
 696                         }
 697                         count = min_t(int, port->break_length, 0xff);
 698                         sx_out(bp, CD186x_TDR, CD186x_C_ESC);
 699                         sx_out(bp, CD186x_TDR, CD186x_C_DELAY);
 700                         sx_out(bp, CD186x_TDR, count);
 701                         port->break_length -= count;
 702                         if (port->break_length == 0)
 703                                 port->break_length--;
 704                 } else {
 705                         sx_out(bp, CD186x_TDR, CD186x_C_ESC);
 706                         sx_out(bp, CD186x_TDR, CD186x_C_EBRK);
 707                         sx_out(bp, CD186x_COR2, port->COR2);
 708                         sx_wait_CCR(bp);
 709                         sx_out(bp, CD186x_CCR, CCR_CORCHG2);
 710                         port->break_length = 0;
 711                 }
 712
 713                 func_exit();
 714                 return;
 715         }
 716
 717         count = CD186x_NFIFO;
 718         do {
 719                 sx_out(bp, CD186x_TDR, port->xmit_buf[port->xmit_tail++]);
 720                 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
 721                 if (--port->xmit_cnt <= 0)
 722                         break;
 723         } while (--count > 0);
 724
 725         if (port->xmit_cnt <= 0) {
 726                 sx_out(bp, CD186x_CAR, port_No(port));
 727                 port->IER &= ~IER_TXRDY;
 728                 sx_out(bp, CD186x_IER, port->IER);
 729         }
 730         if (port->xmit_cnt <= port->wakeup_chars)
 731                 tty_wakeup(tty);
 732
 733         func_exit();
 734 }
 735
 736
 737 static void sx_check_modem(struct specialix_board *bp)
 738 {
 739         struct specialix_port *port;
 740         struct tty_struct *tty;
 741         unsigned char mcr;
 742         int msvr_cd;
 743
 744         dprintk(SX_DEBUG_SIGNALS, "Modem intr. ");
 745         port = sx_get_port(bp, "Modem");
 746         if (port == NULL)
 747                 return;
 748
 749         tty = port->port.tty;
 750
 751         mcr = sx_in(bp, CD186x_MCR);
 752
 753         if ((mcr & MCR_CDCHG)) {
 754                 dprintk(SX_DEBUG_SIGNALS, "CD just changed... ");
 755                 msvr_cd = sx_in(bp, CD186x_MSVR) & MSVR_CD;
 756                 if (msvr_cd) {
 757                         dprintk(SX_DEBUG_SIGNALS, "Waking up guys in open.\n");
 758                         wake_up_interruptible(&port->port.open_wait);
 759                 } else {
 760                         dprintk(SX_DEBUG_SIGNALS, "Sending HUP.\n");
 761                         tty_hangup(tty);
 762                 }
 763         }
 764
 765 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
 766         if (mcr & MCR_CTSCHG) {
 767                 if (sx_in(bp, CD186x_MSVR) & MSVR_CTS) {
 768                         tty->hw_stopped = 0;
 769                         port->IER |= IER_TXRDY;
 770                         if (port->xmit_cnt <= port->wakeup_chars)
 771                                 tty_wakeup(tty);
 772                 } else {
 773                         tty->hw_stopped = 1;
 774                         port->IER &= ~IER_TXRDY;
 775                 }
 776                 sx_out(bp, CD186x_IER, port->IER);
 777         }
 778         if (mcr & MCR_DSSXHG) {
 779                 if (sx_in(bp, CD186x_MSVR) & MSVR_DSR) {
 780                         tty->hw_stopped = 0;
 781                         port->IER |= IER_TXRDY;
 782                         if (port->xmit_cnt <= port->wakeup_chars)
 783                                 tty_wakeup(tty);
 784                 } else {
 785                         tty->hw_stopped = 1;
 786                         port->IER &= ~IER_TXRDY;
 787                 }
 788                 sx_out(bp, CD186x_IER, port->IER);
 789         }
 790 #endif /* SPECIALIX_BRAIN_DAMAGED_CTS */
 791
 792         /* Clear change bits */
 793         sx_out(bp, CD186x_MCR, 0);
 794 }
 795
 796
 797 /* The main interrupt processing routine */
 798 static irqreturn_t sx_interrupt(int dummy, void *dev_id)
 799 {
 800         unsigned char status;
 801         unsigned char ack;
 802         struct specialix_board *bp = dev_id;
 803         unsigned long loop = 0;
 804         int saved_reg;
 805         unsigned long flags;
 806
 807         func_enter();
 808
 809         spin_lock_irqsave(&bp->lock, flags);
 810
 811         dprintk(SX_DEBUG_FLOW, "enter %s port %d room: %ld\n", __func__,
 812                 port_No(sx_get_port(bp, "INT")),
 813                 SERIAL_XMIT_SIZE - sx_get_port(bp, "ITN")->xmit_cnt - 1);
 814         if (!(bp->flags & SX_BOARD_ACTIVE)) {
 815                 dprintk(SX_DEBUG_IRQ, "sx: False interrupt. irq %d.\n",
 816                                                                 bp->irq);
 817                 spin_unlock_irqrestore(&bp->lock, flags);
 818                 func_exit();
 819                 return IRQ_NONE;
 820         }
 821
 822         saved_reg = bp->reg;
 823
 824         while (++loop < 16) {
 825                 status = sx_in(bp, CD186x_SRSR) &
 826                                 (SRSR_RREQint | SRSR_TREQint | SRSR_MREQint);
 827                 if (status == 0)
 828                         break;
 829                 if (status & SRSR_RREQint) {
 830                         ack = sx_in(bp, CD186x_RRAR);
 831
 832                         if (ack == (SX_ID | GIVR_IT_RCV))
 833                                 sx_receive(bp);
 834                         else if (ack == (SX_ID | GIVR_IT_REXC))
 835                                 sx_receive_exc(bp);
 836                         else
 837                                 printk(KERN_ERR
 838                                 "sx%d: status: 0x%x Bad receive ack 0x%02x.\n",
 839                                                 board_No(bp), status, ack);
 840
 841                 } else if (status & SRSR_TREQint) {
 842                         ack = sx_in(bp, CD186x_TRAR);
 843
 844                         if (ack == (SX_ID | GIVR_IT_TX))
 845                                 sx_transmit(bp);
 846                         else
 847                                 printk(KERN_ERR "sx%d: status: 0x%x Bad transmit ack 0x%02x. port: %d\n",
 848                                         board_No(bp), status, ack,
 849                                         port_No(sx_get_port(bp, "Int")));
 850                 } else if (status & SRSR_MREQint) {
 851                         ack = sx_in(bp, CD186x_MRAR);
 852
 853                         if (ack == (SX_ID | GIVR_IT_MODEM))
 854                                 sx_check_modem(bp);
 855                         else
 856                                 printk(KERN_ERR
 857                                   "sx%d: status: 0x%x Bad modem ack 0x%02x.\n",
 858                                        board_No(bp), status, ack);
 859
 860                 }
 861
 862                 sx_out(bp, CD186x_EOIR, 0);   /* Mark end of interrupt */
 863         }
 864         bp->reg = saved_reg;
 865         outb(bp->reg, bp->base + SX_ADDR_REG);
 866         spin_unlock_irqrestore(&bp->lock, flags);
 867         func_exit();
 868         return IRQ_HANDLED;
 869 }
 870
 871
 872 /*
 873  *  Routines for open & close processing.
 874  */
 875
 876 static void turn_ints_off(struct specialix_board *bp)
 877 {
 878         unsigned long flags;
 879
 880         func_enter();
 881         spin_lock_irqsave(&bp->lock, flags);
 882         (void) sx_in_off(bp, 0); /* Turn off interrupts. */
 883         spin_unlock_irqrestore(&bp->lock, flags);
 884
 885         func_exit();
 886 }
 887
 888 static void turn_ints_on(struct specialix_board *bp)
 889 {
 890         unsigned long flags;
 891
 892         func_enter();
 893
 894         spin_lock_irqsave(&bp->lock, flags);
 895         (void) sx_in(bp, 0); /* Turn ON interrupts. */
 896         spin_unlock_irqrestore(&bp->lock, flags);
 897
 898         func_exit();
 899 }
 900
 901
 902 /* Called with disabled interrupts */
 903 static int sx_setup_board(struct specialix_board *bp)
 904 {
 905         int error;
 906
 907         if (bp->flags & SX_BOARD_ACTIVE)
 908                 return 0;
 909
 910         if (bp->flags & SX_BOARD_IS_PCI)
 911                 error = request_irq(bp->irq, sx_interrupt,
 912                         IRQF_DISABLED | IRQF_SHARED, "specialix IO8+", bp);
 913         else
 914                 error = request_irq(bp->irq, sx_interrupt,
 915                         IRQF_DISABLED, "specialix IO8+", bp);
 916
 917         if (error)
 918                 return error;
 919
 920         turn_ints_on(bp);
 921         bp->flags |= SX_BOARD_ACTIVE;
 922
 923         return 0;
 924 }
 925
 926
 927 /* Called with disabled interrupts */
 928 static void sx_shutdown_board(struct specialix_board *bp)
 929 {
 930         func_enter();
 931
 932         if (!(bp->flags & SX_BOARD_ACTIVE)) {
 933                 func_exit();
 934                 return;
 935         }
 936
 937         bp->flags &= ~SX_BOARD_ACTIVE;
 938
 939         dprintk(SX_DEBUG_IRQ, "Freeing IRQ%d for board %d.\n",
 940                  bp->irq, board_No(bp));
 941         free_irq(bp->irq, bp);
 942         turn_ints_off(bp);
 943         func_exit();
 944 }
 945
 946 static unsigned int sx_crtscts(struct tty_struct *tty)
 947 {
 948         if (sx_rtscts)
 949                 return C_CRTSCTS(tty);
 950         return 1;
 951 }
 952
 953 /*
 954  * Setting up port characteristics.
 955  * Must be called with disabled interrupts
 956  */
 957 static void sx_change_speed(struct specialix_board *bp,
 958                                                 struct specialix_port *port)
 959 {
 960         struct tty_struct *tty;
 961         unsigned long baud;
 962         long tmp;
 963         unsigned char cor1 = 0, cor3 = 0;
 964         unsigned char mcor1 = 0, mcor2 = 0;
 965         static unsigned long again;
 966         unsigned long flags;
 967
 968         func_enter();
 969
 970         tty = port->port.tty;
 971         if (!tty || !tty->termios) {
 972                 func_exit();
 973                 return;
 974         }
 975
 976         port->IER  = 0;
 977         port->COR2 = 0;
 978         /* Select port on the board */
 979         spin_lock_irqsave(&bp->lock, flags);
 980         sx_out(bp, CD186x_CAR, port_No(port));
 981
 982         /* The Specialix board doens't implement the RTS lines.
 983            They are used to set the IRQ level. Don't touch them. */
 984         if (sx_crtscts(tty))
 985                 port->MSVR = MSVR_DTR | (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
 986         else
 987                 port->MSVR =  (sx_in(bp, CD186x_MSVR) & MSVR_RTS);
 988         spin_unlock_irqrestore(&bp->lock, flags);
 989         dprintk(SX_DEBUG_TERMIOS, "sx: got MSVR=%02x.\n", port->MSVR);
 990         baud = tty_get_baud_rate(tty);
 991
 992         if (baud == 38400) {
 993                 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
 994                         baud = 57600;
 995                 if ((port->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
 996                         baud = 115200;
 997         }
 998
 999         if (!baud) {
1000                 /* Drop DTR & exit */
1001                 dprintk(SX_DEBUG_TERMIOS, "Dropping DTR...  Hmm....\n");
1002                 if (!sx_crtscts(tty)) {
1003                         port->MSVR &= ~MSVR_DTR;
1004                         spin_lock_irqsave(&bp->lock, flags);
1005                         sx_out(bp, CD186x_MSVR, port->MSVR);
1006                         spin_unlock_irqrestore(&bp->lock, flags);
1007                 } else
1008                         dprintk(SX_DEBUG_TERMIOS, "Can't drop DTR: no DTR.\n");
1009                 return;
1010         } else {
1011                 /* Set DTR on */
1012                 if (!sx_crtscts(tty))
1013                         port->MSVR |= MSVR_DTR;
1014         }
1015
1016         /*
1017          * Now we must calculate some speed depended things
1018          */
1019
1020         /* Set baud rate for port */
1021         tmp = port->custom_divisor ;
1022         if (tmp)
1023                 printk(KERN_INFO
1024                         "sx%d: Using custom baud rate divisor %ld. \n"
1025                         "This is an untested option, please be careful.\n",
1026                                                         port_No(port), tmp);
1027         else
1028                 tmp = (((SX_OSCFREQ + baud/2) / baud + CD186x_TPC/2) /
1029                                                                 CD186x_TPC);
1030
1031         if (tmp < 0x10 && time_before(again, jiffies)) {
1032                 again = jiffies + HZ * 60;
1033                 /* Page 48 of version 2.0 of the CL-CD1865 databook */
1034                 if (tmp >= 12) {
1035                         printk(KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1036                                 "Performance degradation is possible.\n"
1037                                 "Read specialix.txt for more info.\n",
1038                                                 port_No(port), tmp);
1039                 } else {
1040                         printk(KERN_INFO "sx%d: Baud rate divisor is %ld. \n"
1041                 "Warning: overstressing Cirrus chip. This might not work.\n"
1042                 "Read specialix.txt for more info.\n", port_No(port), tmp);
1043                 }
1044         }
1045         spin_lock_irqsave(&bp->lock, flags);
1046         sx_out(bp, CD186x_RBPRH, (tmp >> 8) & 0xff);
1047         sx_out(bp, CD186x_TBPRH, (tmp >> 8) & 0xff);
1048         sx_out(bp, CD186x_RBPRL, tmp & 0xff);
1049         sx_out(bp, CD186x_TBPRL, tmp & 0xff);
1050         spin_unlock_irqrestore(&bp->lock, flags);
1051         if (port->custom_divisor)
1052                 baud = (SX_OSCFREQ + port->custom_divisor/2) /
1053                                                         port->custom_divisor;
1054         baud = (baud + 5) / 10;         /* Estimated CPS */
1055
1056         /* Two timer ticks seems enough to wakeup something like SLIP driver */
1057         tmp = ((baud + HZ/2) / HZ) * 2 - CD186x_NFIFO;
1058         port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
1059                                               SERIAL_XMIT_SIZE - 1 : tmp);
1060
1061         /* Receiver timeout will be transmission time for 1.5 chars */
1062         tmp = (SPECIALIX_TPS + SPECIALIX_TPS/2 + baud/2) / baud;
1063         tmp = (tmp > 0xff) ? 0xff : tmp;
1064         spin_lock_irqsave(&bp->lock, flags);
1065         sx_out(bp, CD186x_RTPR, tmp);
1066         spin_unlock_irqrestore(&bp->lock, flags);
1067         switch (C_CSIZE(tty)) {
1068         case CS5:
1069                 cor1 |= COR1_5BITS;
1070                 break;
1071         case CS6:
1072                 cor1 |= COR1_6BITS;
1073                 break;
1074         case CS7:
1075                 cor1 |= COR1_7BITS;
1076                 break;
1077         case CS8:
1078                 cor1 |= COR1_8BITS;
1079                 break;
1080         }
1081
1082         if (C_CSTOPB(tty))
1083                 cor1 |= COR1_2SB;
1084
1085         cor1 |= COR1_IGNORE;
1086         if (C_PARENB(tty)) {
1087                 cor1 |= COR1_NORMPAR;
1088                 if (C_PARODD(tty))
1089                         cor1 |= COR1_ODDP;
1090                 if (I_INPCK(tty))
1091                         cor1 &= ~COR1_IGNORE;
1092         }
1093         /* Set marking of some errors */
1094         port->mark_mask = RCSR_OE | RCSR_TOUT;
1095         if (I_INPCK(tty))
1096                 port->mark_mask |= RCSR_FE | RCSR_PE;
1097         if (I_BRKINT(tty) || I_PARMRK(tty))
1098                 port->mark_mask |= RCSR_BREAK;
1099         if (I_IGNPAR(tty))
1100                 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
1101         if (I_IGNBRK(tty)) {
1102                 port->mark_mask &= ~RCSR_BREAK;
1103                 if (I_IGNPAR(tty))
1104                         /* Real raw mode. Ignore all */
1105                         port->mark_mask &= ~RCSR_OE;
1106         }
1107         /* Enable Hardware Flow Control */
1108         if (C_CRTSCTS(tty)) {
1109 #ifdef SPECIALIX_BRAIN_DAMAGED_CTS
1110                 port->IER |= IER_DSR | IER_CTS;
1111                 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
1112                 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
1113                 spin_lock_irqsave(&bp->lock, flags);
1114                 tty->hw_stopped = !(sx_in(bp, CD186x_MSVR) &
1115                                                         (MSVR_CTS|MSVR_DSR));
1116                 spin_unlock_irqrestore(&bp->lock, flags);
1117 #else
1118                 port->COR2 |= COR2_CTSAE;
1119 #endif
1120         }
1121         /* Enable Software Flow Control. FIXME: I'm not sure about this */
1122         /* Some people reported that it works, but I still doubt it */
1123         if (I_IXON(tty)) {
1124                 port->COR2 |= COR2_TXIBE;
1125                 cor3 |= (COR3_FCT | COR3_SCDE);
1126                 if (I_IXANY(tty))
1127                         port->COR2 |= COR2_IXM;
1128                 spin_lock_irqsave(&bp->lock, flags);
1129                 sx_out(bp, CD186x_SCHR1, START_CHAR(tty));
1130                 sx_out(bp, CD186x_SCHR2, STOP_CHAR(tty));
1131                 sx_out(bp, CD186x_SCHR3, START_CHAR(tty));
1132                 sx_out(bp, CD186x_SCHR4, STOP_CHAR(tty));
1133                 spin_unlock_irqrestore(&bp->lock, flags);
1134         }
1135         if (!C_CLOCAL(tty)) {
1136                 /* Enable CD check */
1137                 port->IER |= IER_CD;
1138                 mcor1 |= MCOR1_CDZD;
1139                 mcor2 |= MCOR2_CDOD;
1140         }
1141
1142         if (C_CREAD(tty))
1143                 /* Enable receiver */
1144                 port->IER |= IER_RXD;
1145
1146         /* Set input FIFO size (1-8 bytes) */
1147         cor3 |= sx_rxfifo;
1148         /* Setting up CD186x channel registers */
1149         spin_lock_irqsave(&bp->lock, flags);
1150         sx_out(bp, CD186x_COR1, cor1);
1151         sx_out(bp, CD186x_COR2, port->COR2);
1152         sx_out(bp, CD186x_COR3, cor3);
1153         spin_unlock_irqrestore(&bp->lock, flags);
1154         /* Make CD186x know about registers change */
1155         sx_wait_CCR(bp);
1156         spin_lock_irqsave(&bp->lock, flags);
1157         sx_out(bp, CD186x_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
1158         /* Setting up modem option registers */
1159         dprintk(SX_DEBUG_TERMIOS, "Mcor1 = %02x, mcor2 = %02x.\n",
1160                                                                 mcor1, mcor2);
1161         sx_out(bp, CD186x_MCOR1, mcor1);
1162         sx_out(bp, CD186x_MCOR2, mcor2);
1163         spin_unlock_irqrestore(&bp->lock, flags);
1164         /* Enable CD186x transmitter & receiver */
1165         sx_wait_CCR(bp);
1166         spin_lock_irqsave(&bp->lock, flags);
1167         sx_out(bp, CD186x_CCR, CCR_TXEN | CCR_RXEN);
1168         /* Enable interrupts */
1169         sx_out(bp, CD186x_IER, port->IER);
1170         /* And finally set the modem lines... */
1171         sx_out(bp, CD186x_MSVR, port->MSVR);
1172         spin_unlock_irqrestore(&bp->lock, flags);
1173
1174         func_exit();
1175 }
1176
1177
1178 /* Must be called with interrupts enabled */
1179 static int sx_setup_port(struct specialix_board *bp,
1180                                                 struct specialix_port *port)
1181 {
1182         unsigned long flags;
1183
1184         func_enter();
1185
1186         if (port->port.flags & ASYNC_INITIALIZED) {
1187                 func_exit();
1188                 return 0;
1189         }
1190
1191         if (!port->xmit_buf) {
1192                 /* We may sleep in get_zeroed_page() */
1193                 unsigned long tmp;
1194
1195                 tmp = get_zeroed_page(GFP_KERNEL);
1196                 if (tmp == 0L) {
1197                         func_exit();
1198                         return -ENOMEM;
1199                 }
1200
1201                 if (port->xmit_buf) {
1202                         free_page(tmp);
1203                         func_exit();
1204                         return -ERESTARTSYS;
1205                 }
1206                 port->xmit_buf = (unsigned char *) tmp;
1207         }
1208
1209         spin_lock_irqsave(&port->lock, flags);
1210
1211         if (port->port.tty)
1212                 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
1213
1214         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1215         sx_change_speed(bp, port);
1216         port->port.flags |= ASYNC_INITIALIZED;
1217
1218         spin_unlock_irqrestore(&port->lock, flags);
1219
1220
1221         func_exit();
1222         return 0;
1223 }
1224
1225
1226 /* Must be called with interrupts disabled */
1227 static void sx_shutdown_port(struct specialix_board *bp,
1228                                                 struct specialix_port *port)
1229 {
1230         struct tty_struct *tty;
1231         int i;
1232         unsigned long flags;
1233
1234         func_enter();
1235
1236         if (!(port->port.flags & ASYNC_INITIALIZED)) {
1237                 func_exit();
1238                 return;
1239         }
1240
1241         if (sx_debug & SX_DEBUG_FIFO) {
1242                 dprintk(SX_DEBUG_FIFO,
1243                         "sx%d: port %d: %ld overruns, FIFO hits [ ",
1244                                 board_No(bp), port_No(port), port->overrun);
1245                 for (i = 0; i < 10; i++)
1246                         dprintk(SX_DEBUG_FIFO, "%ld ", port->hits[i]);
1247                 dprintk(SX_DEBUG_FIFO, "].\n");
1248         }
1249
1250         if (port->xmit_buf) {
1251                 free_page((unsigned long) port->xmit_buf);
1252                 port->xmit_buf = NULL;
1253         }
1254
1255         /* Select port */
1256         spin_lock_irqsave(&bp->lock, flags);
1257         sx_out(bp, CD186x_CAR, port_No(port));
1258
1259         tty = port->port.tty;
1260         if (tty == NULL || C_HUPCL(tty)) {
1261                 /* Drop DTR */
1262                 sx_out(bp, CD186x_MSVDTR, 0);
1263         }
1264         spin_unlock_irqrestore(&bp->lock, flags);
1265         /* Reset port */
1266         sx_wait_CCR(bp);
1267         spin_lock_irqsave(&bp->lock, flags);
1268         sx_out(bp, CD186x_CCR, CCR_SOFTRESET);
1269         /* Disable all interrupts from this port */
1270         port->IER = 0;
1271         sx_out(bp, CD186x_IER, port->IER);
1272         spin_unlock_irqrestore(&bp->lock, flags);
1273         if (tty)
1274                 set_bit(TTY_IO_ERROR, &tty->flags);
1275         port->port.flags &= ~ASYNC_INITIALIZED;
1276
1277         if (!bp->count)
1278                 sx_shutdown_board(bp);
1279         func_exit();
1280 }
1281
1282
1283 static int block_til_ready(struct tty_struct *tty, struct file *filp,
1284                                                 struct specialix_port *port)
1285 {
1286         DECLARE_WAITQUEUE(wait,  current);
1287         struct specialix_board *bp = port_Board(port);
1288         int    retval;
1289         int    do_clocal = 0;
1290         int    CD;
1291         unsigned long flags;
1292
1293         func_enter();
1294
1295         /*
1296          * If the device is in the middle of being closed, then block
1297          * until it's done, and then try again.
1298          */
1299         if (tty_hung_up_p(filp) || port->port.flags & ASYNC_CLOSING) {
1300                 interruptible_sleep_on(&port->port.close_wait);
1301                 if (port->port.flags & ASYNC_HUP_NOTIFY) {
1302                         func_exit();
1303                         return -EAGAIN;
1304                 } else {
1305                         func_exit();
1306                         return -ERESTARTSYS;
1307                 }
1308         }
1309
1310         /*
1311          * If non-blocking mode is set, or the port is not enabled,
1312          * then make the check up front and then exit.
1313          */
1314         if ((filp->f_flags & O_NONBLOCK) ||
1315             (tty->flags & (1 << TTY_IO_ERROR))) {
1316                 port->port.flags |= ASYNC_NORMAL_ACTIVE;
1317                 func_exit();
1318                 return 0;
1319         }
1320
1321         if (C_CLOCAL(tty))
1322                 do_clocal = 1;
1323
1324         /*
1325          * Block waiting for the carrier detect and the line to become
1326          * free (i.e., not in use by the callout).  While we are in
1327          * this loop, info->count is dropped by one, so that
1328          * rs_close() knows when to free things.  We restore it upon
1329          * exit, either normal or abnormal.
1330          */
1331         retval = 0;
1332         add_wait_queue(&port->port.open_wait, &wait);
1333         spin_lock_irqsave(&port->lock, flags);
1334         if (!tty_hung_up_p(filp))
1335                 port->port.count--;
1336         spin_unlock_irqrestore(&port->lock, flags);
1337         port->port.blocked_open++;
1338         while (1) {
1339                 spin_lock_irqsave(&bp->lock, flags);
1340                 sx_out(bp, CD186x_CAR, port_No(port));
1341                 CD = sx_in(bp, CD186x_MSVR) & MSVR_CD;
1342                 if (sx_crtscts(tty)) {
1343                         /* Activate RTS */
1344                         port->MSVR |= MSVR_DTR;         /* WTF? */
1345                         sx_out(bp, CD186x_MSVR, port->MSVR);
1346                 } else {
1347                         /* Activate DTR */
1348                         port->MSVR |= MSVR_DTR;
1349                         sx_out(bp, CD186x_MSVR, port->MSVR);
1350                 }
1351                 spin_unlock_irqrestore(&bp->lock, flags);
1352                 set_current_state(TASK_INTERRUPTIBLE);
1353                 if (tty_hung_up_p(filp) ||
1354                     !(port->port.flags & ASYNC_INITIALIZED)) {
1355                         if (port->port.flags & ASYNC_HUP_NOTIFY)
1356                                 retval = -EAGAIN;
1357                         else
1358                                 retval = -ERESTARTSYS;
1359                         break;
1360                 }
1361                 if (!(port->port.flags & ASYNC_CLOSING) &&
1362                     (do_clocal || CD))
1363                         break;
1364                 if (signal_pending(current)) {
1365                         retval = -ERESTARTSYS;
1366                         break;
1367                 }
1368                 schedule();
1369         }
1370
1371         set_current_state(TASK_RUNNING);
1372         remove_wait_queue(&port->port.open_wait, &wait);
1373         spin_lock_irqsave(&port->lock, flags);
1374         if (!tty_hung_up_p(filp))
1375                 port->port.count++;
1376         port->port.blocked_open--;
1377         spin_unlock_irqrestore(&port->lock, flags);
1378         if (retval) {
1379                 func_exit();
1380                 return retval;
1381         }
1382
1383         port->port.flags |= ASYNC_NORMAL_ACTIVE;
1384         func_exit();
1385         return 0;
1386 }
1387
1388
1389 static int sx_open(struct tty_struct *tty, struct file *filp)
1390 {
1391         int board;
1392         int error;
1393         struct specialix_port *port;
1394         struct specialix_board *bp;
1395         int i;
1396         unsigned long flags;
1397
1398         func_enter();
1399
1400         board = SX_BOARD(tty->index);
1401
1402         if (board >= SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT)) {
1403                 func_exit();
1404                 return -ENODEV;
1405         }
1406
1407         bp = &sx_board[board];
1408         port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
1409         port->overrun = 0;
1410         for (i = 0; i < 10; i++)
1411                 port->hits[i] = 0;
1412
1413         dprintk(SX_DEBUG_OPEN,
1414                         "Board = %d, bp = %p, port = %p, portno = %d.\n",
1415                                  board, bp, port, SX_PORT(tty->index));
1416
1417         if (sx_paranoia_check(port, tty->name, "sx_open")) {
1418                 func_enter();
1419                 return -ENODEV;
1420         }
1421
1422         error = sx_setup_board(bp);
1423         if (error) {
1424                 func_exit();
1425                 return error;
1426         }
1427
1428         spin_lock_irqsave(&bp->lock, flags);
1429         port->port.count++;
1430         bp->count++;
1431         tty->driver_data = port;
1432         port->port.tty = tty;
1433         spin_unlock_irqrestore(&bp->lock, flags);
1434
1435         error = sx_setup_port(bp, port);
1436         if (error) {
1437                 func_enter();
1438                 return error;
1439         }
1440
1441         error = block_til_ready(tty, filp, port);
1442         if (error) {
1443                 func_enter();
1444                 return error;
1445         }
1446
1447         func_exit();
1448         return 0;
1449 }
1450
1451 static void sx_flush_buffer(struct tty_struct *tty)
1452 {
1453         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1454         unsigned long flags;
1455         struct specialix_board  *bp;
1456
1457         func_enter();
1458
1459         if (sx_paranoia_check(port, tty->name, "sx_flush_buffer")) {
1460                 func_exit();
1461                 return;
1462         }
1463
1464         bp = port_Board(port);
1465         spin_lock_irqsave(&port->lock, flags);
1466         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1467         spin_unlock_irqrestore(&port->lock, flags);
1468         tty_wakeup(tty);
1469
1470         func_exit();
1471 }
1472
1473 static void sx_close(struct tty_struct *tty, struct file *filp)
1474 {
1475         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1476         struct specialix_board *bp;
1477         unsigned long flags;
1478         unsigned long timeout;
1479
1480         func_enter();
1481         if (!port || sx_paranoia_check(port, tty->name, "close")) {
1482                 func_exit();
1483                 return;
1484         }
1485         spin_lock_irqsave(&port->lock, flags);
1486
1487         if (tty_hung_up_p(filp)) {
1488                 spin_unlock_irqrestore(&port->lock, flags);
1489                 func_exit();
1490                 return;
1491         }
1492
1493         bp = port_Board(port);
1494         if (tty->count == 1 && port->port.count != 1) {
1495                 printk(KERN_ERR "sx%d: sx_close: bad port count;"
1496                        " tty->count is 1, port count is %d\n",
1497                        board_No(bp), port->port.count);
1498                 port->port.count = 1;
1499         }
1500
1501         if (port->port.count > 1) {
1502                 port->port.count--;
1503                 bp->count--;
1504
1505                 spin_unlock_irqrestore(&port->lock, flags);
1506
1507                 func_exit();
1508                 return;
1509         }
1510         port->port.flags |= ASYNC_CLOSING;
1511         /*
1512          * Now we wait for the transmit buffer to clear; and we notify
1513          * the line discipline to only process XON/XOFF characters.
1514          */
1515         tty->closing = 1;
1516         spin_unlock_irqrestore(&port->lock, flags);
1517         dprintk(SX_DEBUG_OPEN, "Closing\n");
1518         if (port->port.closing_wait != ASYNC_CLOSING_WAIT_NONE)
1519                 tty_wait_until_sent(tty, port->port.closing_wait);
1520         /*
1521          * At this point we stop accepting input.  To do this, we
1522          * disable the receive line status interrupts, and tell the
1523          * interrupt driver to stop checking the data ready bit in the
1524          * line status register.
1525          */
1526         dprintk(SX_DEBUG_OPEN, "Closed\n");
1527         port->IER &= ~IER_RXD;
1528         if (port->port.flags & ASYNC_INITIALIZED) {
1529                 port->IER &= ~IER_TXRDY;
1530                 port->IER |= IER_TXEMPTY;
1531                 spin_lock_irqsave(&bp->lock, flags);
1532                 sx_out(bp, CD186x_CAR, port_No(port));
1533                 sx_out(bp, CD186x_IER, port->IER);
1534                 spin_unlock_irqrestore(&bp->lock, flags);
1535                 /*
1536                  * Before we drop DTR, make sure the UART transmitter
1537                  * has completely drained; this is especially
1538                  * important if there is a transmit FIFO!
1539                  */
1540                 timeout = jiffies+HZ;
1541                 while (port->IER & IER_TXEMPTY) {
1542                         set_current_state(TASK_INTERRUPTIBLE);
1543                         msleep_interruptible(jiffies_to_msecs(port->timeout));
1544                         if (time_after(jiffies, timeout)) {
1545                                 printk(KERN_INFO "Timeout waiting for close\n");
1546                                 break;
1547                         }
1548                 }
1549
1550         }
1551
1552         if (--bp->count < 0) {
1553                 printk(KERN_ERR
1554                     "sx%d: sx_shutdown_port: bad board count: %d port: %d\n",
1555                                 board_No(bp), bp->count, tty->index);
1556                 bp->count = 0;
1557         }
1558         if (--port->port.count < 0) {
1559                 printk(KERN_ERR
1560                         "sx%d: sx_close: bad port count for tty%d: %d\n",
1561                                 board_No(bp), port_No(port), port->port.count);
1562                 port->port.count = 0;
1563         }
1564
1565         sx_shutdown_port(bp, port);
1566         sx_flush_buffer(tty);
1567         tty_ldisc_flush(tty);
1568         spin_lock_irqsave(&port->lock, flags);
1569         tty->closing = 0;
1570         port->port.tty = NULL;
1571         spin_unlock_irqrestore(&port->lock, flags);
1572         if (port->port.blocked_open) {
1573                 if (port->port.close_delay)
1574                         msleep_interruptible(
1575                                 jiffies_to_msecs(port->port.close_delay));
1576                 wake_up_interruptible(&port->port.open_wait);
1577         }
1578         port->port.flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1579         wake_up_interruptible(&port->port.close_wait);
1580
1581         func_exit();
1582 }
1583
1584
1585 static int sx_write(struct tty_struct *tty,
1586                                         const unsigned char *buf, int count)
1587 {
1588         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1589         struct specialix_board *bp;
1590         int c, total = 0;
1591         unsigned long flags;
1592
1593         func_enter();
1594         if (sx_paranoia_check(port, tty->name, "sx_write")) {
1595                 func_exit();
1596                 return 0;
1597         }
1598
1599         bp = port_Board(port);
1600
1601         if (!port->xmit_buf) {
1602                 func_exit();
1603                 return 0;
1604         }
1605
1606         while (1) {
1607                 spin_lock_irqsave(&port->lock, flags);
1608                 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1609                                    SERIAL_XMIT_SIZE - port->xmit_head));
1610                 if (c <= 0) {
1611                         spin_unlock_irqrestore(&port->lock, flags);
1612                         break;
1613                 }
1614                 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1615                 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1616                 port->xmit_cnt += c;
1617                 spin_unlock_irqrestore(&port->lock, flags);
1618
1619                 buf += c;
1620                 count -= c;
1621                 total += c;
1622         }
1623
1624         spin_lock_irqsave(&bp->lock, flags);
1625         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1626             !(port->IER & IER_TXRDY)) {
1627                 port->IER |= IER_TXRDY;
1628                 sx_out(bp, CD186x_CAR, port_No(port));
1629                 sx_out(bp, CD186x_IER, port->IER);
1630         }
1631         spin_unlock_irqrestore(&bp->lock, flags);
1632         func_exit();
1633
1634         return total;
1635 }
1636
1637
1638 static int sx_put_char(struct tty_struct *tty, unsigned char ch)
1639 {
1640         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1641         unsigned long flags;
1642         struct specialix_board  *bp;
1643
1644         func_enter();
1645
1646         if (sx_paranoia_check(port, tty->name, "sx_put_char")) {
1647                 func_exit();
1648                 return 0;
1649         }
1650         dprintk(SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
1651         if (!port->xmit_buf) {
1652                 func_exit();
1653                 return 0;
1654         }
1655         bp = port_Board(port);
1656         spin_lock_irqsave(&port->lock, flags);
1657
1658         dprintk(SX_DEBUG_TX, "xmit_cnt: %d xmit_buf: %p\n",
1659                                         port->xmit_cnt, port->xmit_buf);
1660         if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1 || !port->xmit_buf) {
1661                 spin_unlock_irqrestore(&port->lock, flags);
1662                 dprintk(SX_DEBUG_TX, "Exit size\n");
1663                 func_exit();
1664                 return 0;
1665         }
1666         dprintk(SX_DEBUG_TX, "Handle xmit: %p %p\n", port, port->xmit_buf);
1667         port->xmit_buf[port->xmit_head++] = ch;
1668         port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1669         port->xmit_cnt++;
1670         spin_unlock_irqrestore(&port->lock, flags);
1671
1672         func_exit();
1673         return 1;
1674 }
1675
1676
1677 static void sx_flush_chars(struct tty_struct *tty)
1678 {
1679         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1680         unsigned long flags;
1681         struct specialix_board  *bp = port_Board(port);
1682
1683         func_enter();
1684
1685         if (sx_paranoia_check(port, tty->name, "sx_flush_chars")) {
1686                 func_exit();
1687                 return;
1688         }
1689         if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1690             !port->xmit_buf) {
1691                 func_exit();
1692                 return;
1693         }
1694         spin_lock_irqsave(&bp->lock, flags);
1695         port->IER |= IER_TXRDY;
1696         sx_out(port_Board(port), CD186x_CAR, port_No(port));
1697         sx_out(port_Board(port), CD186x_IER, port->IER);
1698         spin_unlock_irqrestore(&bp->lock, flags);
1699
1700         func_exit();
1701 }
1702
1703
1704 static int sx_write_room(struct tty_struct *tty)
1705 {
1706         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1707         int     ret;
1708
1709         func_enter();
1710
1711         if (sx_paranoia_check(port, tty->name, "sx_write_room")) {
1712                 func_exit();
1713                 return 0;
1714         }
1715
1716         ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1717         if (ret < 0)
1718                 ret = 0;
1719
1720         func_exit();
1721         return ret;
1722 }
1723
1724
1725 static int sx_chars_in_buffer(struct tty_struct *tty)
1726 {
1727         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1728
1729         func_enter();
1730
1731         if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
1732                 func_exit();
1733                 return 0;
1734         }
1735         func_exit();
1736         return port->xmit_cnt;
1737 }
1738
1739 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1740 {
1741         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1742         struct specialix_board *bp;
1743         unsigned char status;
1744         unsigned int result;
1745         unsigned long flags;
1746
1747         func_enter();
1748
1749         if (sx_paranoia_check(port, tty->name, __func__)) {
1750                 func_exit();
1751                 return -ENODEV;
1752         }
1753
1754         bp = port_Board(port);
1755         spin_lock_irqsave(&bp->lock, flags);
1756         sx_out(bp, CD186x_CAR, port_No(port));
1757         status = sx_in(bp, CD186x_MSVR);
1758         spin_unlock_irqrestore(&bp->lock, flags);
1759         dprintk(SX_DEBUG_INIT, "Got msvr[%d] = %02x, car = %d.\n",
1760                         port_No(port), status, sx_in(bp, CD186x_CAR));
1761         dprintk(SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
1762         if (sx_crtscts(port->port.tty)) {
1763                 result  = TIOCM_DTR | TIOCM_DSR
1764                           |   ((status & MSVR_DTR) ? TIOCM_RTS : 0)
1765                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1766                           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1767         } else {
1768                 result  = TIOCM_RTS | TIOCM_DSR
1769                           |   ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1770                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1771                           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1772         }
1773
1774         func_exit();
1775
1776         return result;
1777 }
1778
1779
1780 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1781                        unsigned int set, unsigned int clear)
1782 {
1783         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1784         unsigned long flags;
1785         struct specialix_board *bp;
1786
1787         func_enter();
1788
1789         if (sx_paranoia_check(port, tty->name, __func__)) {
1790                 func_exit();
1791                 return -ENODEV;
1792         }
1793
1794         bp = port_Board(port);
1795
1796         spin_lock_irqsave(&port->lock, flags);
1797         if (sx_crtscts(port->port.tty)) {
1798                 if (set & TIOCM_RTS)
1799                         port->MSVR |= MSVR_DTR;
1800         } else {
1801                 if (set & TIOCM_DTR)
1802                         port->MSVR |= MSVR_DTR;
1803         }
1804         if (sx_crtscts(port->port.tty)) {
1805                 if (clear & TIOCM_RTS)
1806                         port->MSVR &= ~MSVR_DTR;
1807         } else {
1808                 if (clear & TIOCM_DTR)
1809                         port->MSVR &= ~MSVR_DTR;
1810         }
1811         spin_lock_irqsave(&bp->lock, flags);
1812         sx_out(bp, CD186x_CAR, port_No(port));
1813         sx_out(bp, CD186x_MSVR, port->MSVR);
1814         spin_unlock_irqrestore(&bp->lock, flags);
1815         spin_unlock_irqrestore(&port->lock, flags);
1816         func_exit();
1817         return 0;
1818 }
1819
1820
1821 static int sx_send_break(struct tty_struct *tty, int length)
1822 {
1823         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1824         struct specialix_board *bp = port_Board(port);
1825         unsigned long flags;
1826
1827         func_enter();
1828         if (length == 0 || length == -1)
1829                 return -EOPNOTSUPP;
1830
1831         spin_lock_irqsave(&port->lock, flags);
1832         port->break_length = SPECIALIX_TPS / HZ * length;
1833         port->COR2 |= COR2_ETC;
1834         port->IER  |= IER_TXRDY;
1835         spin_lock_irqsave(&bp->lock, flags);
1836         sx_out(bp, CD186x_CAR, port_No(port));
1837         sx_out(bp, CD186x_COR2, port->COR2);
1838         sx_out(bp, CD186x_IER, port->IER);
1839         spin_unlock_irqrestore(&bp->lock, flags);
1840         spin_unlock_irqrestore(&port->lock, flags);
1841         sx_wait_CCR(bp);
1842         spin_lock_irqsave(&bp->lock, flags);
1843         sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1844         spin_unlock_irqrestore(&bp->lock, flags);
1845         sx_wait_CCR(bp);
1846
1847         func_exit();
1848         return 0;
1849 }
1850
1851
1852 static int sx_set_serial_info(struct specialix_port *port,
1853                                         struct serial_struct __user *newinfo)
1854 {
1855         struct serial_struct tmp;
1856         struct specialix_board *bp = port_Board(port);
1857         int change_speed;
1858
1859         func_enter();
1860
1861         if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1862                 func_enter();
1863                 return -EFAULT;
1864         }
1865
1866         lock_kernel();
1867
1868         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1869                         (tmp.flags & ASYNC_SPD_MASK));
1870         change_speed |= (tmp.custom_divisor != port->custom_divisor);
1871
1872         if (!capable(CAP_SYS_ADMIN)) {
1873                 if ((tmp.close_delay != port->port.close_delay) ||
1874                     (tmp.closing_wait != port->port.closing_wait) ||
1875                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1876                      (port->port.flags & ~ASYNC_USR_MASK))) {
1877                         func_exit();
1878                         unlock_kernel();
1879                         return -EPERM;
1880                 }
1881                 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1882                                                 (tmp.flags & ASYNC_USR_MASK));
1883                 port->custom_divisor = tmp.custom_divisor;
1884         } else {
1885                 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1886                                                 (tmp.flags & ASYNC_FLAGS));
1887                 port->port.close_delay = tmp.close_delay;
1888                 port->port.closing_wait = tmp.closing_wait;
1889                 port->custom_divisor = tmp.custom_divisor;
1890         }
1891         if (change_speed)
1892                 sx_change_speed(bp, port);
1893
1894         func_exit();
1895         unlock_kernel();
1896         return 0;
1897 }
1898
1899
1900 static int sx_get_serial_info(struct specialix_port *port,
1901                                      struct serial_struct __user *retinfo)
1902 {
1903         struct serial_struct tmp;
1904         struct specialix_board *bp = port_Board(port);
1905
1906         func_enter();
1907
1908         memset(&tmp, 0, sizeof(tmp));
1909         lock_kernel();
1910         tmp.type = PORT_CIRRUS;
1911         tmp.line = port - sx_port;
1912         tmp.port = bp->base;
1913         tmp.irq  = bp->irq;
1914         tmp.flags = port->port.flags;
1915         tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
1916         tmp.close_delay = port->port.close_delay * HZ/100;
1917         tmp.closing_wait = port->port.closing_wait * HZ/100;
1918         tmp.custom_divisor =  port->custom_divisor;
1919         tmp.xmit_fifo_size = CD186x_NFIFO;
1920         unlock_kernel();
1921         if (copy_to_user(retinfo, &tmp, sizeof(tmp))) {
1922                 func_exit();
1923                 return -EFAULT;
1924         }
1925
1926         func_exit();
1927         return 0;
1928 }
1929
1930
1931 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1932                                 unsigned int cmd, unsigned long arg)
1933 {
1934         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1935         void __user *argp = (void __user *)arg;
1936
1937         func_enter();
1938
1939         if (sx_paranoia_check(port, tty->name, "sx_ioctl")) {
1940                 func_exit();
1941                 return -ENODEV;
1942         }
1943
1944         switch (cmd) {
1945         case TIOCGSERIAL:
1946                 func_exit();
1947                 return sx_get_serial_info(port, argp);
1948         case TIOCSSERIAL:
1949                 func_exit();
1950                 return sx_set_serial_info(port, argp);
1951         default:
1952                 func_exit();
1953                 return -ENOIOCTLCMD;
1954         }
1955         func_exit();
1956         return 0;
1957 }
1958
1959
1960 static void sx_throttle(struct tty_struct *tty)
1961 {
1962         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1963         struct specialix_board *bp;
1964         unsigned long flags;
1965
1966         func_enter();
1967
1968         if (sx_paranoia_check(port, tty->name, "sx_throttle")) {
1969                 func_exit();
1970                 return;
1971         }
1972
1973         bp = port_Board(port);
1974
1975         /* Use DTR instead of RTS ! */
1976         if (sx_crtscts(tty))
1977                 port->MSVR &= ~MSVR_DTR;
1978         else {
1979                 /* Auch!!! I think the system shouldn't call this then. */
1980                 /* Or maybe we're supposed (allowed?) to do our side of hw
1981                    handshake anyway, even when hardware handshake is off.
1982                    When you see this in your logs, please report.... */
1983                 printk(KERN_ERR
1984                    "sx%d: Need to throttle, but can't (hardware hs is off)\n",
1985                                                         port_No(port));
1986         }
1987         spin_lock_irqsave(&bp->lock, flags);
1988         sx_out(bp, CD186x_CAR, port_No(port));
1989         spin_unlock_irqrestore(&bp->lock, flags);
1990         if (I_IXOFF(tty)) {
1991                 sx_wait_CCR(bp);
1992                 spin_lock_irqsave(&bp->lock, flags);
1993                 sx_out(bp, CD186x_CCR, CCR_SSCH2);
1994                 spin_unlock_irqrestore(&bp->lock, flags);
1995                 sx_wait_CCR(bp);
1996         }
1997         spin_lock_irqsave(&bp->lock, flags);
1998         sx_out(bp, CD186x_MSVR, port->MSVR);
1999         spin_unlock_irqrestore(&bp->lock, flags);
2000
2001         func_exit();
2002 }
2003
2004
2005 static void sx_unthrottle(struct tty_struct *tty)
2006 {
2007         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2008         struct specialix_board *bp;
2009         unsigned long flags;
2010
2011         func_enter();
2012
2013         if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
2014                 func_exit();
2015                 return;
2016         }
2017
2018         bp = port_Board(port);
2019
2020         spin_lock_irqsave(&port->lock, flags);
2021         /* XXXX Use DTR INSTEAD???? */
2022         if (sx_crtscts(tty))
2023                 port->MSVR |= MSVR_DTR;
2024         /* Else clause: see remark in "sx_throttle"... */
2025         spin_lock_irqsave(&bp->lock, flags);
2026         sx_out(bp, CD186x_CAR, port_No(port));
2027         spin_unlock_irqrestore(&bp->lock, flags);
2028         if (I_IXOFF(tty)) {
2029                 spin_unlock_irqrestore(&port->lock, flags);
2030                 sx_wait_CCR(bp);
2031                 spin_lock_irqsave(&bp->lock, flags);
2032                 sx_out(bp, CD186x_CCR, CCR_SSCH1);
2033                 spin_unlock_irqrestore(&bp->lock, flags);
2034                 sx_wait_CCR(bp);
2035                 spin_lock_irqsave(&port->lock, flags);
2036         }
2037         spin_lock_irqsave(&bp->lock, flags);
2038         sx_out(bp, CD186x_MSVR, port->MSVR);
2039         spin_unlock_irqrestore(&bp->lock, flags);
2040         spin_unlock_irqrestore(&port->lock, flags);
2041
2042         func_exit();
2043 }
2044
2045
2046 static void sx_stop(struct tty_struct *tty)
2047 {
2048         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2049         struct specialix_board *bp;
2050         unsigned long flags;
2051
2052         func_enter();
2053
2054         if (sx_paranoia_check(port, tty->name, "sx_stop")) {
2055                 func_exit();
2056                 return;
2057         }
2058
2059         bp = port_Board(port);
2060
2061         spin_lock_irqsave(&port->lock, flags);
2062         port->IER &= ~IER_TXRDY;
2063         spin_lock_irqsave(&bp->lock, flags);
2064         sx_out(bp, CD186x_CAR, port_No(port));
2065         sx_out(bp, CD186x_IER, port->IER);
2066         spin_unlock_irqrestore(&bp->lock, flags);
2067         spin_unlock_irqrestore(&port->lock, flags);
2068
2069         func_exit();
2070 }
2071
2072
2073 static void sx_start(struct tty_struct *tty)
2074 {
2075         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2076         struct specialix_board *bp;
2077         unsigned long flags;
2078
2079         func_enter();
2080
2081         if (sx_paranoia_check(port, tty->name, "sx_start")) {
2082                 func_exit();
2083                 return;
2084         }
2085
2086         bp = port_Board(port);
2087
2088         spin_lock_irqsave(&port->lock, flags);
2089         if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
2090                 port->IER |= IER_TXRDY;
2091                 spin_lock_irqsave(&bp->lock, flags);
2092                 sx_out(bp, CD186x_CAR, port_No(port));
2093                 sx_out(bp, CD186x_IER, port->IER);
2094                 spin_unlock_irqrestore(&bp->lock, flags);
2095         }
2096         spin_unlock_irqrestore(&port->lock, flags);
2097
2098         func_exit();
2099 }
2100
2101 static void sx_hangup(struct tty_struct *tty)
2102 {
2103         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2104         struct specialix_board *bp;
2105         unsigned long flags;
2106
2107         func_enter();
2108
2109         if (sx_paranoia_check(port, tty->name, "sx_hangup")) {
2110                 func_exit();
2111                 return;
2112         }
2113
2114         bp = port_Board(port);
2115
2116         sx_shutdown_port(bp, port);
2117         spin_lock_irqsave(&port->lock, flags);
2118         bp->count -= port->port.count;
2119         if (bp->count < 0) {
2120                 printk(KERN_ERR
2121                         "sx%d: sx_hangup: bad board count: %d port: %d\n",
2122                                         board_No(bp), bp->count, tty->index);
2123                 bp->count = 0;
2124         }
2125         port->port.count = 0;
2126         port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
2127         port->port.tty = NULL;
2128         spin_unlock_irqrestore(&port->lock, flags);
2129         wake_up_interruptible(&port->port.open_wait);
2130
2131         func_exit();
2132 }
2133
2134
2135 static void sx_set_termios(struct tty_struct *tty,
2136                                         struct ktermios *old_termios)
2137 {
2138         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2139         unsigned long flags;
2140         struct specialix_board  *bp;
2141
2142         if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
2143                 return;
2144
2145         bp = port_Board(port);
2146         spin_lock_irqsave(&port->lock, flags);
2147         sx_change_speed(port_Board(port), port);
2148         spin_unlock_irqrestore(&port->lock, flags);
2149
2150         if ((old_termios->c_cflag & CRTSCTS) &&
2151             !(tty->termios->c_cflag & CRTSCTS)) {
2152                 tty->hw_stopped = 0;
2153                 sx_start(tty);
2154         }
2155 }
2156
2157 static const struct tty_operations sx_ops = {
2158         .open  = sx_open,
2159         .close = sx_close,
2160         .write = sx_write,
2161         .put_char = sx_put_char,
2162         .flush_chars = sx_flush_chars,
2163         .write_room = sx_write_room,
2164         .chars_in_buffer = sx_chars_in_buffer,
2165         .flush_buffer = sx_flush_buffer,
2166         .ioctl = sx_ioctl,
2167         .throttle = sx_throttle,
2168         .unthrottle = sx_unthrottle,
2169         .set_termios = sx_set_termios,
2170         .stop = sx_stop,
2171         .start = sx_start,
2172         .hangup = sx_hangup,
2173         .tiocmget = sx_tiocmget,
2174         .tiocmset = sx_tiocmset,
2175         .break_ctl = sx_send_break,
2176 };
2177
2178 static int sx_init_drivers(void)
2179 {
2180         int error;
2181         int i;
2182
2183         func_enter();
2184
2185         specialix_driver = alloc_tty_driver(SX_NBOARD * SX_NPORT);
2186         if (!specialix_driver) {
2187                 printk(KERN_ERR "sx: Couldn't allocate tty_driver.\n");
2188                 func_exit();
2189                 return 1;
2190         }
2191
2192         specialix_driver->owner = THIS_MODULE;
2193         specialix_driver->name = "ttyW";
2194         specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
2195         specialix_driver->type = TTY_DRIVER_TYPE_SERIAL;
2196         specialix_driver->subtype = SERIAL_TYPE_NORMAL;
2197         specialix_driver->init_termios = tty_std_termios;
2198         specialix_driver->init_termios.c_cflag =
2199                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2200         specialix_driver->init_termios.c_ispeed = 9600;
2201         specialix_driver->init_termios.c_ospeed = 9600;
2202         specialix_driver->flags = TTY_DRIVER_REAL_RAW |
2203                                                 TTY_DRIVER_HARDWARE_BREAK;
2204         tty_set_operations(specialix_driver, &sx_ops);
2205
2206         error = tty_register_driver(specialix_driver);
2207         if (error) {
2208                 put_tty_driver(specialix_driver);
2209                 printk(KERN_ERR
2210                   "sx: Couldn't register specialix IO8+ driver, error = %d\n",
2211                                                                 error);
2212                 func_exit();
2213                 return 1;
2214         }
2215         memset(sx_port, 0, sizeof(sx_port));
2216         for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
2217                 sx_port[i].magic = SPECIALIX_MAGIC;
2218                 tty_port_init(&sx_port[i].port);
2219                 spin_lock_init(&sx_port[i].lock);
2220         }
2221
2222         func_exit();
2223         return 0;
2224 }
2225
2226 static void sx_release_drivers(void)
2227 {
2228         func_enter();
2229
2230         tty_unregister_driver(specialix_driver);
2231         put_tty_driver(specialix_driver);
2232         func_exit();
2233 }
2234
2235 /*
2236  * This routine must be called by kernel at boot time
2237  */
2238 static int __init specialix_init(void)
2239 {
2240         int i;
2241         int found = 0;
2242
2243         func_enter();
2244
2245         printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.\n");
2246         printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.\n");
2247         if (sx_rtscts)
2248                 printk(KERN_INFO
2249                         "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
2250         else
2251                 printk(KERN_INFO "sx: DTR/RTS pin is always RTS.\n");
2252
2253         for (i = 0; i < SX_NBOARD; i++)
2254                 spin_lock_init(&sx_board[i].lock);
2255
2256         if (sx_init_drivers()) {
2257                 func_exit();
2258                 return -EIO;
2259         }
2260
2261         for (i = 0; i < SX_NBOARD; i++)
2262                 if (sx_board[i].base && !sx_probe(&sx_board[i]))
2263                         found++;
2264
2265 #ifdef CONFIG_PCI
2266         {
2267                 struct pci_dev *pdev = NULL;
2268
2269                 i = 0;
2270                 while (i < SX_NBOARD) {
2271                         if (sx_board[i].flags & SX_BOARD_PRESENT) {
2272                                 i++;
2273                                 continue;
2274                         }
2275                         pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX,
2276                                         PCI_DEVICE_ID_SPECIALIX_IO8, pdev);
2277                         if (!pdev)
2278                                 break;
2279
2280                         if (pci_enable_device(pdev))
2281                                 continue;
2282
2283                         sx_board[i].irq = pdev->irq;
2284
2285                         sx_board[i].base = pci_resource_start(pdev, 2);
2286
2287                         sx_board[i].flags |= SX_BOARD_IS_PCI;
2288                         if (!sx_probe(&sx_board[i]))
2289                                 found++;
2290                 }
2291                 /* May exit pci_get sequence early with lots of boards */
2292                 if (pdev != NULL)
2293                         pci_dev_put(pdev);
2294         }
2295 #endif
2296
2297         if (!found) {
2298                 sx_release_drivers();
2299                 printk(KERN_INFO "sx: No specialix IO8+ boards detected.\n");
2300                 func_exit();
2301                 return -EIO;
2302         }
2303
2304         func_exit();
2305         return 0;
2306 }
2307
2308 static int iobase[SX_NBOARD]  = {0,};
2309 static int irq[SX_NBOARD] = {0,};
2310
2311 module_param_array(iobase, int, NULL, 0);
2312 module_param_array(irq, int, NULL, 0);
2313 module_param(sx_debug, int, 0);
2314 module_param(sx_rtscts, int, 0);
2315 module_param(sx_rxfifo, int, 0);
2316
2317 /*
2318  * You can setup up to 4 boards.
2319  * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
2320  * You should specify the IRQs too in that case "irq=....,...".
2321  *
2322  * More than 4 boards in one computer is not possible, as the card can
2323  * only use 4 different interrupts.
2324  *
2325  */
2326 static int __init specialix_init_module(void)
2327 {
2328         int i;
2329
2330         func_enter();
2331
2332         if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
2333                 for (i = 0; i < SX_NBOARD; i++) {
2334                         sx_board[i].base = iobase[i];
2335                         sx_board[i].irq = irq[i];
2336                         sx_board[i].count = 0;
2337                 }
2338         }
2339
2340         func_exit();
2341
2342         return specialix_init();
2343 }
2344
2345 static void __exit specialix_exit_module(void)
2346 {
2347         int i;
2348
2349         func_enter();
2350
2351         sx_release_drivers();
2352         for (i = 0; i < SX_NBOARD; i++)
2353                 if (sx_board[i].flags & SX_BOARD_PRESENT)
2354                         sx_release_io_range(&sx_board[i]);
2355         func_exit();
2356 }
2357
2358 static struct pci_device_id specialx_pci_tbl[] __devinitdata = {
2359         { PCI_DEVICE(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_IO8) },
2360         { }
2361 };
2362 MODULE_DEVICE_TABLE(pci, specialx_pci_tbl);
2363
2364 module_init(specialix_init_module);
2365 module_exit(specialix_exit_module);
2366
2367 MODULE_LICENSE("GPL");