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