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