git.oblomov.eu Git - linux-2.6/blob - 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 void sx_send_break(struct specialix_port *port,
1822                                                 unsigned long length)
1823 {
1824         struct specialix_board *bp = port_Board(port);
1825         unsigned long flags;
1826
1827         func_enter();
1828
1829         spin_lock_irqsave(&port->lock, flags);
1830         port->break_length = SPECIALIX_TPS / HZ * length;
1831         port->COR2 |= COR2_ETC;
1832         port->IER  |= IER_TXRDY;
1833         spin_lock_irqsave(&bp->lock, flags);
1834         sx_out(bp, CD186x_CAR, port_No(port));
1835         sx_out(bp, CD186x_COR2, port->COR2);
1836         sx_out(bp, CD186x_IER, port->IER);
1837         spin_unlock_irqrestore(&bp->lock, flags);
1838         spin_unlock_irqrestore(&port->lock, flags);
1839         sx_wait_CCR(bp);
1840         spin_lock_irqsave(&bp->lock, flags);
1841         sx_out(bp, CD186x_CCR, CCR_CORCHG2);
1842         spin_unlock_irqrestore(&bp->lock, flags);
1843         sx_wait_CCR(bp);
1844
1845         func_exit();
1846 }
1847
1848
1849 static int sx_set_serial_info(struct specialix_port *port,
1850                                         struct serial_struct __user *newinfo)
1851 {
1852         struct serial_struct tmp;
1853         struct specialix_board *bp = port_Board(port);
1854         int change_speed;
1855
1856         func_enter();
1857
1858         if (copy_from_user(&tmp, newinfo, sizeof(tmp))) {
1859                 func_enter();
1860                 return -EFAULT;
1861         }
1862
1863         lock_kernel();
1864
1865         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1866                         (tmp.flags & ASYNC_SPD_MASK));
1867         change_speed |= (tmp.custom_divisor != port->custom_divisor);
1868
1869         if (!capable(CAP_SYS_ADMIN)) {
1870                 if ((tmp.close_delay != port->port.close_delay) ||
1871                     (tmp.closing_wait != port->port.closing_wait) ||
1872                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1873                      (port->port.flags & ~ASYNC_USR_MASK))) {
1874                         func_exit();
1875                         unlock_kernel();
1876                         return -EPERM;
1877                 }
1878                 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1879                                                 (tmp.flags & ASYNC_USR_MASK));
1880                 port->custom_divisor = tmp.custom_divisor;
1881         } else {
1882                 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1883                                                 (tmp.flags & ASYNC_FLAGS));
1884                 port->port.close_delay = tmp.close_delay;
1885                 port->port.closing_wait = tmp.closing_wait;
1886                 port->custom_divisor = tmp.custom_divisor;
1887         }
1888         if (change_speed)
1889                 sx_change_speed(bp, port);
1890
1891         func_exit();
1892         unlock_kernel();
1893         return 0;
1894 }
1895
1896
1897 static int sx_get_serial_info(struct specialix_port *port,
1898                                      struct serial_struct __user *retinfo)
1899 {
1900         struct serial_struct tmp;
1901         struct specialix_board *bp = port_Board(port);
1902
1903         func_enter();
1904
1905         memset(&tmp, 0, sizeof(tmp));
1906         lock_kernel();
1907         tmp.type = PORT_CIRRUS;
1908         tmp.line = port - sx_port;
1909         tmp.port = bp->base;
1910         tmp.irq  = bp->irq;
1911         tmp.flags = port->port.flags;
1912         tmp.baud_base = (SX_OSCFREQ + CD186x_TPC/2) / CD186x_TPC;
1913         tmp.close_delay = port->port.close_delay * HZ/100;
1914         tmp.closing_wait = port->port.closing_wait * HZ/100;
1915         tmp.custom_divisor =  port->custom_divisor;
1916         tmp.xmit_fifo_size = CD186x_NFIFO;
1917         unlock_kernel();
1918         if (copy_to_user(retinfo, &tmp, sizeof(tmp))) {
1919                 func_exit();
1920                 return -EFAULT;
1921         }
1922
1923         func_exit();
1924         return 0;
1925 }
1926
1927
1928 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1929                                 unsigned int cmd, unsigned long arg)
1930 {
1931         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1932         int retval;
1933         void __user *argp = (void __user *)arg;
1934
1935         func_enter();
1936
1937         if (sx_paranoia_check(port, tty->name, "sx_ioctl")) {
1938                 func_exit();
1939                 return -ENODEV;
1940         }
1941
1942         switch (cmd) {
1943         case TCSBRK:    /* SVID version: non-zero arg --> no break */
1944                 retval = tty_check_change(tty);
1945                 if (retval) {
1946                         func_exit();
1947                         return retval;
1948                 }
1949                 tty_wait_until_sent(tty, 0);
1950                 if (!arg)
1951                         sx_send_break(port, HZ/4);      /* 1/4 second */
1952                 return 0;
1953         case TCSBRKP:   /* support for POSIX tcsendbreak() */
1954                 retval = tty_check_change(tty);
1955                 if (retval) {
1956                         func_exit();
1957                         return retval;
1958                 }
1959                 tty_wait_until_sent(tty, 0);
1960                 sx_send_break(port, arg ? arg*(HZ/10) : HZ/4);
1961                 func_exit();
1962                 return 0;
1963         case TIOCGSERIAL:
1964                  func_exit();
1965                 return sx_get_serial_info(port, argp);
1966         case TIOCSSERIAL:
1967                  func_exit();
1968                 return sx_set_serial_info(port, argp);
1969         default:
1970                  func_exit();
1971                 return -ENOIOCTLCMD;
1972         }
1973         func_exit();
1974         return 0;
1975 }
1976
1977
1978 static void sx_throttle(struct tty_struct *tty)
1979 {
1980         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
1981         struct specialix_board *bp;
1982         unsigned long flags;
1983
1984         func_enter();
1985
1986         if (sx_paranoia_check(port, tty->name, "sx_throttle")) {
1987                 func_exit();
1988                 return;
1989         }
1990
1991         bp = port_Board(port);
1992
1993         /* Use DTR instead of RTS ! */
1994         if (sx_crtscts(tty))
1995                 port->MSVR &= ~MSVR_DTR;
1996         else {
1997                 /* Auch!!! I think the system shouldn't call this then. */
1998                 /* Or maybe we're supposed (allowed?) to do our side of hw
1999                    handshake anyway, even when hardware handshake is off.
2000                    When you see this in your logs, please report.... */
2001                 printk(KERN_ERR
2002                    "sx%d: Need to throttle, but can't (hardware hs is off)\n",
2003                                                         port_No(port));
2004         }
2005         spin_lock_irqsave(&bp->lock, flags);
2006         sx_out(bp, CD186x_CAR, port_No(port));
2007         spin_unlock_irqrestore(&bp->lock, flags);
2008         if (I_IXOFF(tty)) {
2009                 sx_wait_CCR(bp);
2010                 spin_lock_irqsave(&bp->lock, flags);
2011                 sx_out(bp, CD186x_CCR, CCR_SSCH2);
2012                 spin_unlock_irqrestore(&bp->lock, flags);
2013                 sx_wait_CCR(bp);
2014         }
2015         spin_lock_irqsave(&bp->lock, flags);
2016         sx_out(bp, CD186x_MSVR, port->MSVR);
2017         spin_unlock_irqrestore(&bp->lock, flags);
2018
2019         func_exit();
2020 }
2021
2022
2023 static void sx_unthrottle(struct tty_struct *tty)
2024 {
2025         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2026         struct specialix_board *bp;
2027         unsigned long flags;
2028
2029         func_enter();
2030
2031         if (sx_paranoia_check(port, tty->name, "sx_unthrottle")) {
2032                 func_exit();
2033                 return;
2034         }
2035
2036         bp = port_Board(port);
2037
2038         spin_lock_irqsave(&port->lock, flags);
2039         /* XXXX Use DTR INSTEAD???? */
2040         if (sx_crtscts(tty))
2041                 port->MSVR |= MSVR_DTR;
2042         /* Else clause: see remark in "sx_throttle"... */
2043         spin_lock_irqsave(&bp->lock, flags);
2044         sx_out(bp, CD186x_CAR, port_No(port));
2045         spin_unlock_irqrestore(&bp->lock, flags);
2046         if (I_IXOFF(tty)) {
2047                 spin_unlock_irqrestore(&port->lock, flags);
2048                 sx_wait_CCR(bp);
2049                 spin_lock_irqsave(&bp->lock, flags);
2050                 sx_out(bp, CD186x_CCR, CCR_SSCH1);
2051                 spin_unlock_irqrestore(&bp->lock, flags);
2052                 sx_wait_CCR(bp);
2053                 spin_lock_irqsave(&port->lock, flags);
2054         }
2055         spin_lock_irqsave(&bp->lock, flags);
2056         sx_out(bp, CD186x_MSVR, port->MSVR);
2057         spin_unlock_irqrestore(&bp->lock, flags);
2058         spin_unlock_irqrestore(&port->lock, flags);
2059
2060         func_exit();
2061 }
2062
2063
2064 static void sx_stop(struct tty_struct *tty)
2065 {
2066         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2067         struct specialix_board *bp;
2068         unsigned long flags;
2069
2070         func_enter();
2071
2072         if (sx_paranoia_check(port, tty->name, "sx_stop")) {
2073                 func_exit();
2074                 return;
2075         }
2076
2077         bp = port_Board(port);
2078
2079         spin_lock_irqsave(&port->lock, flags);
2080         port->IER &= ~IER_TXRDY;
2081         spin_lock_irqsave(&bp->lock, flags);
2082         sx_out(bp, CD186x_CAR, port_No(port));
2083         sx_out(bp, CD186x_IER, port->IER);
2084         spin_unlock_irqrestore(&bp->lock, flags);
2085         spin_unlock_irqrestore(&port->lock, flags);
2086
2087         func_exit();
2088 }
2089
2090
2091 static void sx_start(struct tty_struct *tty)
2092 {
2093         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2094         struct specialix_board *bp;
2095         unsigned long flags;
2096
2097         func_enter();
2098
2099         if (sx_paranoia_check(port, tty->name, "sx_start")) {
2100                 func_exit();
2101                 return;
2102         }
2103
2104         bp = port_Board(port);
2105
2106         spin_lock_irqsave(&port->lock, flags);
2107         if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
2108                 port->IER |= IER_TXRDY;
2109                 spin_lock_irqsave(&bp->lock, flags);
2110                 sx_out(bp, CD186x_CAR, port_No(port));
2111                 sx_out(bp, CD186x_IER, port->IER);
2112                 spin_unlock_irqrestore(&bp->lock, flags);
2113         }
2114         spin_unlock_irqrestore(&port->lock, flags);
2115
2116         func_exit();
2117 }
2118
2119 static void sx_hangup(struct tty_struct *tty)
2120 {
2121         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2122         struct specialix_board *bp;
2123         unsigned long flags;
2124
2125         func_enter();
2126
2127         if (sx_paranoia_check(port, tty->name, "sx_hangup")) {
2128                 func_exit();
2129                 return;
2130         }
2131
2132         bp = port_Board(port);
2133
2134         sx_shutdown_port(bp, port);
2135         spin_lock_irqsave(&port->lock, flags);
2136         bp->count -= port->port.count;
2137         if (bp->count < 0) {
2138                 printk(KERN_ERR
2139                         "sx%d: sx_hangup: bad board count: %d port: %d\n",
2140                                         board_No(bp), bp->count, tty->index);
2141                 bp->count = 0;
2142         }
2143         port->port.count = 0;
2144         port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
2145         port->port.tty = NULL;
2146         spin_unlock_irqrestore(&port->lock, flags);
2147         wake_up_interruptible(&port->port.open_wait);
2148
2149         func_exit();
2150 }
2151
2152
2153 static void sx_set_termios(struct tty_struct *tty,
2154                                         struct ktermios *old_termios)
2155 {
2156         struct specialix_port *port = (struct specialix_port *)tty->driver_data;
2157         unsigned long flags;
2158         struct specialix_board  *bp;
2159
2160         if (sx_paranoia_check(port, tty->name, "sx_set_termios"))
2161                 return;
2162
2163         bp = port_Board(port);
2164         spin_lock_irqsave(&port->lock, flags);
2165         sx_change_speed(port_Board(port), port);
2166         spin_unlock_irqrestore(&port->lock, flags);
2167
2168         if ((old_termios->c_cflag & CRTSCTS) &&
2169             !(tty->termios->c_cflag & CRTSCTS)) {
2170                 tty->hw_stopped = 0;
2171                 sx_start(tty);
2172         }
2173 }
2174
2175 static const struct tty_operations sx_ops = {
2176         .open  = sx_open,
2177         .close = sx_close,
2178         .write = sx_write,
2179         .put_char = sx_put_char,
2180         .flush_chars = sx_flush_chars,
2181         .write_room = sx_write_room,
2182         .chars_in_buffer = sx_chars_in_buffer,
2183         .flush_buffer = sx_flush_buffer,
2184         .ioctl = sx_ioctl,
2185         .throttle = sx_throttle,
2186         .unthrottle = sx_unthrottle,
2187         .set_termios = sx_set_termios,
2188         .stop = sx_stop,
2189         .start = sx_start,
2190         .hangup = sx_hangup,
2191         .tiocmget = sx_tiocmget,
2192         .tiocmset = sx_tiocmset,
2193 };
2194
2195 static int sx_init_drivers(void)
2196 {
2197         int error;
2198         int i;
2199
2200         func_enter();
2201
2202         specialix_driver = alloc_tty_driver(SX_NBOARD * SX_NPORT);
2203         if (!specialix_driver) {
2204                 printk(KERN_ERR "sx: Couldn't allocate tty_driver.\n");
2205                 func_exit();
2206                 return 1;
2207         }
2208
2209         specialix_driver->owner = THIS_MODULE;
2210         specialix_driver->name = "ttyW";
2211         specialix_driver->major = SPECIALIX_NORMAL_MAJOR;
2212         specialix_driver->type = TTY_DRIVER_TYPE_SERIAL;
2213         specialix_driver->subtype = SERIAL_TYPE_NORMAL;
2214         specialix_driver->init_termios = tty_std_termios;
2215         specialix_driver->init_termios.c_cflag =
2216                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2217         specialix_driver->init_termios.c_ispeed = 9600;
2218         specialix_driver->init_termios.c_ospeed = 9600;
2219         specialix_driver->flags = TTY_DRIVER_REAL_RAW;
2220         tty_set_operations(specialix_driver, &sx_ops);
2221
2222         error = tty_register_driver(specialix_driver);
2223         if (error) {
2224                 put_tty_driver(specialix_driver);
2225                 printk(KERN_ERR
2226                   "sx: Couldn't register specialix IO8+ driver, error = %d\n",
2227                                                                 error);
2228                 func_exit();
2229                 return 1;
2230         }
2231         memset(sx_port, 0, sizeof(sx_port));
2232         for (i = 0; i < SX_NPORT * SX_NBOARD; i++) {
2233                 sx_port[i].magic = SPECIALIX_MAGIC;
2234                 tty_port_init(&sx_port[i].port);
2235                 spin_lock_init(&sx_port[i].lock);
2236         }
2237
2238         func_exit();
2239         return 0;
2240 }
2241
2242 static void sx_release_drivers(void)
2243 {
2244         func_enter();
2245
2246         tty_unregister_driver(specialix_driver);
2247         put_tty_driver(specialix_driver);
2248         func_exit();
2249 }
2250
2251 /*
2252  * This routine must be called by kernel at boot time
2253  */
2254 static int __init specialix_init(void)
2255 {
2256         int i;
2257         int found = 0;
2258
2259         func_enter();
2260
2261         printk(KERN_INFO "sx: Specialix IO8+ driver v" VERSION ", (c) R.E.Wolff 1997/1998.\n");
2262         printk(KERN_INFO "sx: derived from work (c) D.Gorodchanin 1994-1996.\n");
2263         if (sx_rtscts)
2264                 printk(KERN_INFO
2265                         "sx: DTR/RTS pin is RTS when CRTSCTS is on.\n");
2266         else
2267                 printk(KERN_INFO "sx: DTR/RTS pin is always RTS.\n");
2268
2269         for (i = 0; i < SX_NBOARD; i++)
2270                 spin_lock_init(&sx_board[i].lock);
2271
2272         if (sx_init_drivers()) {
2273                 func_exit();
2274                 return -EIO;
2275         }
2276
2277         for (i = 0; i < SX_NBOARD; i++)
2278                 if (sx_board[i].base && !sx_probe(&sx_board[i]))
2279                         found++;
2280
2281 #ifdef CONFIG_PCI
2282         {
2283                 struct pci_dev *pdev = NULL;
2284
2285                 i = 0;
2286                 while (i < SX_NBOARD) {
2287                         if (sx_board[i].flags & SX_BOARD_PRESENT) {
2288                                 i++;
2289                                 continue;
2290                         }
2291                         pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX,
2292                                         PCI_DEVICE_ID_SPECIALIX_IO8, pdev);
2293                         if (!pdev)
2294                                 break;
2295
2296                         if (pci_enable_device(pdev))
2297                                 continue;
2298
2299                         sx_board[i].irq = pdev->irq;
2300
2301                         sx_board[i].base = pci_resource_start(pdev, 2);
2302
2303                         sx_board[i].flags |= SX_BOARD_IS_PCI;
2304                         if (!sx_probe(&sx_board[i]))
2305                                 found++;
2306                 }
2307                 /* May exit pci_get sequence early with lots of boards */
2308                 if (pdev != NULL)
2309                         pci_dev_put(pdev);
2310         }
2311 #endif
2312
2313         if (!found) {
2314                 sx_release_drivers();
2315                 printk(KERN_INFO "sx: No specialix IO8+ boards detected.\n");
2316                 func_exit();
2317                 return -EIO;
2318         }
2319
2320         func_exit();
2321         return 0;
2322 }
2323
2324 static int iobase[SX_NBOARD]  = {0,};
2325 static int irq[SX_NBOARD] = {0,};
2326
2327 module_param_array(iobase, int, NULL, 0);
2328 module_param_array(irq, int, NULL, 0);
2329 module_param(sx_debug, int, 0);
2330 module_param(sx_rtscts, int, 0);
2331 module_param(sx_rxfifo, int, 0);
2332
2333 /*
2334  * You can setup up to 4 boards.
2335  * by specifying "iobase=0xXXX,0xXXX ..." as insmod parameter.
2336  * You should specify the IRQs too in that case "irq=....,...".
2337  *
2338  * More than 4 boards in one computer is not possible, as the card can
2339  * only use 4 different interrupts.
2340  *
2341  */
2342 static int __init specialix_init_module(void)
2343 {
2344         int i;
2345
2346         func_enter();
2347
2348         if (iobase[0] || iobase[1] || iobase[2] || iobase[3]) {
2349                 for (i = 0; i < SX_NBOARD; i++) {
2350                         sx_board[i].base = iobase[i];
2351                         sx_board[i].irq = irq[i];
2352                         sx_board[i].count = 0;
2353                 }
2354         }
2355
2356         func_exit();
2357
2358         return specialix_init();
2359 }
2360
2361 static void __exit specialix_exit_module(void)
2362 {
2363         int i;
2364
2365         func_enter();
2366
2367         sx_release_drivers();
2368         for (i = 0; i < SX_NBOARD; i++)
2369                 if (sx_board[i].flags & SX_BOARD_PRESENT)
2370                         sx_release_io_range(&sx_board[i]);
2371         func_exit();
2372 }
2373
2374 static struct pci_device_id specialx_pci_tbl[] __devinitdata = {
2375         { PCI_DEVICE(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_IO8) },
2376         { }
2377 };
2378 MODULE_DEVICE_TABLE(pci, specialx_pci_tbl);
2379
2380 module_init(specialix_init_module);
2381 module_exit(specialix_exit_module);
2382
2383 MODULE_LICENSE("GPL");