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/serial/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/smp_lock.h>
  91 #include <linux/fcntl.h>
  92 #include <linux/major.h>
  93 #include <linux/delay.h>
  94 #include <linux/pci.h>
  95 #include <linux/init.h>
  96 #include <linux/uaccess.h>
  97 #include <linux/gfp.h>
  98
  99 #include "specialix_io8.h"
 100 #include "cd1865.h"
 101
 102
 103 /*
 104    This driver can spew a whole lot of debugging output at you. If you
 105    need maximum performance, you should disable the DEBUG define. To
 106    aid in debugging in the field, I'm leaving the compile-time debug
 107    features enabled, and disable them "runtime". That allows me to
 108    instruct people with problems to enable debugging without requiring
 109    them to recompile...
 110 */
 111 #define DEBUG
 112
 113 static int sx_debug;
 114 static int sx_rxfifo = SPECIALIX_RXFIFO;
 115 static int sx_rtscts;
 116
 117 #ifdef DEBUG
 118 #define dprintk(f, str...) if (sx_debug & f) printk(str)
 119 #else
 120 #define dprintk(f, str...) /* nothing */
 121 #endif
 122
 123 #define SX_DEBUG_FLOW    0x0001
 124 #define SX_DEBUG_DATA    0x0002
 125 #define SX_DEBUG_PROBE   0x0004
 126 #define SX_DEBUG_CHAN    0x0008
 127 #define SX_DEBUG_INIT    0x0010
 128 #define SX_DEBUG_RX      0x0020
 129 #define SX_DEBUG_TX      0x0040
 130 #define SX_DEBUG_IRQ     0x0080
 131 #define SX_DEBUG_OPEN    0x0100
 132 #define SX_DEBUG_TERMIOS 0x0200
 133 #define SX_DEBUG_SIGNALS 0x0400
 134 #define SX_DEBUG_FIFO    0x0800
 135
 136
 137 #define func_enter() dprintk(SX_DEBUG_FLOW, "io8: enter %s\n", __func__)
 138 #define func_exit()  dprintk(SX_DEBUG_FLOW, "io8: exit  %s\n", __func__)
 139
 140
 141 /* Configurable options: */
 142
 143 /* Am I paranoid or not ? ;-) */
 144 #define SPECIALIX_PARANOIA_CHECK
 145
 146 /*
 147  * The following defines are mostly for testing purposes. But if you need
 148  * some nice reporting in your syslog, you can define them also.
 149  */
 150 #undef SX_REPORT_FIFO
 151 #undef SX_REPORT_OVERRUN
 152
 153
 154
 155
 156 #define SPECIALIX_LEGAL_FLAGS \
 157         (ASYNC_HUP_NOTIFY   | ASYNC_SAK          | ASYNC_SPLIT_TERMIOS   | \
 158          ASYNC_SPD_HI       | ASYNC_SPEED_VHI    | ASYNC_SESSION_LOCKOUT | \
 159          ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
 160
 161 static struct tty_driver *specialix_driver;
 162
 163 static struct specialix_board sx_board[SX_NBOARD] =  {
 164         { 0, SX_IOBASE1,  9, },
 165         { 0, SX_IOBASE2, 11, },
 166         { 0, SX_IOBASE3, 12, },
 167         { 0, SX_IOBASE4, 15, },
 168 };
 169
 170 static struct specialix_port sx_port[SX_NBOARD * SX_NPORT];
 171
 172
 173 static int sx_paranoia_check(struct specialix_port const *port,
 174                                     char *name, const char *routine)
 175 {
 176 #ifdef SPECIALIX_PARANOIA_CHECK
 177         static const char *badmagic = KERN_ERR
 178           "sx: Warning: bad specialix port magic number for device %s in %s\n";
 179         static const char *badinfo = KERN_ERR
 180           "sx: Warning: null specialix port for device %s in %s\n";
 181
 182         if (!port) {
 183                 printk(badinfo, name, routine);
 184                 return 1;
 185         }
 186         if (port->magic != SPECIALIX_MAGIC) {
 187                 printk(badmagic, name, routine);
 188                 return 1;
 189         }
 190 #endif
 191         return 0;
 192 }
 193
 194
 195 /*
 196  *
 197  *  Service functions for specialix IO8+ driver.
 198  *
 199  */
 200
 201 /* Get board number from pointer */
 202 static inline int board_No(struct specialix_board *bp)
 203 {
 204         return bp - sx_board;
 205 }
 206
 207
 208 /* Get port number from pointer */
 209 static inline int port_No(struct specialix_port const *port)
 210 {
 211         return SX_PORT(port - sx_port);
 212 }
 213
 214
 215 /* Get pointer to board from pointer to port */
 216 static inline struct specialix_board *port_Board(
 217                                         struct specialix_port const *port)
 218 {
 219         return &sx_board[SX_BOARD(port - sx_port)];
 220 }
 221
 222
 223 /* Input Byte from CL CD186x register */
 224 static inline unsigned char sx_in(struct specialix_board *bp,
 225                                                         unsigned short reg)
 226 {
 227         bp->reg = reg | 0x80;
 228         outb(reg | 0x80, bp->base + SX_ADDR_REG);
 229         return inb(bp->base + SX_DATA_REG);
 230 }
 231
 232
 233 /* Output Byte to CL CD186x register */
 234 static inline void sx_out(struct specialix_board *bp, unsigned short reg,
 235                           unsigned char val)
 236 {
 237         bp->reg = reg | 0x80;
 238         outb(reg | 0x80, bp->base + SX_ADDR_REG);
 239         outb(val, bp->base + SX_DATA_REG);
 240 }
 241
 242
 243 /* Input Byte from CL CD186x register */
 244 static inline unsigned char sx_in_off(struct specialix_board *bp,
 245                                 unsigned short reg)
 246 {
 247         bp->reg = reg;
 248         outb(reg, bp->base + SX_ADDR_REG);
 249         return inb(bp->base + SX_DATA_REG);
 250 }
 251
 252
 253 /* Output Byte to CL CD186x register */
 254 static inline void sx_out_off(struct specialix_board  *bp,
 255                                 unsigned short reg, unsigned char val)
 256 {
 257         bp->reg = reg;
 258         outb(reg, bp->base + SX_ADDR_REG);
 259         outb(val, bp->base + SX_DATA_REG);
 260 }
 261
 262
 263 /* Wait for Channel Command Register ready */
 264 static void sx_wait_CCR(struct specialix_board  *bp)
 265 {
 266         unsigned long delay, flags;
 267         unsigned char ccr;
 268
 269         for (delay = SX_CCR_TIMEOUT; delay; delay--) {
 270                 spin_lock_irqsave(&bp->lock, flags);
 271                 ccr = sx_in(bp, CD186x_CCR);
 272                 spin_unlock_irqrestore(&bp->lock, flags);
 273                 if (!ccr)
 274                         return;
 275                 udelay(1);
 276         }
 277
 278         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 279 }
 280
 281
 282 /* Wait for Channel Command Register ready */
 283 static void sx_wait_CCR_off(struct specialix_board  *bp)
 284 {
 285         unsigned long delay;
 286         unsigned char crr;
 287         unsigned long flags;
 288
 289         for (delay = SX_CCR_TIMEOUT; delay; delay--) {
 290                 spin_lock_irqsave(&bp->lock, flags);
 291                 crr = sx_in_off(bp, CD186x_CCR);
 292                 spin_unlock_irqrestore(&bp->lock, flags);
 293                 if (!crr)
 294                         return;
 295                 udelay(1);
 296         }
 297
 298         printk(KERN_ERR "sx%d: Timeout waiting for CCR.\n", board_No(bp));
 299 }
 300
 301
 302 /*
 303  *  specialix IO8+ IO range functions.
 304  */
 305
 306 static int sx_request_io_range(struct specialix_board *bp)
 307 {
 308         return request_region(bp->base,
 309                 bp->flags & SX_BOARD_IS_PCI ? SX_PCI_IO_SPACE : SX_IO_SPACE,
 310                 "specialix IO8+") == NULL;
 311 }
 312
 313
 314 static void sx_release_io_range(struct specialix_board *bp)
 315 {
 316         release_region(bp->base, bp->flags & SX_BOARD_IS_PCI ?
 317                                         SX_PCI_IO_SPACE : SX_IO_SPACE);
 318 }
 319
 320
 321 /* Set the IRQ using the RTS lines that run to the PAL on the board.... */
 322 static int sx_set_irq(struct specialix_board *bp)
 323 {
 324         int virq;
 325         int i;
 326         unsigned long flags;
 327
 328         if (bp->flags & SX_BOARD_IS_PCI)
 329                 return 1;
 330         switch (bp->irq) {
 331         /* In the same order as in the docs... */
 332         case 15:
 333                 virq = 0;
 334                 break;
 335         case 12:
 336                 virq = 1;
 337                 break;
 338         case 11:
 339                 virq = 2;
 340                 break;
 341         case 9:
 342                 virq = 3;
 343                 break;
 344         default:printk(KERN_ERR
 345                             "Speclialix: cannot set irq to %d.\n", bp->irq);
 346                 return 0;
 347         }
 348         spin_lock_irqsave(&bp->lock, flags);
 349         for (i = 0; i < 2; i++) {
 350                 sx_out(bp, CD186x_CAR, i);
 351                 sx_out(bp, CD186x_MSVRTS, ((virq >> i) & 0x1)? MSVR_RTS:0);
 352         }
 353         spin_unlock_irqrestore(&bp->lock, flags);
 354         return 1;
 355 }
 356
 357
 358 /* Reset and setup CD186x chip */
 359 static int sx_init_CD186x(struct specialix_board  *bp)
 360 {
 361         unsigned long flags;
 362         int scaler;
 363         int rv = 1;
 364
 365         func_enter();
 366         sx_wait_CCR_off(bp);                       /* Wait for CCR ready        */
 367         spin_lock_irqsave(&bp->lock, flags);
 368         sx_out_off(bp, CD186x_CCR, CCR_HARDRESET);      /* Reset CD186x chip          */
 369         spin_unlock_irqrestore(&bp->lock, flags);
 370         msleep(50);                                     /* Delay 0.05 sec            */
 371         spin_lock_irqsave(&bp->lock, flags);
 372         sx_out_off(bp, CD186x_GIVR, SX_ID);             /* Set ID for this chip      */
 373         sx_out_off(bp, CD186x_GICR, 0);                 /* Clear all bits            */
 374         sx_out_off(bp, CD186x_PILR1, SX_ACK_MINT);      /* Prio for modem intr       */
 375         sx_out_off(bp, CD186x_PILR2, SX_ACK_TINT);      /* Prio for transmitter intr */
 376         sx_out_off(bp, CD186x_PILR3, SX_ACK_RINT);      /* Prio for receiver intr    */
 377         /* Set RegAckEn */
 378         sx_out_off(bp, CD186x_SRCR, sx_in(bp, CD186x_SRCR) | SRCR_REGACKEN);
 379
 380         /* Setting up prescaler. We need 4 ticks per 1 ms */
 381         scaler =  SX_OSCFREQ/SPECIALIX_TPS;
 382
 383         sx_out_off(bp, CD186x_PPRH, scaler >> 8);
 384         sx_out_off(bp, CD186x_PPRL, scaler & 0xff);
 385         spin_unlock_irqrestore(&bp->lock, flags);
 386
 387         if (!sx_set_irq(bp)) {
 388                 /* Figure out how to pass this along... */
 389                 printk(KERN_ERR "Cannot set irq to %d.\n", bp->irq);
 390                 rv = 0;
 391         }
 392
 393         func_exit();
 394         return rv;
 395 }
 396
 397
 398 static int read_cross_byte(struct specialix_board *bp, int reg, int bit)
 399 {
 400         int i;
 401         int t;
 402         unsigned long flags;
 403
 404         spin_lock_irqsave(&bp->lock, flags);
 405         for (i = 0, t = 0; i < 8; i++) {
 406                 sx_out_off(bp, CD186x_CAR, i);
 407                 if (sx_in_off(bp, reg) & bit)
 408                         t |= 1 << i;
 409         }
 410         spin_unlock_irqrestore(&bp->lock, flags);
 411
 412         return t;
 413 }
 414
 415
 416 /* Main probing routine, also sets irq. */
 417 static int sx_probe(struct specialix_board *bp)
 418 {
 419         unsigned char val1, val2;
 420         int rev;
 421         int chip;
 422
 423         func_enter();
 424
 425         if (sx_request_io_range(bp)) {
 426                 func_exit();
 427                 return 1;
 428         }
 429
 430         /* Are the I/O ports here ? */
 431         sx_out_off(bp, CD186x_PPRL, 0x5a);
 432         udelay(1);
 433         val1 = sx_in_off(bp, CD186x_PPRL);
 434
 435         sx_out_off(bp, CD186x_PPRL, 0xa5);
 436         udelay(1);
 437         val2 = sx_in_off(bp, CD186x_PPRL);
 438
 439
 440         if (val1 != 0x5a || val2 != 0xa5) {
 441                 printk(KERN_INFO
 442                         "sx%d: specialix IO8+ Board at 0x%03x not found.\n",
 443                                                 board_No(bp), bp->base);
 444                 sx_release_io_range(bp);
 445                 func_exit();
 446                 return 1;
 447         }
 448
 449         /* Check the DSR lines that Specialix uses as board
 450            identification */
 451         val1 = read_cross_byte(bp, CD186x_MSVR, MSVR_DSR);
 452         val2 = read_cross_byte(bp, CD186x_MSVR, MSVR_RTS);
 453         dprintk(SX_DEBUG_INIT,
 454                         "sx%d: DSR lines are: %02x, rts lines are: %02x\n",
 455                                         board_No(bp), val1, val2);
 456
 457         /* They managed to switch the bit order between the docs and
 458            the IO8+ card. The new PCI card now conforms to old docs.
 459            They changed the PCI docs to reflect the situation on the
 460            old card. */
 461         val2 = (bp->flags & SX_BOARD_IS_PCI)?0x4d : 0xb2;
 462         if (val1 != val2) {
 463                 printk(KERN_INFO
 464                   "sx%d: specialix IO8+ ID %02x at 0x%03x not found (%02x).\n",
 465                        board_No(bp), val2, bp->base, val1);
 466                 sx_release_io_range(bp);
 467                 func_exit();
 468                 return 1;
 469         }
 470
 471
 472         /* Reset CD186x again  */
 473         if (!sx_init_CD186x(bp)) {
 474                 sx_release_io_range(bp);
 475                 func_exit();
 476                 return 1;
 477         }
 478
 479         sx_request_io_range(bp);
 480         bp->flags |= SX_BOARD_PRESENT;
 481
 482         /* Chip           revcode   pkgtype
 483                           GFRCR     SRCR bit 7
 484            CD180 rev B    0x81      0
 485            CD180 rev C    0x82      0
 486            CD1864 rev A   0x82      1
 487            CD1865 rev A   0x83      1  -- Do not use!!! Does not work.
 488            CD1865 rev B   0x84      1
 489          -- Thanks to Gwen Wang, Cirrus Logic.
 490          */
 491
 492         switch (sx_in_off(bp, CD186x_GFRCR)) {
 493         case 0x82:
 494                 chip = 1864;
 495                 rev = 'A';
 496                 break;
 497         case 0x83:
 498                 chip = 1865;
 499                 rev = 'A';
 500                 break;
 501         case 0x84:
 502                 chip = 1865;
 503                 rev = 'B';
 504                 break;
 505         case 0x85:
 506                 chip = 1865;
 507                 rev = 'C';
 508                 break; /* Does not exist at this time */
 509         default:
 510                 chip = -1;
 511                 rev = 'x';
 512         }
 513
 514         dprintk(SX_DEBUG_INIT, " GFCR = 0x%02x\n", sx_in_off(bp, CD186x_GFRCR));
 515
 516         printk(KERN_INFO
 517     "sx%d: specialix IO8+ board detected at 0x%03x, IRQ %d, CD%d Rev. %c.\n",
 518                                 board_No(bp), bp->base, bp->irq, chip, rev);
 519
 520         func_exit();
 521         return 0;
 522 }
 523
 524 /*
 525  *
 526  *  Interrupt processing routines.
 527  * */
 528
 529 static struct specialix_port *sx_get_port(struct specialix_board *bp,
 530                                                unsigned char const *what)
 531 {
 532         unsigned char channel;
 533         struct specialix_port *port = NULL;
 534
 535         channel = sx_in(bp, CD186x_GICR) >> GICR_CHAN_OFF;
 536         dprintk(SX_DEBUG_CHAN, "channel: %d\n", channel);
 537         if (channel < CD186x_NCH) {
 538                 port = &sx_port[board_No(bp) * SX_NPORT + channel];
 539                 dprintk(SX_DEBUG_CHAN, "port: %d %p flags: 0x%lx\n",
 540                         board_No(bp) * SX_NPORT + channel,  port,
 541                         port->port.flags & ASYNC_INITIALIZED);
 542
 543                 if (port->port.flags & ASYNC_INITIALIZED) {
 544                         dprintk(SX_DEBUG_CHAN, "port: %d %p\n", channel, port);
 545                         func_exit();
 546                         return port;
 547                 }
 548         }
 549         printk(KERN_INFO "sx%d: %s interrupt from invalid port %d\n",
 550                board_No(bp), what, channel);
 551         return NULL;
 552 }
 553
 554
 555 static void sx_receive_exc(struct specialix_board *bp)
 556 {
 557         struct specialix_port *port;
 558         struct tty_struct *tty;
 559         unsigned char status;
 560         unsigned char ch, flag;
 561
 562         func_enter();
 563
 564         port = sx_get_port(bp, "Receive");
 565         if (!port) {
 566                 dprintk(SX_DEBUG_RX, "Hmm, couldn't find port.\n");
 567                 func_exit();
 568                 return;
 569         }
 570         tty = port->port.tty;
 571
 572         status = sx_in(bp, CD186x_RCSR);
 573
 574         dprintk(SX_DEBUG_RX, "status: 0x%x\n", status);
 575         if (status & RCSR_OE) {
 576                 port->overrun++;
 577                 dprintk(SX_DEBUG_FIFO,
 578                         "sx%d: port %d: Overrun. Total %ld overruns.\n",
 579                                 board_No(bp), port_No(port), port->overrun);
 580         }
 581         status &= port->mark_mask;
 582
 583         /* This flip buffer check needs to be below the reading of the
 584            status register to reset the chip's IRQ.... */
 585         if (tty_buffer_request_room(tty, 1) == 0) {
 586                 dprintk(SX_DEBUG_FIFO,
 587                     "sx%d: port %d: Working around flip buffer overflow.\n",
 588                                         board_No(bp), port_No(port));
 589                 func_exit();
 590                 return;
 591         }
 592
 593         ch = sx_in(bp, CD186x_RDR);
 594         if (!status) {
 595                 func_exit();
 596                 return;
 597         }
 598         if (status & RCSR_TOUT) {
 599                 printk(KERN_INFO
 600                     "sx%d: port %d: Receiver timeout. Hardware problems ?\n",
 601                                         board_No(bp), port_No(port));
 602                 func_exit();
 603                 return;
 604
 605         } else if (status & RCSR_BREAK) {
 606                 dprintk(SX_DEBUG_RX, "sx%d: port %d: Handling break...\n",
 607                        board_No(bp), port_No(port));
 608                 flag = TTY_BREAK;
 609                 if (port->port.flags & ASYNC_SAK)
 610                         do_SAK(tty);
 611
 612         } else if (status & RCSR_PE)
 613                 flag = TTY_PARITY;
 614
 615         else if (status & RCSR_FE)
 616                 flag = TTY_FRAME;
 617
 618         else if (status & RCSR_OE)
 619                 flag = TTY_OVERRUN;
 620
 621         else
 622                 flag = TTY_NORMAL;
 623
 624         if (tty_insert_flip_char(tty, ch, flag))
 625                 tty_flip_buffer_push(tty);
 626         func_exit();
 627 }
 628
 629
 630 static void sx_receive(struct specialix_board *bp)
 631 {
 632         struct specialix_port *port;
 633         struct tty_struct *tty;
 634         unsigned char count;
 635
 636         func_enter();
 637
 638         port = sx_get_port(bp, "Receive");
 639         if (port == NULL) {
 640                 dprintk(SX_DEBUG_RX, "Hmm, couldn't find port.\n");
 641                 func_exit();
 642                 return;
 643         }
 644         tty = port->port.tty;
 645
 646         count = sx_in(bp, CD186x_RDCR);
 647         dprintk(SX_DEBUG_RX, "port: %p: count: %d\n", port, count);
 648         port->hits[count > 8 ? 9 : 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                 tty_unlock();
1369                 schedule();
1370                 tty_lock();
1371         }
1372
1373         set_current_state(TASK_RUNNING);
1374         remove_wait_queue(&port->port.open_wait, &wait);
1375         spin_lock_irqsave(&port->lock, flags);
1376         if (!tty_hung_up_p(filp))
1377                 port->port.count++;
1378         port->port.blocked_open--;
1379         spin_unlock_irqrestore(&port->lock, flags);
1380         if (retval) {
1381                 func_exit();
1382                 return retval;
1383         }
1384
1385         port->port.flags |= ASYNC_NORMAL_ACTIVE;
1386         func_exit();
1387         return 0;
1388 }
1389
1390
1391 static int sx_open(struct tty_struct *tty, struct file *filp)
1392 {
1393         int board;
1394         int error;
1395         struct specialix_port *port;
1396         struct specialix_board *bp;
1397         int i;
1398         unsigned long flags;
1399
1400         func_enter();
1401
1402         board = SX_BOARD(tty->index);
1403
1404         if (board >= SX_NBOARD || !(sx_board[board].flags & SX_BOARD_PRESENT)) {
1405                 func_exit();
1406                 return -ENODEV;
1407         }
1408
1409         bp = &sx_board[board];
1410         port = sx_port + board * SX_NPORT + SX_PORT(tty->index);
1411         port->overrun = 0;
1412         for (i = 0; i < 10; i++)
1413                 port->hits[i] = 0;
1414
1415         dprintk(SX_DEBUG_OPEN,
1416                         "Board = %d, bp = %p, port = %p, portno = %d.\n",
1417                                  board, bp, port, SX_PORT(tty->index));
1418
1419         if (sx_paranoia_check(port, tty->name, "sx_open")) {
1420                 func_enter();
1421                 return -ENODEV;
1422         }
1423
1424         error = sx_setup_board(bp);
1425         if (error) {
1426                 func_exit();
1427                 return error;
1428         }
1429
1430         spin_lock_irqsave(&bp->lock, flags);
1431         port->port.count++;
1432         bp->count++;
1433         tty->driver_data = port;
1434         port->port.tty = tty;
1435         spin_unlock_irqrestore(&bp->lock, flags);
1436
1437         error = sx_setup_port(bp, port);
1438         if (error) {
1439                 func_enter();
1440                 return error;
1441         }
1442
1443         error = block_til_ready(tty, filp, port);
1444         if (error) {
1445                 func_enter();
1446                 return error;
1447         }
1448
1449         func_exit();
1450         return 0;
1451 }
1452
1453 static void sx_flush_buffer(struct tty_struct *tty)
1454 {
1455         struct specialix_port *port = tty->driver_data;
1456         unsigned long flags;
1457         struct specialix_board  *bp;
1458
1459         func_enter();
1460
1461         if (sx_paranoia_check(port, tty->name, "sx_flush_buffer")) {
1462                 func_exit();
1463                 return;
1464         }
1465
1466         bp = port_Board(port);
1467         spin_lock_irqsave(&port->lock, flags);
1468         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1469         spin_unlock_irqrestore(&port->lock, flags);
1470         tty_wakeup(tty);
1471
1472         func_exit();
1473 }
1474
1475 static void sx_close(struct tty_struct *tty, struct file *filp)
1476 {
1477         struct specialix_port *port = tty->driver_data;
1478         struct specialix_board *bp;
1479         unsigned long flags;
1480         unsigned long timeout;
1481
1482         func_enter();
1483         if (!port || sx_paranoia_check(port, tty->name, "close")) {
1484                 func_exit();
1485                 return;
1486         }
1487         spin_lock_irqsave(&port->lock, flags);
1488
1489         if (tty_hung_up_p(filp)) {
1490                 spin_unlock_irqrestore(&port->lock, flags);
1491                 func_exit();
1492                 return;
1493         }
1494
1495         bp = port_Board(port);
1496         if (tty->count == 1 && port->port.count != 1) {
1497                 printk(KERN_ERR "sx%d: sx_close: bad port count;"
1498                        " tty->count is 1, port count is %d\n",
1499                        board_No(bp), port->port.count);
1500                 port->port.count = 1;
1501         }
1502
1503         if (port->port.count > 1) {
1504                 port->port.count--;
1505                 bp->count--;
1506
1507                 spin_unlock_irqrestore(&port->lock, flags);
1508
1509                 func_exit();
1510                 return;
1511         }
1512         port->port.flags |= ASYNC_CLOSING;
1513         /*
1514          * Now we wait for the transmit buffer to clear; and we notify
1515          * the line discipline to only process XON/XOFF characters.
1516          */
1517         tty->closing = 1;
1518         spin_unlock_irqrestore(&port->lock, flags);
1519         dprintk(SX_DEBUG_OPEN, "Closing\n");
1520         if (port->port.closing_wait != ASYNC_CLOSING_WAIT_NONE)
1521                 tty_wait_until_sent(tty, port->port.closing_wait);
1522         /*
1523          * At this point we stop accepting input.  To do this, we
1524          * disable the receive line status interrupts, and tell the
1525          * interrupt driver to stop checking the data ready bit in the
1526          * line status register.
1527          */
1528         dprintk(SX_DEBUG_OPEN, "Closed\n");
1529         port->IER &= ~IER_RXD;
1530         if (port->port.flags & ASYNC_INITIALIZED) {
1531                 port->IER &= ~IER_TXRDY;
1532                 port->IER |= IER_TXEMPTY;
1533                 spin_lock_irqsave(&bp->lock, flags);
1534                 sx_out(bp, CD186x_CAR, port_No(port));
1535                 sx_out(bp, CD186x_IER, port->IER);
1536                 spin_unlock_irqrestore(&bp->lock, flags);
1537                 /*
1538                  * Before we drop DTR, make sure the UART transmitter
1539                  * has completely drained; this is especially
1540                  * important if there is a transmit FIFO!
1541                  */
1542                 timeout = jiffies+HZ;
1543                 while (port->IER & IER_TXEMPTY) {
1544                         set_current_state(TASK_INTERRUPTIBLE);
1545                         msleep_interruptible(jiffies_to_msecs(port->timeout));
1546                         if (time_after(jiffies, timeout)) {
1547                                 printk(KERN_INFO "Timeout waiting for close\n");
1548                                 break;
1549                         }
1550                 }
1551
1552         }
1553
1554         if (--bp->count < 0) {
1555                 printk(KERN_ERR
1556                     "sx%d: sx_shutdown_port: bad board count: %d port: %d\n",
1557                                 board_No(bp), bp->count, tty->index);
1558                 bp->count = 0;
1559         }
1560         if (--port->port.count < 0) {
1561                 printk(KERN_ERR
1562                         "sx%d: sx_close: bad port count for tty%d: %d\n",
1563                                 board_No(bp), port_No(port), port->port.count);
1564                 port->port.count = 0;
1565         }
1566
1567         sx_shutdown_port(bp, port);
1568         sx_flush_buffer(tty);
1569         tty_ldisc_flush(tty);
1570         spin_lock_irqsave(&port->lock, flags);
1571         tty->closing = 0;
1572         port->port.tty = NULL;
1573         spin_unlock_irqrestore(&port->lock, flags);
1574         if (port->port.blocked_open) {
1575                 if (port->port.close_delay)
1576                         msleep_interruptible(
1577                                 jiffies_to_msecs(port->port.close_delay));
1578                 wake_up_interruptible(&port->port.open_wait);
1579         }
1580         port->port.flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1581         wake_up_interruptible(&port->port.close_wait);
1582
1583         func_exit();
1584 }
1585
1586
1587 static int sx_write(struct tty_struct *tty,
1588                                         const unsigned char *buf, int count)
1589 {
1590         struct specialix_port *port = tty->driver_data;
1591         struct specialix_board *bp;
1592         int c, total = 0;
1593         unsigned long flags;
1594
1595         func_enter();
1596         if (sx_paranoia_check(port, tty->name, "sx_write")) {
1597                 func_exit();
1598                 return 0;
1599         }
1600
1601         bp = port_Board(port);
1602
1603         if (!port->xmit_buf) {
1604                 func_exit();
1605                 return 0;
1606         }
1607
1608         while (1) {
1609                 spin_lock_irqsave(&port->lock, flags);
1610                 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1611                                    SERIAL_XMIT_SIZE - port->xmit_head));
1612                 if (c <= 0) {
1613                         spin_unlock_irqrestore(&port->lock, flags);
1614                         break;
1615                 }
1616                 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1617                 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1618                 port->xmit_cnt += c;
1619                 spin_unlock_irqrestore(&port->lock, flags);
1620
1621                 buf += c;
1622                 count -= c;
1623                 total += c;
1624         }
1625
1626         spin_lock_irqsave(&bp->lock, flags);
1627         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1628             !(port->IER & IER_TXRDY)) {
1629                 port->IER |= IER_TXRDY;
1630                 sx_out(bp, CD186x_CAR, port_No(port));
1631                 sx_out(bp, CD186x_IER, port->IER);
1632         }
1633         spin_unlock_irqrestore(&bp->lock, flags);
1634         func_exit();
1635
1636         return total;
1637 }
1638
1639
1640 static int sx_put_char(struct tty_struct *tty, unsigned char ch)
1641 {
1642         struct specialix_port *port = tty->driver_data;
1643         unsigned long flags;
1644         struct specialix_board  *bp;
1645
1646         func_enter();
1647
1648         if (sx_paranoia_check(port, tty->name, "sx_put_char")) {
1649                 func_exit();
1650                 return 0;
1651         }
1652         dprintk(SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
1653         if (!port->xmit_buf) {
1654                 func_exit();
1655                 return 0;
1656         }
1657         bp = port_Board(port);
1658         spin_lock_irqsave(&port->lock, flags);
1659
1660         dprintk(SX_DEBUG_TX, "xmit_cnt: %d xmit_buf: %p\n",
1661                                         port->xmit_cnt, port->xmit_buf);
1662         if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1 || !port->xmit_buf) {
1663                 spin_unlock_irqrestore(&port->lock, flags);
1664                 dprintk(SX_DEBUG_TX, "Exit size\n");
1665                 func_exit();
1666                 return 0;
1667         }
1668         dprintk(SX_DEBUG_TX, "Handle xmit: %p %p\n", port, port->xmit_buf);
1669         port->xmit_buf[port->xmit_head++] = ch;
1670         port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1671         port->xmit_cnt++;
1672         spin_unlock_irqrestore(&port->lock, flags);
1673
1674         func_exit();
1675         return 1;
1676 }
1677
1678
1679 static void sx_flush_chars(struct tty_struct *tty)
1680 {
1681         struct specialix_port *port = tty->driver_data;
1682         unsigned long flags;
1683         struct specialix_board  *bp = port_Board(port);
1684
1685         func_enter();
1686
1687         if (sx_paranoia_check(port, tty->name, "sx_flush_chars")) {
1688                 func_exit();
1689                 return;
1690         }
1691         if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1692             !port->xmit_buf) {
1693                 func_exit();
1694                 return;
1695         }
1696         spin_lock_irqsave(&bp->lock, flags);
1697         port->IER |= IER_TXRDY;
1698         sx_out(port_Board(port), CD186x_CAR, port_No(port));
1699         sx_out(port_Board(port), CD186x_IER, port->IER);
1700         spin_unlock_irqrestore(&bp->lock, flags);
1701
1702         func_exit();
1703 }
1704
1705
1706 static int sx_write_room(struct tty_struct *tty)
1707 {
1708         struct specialix_port *port = tty->driver_data;
1709         int     ret;
1710
1711         func_enter();
1712
1713         if (sx_paranoia_check(port, tty->name, "sx_write_room")) {
1714                 func_exit();
1715                 return 0;
1716         }
1717
1718         ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1719         if (ret < 0)
1720                 ret = 0;
1721
1722         func_exit();
1723         return ret;
1724 }
1725
1726
1727 static int sx_chars_in_buffer(struct tty_struct *tty)
1728 {
1729         struct specialix_port *port = tty->driver_data;
1730
1731         func_enter();
1732
1733         if (sx_paranoia_check(port, tty->name, "sx_chars_in_buffer")) {
1734                 func_exit();
1735                 return 0;
1736         }
1737         func_exit();
1738         return port->xmit_cnt;
1739 }
1740
1741 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1742 {
1743         struct specialix_port *port = tty->driver_data;
1744         struct specialix_board *bp;
1745         unsigned char status;
1746         unsigned int result;
1747         unsigned long flags;
1748
1749         func_enter();
1750
1751         if (sx_paranoia_check(port, tty->name, __func__)) {
1752                 func_exit();
1753                 return -ENODEV;
1754         }
1755
1756         bp = port_Board(port);
1757         spin_lock_irqsave(&bp->lock, flags);
1758         sx_out(bp, CD186x_CAR, port_No(port));
1759         status = sx_in(bp, CD186x_MSVR);
1760         spin_unlock_irqrestore(&bp->lock, flags);
1761         dprintk(SX_DEBUG_INIT, "Got msvr[%d] = %02x, car = %d.\n",
1762                         port_No(port), status, sx_in(bp, CD186x_CAR));
1763         dprintk(SX_DEBUG_INIT, "sx_port = %p, port = %p\n", sx_port, port);
1764         if (sx_crtscts(port->port.tty)) {
1765                 result  = TIOCM_DTR | TIOCM_DSR
1766                           |   ((status & MSVR_DTR) ? TIOCM_RTS : 0)
1767                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1768                           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1769         } else {
1770                 result  = TIOCM_RTS | TIOCM_DSR
1771                           |   ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1772                           |   ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1773                           |   ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1774         }
1775
1776         func_exit();
1777
1778         return result;
1779 }
1780
1781
1782 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1783                        unsigned int set, unsigned int clear)
1784 {
1785         struct specialix_port *port = tty->driver_data;
1786         unsigned long flags;
1787         struct specialix_board *bp;
1788
1789         func_enter();
1790
1791         if (sx_paranoia_check(port, tty->name, __func__)) {
1792                 func_exit();
1793                 return -ENODEV;
1794         }
1795
1796         bp = port_Board(port);
1797
1798         spin_lock_irqsave(&port->lock, flags);
1799         if (sx_crtscts(port->port.tty)) {
1800                 if (set & TIOCM_RTS)
1801                         port->MSVR |= MSVR_DTR;
1802         } else {
1803                 if (set & TIOCM_DTR)
1804                         port->MSVR |= MSVR_DTR;
1805         }
1806         if (sx_crtscts(port->port.tty)) {
1807                 if (clear & TIOCM_RTS)
1808                         port->MSVR &= ~MSVR_DTR;
1809         } else {
1810                 if (clear & TIOCM_DTR)
1811                         port->MSVR &= ~MSVR_DTR;
1812         }
1813         spin_lock(&bp->lock);
1814         sx_out(bp, CD186x_CAR, port_No(port));
1815         sx_out(bp, CD186x_MSVR, port->MSVR);
1816         spin_unlock(&bp->lock);
1817         spin_unlock_irqrestore(&port->lock, flags);
1818         func_exit();
1819         return 0;
1820 }
1821
1822
1823 static int sx_send_break(struct tty_struct *tty, int length)
1824 {
1825         struct specialix_port *port = tty->driver_data;
1826         struct specialix_board *bp = port_Board(port);
1827         unsigned long flags;
1828
1829         func_enter();
1830         if (length == 0 || length == -1)
1831                 return -EOPNOTSUPP;
1832
1833         spin_lock_irqsave(&port->lock, flags);
1834         port->break_length = SPECIALIX_TPS / HZ * length;
1835         port->COR2 |= COR2_ETC;
1836         port->IER  |= IER_TXRDY;
1837         spin_lock(&bp->lock);
1838         sx_out(bp, CD186x_CAR, port_No(port));
1839         sx_out(bp, CD186x_COR2, port->COR2);
1840         sx_out(bp, CD186x_IER, port->IER);
1841         spin_unlock(&bp->lock);
1842         spin_unlock_irqrestore(&port->lock, flags);
1843         sx_wait_CCR(bp);
1844         spin_lock_irqsave(&bp->lock, flags);
1845         sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1846         spin_unlock_irqrestore(&bp->lock, flags);
1847         sx_wait_CCR(bp);
1848
1849         func_exit();
1850         return 0;
1851 }
1852
1853
1854 static int sx_set_serial_info(struct specialix_port *port,
1855                                         struct serial_struct __user *newinfo)
1856 {
1857         struct serial_struct tmp;
1858         struct specialix_board *bp = port_Board(port);
1859         int change_speed;
1860
1861         func_enter();
1862
1863         if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1864                 func_enter();
1865                 return -EFAULT;
1866         }
1867
1868         mutex_lock(&port->port.mutex);
1869         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1870                         (tmp.flags & ASYNC_SPD_MASK));
1871         change_speed |= (tmp.custom_divisor != port->custom_divisor);
1872
1873         if (!capable(CAP_SYS_ADMIN)) {
1874                 if ((tmp.close_delay != port->port.close_delay) ||
1875                     (tmp.closing_wait != port->port.closing_wait) ||
1876                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1877                      (port->port.flags & ~ASYNC_USR_MASK))) {
1878                         func_exit();
1879                         mutex_unlock(&port->port.mutex);
1880                         return -EPERM;
1881                 }
1882                 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1883                                                 (tmp.flags & ASYNC_USR_MASK));
1884                 port->custom_divisor = tmp.custom_divisor;
1885         } else {
1886                 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1887                                                 (tmp.flags & ASYNC_FLAGS));
1888                 port->port.close_delay = tmp.close_delay;
1889                 port->port.closing_wait = tmp.closing_wait;
1890                 port->custom_divisor = tmp.custom_divisor;
1891         }
1892         if (change_speed)
1893                 sx_change_speed(bp, port);
1894
1895         func_exit();
1896         mutex_unlock(&port->port.mutex);
1897         return 0;
1898 }
1899
1900
1901 static int sx_get_serial_info(struct specialix_port *port,
1902                                      struct serial_struct __user *retinfo)
1903 {
1904         struct serial_struct tmp;
1905         struct specialix_board *bp = port_Board(port);
1906
1907         func_enter();
1908
1909         memset(&tmp, 0, sizeof(tmp));
1910         mutex_lock(&port->port.mutex);
1911         tmp.type = PORT_CIRRUS;
1912         tmp.line = port - sx_port;
1913         tmp.port = bp->base;
1914         tmp.irq  = bp->irq;
1915         tmp.flags = port->port.flags;
1916         tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
1917         tmp.close_delay = port->port.close_delay * HZ/100;
1918         tmp.closing_wait = port->port.closing_wait * HZ/100;
1919         tmp.custom_divisor =  port->custom_divisor;
1920         tmp.xmit_fifo_size = CD186x_NFIFO;
1921         mutex_unlock(&port->port.mutex);
1922         if (copy_to_user(retinfo, &tmp, sizeof(tmp))) {
1923                 func_exit();
1924                 return -EFAULT;
1925         }
1926
1927         func_exit();
1928         return 0;
1929 }
1930
1931
1932 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1933                                 unsigned int cmd, unsigned long arg)
1934 {
1935         struct specialix_port *port = tty->driver_data;
1936         void __user *argp = (void __user *)arg;
1937
1938         func_enter();
1939
1940         if (sx_paranoia_check(port, tty->name, "sx_ioctl")) {
1941                 func_exit();
1942                 return -ENODEV;
1943         }
1944
1945         switch (cmd) {
1946         case TIOCGSERIAL:
1947                 func_exit();
1948                 return sx_get_serial_info(port, argp);
1949         case TIOCSSERIAL:
1950                 func_exit();
1951                 return sx_set_serial_info(port, argp);
1952         default:
1953                 func_exit();
1954                 return -ENOIOCTLCMD;
1955         }
1956         func_exit();
1957         return 0;
1958 }
1959
1960
1961 static void sx_throttle(struct tty_struct *tty)
1962 {
1963         struct specialix_port *port = tty->driver_data;
1964         struct specialix_board *bp;
1965         unsigned long flags;
1966
1967         func_enter();
1968
1969         if (sx_paranoia_check(port, tty->name, "sx_throttle")) {
1970                 func_exit();
1971                 return;
1972         }
1973
1974         bp = port_Board(port);
1975
1976         /* Use DTR instead of RTS ! */
1977         if (sx_crtscts(tty))
1978                 port->MSVR &= ~MSVR_DTR;
1979         else {
1980                 /* Auch!!! I think the system shouldn't call this then. */
1981                 /* Or maybe we're supposed (allowed?) to do our side of hw
1982                    handshake anyway, even when hardware handshake is off.
1983                    When you see this in your logs, please report.... */
1984                 printk(KERN_ERR
1985                    "sx%d: Need to throttle, but can't (hardware hs is off)\n",
1986                                                         port_No(port));
1987         }
1988         spin_lock_irqsave(&bp->lock, flags);
1989         sx_out(bp, CD186x_CAR, port_No(port));
1990         spin_unlock_irqrestore(&bp->lock, flags);
1991         if (I_IXOFF(tty)) {
1992                 sx_wait_CCR(bp);
1993                 spin_lock_irqsave(&bp->lock, flags);
1994                 sx_out(bp, CD186x_CCR, CCR_SSCH2);
1995                 spin_unlock_irqrestore(&bp->lock, flags);
1996                 sx_wait_CCR(bp);
1997         }
1998         spin_lock_irqsave(&bp->lock, flags);
1999         sx_out(bp, CD186x_MSVR, port->MSVR);
2000         spin_unlock_irqrestore(&bp->lock, flags);
2001
2002         func_exit();
2003 }
2004
2005
2006 static void sx_unthrottle(struct tty_struct *tty)
2007 {
2008         struct specialix_port *port = tty->driver_data;
2009         struct specialix_board *bp;
2010         unsigned long flags;
2011
2012         func_enter();
2013
2014         if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
2015                 func_exit();
2016                 return;
2017         }
2018
2019         bp = port_Board(port);
2020
2021         spin_lock_irqsave(&port->lock, flags);
2022         /* XXXX Use DTR INSTEAD???? */
2023         if (sx_crtscts(tty))
2024                 port->MSVR |= MSVR_DTR;
2025         /* Else clause: see remark in "sx_throttle"... */
2026         spin_lock(&bp->lock);
2027         sx_out(bp, CD186x_CAR, port_No(port));
2028         spin_unlock(&bp->lock);
2029         if (I_IXOFF(tty)) {
2030                 spin_unlock_irqrestore(&port->lock, flags);
2031                 sx_wait_CCR(bp);
2032                 spin_lock_irqsave(&bp->lock, flags);
2033                 sx_out(bp, CD186x_CCR, CCR_SSCH1);
2034                 spin_unlock_irqrestore(&bp->lock, flags);
2035                 sx_wait_CCR(bp);
2036                 spin_lock_irqsave(&port->lock, flags);
2037         }
2038         spin_lock(&bp->lock);
2039         sx_out(bp, CD186x_MSVR, port->MSVR);
2040         spin_unlock(&bp->lock);
2041         spin_unlock_irqrestore(&port->lock, flags);
2042
2043         func_exit();
2044 }
2045
2046
2047 static void sx_stop(struct tty_struct *tty)
2048 {
2049         struct specialix_port *port = tty->driver_data;
2050         struct specialix_board *bp;
2051         unsigned long flags;
2052
2053         func_enter();
2054
2055         if (sx_paranoia_check(port, tty->name, "sx_stop")) {
2056                 func_exit();
2057                 return;
2058         }
2059
2060         bp = port_Board(port);
2061
2062         spin_lock_irqsave(&port->lock, flags);
2063         port->IER &= ~IER_TXRDY;
2064         spin_lock(&bp->lock);
2065         sx_out(bp, CD186x_CAR, port_No(port));
2066         sx_out(bp, CD186x_IER, port->IER);
2067         spin_unlock(&bp->lock);
2068         spin_unlock_irqrestore(&port->lock, flags);
2069
2070         func_exit();
2071 }
2072
2073
2074 static void sx_start(struct tty_struct *tty)
2075 {
2076         struct specialix_port *port = tty->driver_data;
2077         struct specialix_board *bp;
2078         unsigned long flags;
2079
2080         func_enter();
2081
2082         if (sx_paranoia_check(port, tty->name, "sx_start")) {
2083                 func_exit();
2084                 return;
2085         }
2086
2087         bp = port_Board(port);
2088
2089         spin_lock_irqsave(&port->lock, flags);
2090         if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
2091                 port->IER |= IER_TXRDY;
2092                 spin_lock(&bp->lock);
2093                 sx_out(bp, CD186x_CAR, port_No(port));
2094                 sx_out(bp, CD186x_IER, port->IER);
2095                 spin_unlock(&bp->lock);
2096         }
2097         spin_unlock_irqrestore(&port->lock, flags);
2098
2099         func_exit();
2100 }
2101
2102 static void sx_hangup(struct tty_struct *tty)
2103 {
2104         struct specialix_port *port = tty->driver_data;
2105         struct specialix_board *bp;
2106         unsigned long flags;
2107
2108         func_enter();
2109
2110         if (sx_paranoia_check(port, tty->name, "sx_hangup")) {
2111                 func_exit();
2112                 return;
2113         }
2114
2115         bp = port_Board(port);
2116
2117         sx_shutdown_port(bp, port);
2118         spin_lock_irqsave(&port->lock, flags);
2119         bp->count -= port->port.count;
2120         if (bp->count < 0) {
2121                 printk(KERN_ERR
2122                         "sx%d: sx_hangup: bad board count: %d port: %d\n",
2123                                         board_No(bp), bp->count, tty->index);
2124                 bp->count = 0;
2125         }
2126         port->port.count = 0;
2127         port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
2128         port->port.tty = NULL;
2129         spin_unlock_irqrestore(&port->lock, flags);
2130         wake_up_interruptible(&port->port.open_wait);
2131
2132         func_exit();
2133 }
2134
2135
2136 static void sx_set_termios(struct tty_struct *tty,
2137                                         struct ktermios *old_termios)
2138 {
2139         struct specialix_port *port = tty->driver_data;
2140         unsigned long flags;
2141         struct specialix_board  *bp;
2142
2143         if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
2144                 return;
2145
2146         bp = port_Board(port);
2147         spin_lock_irqsave(&port->lock, flags);
2148         sx_change_speed(port_Board(port), port);
2149         spin_unlock_irqrestore(&port->lock, flags);
2150
2151         if ((old_termios->c_cflag & CRTSCTS) &&
2152             !(tty->termios->c_cflag & CRTSCTS)) {
2153                 tty->hw_stopped = 0;
2154                 sx_start(tty);
2155         }
2156 }
2157
2158 static const struct tty_operations sx_ops = {
2159         .open  = sx_open,
2160         .close = sx_close,
2161         .write = sx_write,
2162         .put_char = sx_put_char,
2163         .flush_chars = sx_flush_chars,
2164         .write_room = sx_write_room,
2165         .chars_in_buffer = sx_chars_in_buffer,
2166         .flush_buffer = sx_flush_buffer,
2167         .ioctl = sx_ioctl,
2168         .throttle = sx_throttle,
2169         .unthrottle = sx_unthrottle,
2170         .set_termios = sx_set_termios,
2171         .stop = sx_stop,
2172         .start = sx_start,
2173         .hangup = sx_hangup,
2174         .tiocmget = sx_tiocmget,
2175         .tiocmset = sx_tiocmset,
2176         .break_ctl = sx_send_break,
2177 };
2178
2179 static int sx_init_drivers(void)
2180 {
2181         int error;
2182         int i;
2183
2184         func_enter();
2185
2186         specialix_driver = alloc_tty_driver(SX_NBOARD * SX_NPORT);
2187         if (!specialix_driver) {
2188                 printk(KERN_ERR "sx: Couldn't allocate tty_driver.\n");
2189                 func_exit();
2190                 return 1;
2191         }
2192
2193         specialix_driver->owner = THIS_MODULE;
2194         specialix_driver->name = "ttyW";
2195         specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
2196         specialix_driver->type = TTY_DRIVER_TYPE_SERIAL;
2197         specialix_driver->subtype = SERIAL_TYPE_NORMAL;
2198         specialix_driver->init_termios = tty_std_termios;
2199         specialix_driver->init_termios.c_cflag =
2200                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2201         specialix_driver->init_termios.c_ispeed = 9600;
2202         specialix_driver->init_termios.c_ospeed = 9600;
2203         specialix_driver->flags = TTY_DRIVER_REAL_RAW |
2204                                                 TTY_DRIVER_HARDWARE_BREAK;
2205         tty_set_operations(specialix_driver, &sx_ops);
2206
2207         error = tty_register_driver(specialix_driver);
2208         if (error) {
2209                 put_tty_driver(specialix_driver);
2210                 printk(KERN_ERR
2211                   "sx: Couldn't register specialix IO8+ driver, error = %d\n",
2212                                                                 error);
2213                 func_exit();
2214                 return 1;
2215         }
2216         memset(sx_port, 0, sizeof(sx_port));
2217         for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
2218                 sx_port[i].magic = SPECIALIX_MAGIC;
2219                 tty_port_init(&sx_port[i].port);
2220                 spin_lock_init(&sx_port[i].lock);
2221         }
2222
2223         func_exit();
2224         return 0;
2225 }
2226
2227 static void sx_release_drivers(void)
2228 {
2229         func_enter();
2230
2231         tty_unregister_driver(specialix_driver);
2232         put_tty_driver(specialix_driver);
2233         func_exit();
2234 }
2235
2236 /*
2237  * This routine must be called by kernel at boot time
2238  */
2239 static int __init specialix_init(void)
2240 {
2241         int i;
2242         int found = 0;
2243
2244         func_enter();
2245
2246         printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.\n");
2247         printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.\n");
2248         if (sx_rtscts)
2249                 printk(KERN_INFO
2250                         "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
2251         else
2252                 printk(KERN_INFO "sx: DTR/RTS pin is always RTS.\n");
2253
2254         for (i = 0; i < SX_NBOARD; i++)
2255                 spin_lock_init(&sx_board[i].lock);
2256
2257         if (sx_init_drivers()) {
2258                 func_exit();
2259                 return -EIO;
2260         }
2261
2262         for (i = 0; i < SX_NBOARD; i++)
2263                 if (sx_board[i].base && !sx_probe(&sx_board[i]))
2264                         found++;
2265
2266 #ifdef CONFIG_PCI
2267         {
2268                 struct pci_dev *pdev = NULL;
2269
2270                 i = 0;
2271                 while (i < SX_NBOARD) {
2272                         if (sx_board[i].flags & SX_BOARD_PRESENT) {
2273                                 i++;
2274                                 continue;
2275                         }
2276                         pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX,
2277                                         PCI_DEVICE_ID_SPECIALIX_IO8, pdev);
2278                         if (!pdev)
2279                                 break;
2280
2281                         if (pci_enable_device(pdev))
2282                                 continue;
2283
2284                         sx_board[i].irq = pdev->irq;
2285
2286                         sx_board[i].base = pci_resource_start(pdev, 2);
2287
2288                         sx_board[i].flags |= SX_BOARD_IS_PCI;
2289                         if (!sx_probe(&sx_board[i]))
2290                                 found++;
2291                 }
2292                 /* May exit pci_get sequence early with lots of boards */
2293                 if (pdev != NULL)
2294                         pci_dev_put(pdev);
2295         }
2296 #endif
2297
2298         if (!found) {
2299                 sx_release_drivers();
2300                 printk(KERN_INFO "sx: No specialix IO8+ boards detected.\n");
2301                 func_exit();
2302                 return -EIO;
2303         }
2304
2305         func_exit();
2306         return 0;
2307 }
2308
2309 static int iobase[SX_NBOARD]  = {0,};
2310 static int irq[SX_NBOARD] = {0,};
2311
2312 module_param_array(iobase, int, NULL, 0);
2313 module_param_array(irq, int, NULL, 0);
2314 module_param(sx_debug, int, 0);
2315 module_param(sx_rtscts, int, 0);
2316 module_param(sx_rxfifo, int, 0);
2317
2318 /*
2319  * You can setup up to 4 boards.
2320  * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
2321  * You should specify the IRQs too in that case "irq=....,...".
2322  *
2323  * More than 4 boards in one computer is not possible, as the card can
2324  * only use 4 different interrupts.
2325  *
2326  */
2327 static int __init specialix_init_module(void)
2328 {
2329         int i;
2330
2331         func_enter();
2332
2333         if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
2334                 for (i = 0; i < SX_NBOARD; i++) {
2335                         sx_board[i].base = iobase[i];
2336                         sx_board[i].irq = irq[i];
2337                         sx_board[i].count = 0;
2338                 }
2339         }
2340
2341         func_exit();
2342
2343         return specialix_init();
2344 }
2345
2346 static void __exit specialix_exit_module(void)
2347 {
2348         int i;
2349
2350         func_enter();
2351
2352         sx_release_drivers();
2353         for (i = 0; i < SX_NBOARD; i++)
2354                 if (sx_board[i].flags & SX_BOARD_PRESENT)
2355                         sx_release_io_range(&sx_board[i]);
2356         func_exit();
2357 }
2358
2359 static struct pci_device_id specialx_pci_tbl[] __devinitdata = {
2360         { PCI_DEVICE(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_IO8) },
2361         { }
2362 };
2363 MODULE_DEVICE_TABLE(pci, specialx_pci_tbl);
2364
2365 module_init(specialix_init_module);
2366 module_exit(specialix_exit_module);
2367
2368 MODULE_LICENSE("GPL");
2369 MODULE_ALIAS_CHARDEV_MAJOR(SPECIALIX_NORMAL_MAJOR);