drivers/char/sx.c

   1 /* sx.c -- driver for the Specialix SX series cards.
   2  *
   3  *  This driver will also support the older SI, and XIO cards.
   4  *
   5  *
   6  *   (C) 1998 - 2004  R.E.Wolff@BitWizard.nl
   7  *
   8  *  Simon Allen (simonallen@cix.compulink.co.uk) wrote a previous
   9  *  version of this driver. Some fragments may have been copied. (none
  10  *  yet :-)
  11  *
  12  * Specialix pays for the development and support of this driver.
  13  * Please DO contact support@specialix.co.uk if you require
  14  * support. But please read the documentation (sx.txt) first.
  15  *
  16  *
  17  *
  18  *      This program is free software; you can redistribute it and/or
  19  *      modify it under the terms of the GNU General Public License as
  20  *      published by the Free Software Foundation; either version 2 of
  21  *      the License, or (at your option) any later version.
  22  *
  23  *      This program is distributed in the hope that it will be
  24  *      useful, but WITHOUT ANY WARRANTY; without even the implied
  25  *      warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  26  *      PURPOSE.  See the GNU General Public License for more details.
  27  *
  28  *      You should have received a copy of the GNU General Public
  29  *      License along with this program; if not, write to the Free
  30  *      Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  31  *      USA.
  32  *
  33  * Revision history:
  34  * Revision 1.33  2000/03/09 10:00:00  pvdl,wolff
  35  * - Fixed module and port counting
  36  * - Fixed signal handling
  37  * - Fixed an Ooops
  38  *
  39  * Revision 1.32  2000/03/07 09:00:00  wolff,pvdl
  40  * - Fixed some sx_dprintk typos
  41  * - added detection for an invalid board/module configuration
  42  *
  43  * Revision 1.31  2000/03/06 12:00:00  wolff,pvdl
  44  * - Added support for EISA
  45  *
  46  * Revision 1.30  2000/01/21 17:43:06  wolff
  47  * - Added support for SX+
  48  *
  49  * Revision 1.26  1999/08/05 15:22:14  wolff
  50  * - Port to 2.3.x
  51  * - Reformatted to Linus' liking.
  52  *
  53  * Revision 1.25  1999/07/30 14:24:08  wolff
  54  * Had accidentally left "gs_debug" set to "-1" instead of "off" (=0).
  55  *
  56  * Revision 1.24  1999/07/28 09:41:52  wolff
  57  * - I noticed the remark about use-count straying in sx.txt. I checked
  58  *   sx_open, and found a few places where that could happen. I hope it's
  59  *   fixed now.
  60  *
  61  * Revision 1.23  1999/07/28 08:56:06  wolff
  62  * - Fixed crash when sx_firmware run twice.
  63  * - Added sx_slowpoll as a module parameter (I guess nobody really wanted
  64  *   to change it from the default... )
  65  * - Fixed a stupid editing problem I introduced in 1.22.
  66  * - Fixed dropping characters on a termios change.
  67  *
  68  * Revision 1.22  1999/07/26 21:01:43  wolff
  69  * Russell Brown noticed that I had overlooked 4 out of six modem control
  70  * signals in sx_getsignals. Ooops.
  71  *
  72  * Revision 1.21  1999/07/23 09:11:33  wolff
  73  * I forgot to free dynamically allocated memory when the driver is unloaded.
  74  *
  75  * Revision 1.20  1999/07/20 06:25:26  wolff
  76  * The "closing wait" wasn't honoured. Thanks to James Griffiths for
  77  * reporting this.
  78  *
  79  * Revision 1.19  1999/07/11 08:59:59  wolff
  80  * Fixed an oops in close, when an open was pending. Changed the memtest
  81  * a bit. Should also test the board in word-mode, however my card fails the
  82  * memtest then. I still have to figure out what is wrong...
  83  *
  84  * Revision 1.18  1999/06/10 09:38:42  wolff
  85  * Changed the format of the firmware revision from %04x to %x.%02x .
  86  *
  87  * Revision 1.17  1999/06/04 09:44:35  wolff
  88  * fixed problem: reference to pci stuff when config_pci was off...
  89  * Thanks to Jorge Novo for noticing this.
  90  *
  91  * Revision 1.16  1999/06/02 08:30:15  wolff
  92  * added/removed the workaround for the DCD bug in the Firmware.
  93  * A bit more debugging code to locate that...
  94  *
  95  * Revision 1.15  1999/06/01 11:35:30  wolff
  96  * when DCD is left low (floating?), on TA's the firmware first tells us
  97  * that DCD is high, but after a short while suddenly comes to the
  98  * conclusion that it is low. All this would be fine, if it weren't that
  99  * Unix requires us to send a "hangup" signal in that case. This usually
 100  * all happens BEFORE the program has had a chance to ioctl the device
 101  * into clocal mode..
 102  *
 103  * Revision 1.14  1999/05/25 11:18:59  wolff
 104  * Added PCI-fix.
 105  * Added checks for return code of sx_sendcommand.
 106  * Don't issue "reconfig" if port isn't open yet. (bit us on TA modules...)
 107  *
 108  * Revision 1.13  1999/04/29 15:18:01  wolff
 109  * Fixed an "oops" that showed on SuSE 6.0 systems.
 110  * Activate DTR again after stty 0.
 111  *
 112  * Revision 1.12  1999/04/29 07:49:52  wolff
 113  * Improved "stty 0" handling a bit. (used to change baud to 9600 assuming
 114  *     the connection would be dropped anyway. That is not always the case,
 115  *     and confuses people).
 116  * Told the card to always monitor the modem signals.
 117  * Added support for dynamic  gs_debug adjustments.
 118  * Now tells the rest of the system the number of ports.
 119  *
 120  * Revision 1.11  1999/04/24 11:11:30  wolff
 121  * Fixed two stupid typos in the memory test.
 122  *
 123  * Revision 1.10  1999/04/24 10:53:39  wolff
 124  * Added some of Christian's suggestions.
 125  * Fixed an HW_COOK_IN bug (ISIG was not in I_OTHER. We used to trust the
 126  * card to send the signal to the process.....)
 127  *
 128  * Revision 1.9  1999/04/23 07:26:38  wolff
 129  * Included Christian Lademann's 2.0 compile-warning fixes and interrupt
 130  *    assignment redesign.
 131  * Cleanup of some other stuff.
 132  *
 133  * Revision 1.8  1999/04/16 13:05:30  wolff
 134  * fixed a DCD change unnoticed bug.
 135  *
 136  * Revision 1.7  1999/04/14 22:19:51  wolff
 137  * Fixed typo that showed up in 2.0.x builds (get_user instead of Get_user!)
 138  *
 139  * Revision 1.6  1999/04/13 18:40:20  wolff
 140  * changed misc-minor to 161, as assigned by HPA.
 141  *
 142  * Revision 1.5  1999/04/13 15:12:25  wolff
 143  * Fixed use-count leak when "hangup" occurred.
 144  * Added workaround for a stupid-PCIBIOS bug.
 145  *
 146  *
 147  * Revision 1.4  1999/04/01 22:47:40  wolff
 148  * Fixed < 1M linux-2.0 problem.
 149  * (vremap isn't compatible with ioremap in that case)
 150  *
 151  * Revision 1.3  1999/03/31 13:45:45  wolff
 152  * Firmware loading is now done through a separate IOCTL.
 153  *
 154  * Revision 1.2  1999/03/28 12:22:29  wolff
 155  * rcs cleanup
 156  *
 157  * Revision 1.1  1999/03/28 12:10:34  wolff
 158  * Readying for release on 2.0.x (sorry David, 1.01 becomes 1.1 for RCS).
 159  *
 160  * Revision 0.12  1999/03/28 09:20:10  wolff
 161  * Fixed problem in 0.11, continueing cleanup.
 162  *
 163  * Revision 0.11  1999/03/28 08:46:44  wolff
 164  * cleanup. Not good.
 165  *
 166  * Revision 0.10  1999/03/28 08:09:43  wolff
 167  * Fixed loosing characters on close.
 168  *
 169  * Revision 0.9  1999/03/21 22:52:01  wolff
 170  * Ported back to 2.2.... (minor things)
 171  *
 172  * Revision 0.8  1999/03/21 22:40:33  wolff
 173  * Port to 2.0
 174  *
 175  * Revision 0.7  1999/03/21 19:06:34  wolff
 176  * Fixed hangup processing.
 177  *
 178  * Revision 0.6  1999/02/05 08:45:14  wolff
 179  * fixed real_raw problems. Inclusion into kernel imminent.
 180  *
 181  * Revision 0.5  1998/12/21 23:51:06  wolff
 182  * Snatched a nasty bug: sx_transmit_chars was getting re-entered, and it
 183  * shouldn't have. THATs why I want to have transmit interrupts even when
 184  * the buffer is empty.
 185  *
 186  * Revision 0.4  1998/12/17 09:34:46  wolff
 187  * PPP works. ioctl works. Basically works!
 188  *
 189  * Revision 0.3  1998/12/15 13:05:18  wolff
 190  * It works! Wow! Gotta start implementing IOCTL and stuff....
 191  *
 192  * Revision 0.2  1998/12/01 08:33:53  wolff
 193  * moved over to 2.1.130
 194  *
 195  * Revision 0.1  1998/11/03 21:23:51  wolff
 196  * Initial revision. Detects SX card.
 197  *
 198  * */
 199
 200 #define SX_VERSION      1.33
 201
 202 #include <linux/module.h>
 203 #include <linux/kdev_t.h>
 204 #include <linux/kernel.h>
 205 #include <linux/sched.h>
 206 #include <linux/ioport.h>
 207 #include <linux/interrupt.h>
 208 #include <linux/errno.h>
 209 #include <linux/tty.h>
 210 #include <linux/tty_flip.h>
 211 #include <linux/mm.h>
 212 #include <linux/serial.h>
 213 #include <linux/fcntl.h>
 214 #include <linux/major.h>
 215 #include <linux/delay.h>
 216 #include <linux/eisa.h>
 217 #include <linux/pci.h>
 218 #include <linux/slab.h>
 219 #include <linux/init.h>
 220 #include <linux/miscdevice.h>
 221 #include <linux/bitops.h>
 222
 223 #include <asm/io.h>
 224 #include <asm/uaccess.h>
 225
 226 /* The 3.0.0 version of sxboards/sxwindow.h  uses BYTE and WORD.... */
 227 #define BYTE u8
 228 #define WORD u16
 229
 230 /* .... but the 3.0.4 version uses _u8 and _u16. */
 231 #define _u8 u8
 232 #define _u16 u16
 233
 234 #include "sxboards.h"
 235 #include "sxwindow.h"
 236
 237 #include <linux/generic_serial.h>
 238 #include "sx.h"
 239
 240 /* I don't think that this driver can handle more than 256 ports on
 241    one machine. You'll have to increase the number of boards in sx.h
 242    if you want more than 4 boards.  */
 243
 244 #ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
 245 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
 246 #endif
 247
 248 /* Configurable options:
 249    (Don't be too sure that it'll work if you toggle them) */
 250
 251 /* Am I paranoid or not ? ;-) */
 252 #undef SX_PARANOIA_CHECK
 253
 254 /* 20 -> 2000 per second. The card should rate-limit interrupts at 100
 255    Hz, but it is user configurable. I don't recommend going above 1000
 256    Hz. The interrupt ratelimit might trigger if the interrupt is
 257    shared with a very active other device. */
 258 #define IRQ_RATE_LIMIT 20
 259
 260 /* Sharing interrupts is possible now. If the other device wants more
 261    than 2000 interrupts per second, we'd gracefully decline further
 262    interrupts. That's not what we want. On the other hand, if the
 263    other device interrupts 2000 times a second, don't use the SX
 264    interrupt. Use polling. */
 265 #undef IRQ_RATE_LIMIT
 266
 267 #if 0
 268 /* Not implemented */
 269 /*
 270  * The following defines are mostly for testing purposes. But if you need
 271  * some nice reporting in your syslog, you can define them also.
 272  */
 273 #define SX_REPORT_FIFO
 274 #define SX_REPORT_OVERRUN
 275 #endif
 276
 277 /* Function prototypes */
 278 static void sx_disable_tx_interrupts(void *ptr);
 279 static void sx_enable_tx_interrupts(void *ptr);
 280 static void sx_disable_rx_interrupts(void *ptr);
 281 static void sx_enable_rx_interrupts(void *ptr);
 282 static int sx_get_CD(void *ptr);
 283 static void sx_shutdown_port(void *ptr);
 284 static int sx_set_real_termios(void *ptr);
 285 static void sx_close(void *ptr);
 286 static int sx_chars_in_buffer(void *ptr);
 287 static int sx_init_board(struct sx_board *board);
 288 static int sx_init_portstructs(int nboards, int nports);
 289 static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
 290                                                 unsigned long arg);
 291 static int sx_init_drivers(void);
 292
 293 static struct tty_driver *sx_driver;
 294
 295 static DEFINE_MUTEX(sx_boards_lock);
 296 static struct sx_board boards[SX_NBOARDS];
 297 static struct sx_port *sx_ports;
 298 static int sx_initialized;
 299 static int sx_nports;
 300 static int sx_debug;
 301
 302 /* You can have the driver poll your card.
 303     - Set sx_poll to 1 to poll every timer tick (10ms on Intel).
 304       This is used when the card cannot use an interrupt for some reason.
 305
 306     - set sx_slowpoll to 100 to do an extra poll once a second (on Intel). If
 307       the driver misses an interrupt (report this if it DOES happen to you!)
 308       everything will continue to work....
 309  */
 310 static int sx_poll = 1;
 311 static int sx_slowpoll;
 312
 313 /* The card limits the number of interrupts per second.
 314    At 115k2 "100" should be sufficient.
 315    If you're using higher baudrates, you can increase this...
 316  */
 317
 318 static int sx_maxints = 100;
 319
 320 #ifdef CONFIG_ISA
 321
 322 /* These are the only open spaces in my computer. Yours may have more
 323    or less.... -- REW
 324    duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
 325 */
 326 static int sx_probe_addrs[] = {
 327         0xc0000, 0xd0000, 0xe0000,
 328         0xc8000, 0xd8000, 0xe8000
 329 };
 330 static int si_probe_addrs[] = {
 331         0xc0000, 0xd0000, 0xe0000,
 332         0xc8000, 0xd8000, 0xe8000, 0xa0000
 333 };
 334 static int si1_probe_addrs[] = {
 335         0xd0000
 336 };
 337
 338 #define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
 339 #define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
 340 #define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
 341
 342 module_param_array(sx_probe_addrs, int, NULL, 0);
 343 module_param_array(si_probe_addrs, int, NULL, 0);
 344 #endif
 345
 346 /* Set the mask to all-ones. This alas, only supports 32 interrupts.
 347    Some architectures may need more. */
 348 static int sx_irqmask = -1;
 349
 350 module_param(sx_poll, int, 0);
 351 module_param(sx_slowpoll, int, 0);
 352 module_param(sx_maxints, int, 0);
 353 module_param(sx_debug, int, 0);
 354 module_param(sx_irqmask, int, 0);
 355
 356 MODULE_LICENSE("GPL");
 357
 358 static struct real_driver sx_real_driver = {
 359         sx_disable_tx_interrupts,
 360         sx_enable_tx_interrupts,
 361         sx_disable_rx_interrupts,
 362         sx_enable_rx_interrupts,
 363         sx_get_CD,
 364         sx_shutdown_port,
 365         sx_set_real_termios,
 366         sx_chars_in_buffer,
 367         sx_close,
 368 };
 369
 370 /*
 371    This driver can spew a whole lot of debugging output at you. If you
 372    need maximum performance, you should disable the DEBUG define. To
 373    aid in debugging in the field, I'm leaving the compile-time debug
 374    features enabled, and disable them "runtime". That allows me to
 375    instruct people with problems to enable debugging without requiring
 376    them to recompile...
 377 */
 378 #define DEBUG
 379
 380 #ifdef DEBUG
 381 #define sx_dprintk(f, str...)   if (sx_debug & f) printk (str)
 382 #else
 383 #define sx_dprintk(f, str...)   /* nothing */
 384 #endif
 385
 386 #define func_enter()    sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__func__)
 387 #define func_exit()     sx_dprintk(SX_DEBUG_FLOW, "sx: exit  %s\n",__func__)
 388
 389 #define func_enter2()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
 390                                 __func__, port->line)
 391
 392 /*
 393  *  Firmware loader driver specific routines
 394  *
 395  */
 396
 397 static const struct file_operations sx_fw_fops = {
 398         .owner = THIS_MODULE,
 399         .unlocked_ioctl = sx_fw_ioctl,
 400 };
 401
 402 static struct miscdevice sx_fw_device = {
 403         SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
 404 };
 405
 406 #ifdef SX_PARANOIA_CHECK
 407
 408 /* This doesn't work. Who's paranoid around here? Not me! */
 409
 410 static inline int sx_paranoia_check(struct sx_port const *port,
 411                                     char *name, const char *routine)
 412 {
 413         static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
 414                         "number for device %s in %s\n";
 415         static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
 416                         "device %s in %s\n";
 417
 418         if (!port) {
 419                 printk(badinfo, name, routine);
 420                 return 1;
 421         }
 422         if (port->magic != SX_MAGIC) {
 423                 printk(badmagic, name, routine);
 424                 return 1;
 425         }
 426
 427         return 0;
 428 }
 429 #else
 430 #define sx_paranoia_check(a,b,c) 0
 431 #endif
 432
 433 /* The timeouts. First try 30 times as fast as possible. Then give
 434    the card some time to breathe between accesses. (Otherwise the
 435    processor on the card might not be able to access its OWN bus... */
 436
 437 #define TIMEOUT_1 30
 438 #define TIMEOUT_2 1000000
 439
 440 #ifdef DEBUG
 441 static void my_hd_io(void __iomem *p, int len)
 442 {
 443         int i, j, ch;
 444         unsigned char __iomem *addr = p;
 445
 446         for (i = 0; i < len; i += 16) {
 447                 printk("%p ", addr + i);
 448                 for (j = 0; j < 16; j++) {
 449                         printk("%02x %s", readb(addr + j + i),
 450                                         (j == 7) ? " " : "");
 451                 }
 452                 for (j = 0; j < 16; j++) {
 453                         ch = readb(addr + j + i);
 454                         printk("%c", (ch < 0x20) ? '.' :
 455                                         ((ch > 0x7f) ? '.' : ch));
 456                 }
 457                 printk("\n");
 458         }
 459 }
 460 static void my_hd(void *p, int len)
 461 {
 462         int i, j, ch;
 463         unsigned char *addr = p;
 464
 465         for (i = 0; i < len; i += 16) {
 466                 printk("%p ", addr + i);
 467                 for (j = 0; j < 16; j++) {
 468                         printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
 469                 }
 470                 for (j = 0; j < 16; j++) {
 471                         ch = addr[j + i];
 472                         printk("%c", (ch < 0x20) ? '.' :
 473                                         ((ch > 0x7f) ? '.' : ch));
 474                 }
 475                 printk("\n");
 476         }
 477 }
 478 #endif
 479
 480 /* This needs redoing for Alpha -- REW -- Done. */
 481
 482 static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
 483 {
 484         writeb(byte, board->base + offset);
 485 }
 486
 487 static inline u8 read_sx_byte(struct sx_board *board, int offset)
 488 {
 489         return readb(board->base + offset);
 490 }
 491
 492 static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
 493 {
 494         writew(word, board->base + offset);
 495 }
 496
 497 static inline u16 read_sx_word(struct sx_board *board, int offset)
 498 {
 499         return readw(board->base + offset);
 500 }
 501
 502 static int sx_busy_wait_eq(struct sx_board *board,
 503                 int offset, int mask, int correctval)
 504 {
 505         int i;
 506
 507         func_enter();
 508
 509         for (i = 0; i < TIMEOUT_1; i++)
 510                 if ((read_sx_byte(board, offset) & mask) == correctval) {
 511                         func_exit();
 512                         return 1;
 513                 }
 514
 515         for (i = 0; i < TIMEOUT_2; i++) {
 516                 if ((read_sx_byte(board, offset) & mask) == correctval) {
 517                         func_exit();
 518                         return 1;
 519                 }
 520                 udelay(1);
 521         }
 522
 523         func_exit();
 524         return 0;
 525 }
 526
 527 static int sx_busy_wait_neq(struct sx_board *board,
 528                 int offset, int mask, int badval)
 529 {
 530         int i;
 531
 532         func_enter();
 533
 534         for (i = 0; i < TIMEOUT_1; i++)
 535                 if ((read_sx_byte(board, offset) & mask) != badval) {
 536                         func_exit();
 537                         return 1;
 538                 }
 539
 540         for (i = 0; i < TIMEOUT_2; i++) {
 541                 if ((read_sx_byte(board, offset) & mask) != badval) {
 542                         func_exit();
 543                         return 1;
 544                 }
 545                 udelay(1);
 546         }
 547
 548         func_exit();
 549         return 0;
 550 }
 551
 552 /* 5.6.4 of 6210028 r2.3 */
 553 static int sx_reset(struct sx_board *board)
 554 {
 555         func_enter();
 556
 557         if (IS_SX_BOARD(board)) {
 558
 559                 write_sx_byte(board, SX_CONFIG, 0);
 560                 write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
 561
 562                 if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
 563                         printk(KERN_INFO "sx: Card doesn't respond to "
 564                                         "reset...\n");
 565                         return 0;
 566                 }
 567         } else if (IS_EISA_BOARD(board)) {
 568                 outb(board->irq << 4, board->eisa_base + 0xc02);
 569         } else if (IS_SI1_BOARD(board)) {
 570                 write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
 571         } else {
 572                 /* Gory details of the SI/ISA board */
 573                 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
 574                 write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
 575                 write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
 576                 write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
 577                 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
 578                 write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
 579         }
 580
 581         func_exit();
 582         return 1;
 583 }
 584
 585 /* This doesn't work on machines where "NULL" isn't 0 */
 586 /* If you have one of those, someone will need to write
 587    the equivalent of this, which will amount to about 3 lines. I don't
 588    want to complicate this right now. -- REW
 589    (See, I do write comments every now and then :-) */
 590 #define OFFSETOF(strct, elem)   ((long)&(((struct strct *)NULL)->elem))
 591
 592 #define CHAN_OFFSET(port,elem)  (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
 593 #define MODU_OFFSET(board,addr,elem)    (addr + OFFSETOF (_SXMODULE, elem))
 594 #define  BRD_OFFSET(board,elem) (OFFSETOF (_SXCARD, elem))
 595
 596 #define sx_write_channel_byte(port, elem, val) \
 597         write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
 598
 599 #define sx_read_channel_byte(port, elem) \
 600         read_sx_byte (port->board, CHAN_OFFSET (port, elem))
 601
 602 #define sx_write_channel_word(port, elem, val) \
 603         write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
 604
 605 #define sx_read_channel_word(port, elem) \
 606         read_sx_word (port->board, CHAN_OFFSET (port, elem))
 607
 608 #define sx_write_module_byte(board, addr, elem, val) \
 609         write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
 610
 611 #define sx_read_module_byte(board, addr, elem) \
 612         read_sx_byte (board, MODU_OFFSET (board, addr, elem))
 613
 614 #define sx_write_module_word(board, addr, elem, val) \
 615         write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
 616
 617 #define sx_read_module_word(board, addr, elem) \
 618         read_sx_word (board, MODU_OFFSET (board, addr, elem))
 619
 620 #define sx_write_board_byte(board, elem, val) \
 621         write_sx_byte (board, BRD_OFFSET (board, elem), val)
 622
 623 #define sx_read_board_byte(board, elem) \
 624         read_sx_byte (board, BRD_OFFSET (board, elem))
 625
 626 #define sx_write_board_word(board, elem, val) \
 627         write_sx_word (board, BRD_OFFSET (board, elem), val)
 628
 629 #define sx_read_board_word(board, elem) \
 630         read_sx_word (board, BRD_OFFSET (board, elem))
 631
 632 static int sx_start_board(struct sx_board *board)
 633 {
 634         if (IS_SX_BOARD(board)) {
 635                 write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
 636         } else if (IS_EISA_BOARD(board)) {
 637                 write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
 638                 outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
 639         } else if (IS_SI1_BOARD(board)) {
 640                 write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
 641                 write_sx_byte(board, SI1_ISA_INTCL, 0);
 642         } else {
 643                 /* Don't bug me about the clear_set.
 644                    I haven't the foggiest idea what it's about -- REW */
 645                 write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
 646                 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
 647         }
 648         return 1;
 649 }
 650
 651 #define SX_IRQ_REG_VAL(board) \
 652         ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
 653
 654 /* Note. The SX register is write-only. Therefore, we have to enable the
 655    bus too. This is a no-op, if you don't mess with this driver... */
 656 static int sx_start_interrupts(struct sx_board *board)
 657 {
 658
 659         /* Don't call this with board->irq == 0 */
 660
 661         if (IS_SX_BOARD(board)) {
 662                 write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
 663                                 SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
 664         } else if (IS_EISA_BOARD(board)) {
 665                 inb(board->eisa_base + 0xc03);
 666         } else if (IS_SI1_BOARD(board)) {
 667                 write_sx_byte(board, SI1_ISA_INTCL, 0);
 668                 write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
 669         } else {
 670                 switch (board->irq) {
 671                 case 11:
 672                         write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
 673                         break;
 674                 case 12:
 675                         write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
 676                         break;
 677                 case 15:
 678                         write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
 679                         break;
 680                 default:
 681                         printk(KERN_INFO "sx: SI/XIO card doesn't support "
 682                                         "interrupt %d.\n", board->irq);
 683                         return 0;
 684                 }
 685                 write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
 686         }
 687
 688         return 1;
 689 }
 690
 691 static int sx_send_command(struct sx_port *port,
 692                 int command, int mask, int newstat)
 693 {
 694         func_enter2();
 695         write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
 696         func_exit();
 697         return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
 698                         newstat);
 699 }
 700
 701 static char *mod_type_s(int module_type)
 702 {
 703         switch (module_type) {
 704         case TA4:
 705                 return "TA4";
 706         case TA8:
 707                 return "TA8";
 708         case TA4_ASIC:
 709                 return "TA4_ASIC";
 710         case TA8_ASIC:
 711                 return "TA8_ASIC";
 712         case MTA_CD1400:
 713                 return "MTA_CD1400";
 714         case SXDC:
 715                 return "SXDC";
 716         default:
 717                 return "Unknown/invalid";
 718         }
 719 }
 720
 721 static char *pan_type_s(int pan_type)
 722 {
 723         switch (pan_type) {
 724         case MOD_RS232DB25:
 725                 return "MOD_RS232DB25";
 726         case MOD_RS232RJ45:
 727                 return "MOD_RS232RJ45";
 728         case MOD_RS422DB25:
 729                 return "MOD_RS422DB25";
 730         case MOD_PARALLEL:
 731                 return "MOD_PARALLEL";
 732         case MOD_2_RS232DB25:
 733                 return "MOD_2_RS232DB25";
 734         case MOD_2_RS232RJ45:
 735                 return "MOD_2_RS232RJ45";
 736         case MOD_2_RS422DB25:
 737                 return "MOD_2_RS422DB25";
 738         case MOD_RS232DB25MALE:
 739                 return "MOD_RS232DB25MALE";
 740         case MOD_2_PARALLEL:
 741                 return "MOD_2_PARALLEL";
 742         case MOD_BLANK:
 743                 return "empty";
 744         default:
 745                 return "invalid";
 746         }
 747 }
 748
 749 static int mod_compat_type(int module_type)
 750 {
 751         return module_type >> 4;
 752 }
 753
 754 static void sx_reconfigure_port(struct sx_port *port)
 755 {
 756         if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
 757                 if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
 758                         printk(KERN_WARNING "sx: Sent reconfigure command, but "
 759                                         "card didn't react.\n");
 760                 }
 761         } else {
 762                 sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
 763                                 "port isn't open (%02x).\n",
 764                                 sx_read_channel_byte(port, hi_hstat));
 765         }
 766 }
 767
 768 static void sx_setsignals(struct sx_port *port, int dtr, int rts)
 769 {
 770         int t;
 771         func_enter2();
 772
 773         t = sx_read_channel_byte(port, hi_op);
 774         if (dtr >= 0)
 775                 t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
 776         if (rts >= 0)
 777                 t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
 778         sx_write_channel_byte(port, hi_op, t);
 779         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
 780
 781         func_exit();
 782 }
 783
 784 static int sx_getsignals(struct sx_port *port)
 785 {
 786         int i_stat, o_stat;
 787
 788         o_stat = sx_read_channel_byte(port, hi_op);
 789         i_stat = sx_read_channel_byte(port, hi_ip);
 790
 791         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) "
 792                         "%02x/%02x\n",
 793                         (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
 794                         port->c_dcd, sx_get_CD(port),
 795                         sx_read_channel_byte(port, hi_ip),
 796                         sx_read_channel_byte(port, hi_state));
 797
 798         return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
 799                 ((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
 800                 ((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
 801                 ((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
 802                 ((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
 803                 ((i_stat & IP_RI) ? TIOCM_RNG : 0));
 804 }
 805
 806 static void sx_set_baud(struct sx_port *port)
 807 {
 808         int t;
 809
 810         if (port->board->ta_type == MOD_SXDC) {
 811                 switch (port->gs.baud) {
 812                         /* Save some typing work... */
 813 #define e(x) case x: t = BAUD_ ## x; break
 814                         e(50);
 815                         e(75);
 816                         e(110);
 817                         e(150);
 818                         e(200);
 819                         e(300);
 820                         e(600);
 821                         e(1200);
 822                         e(1800);
 823                         e(2000);
 824                         e(2400);
 825                         e(4800);
 826                         e(7200);
 827                         e(9600);
 828                         e(14400);
 829                         e(19200);
 830                         e(28800);
 831                         e(38400);
 832                         e(56000);
 833                         e(57600);
 834                         e(64000);
 835                         e(76800);
 836                         e(115200);
 837                         e(128000);
 838                         e(150000);
 839                         e(230400);
 840                         e(256000);
 841                         e(460800);
 842                         e(921600);
 843                 case 134:
 844                         t = BAUD_134_5;
 845                         break;
 846                 case 0:
 847                         t = -1;
 848                         break;
 849                 default:
 850                         /* Can I return "invalid"? */
 851                         t = BAUD_9600;
 852                         printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
 853                                         port->gs.baud);
 854                         break;
 855                 }
 856 #undef e
 857                 if (t > 0) {
 858 /* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
 859                         sx_setsignals(port, 1, -1);
 860                         /* XXX This is not TA & MTA compatible */
 861                         sx_write_channel_byte(port, hi_csr, 0xff);
 862
 863                         sx_write_channel_byte(port, hi_txbaud, t);
 864                         sx_write_channel_byte(port, hi_rxbaud, t);
 865                 } else {
 866                         sx_setsignals(port, 0, -1);
 867                 }
 868         } else {
 869                 switch (port->gs.baud) {
 870 #define e(x) case x: t = CSR_ ## x; break
 871                         e(75);
 872                         e(150);
 873                         e(300);
 874                         e(600);
 875                         e(1200);
 876                         e(2400);
 877                         e(4800);
 878                         e(1800);
 879                         e(9600);
 880                         e(19200);
 881                         e(57600);
 882                         e(38400);
 883 /* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
 884                 case 110:
 885                         if (port->board->ta_type == MOD_TA) {
 886                                 t = CSR_110;
 887                                 break;
 888                         } else {
 889                                 t = CSR_9600;
 890                                 printk(KERN_INFO "sx: Unsupported baud rate: "
 891                                                 "%d.\n", port->gs.baud);
 892                                 break;
 893                         }
 894                 case 115200:
 895                         if (port->board->ta_type == MOD_TA) {
 896                                 t = CSR_9600;
 897                                 printk(KERN_INFO "sx: Unsupported baud rate: "
 898                                                 "%d.\n", port->gs.baud);
 899                                 break;
 900                         } else {
 901                                 t = CSR_110;
 902                                 break;
 903                         }
 904                 case 0:
 905                         t = -1;
 906                         break;
 907                 default:
 908                         t = CSR_9600;
 909                         printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
 910                                         port->gs.baud);
 911                         break;
 912                 }
 913 #undef e
 914                 if (t >= 0) {
 915                         sx_setsignals(port, 1, -1);
 916                         sx_write_channel_byte(port, hi_csr, t * 0x11);
 917                 } else {
 918                         sx_setsignals(port, 0, -1);
 919                 }
 920         }
 921 }
 922
 923 /* Simon Allen's version of this routine was 225 lines long. 85 is a lot
 924    better. -- REW */
 925
 926 static int sx_set_real_termios(void *ptr)
 927 {
 928         struct sx_port *port = ptr;
 929
 930         func_enter2();
 931
 932         if (!port->gs.port.tty)
 933                 return 0;
 934
 935         /* What is this doing here? -- REW
 936            Ha! figured it out. It is to allow you to get DTR active again
 937            if you've dropped it with stty 0. Moved to set_baud, where it
 938            belongs (next to the drop dtr if baud == 0) -- REW */
 939         /* sx_setsignals (port, 1, -1); */
 940
 941         sx_set_baud(port);
 942
 943 #define CFLAG port->gs.port.tty->termios->c_cflag
 944         sx_write_channel_byte(port, hi_mr1,
 945                         (C_PARENB(port->gs.port.tty) ? MR1_WITH : MR1_NONE) |
 946                         (C_PARODD(port->gs.port.tty) ? MR1_ODD : MR1_EVEN) |
 947                         (C_CRTSCTS(port->gs.port.tty) ? MR1_RTS_RXFLOW : 0) |
 948                         (((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
 949                         (((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
 950                         (((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
 951                         (((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
 952
 953         sx_write_channel_byte(port, hi_mr2,
 954                         (C_CRTSCTS(port->gs.port.tty) ? MR2_CTS_TXFLOW : 0) |
 955                         (C_CSTOPB(port->gs.port.tty) ? MR2_2_STOP :
 956                         MR2_1_STOP));
 957
 958         switch (CFLAG & CSIZE) {
 959         case CS8:
 960                 sx_write_channel_byte(port, hi_mask, 0xff);
 961                 break;
 962         case CS7:
 963                 sx_write_channel_byte(port, hi_mask, 0x7f);
 964                 break;
 965         case CS6:
 966                 sx_write_channel_byte(port, hi_mask, 0x3f);
 967                 break;
 968         case CS5:
 969                 sx_write_channel_byte(port, hi_mask, 0x1f);
 970                 break;
 971         default:
 972                 printk(KERN_INFO "sx: Invalid wordsize: %u\n",
 973                         (unsigned int)CFLAG & CSIZE);
 974                 break;
 975         }
 976
 977         sx_write_channel_byte(port, hi_prtcl,
 978                         (I_IXON(port->gs.port.tty) ? SP_TXEN : 0) |
 979                         (I_IXOFF(port->gs.port.tty) ? SP_RXEN : 0) |
 980                         (I_IXANY(port->gs.port.tty) ? SP_TANY : 0) | SP_DCEN);
 981
 982         sx_write_channel_byte(port, hi_break,
 983                         (I_IGNBRK(port->gs.port.tty) ? BR_IGN : 0 |
 984                         I_BRKINT(port->gs.port.tty) ? BR_INT : 0));
 985
 986         sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.port.tty));
 987         sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.port.tty));
 988         sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.port.tty));
 989         sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.port.tty));
 990
 991         sx_reconfigure_port(port);
 992
 993         /* Tell line discipline whether we will do input cooking */
 994         if (I_OTHER(port->gs.port.tty)) {
 995                 clear_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
 996         } else {
 997                 set_bit(TTY_HW_COOK_IN, &port->gs.port.tty->flags);
 998         }
 999         sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
1000                         (unsigned int)port->gs.port.tty->termios->c_iflag,
1001                         I_OTHER(port->gs.port.tty));
1002
1003 /* Tell line discipline whether we will do output cooking.
1004  * If OPOST is set and no other output flags are set then we can do output
1005  * processing.  Even if only *one* other flag in the O_OTHER group is set
1006  * we do cooking in software.
1007  */
1008         if (O_OPOST(port->gs.port.tty) && !O_OTHER(port->gs.port.tty)) {
1009                 set_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
1010         } else {
1011                 clear_bit(TTY_HW_COOK_OUT, &port->gs.port.tty->flags);
1012         }
1013         sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
1014                         (unsigned int)port->gs.port.tty->termios->c_oflag,
1015                         O_OTHER(port->gs.port.tty));
1016         /* port->c_dcd = sx_get_CD (port); */
1017         func_exit();
1018         return 0;
1019 }
1020
1021 /* ********************************************************************** *
1022  *                   the interrupt related routines                       *
1023  * ********************************************************************** */
1024
1025 /* Note:
1026    Other drivers use the macro "MIN" to calculate how much to copy.
1027    This has the disadvantage that it will evaluate parts twice. That's
1028    expensive when it's IO (and the compiler cannot optimize those away!).
1029    Moreover, I'm not sure that you're race-free.
1030
1031    I assign a value, and then only allow the value to decrease. This
1032    is always safe. This makes the code a few lines longer, and you
1033    know I'm dead against that, but I think it is required in this
1034    case.  */
1035
1036 static void sx_transmit_chars(struct sx_port *port)
1037 {
1038         int c;
1039         int tx_ip;
1040         int txroom;
1041
1042         func_enter2();
1043         sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
1044                         port, port->gs.xmit_cnt);
1045
1046         if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
1047                 return;
1048         }
1049
1050         while (1) {
1051                 c = port->gs.xmit_cnt;
1052
1053                 sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
1054                 tx_ip = sx_read_channel_byte(port, hi_txipos);
1055
1056                 /* Took me 5 minutes to deduce this formula.
1057                    Luckily it is literally in the manual in section 6.5.4.3.5 */
1058                 txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
1059                                 0xff;
1060
1061                 /* Don't copy more bytes than there is room for in the buffer */
1062                 if (c > txroom)
1063                         c = txroom;
1064                 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
1065
1066                 /* Don't copy past the end of the hardware transmit buffer */
1067                 if (c > 0x100 - tx_ip)
1068                         c = 0x100 - tx_ip;
1069
1070                 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
1071
1072                 /* Don't copy pas the end of the source buffer */
1073                 if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
1074                         c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
1075
1076                 sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
1077                                 c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
1078
1079                 /* If for one reason or another, we can't copy more data, we're
1080                    done! */
1081                 if (c == 0)
1082                         break;
1083
1084                 memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
1085                         tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
1086
1087                 /* Update the pointer in the card */
1088                 sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
1089
1090                 /* Update the kernel buffer end */
1091                 port->gs.xmit_tail = (port->gs.xmit_tail + c) &
1092                                 (SERIAL_XMIT_SIZE - 1);
1093
1094                 /* This one last. (this is essential)
1095                    It would allow others to start putting more data into the
1096                    buffer! */
1097                 port->gs.xmit_cnt -= c;
1098         }
1099
1100         if (port->gs.xmit_cnt == 0) {
1101                 sx_disable_tx_interrupts(port);
1102         }
1103
1104         if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.port.tty) {
1105                 tty_wakeup(port->gs.port.tty);
1106                 sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
1107                                 port->gs.wakeup_chars);
1108         }
1109
1110         clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
1111         func_exit();
1112 }
1113
1114 /* Note the symmetry between receiving chars and transmitting them!
1115    Note: The kernel should have implemented both a receive buffer and
1116    a transmit buffer. */
1117
1118 /* Inlined: Called only once. Remove the inline when you add another call */
1119 static inline void sx_receive_chars(struct sx_port *port)
1120 {
1121         int c;
1122         int rx_op;
1123         struct tty_struct *tty;
1124         int copied = 0;
1125         unsigned char *rp;
1126
1127         func_enter2();
1128         tty = port->gs.port.tty;
1129         while (1) {
1130                 rx_op = sx_read_channel_byte(port, hi_rxopos);
1131                 c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
1132
1133                 sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
1134
1135                 /* Don't copy past the end of the hardware receive buffer */
1136                 if (rx_op + c > 0x100)
1137                         c = 0x100 - rx_op;
1138
1139                 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1140
1141                 /* Don't copy more bytes than there is room for in the buffer */
1142
1143                 c = tty_prepare_flip_string(tty, &rp, c);
1144
1145                 sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
1146
1147                 /* If for one reason or another, we can't copy more data, we're done! */
1148                 if (c == 0)
1149                         break;
1150
1151                 sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
1152                                 "%d at %lx\n", c, read_sx_byte(port->board,
1153                                         CHAN_OFFSET(port, hi_rxbuf) + rx_op),
1154                                 CHAN_OFFSET(port, hi_rxbuf));
1155                 memcpy_fromio(rp, port->board->base +
1156                                 CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
1157
1158                 /* This one last. ( Not essential.)
1159                    It allows the card to start putting more data into the
1160                    buffer!
1161                    Update the pointer in the card */
1162                 sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
1163
1164                 copied += c;
1165         }
1166         if (copied) {
1167                 struct timeval tv;
1168
1169                 do_gettimeofday(&tv);
1170                 sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
1171                                 "chars): %d.%06d  (%d/%d)\n", port->line,
1172                                 copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
1173                                 tty->raw, tty->real_raw);
1174
1175                 /* Tell the rest of the system the news. Great news. New
1176                    characters! */
1177                 tty_flip_buffer_push(tty);
1178                 /*    tty_schedule_flip (tty); */
1179         }
1180
1181         func_exit();
1182 }
1183
1184 /* Inlined: it is called only once. Remove the inline if you add another
1185    call */
1186 static inline void sx_check_modem_signals(struct sx_port *port)
1187 {
1188         int hi_state;
1189         int c_dcd;
1190
1191         hi_state = sx_read_channel_byte(port, hi_state);
1192         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
1193                         port->c_dcd, sx_get_CD(port));
1194
1195         if (hi_state & ST_BREAK) {
1196                 hi_state &= ~ST_BREAK;
1197                 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
1198                 sx_write_channel_byte(port, hi_state, hi_state);
1199                 gs_got_break(&port->gs);
1200         }
1201         if (hi_state & ST_DCD) {
1202                 hi_state &= ~ST_DCD;
1203                 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
1204                 sx_write_channel_byte(port, hi_state, hi_state);
1205                 c_dcd = sx_get_CD(port);
1206                 sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
1207                 if (c_dcd != port->c_dcd) {
1208                         port->c_dcd = c_dcd;
1209                         if (sx_get_CD(port)) {
1210                                 /* DCD went UP */
1211                                 if ((sx_read_channel_byte(port, hi_hstat) !=
1212                                                 HS_IDLE_CLOSED) &&
1213                                                 !(port->gs.port.tty->termios->
1214                                                         c_cflag & CLOCAL)) {
1215                                         /* Are we blocking in open? */
1216                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1217                                                 "active, unblocking open\n");
1218                                         wake_up_interruptible(&port->gs.port.
1219                                                         open_wait);
1220                                 } else {
1221                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1222                                                 "raised. Ignoring.\n");
1223                                 }
1224                         } else {
1225                                 /* DCD went down! */
1226                                 if (!(port->gs.port.tty->termios->c_cflag & CLOCAL)){
1227                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1228                                                 "dropped. hanging up....\n");
1229                                         tty_hangup(port->gs.port.tty);
1230                                 } else {
1231                                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
1232                                                 "dropped. ignoring.\n");
1233                                 }
1234                         }
1235                 } else {
1236                         sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
1237                                 "DCD changed, but it didn't.\n");
1238                 }
1239         }
1240 }
1241
1242 /* This is what an interrupt routine should look like.
1243  * Small, elegant, clear.
1244  */
1245
1246 static irqreturn_t sx_interrupt(int irq, void *ptr)
1247 {
1248         struct sx_board *board = ptr;
1249         struct sx_port *port;
1250         int i;
1251
1252         func_enter();
1253         sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
1254                         board->irq);
1255
1256         /* AAargh! The order in which to do these things is essential and
1257            not trivial.
1258
1259            - Rate limit goes before "recursive". Otherwise a series of
1260            recursive calls will hang the machine in the interrupt routine.
1261
1262            - hardware twiddling goes before "recursive". Otherwise when we
1263            poll the card, and a recursive interrupt happens, we won't
1264            ack the card, so it might keep on interrupting us. (especially
1265            level sensitive interrupt systems like PCI).
1266
1267            - Rate limit goes before hardware twiddling. Otherwise we won't
1268            catch a card that has gone bonkers.
1269
1270            - The "initialized" test goes after the hardware twiddling. Otherwise
1271            the card will stick us in the interrupt routine again.
1272
1273            - The initialized test goes before recursive.
1274          */
1275
1276 #ifdef IRQ_RATE_LIMIT
1277         /* Aaargh! I'm ashamed. This costs more lines-of-code than the
1278            actual interrupt routine!. (Well, used to when I wrote that
1279            comment) */
1280         {
1281                 static int lastjif;
1282                 static int nintr = 0;
1283
1284                 if (lastjif == jiffies) {
1285                         if (++nintr > IRQ_RATE_LIMIT) {
1286                                 free_irq(board->irq, board);
1287                                 printk(KERN_ERR "sx: Too many interrupts. "
1288                                                 "Turning off interrupt %d.\n",
1289                                                 board->irq);
1290                         }
1291                 } else {
1292                         lastjif = jiffies;
1293                         nintr = 0;
1294                 }
1295         }
1296 #endif
1297
1298         if (board->irq == irq) {
1299                 /* Tell the card we've noticed the interrupt. */
1300
1301                 sx_write_board_word(board, cc_int_pending, 0);
1302                 if (IS_SX_BOARD(board)) {
1303                         write_sx_byte(board, SX_RESET_IRQ, 1);
1304                 } else if (IS_EISA_BOARD(board)) {
1305                         inb(board->eisa_base + 0xc03);
1306                         write_sx_word(board, 8, 0);
1307                 } else {
1308                         write_sx_byte(board, SI2_ISA_INTCLEAR,
1309                                         SI2_ISA_INTCLEAR_CLEAR);
1310                         write_sx_byte(board, SI2_ISA_INTCLEAR,
1311                                         SI2_ISA_INTCLEAR_SET);
1312                 }
1313         }
1314
1315         if (!sx_initialized)
1316                 return IRQ_HANDLED;
1317         if (!(board->flags & SX_BOARD_INITIALIZED))
1318                 return IRQ_HANDLED;
1319
1320         if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
1321                 printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
1322                 return IRQ_HANDLED;
1323         }
1324
1325         for (i = 0; i < board->nports; i++) {
1326                 port = &board->ports[i];
1327                 if (port->gs.port.flags & GS_ACTIVE) {
1328                         if (sx_read_channel_byte(port, hi_state)) {
1329                                 sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
1330                                                 "modem signal change?... \n",i);
1331                                 sx_check_modem_signals(port);
1332                         }
1333                         if (port->gs.xmit_cnt) {
1334                                 sx_transmit_chars(port);
1335                         }
1336                         if (!(port->gs.port.flags & SX_RX_THROTTLE)) {
1337                                 sx_receive_chars(port);
1338                         }
1339                 }
1340         }
1341
1342         clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
1343
1344         sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
1345                         board->irq);
1346         func_exit();
1347         return IRQ_HANDLED;
1348 }
1349
1350 static void sx_pollfunc(unsigned long data)
1351 {
1352         struct sx_board *board = (struct sx_board *)data;
1353
1354         func_enter();
1355
1356         sx_interrupt(0, board);
1357
1358         mod_timer(&board->timer, jiffies + sx_poll);
1359         func_exit();
1360 }
1361
1362 /* ********************************************************************** *
1363  *                Here are the routines that actually                     *
1364  *              interface with the generic_serial driver                  *
1365  * ********************************************************************** */
1366
1367 /* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
1368 /* Hmm. Ok I figured it out. You don't.  */
1369
1370 static void sx_disable_tx_interrupts(void *ptr)
1371 {
1372         struct sx_port *port = ptr;
1373         func_enter2();
1374
1375         port->gs.port.flags &= ~GS_TX_INTEN;
1376
1377         func_exit();
1378 }
1379
1380 static void sx_enable_tx_interrupts(void *ptr)
1381 {
1382         struct sx_port *port = ptr;
1383         int data_in_buffer;
1384         func_enter2();
1385
1386         /* First transmit the characters that we're supposed to */
1387         sx_transmit_chars(port);
1388
1389         /* The sx card will never interrupt us if we don't fill the buffer
1390            past 25%. So we keep considering interrupts off if that's the case. */
1391         data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
1392                           sx_read_channel_byte(port, hi_txopos)) & 0xff;
1393
1394         /* XXX Must be "HIGH_WATER" for SI card according to doc. */
1395         if (data_in_buffer < LOW_WATER)
1396                 port->gs.port.flags &= ~GS_TX_INTEN;
1397
1398         func_exit();
1399 }
1400
1401 static void sx_disable_rx_interrupts(void *ptr)
1402 {
1403         /*  struct sx_port *port = ptr; */
1404         func_enter();
1405
1406         func_exit();
1407 }
1408
1409 static void sx_enable_rx_interrupts(void *ptr)
1410 {
1411         /*  struct sx_port *port = ptr; */
1412         func_enter();
1413
1414         func_exit();
1415 }
1416
1417 /* Jeez. Isn't this simple? */
1418 static int sx_get_CD(void *ptr)
1419 {
1420         struct sx_port *port = ptr;
1421         func_enter2();
1422
1423         func_exit();
1424         return ((sx_read_channel_byte(port, hi_ip) & IP_DCD) != 0);
1425 }
1426
1427 /* Jeez. Isn't this simple? */
1428 static int sx_chars_in_buffer(void *ptr)
1429 {
1430         struct sx_port *port = ptr;
1431         func_enter2();
1432
1433         func_exit();
1434         return ((sx_read_channel_byte(port, hi_txipos) -
1435                  sx_read_channel_byte(port, hi_txopos)) & 0xff);
1436 }
1437
1438 static void sx_shutdown_port(void *ptr)
1439 {
1440         struct sx_port *port = ptr;
1441
1442         func_enter();
1443
1444         port->gs.port.flags &= ~GS_ACTIVE;
1445         if (port->gs.port.tty && (port->gs.port.tty->termios->c_cflag & HUPCL)) {
1446                 sx_setsignals(port, 0, 0);
1447                 sx_reconfigure_port(port);
1448         }
1449
1450         func_exit();
1451 }
1452
1453 /* ********************************************************************** *
1454  *                Here are the routines that actually                     *
1455  *               interface with the rest of the system                    *
1456  * ********************************************************************** */
1457
1458 static int sx_open(struct tty_struct *tty, struct file *filp)
1459 {
1460         struct sx_port *port;
1461         int retval, line;
1462         unsigned long flags;
1463
1464         func_enter();
1465
1466         if (!sx_initialized) {
1467                 return -EIO;
1468         }
1469
1470         line = tty->index;
1471         sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
1472                         "np=%d)\n", task_pid_nr(current), line, tty,
1473                         current->signal->tty, sx_nports);
1474
1475         if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
1476                 return -ENODEV;
1477
1478         port = &sx_ports[line];
1479         port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
1480                             1 -> 0 transition. */
1481
1482         sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
1483
1484         spin_lock_irqsave(&port->gs.driver_lock, flags);
1485
1486         tty->driver_data = port;
1487         port->gs.port.tty = tty;
1488         port->gs.port.count++;
1489         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1490
1491         sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
1492
1493         /*
1494          * Start up serial port
1495          */
1496         retval = gs_init_port(&port->gs);
1497         sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
1498         if (retval) {
1499                 port->gs.port.count--;
1500                 return retval;
1501         }
1502
1503         port->gs.port.flags |= GS_ACTIVE;
1504         if (port->gs.port.count <= 1)
1505                 sx_setsignals(port, 1, 1);
1506
1507 #if 0
1508         if (sx_debug & SX_DEBUG_OPEN)
1509                 my_hd(port, sizeof(*port));
1510 #else
1511         if (sx_debug & SX_DEBUG_OPEN)
1512                 my_hd_io(port->board->base + port->ch_base, sizeof(*port));
1513 #endif
1514
1515         if (port->gs.port.count <= 1) {
1516                 if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
1517                         printk(KERN_ERR "sx: Card didn't respond to LOPEN "
1518                                         "command.\n");
1519                         spin_lock_irqsave(&port->gs.driver_lock, flags);
1520                         port->gs.port.count--;
1521                         spin_unlock_irqrestore(&port->gs.driver_lock, flags);
1522                         return -EIO;
1523                 }
1524         }
1525
1526         retval = gs_block_til_ready(port, filp);
1527         sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
1528                         retval, port->gs.port.count);
1529
1530         if (retval) {
1531 /*
1532  * Don't lower gs.port.count here because sx_close() will be called later
1533  */
1534
1535                 return retval;
1536         }
1537         /* tty->low_latency = 1; */
1538
1539         port->c_dcd = sx_get_CD(port);
1540         sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
1541
1542         func_exit();
1543         return 0;
1544
1545 }
1546
1547 static void sx_close(void *ptr)
1548 {
1549         struct sx_port *port = ptr;
1550         /* Give the port 5 seconds to close down. */
1551         int to = 5 * HZ;
1552
1553         func_enter();
1554
1555         sx_setsignals(port, 0, 0);
1556         sx_reconfigure_port(port);
1557         sx_send_command(port, HS_CLOSE, 0, 0);
1558
1559         while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
1560                 if (msleep_interruptible(10))
1561                         break;
1562         if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
1563                 if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
1564                                 != 1) {
1565                         printk(KERN_ERR "sx: sent the force_close command, but "
1566                                         "card didn't react\n");
1567                 } else
1568                         sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
1569                                         "command.\n");
1570         }
1571
1572         sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
1573                         5 * HZ - to - 1, port->gs.port.count);
1574
1575         if (port->gs.port.count) {
1576                 sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
1577                                 port->gs.port.count);
1578                 /*printk("%s SETTING port count to zero: %p count: %d\n",
1579                                 __func__, port, port->gs.port.count);
1580                 port->gs.port.count = 0;*/
1581         }
1582
1583         func_exit();
1584 }
1585
1586 /* This is relatively thorough. But then again it is only 20 lines. */
1587 #define MARCHUP         for (i = min; i < max; i++)
1588 #define MARCHDOWN       for (i = max - 1; i >= min; i--)
1589 #define W0              write_sx_byte(board, i, 0x55)
1590 #define W1              write_sx_byte(board, i, 0xaa)
1591 #define R0              if (read_sx_byte(board, i) != 0x55) return 1
1592 #define R1              if (read_sx_byte(board, i) != 0xaa) return 1
1593
1594 /* This memtest takes a human-noticable time. You normally only do it
1595    once a boot, so I guess that it is worth it. */
1596 static int do_memtest(struct sx_board *board, int min, int max)
1597 {
1598         int i;
1599
1600         /* This is a marchb. Theoretically, marchb catches much more than
1601            simpler tests. In practise, the longer test just catches more
1602            intermittent errors. -- REW
1603            (For the theory behind memory testing see:
1604            Testing Semiconductor Memories by A.J. van de Goor.) */
1605         MARCHUP {
1606                 W0;
1607         }
1608         MARCHUP {
1609                 R0;
1610                 W1;
1611                 R1;
1612                 W0;
1613                 R0;
1614                 W1;
1615         }
1616         MARCHUP {
1617                 R1;
1618                 W0;
1619                 W1;
1620         }
1621         MARCHDOWN {
1622                 R1;
1623                 W0;
1624                 W1;
1625                 W0;
1626         }
1627         MARCHDOWN {
1628                 R0;
1629                 W1;
1630                 W0;
1631         }
1632
1633         return 0;
1634 }
1635
1636 #undef MARCHUP
1637 #undef MARCHDOWN
1638 #undef W0
1639 #undef W1
1640 #undef R0
1641 #undef R1
1642
1643 #define MARCHUP         for (i = min; i < max; i += 2)
1644 #define MARCHDOWN       for (i = max - 1; i >= min; i -= 2)
1645 #define W0              write_sx_word(board, i, 0x55aa)
1646 #define W1              write_sx_word(board, i, 0xaa55)
1647 #define R0              if (read_sx_word(board, i) != 0x55aa) return 1
1648 #define R1              if (read_sx_word(board, i) != 0xaa55) return 1
1649
1650 #if 0
1651 /* This memtest takes a human-noticable time. You normally only do it
1652    once a boot, so I guess that it is worth it. */
1653 static int do_memtest_w(struct sx_board *board, int min, int max)
1654 {
1655         int i;
1656
1657         MARCHUP {
1658                 W0;
1659         }
1660         MARCHUP {
1661                 R0;
1662                 W1;
1663                 R1;
1664                 W0;
1665                 R0;
1666                 W1;
1667         }
1668         MARCHUP {
1669                 R1;
1670                 W0;
1671                 W1;
1672         }
1673         MARCHDOWN {
1674                 R1;
1675                 W0;
1676                 W1;
1677                 W0;
1678         }
1679         MARCHDOWN {
1680                 R0;
1681                 W1;
1682                 W0;
1683         }
1684
1685         return 0;
1686 }
1687 #endif
1688
1689 static long sx_fw_ioctl(struct file *filp, unsigned int cmd,
1690                                                         unsigned long arg)
1691 {
1692         long rc = 0;
1693         int __user *descr = (int __user *)arg;
1694         int i;
1695         static struct sx_board *board = NULL;
1696         int nbytes, offset;
1697         unsigned long data;
1698         char *tmp;
1699
1700         func_enter();
1701
1702         if (!capable(CAP_SYS_RAWIO))
1703                 return -EPERM;
1704
1705         lock_kernel();
1706
1707         sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
1708
1709         if (!board)
1710                 board = &boards[0];
1711         if (board->flags & SX_BOARD_PRESENT) {
1712                 sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
1713                                 board->flags);
1714         } else {
1715                 sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
1716                                 board->flags);
1717                 for (i = 0; i < SX_NBOARDS; i++)
1718                         sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
1719                 sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
1720                 unlock_kernel();
1721                 return -EIO;
1722         }
1723
1724         switch (cmd) {
1725         case SXIO_SET_BOARD:
1726                 sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
1727                 rc = -EIO;
1728                 if (arg >= SX_NBOARDS)
1729                         break;
1730                 sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
1731                 if (!(boards[arg].flags & SX_BOARD_PRESENT))
1732                         break;
1733                 sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
1734                 board = &boards[arg];
1735                 rc = 0;
1736                 /* FIXME: And this does ... nothing?? */
1737                 break;
1738         case SXIO_GET_TYPE:
1739                 rc = -ENOENT;   /* If we manage to miss one, return error. */
1740                 if (IS_SX_BOARD(board))
1741                         rc = SX_TYPE_SX;
1742                 if (IS_CF_BOARD(board))
1743                         rc = SX_TYPE_CF;
1744                 if (IS_SI_BOARD(board))
1745                         rc = SX_TYPE_SI;
1746                 if (IS_SI1_BOARD(board))
1747                         rc = SX_TYPE_SI;
1748                 if (IS_EISA_BOARD(board))
1749                         rc = SX_TYPE_SI;
1750                 sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %ld\n", rc);
1751                 break;
1752         case SXIO_DO_RAMTEST:
1753                 if (sx_initialized)     /* Already initialized: better not ramtest the board.  */
1754                         return -EPERM;
1755                 if (IS_SX_BOARD(board)) {
1756                         rc = do_memtest(board, 0, 0x7000);
1757                         if (!rc)
1758                                 rc = do_memtest(board, 0, 0x7000);
1759                         /*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
1760                 } else {
1761                         rc = do_memtest(board, 0, 0x7ff8);
1762                         /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
1763                 }
1764                 sx_dprintk(SX_DEBUG_FIRMWARE,
1765                                 "returning memtest result= %ld\n", rc);
1766                 break;
1767         case SXIO_DOWNLOAD:
1768                 if (sx_initialized) {/* Already initialized */
1769                         rc = -EEXIST;
1770                         break;
1771                 }
1772                 if (!sx_reset(board)) {
1773                         rc = -EIO;
1774                         break;
1775                 }
1776                 sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
1777
1778                 tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
1779                 if (!tmp) {
1780                         rc = -ENOMEM;
1781                         break;
1782                 }
1783                 /* FIXME: check returns */
1784                 get_user(nbytes, descr++);
1785                 get_user(offset, descr++);
1786                 get_user(data, descr++);
1787                 while (nbytes && data) {
1788                         for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
1789                                 if (copy_from_user(tmp, (char __user *)data + i,
1790                                                 (i + SX_CHUNK_SIZE > nbytes) ?
1791                                                 nbytes - i : SX_CHUNK_SIZE)) {
1792                                         kfree(tmp);
1793                                         rc = -EFAULT;
1794                                         break;
1795                                 }
1796                                 memcpy_toio(board->base2 + offset + i, tmp,
1797                                                 (i + SX_CHUNK_SIZE > nbytes) ?
1798                                                 nbytes - i : SX_CHUNK_SIZE);
1799                         }
1800
1801                         get_user(nbytes, descr++);
1802                         get_user(offset, descr++);
1803                         get_user(data, descr++);
1804                 }
1805                 kfree(tmp);
1806                 sx_nports += sx_init_board(board);
1807                 rc = sx_nports;
1808                 break;
1809         case SXIO_INIT:
1810                 if (sx_initialized) {   /* Already initialized */
1811                         rc = -EEXIST;
1812                         break;
1813                 }
1814                 /* This is not allowed until all boards are initialized... */
1815                 for (i = 0; i < SX_NBOARDS; i++) {
1816                         if ((boards[i].flags & SX_BOARD_PRESENT) &&
1817                                 !(boards[i].flags & SX_BOARD_INITIALIZED)) {
1818                                 rc = -EIO;
1819                                 break;
1820                         }
1821                 }
1822                 for (i = 0; i < SX_NBOARDS; i++)
1823                         if (!(boards[i].flags & SX_BOARD_PRESENT))
1824                                 break;
1825
1826                 sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
1827                                 "%d channels, first board: %d ports\n",
1828                                 i, sx_nports, boards[0].nports);
1829                 rc = sx_init_portstructs(i, sx_nports);
1830                 sx_init_drivers();
1831                 if (rc >= 0)
1832                         sx_initialized++;
1833                 break;
1834         case SXIO_SETDEBUG:
1835                 sx_debug = arg;
1836                 break;
1837         case SXIO_GETDEBUG:
1838                 rc = sx_debug;
1839                 break;
1840         case SXIO_GETGSDEBUG:
1841         case SXIO_SETGSDEBUG:
1842                 rc = -EINVAL;
1843                 break;
1844         case SXIO_GETNPORTS:
1845                 rc = sx_nports;
1846                 break;
1847         default:
1848                 rc = -ENOTTY;
1849                 break;
1850         }
1851         unlock_kernel();
1852         func_exit();
1853         return rc;
1854 }
1855
1856 static int sx_break(struct tty_struct *tty, int flag)
1857 {
1858         struct sx_port *port = tty->driver_data;
1859         int rv;
1860
1861         func_enter();
1862         lock_kernel();
1863
1864         if (flag)
1865                 rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1866         else
1867                 rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1868         if (rv != 1)
1869                 printk(KERN_ERR "sx: couldn't send break (%x).\n",
1870                         read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
1871         unlock_kernel();
1872         func_exit();
1873         return 0;
1874 }
1875
1876 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1877 {
1878         struct sx_port *port = tty->driver_data;
1879         return sx_getsignals(port);
1880 }
1881
1882 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1883                 unsigned int set, unsigned int clear)
1884 {
1885         struct sx_port *port = tty->driver_data;
1886         int rts = -1, dtr = -1;
1887
1888         if (set & TIOCM_RTS)
1889                 rts = 1;
1890         if (set & TIOCM_DTR)
1891                 dtr = 1;
1892         if (clear & TIOCM_RTS)
1893                 rts = 0;
1894         if (clear & TIOCM_DTR)
1895                 dtr = 0;
1896
1897         sx_setsignals(port, dtr, rts);
1898         sx_reconfigure_port(port);
1899         return 0;
1900 }
1901
1902 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1903                 unsigned int cmd, unsigned long arg)
1904 {
1905         int rc;
1906         struct sx_port *port = tty->driver_data;
1907         void __user *argp = (void __user *)arg;
1908
1909         /* func_enter2(); */
1910
1911         rc = 0;
1912         lock_kernel();
1913         switch (cmd) {
1914         case TIOCGSERIAL:
1915                 rc = gs_getserial(&port->gs, argp);
1916                 break;
1917         case TIOCSSERIAL:
1918                 rc = gs_setserial(&port->gs, argp);
1919                 break;
1920         default:
1921                 rc = -ENOIOCTLCMD;
1922                 break;
1923         }
1924         unlock_kernel();
1925
1926         /* func_exit(); */
1927         return rc;
1928 }
1929
1930 /* The throttle/unthrottle scheme for the Specialix card is different
1931  * from other drivers and deserves some explanation.
1932  * The Specialix hardware takes care of XON/XOFF
1933  * and CTS/RTS flow control itself.  This means that all we have to
1934  * do when signalled by the upper tty layer to throttle/unthrottle is
1935  * to make a note of it here.  When we come to read characters from the
1936  * rx buffers on the card (sx_receive_chars()) we look to see if the
1937  * upper layer can accept more (as noted here in sx_rx_throt[]).
1938  * If it can't we simply don't remove chars from the cards buffer.
1939  * When the tty layer can accept chars, we again note that here and when
1940  * sx_receive_chars() is called it will remove them from the cards buffer.
1941  * The card will notice that a ports buffer has drained below some low
1942  * water mark and will unflow control the line itself, using whatever
1943  * flow control scheme is in use for that port. -- Simon Allen
1944  */
1945
1946 static void sx_throttle(struct tty_struct *tty)
1947 {
1948         struct sx_port *port = (struct sx_port *)tty->driver_data;
1949
1950         func_enter2();
1951         /* If the port is using any type of input flow
1952          * control then throttle the port.
1953          */
1954         if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
1955                 port->gs.port.flags |= SX_RX_THROTTLE;
1956         }
1957         func_exit();
1958 }
1959
1960 static void sx_unthrottle(struct tty_struct *tty)
1961 {
1962         struct sx_port *port = (struct sx_port *)tty->driver_data;
1963
1964         func_enter2();
1965         /* Always unthrottle even if flow control is not enabled on
1966          * this port in case we disabled flow control while the port
1967          * was throttled
1968          */
1969         port->gs.port.flags &= ~SX_RX_THROTTLE;
1970         func_exit();
1971         return;
1972 }
1973
1974 /* ********************************************************************** *
1975  *                    Here are the initialization routines.               *
1976  * ********************************************************************** */
1977
1978 static int sx_init_board(struct sx_board *board)
1979 {
1980         int addr;
1981         int chans;
1982         int type;
1983
1984         func_enter();
1985
1986         /* This is preceded by downloading the download code. */
1987
1988         board->flags |= SX_BOARD_INITIALIZED;
1989
1990         if (read_sx_byte(board, 0))
1991                 /* CF boards may need this. */
1992                 write_sx_byte(board, 0, 0);
1993
1994         /* This resets the processor again, to make sure it didn't do any
1995            foolish things while we were downloading the image */
1996         if (!sx_reset(board))
1997                 return 0;
1998
1999         sx_start_board(board);
2000         udelay(10);
2001         if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
2002                 printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
2003                 return 0;
2004         }
2005
2006         /* Ok. So now the processor on the card is running. It gathered
2007            some info for us... */
2008         sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
2009         if (sx_debug & SX_DEBUG_INIT)
2010                 my_hd_io(board->base, 0x10);
2011         sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
2012         if (sx_debug & SX_DEBUG_INIT)
2013                 my_hd_io(board->base + 0x80, 0x30);
2014
2015         sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2016                         "V%x.%02x,\n",
2017                         read_sx_byte(board, 0), read_sx_byte(board, 1),
2018                         read_sx_byte(board, 5), read_sx_byte(board, 4));
2019
2020         if (read_sx_byte(board, 0) == 0xff) {
2021                 printk(KERN_INFO "sx: No modules found. Sorry.\n");
2022                 board->nports = 0;
2023                 return 0;
2024         }
2025
2026         chans = 0;
2027
2028         if (IS_SX_BOARD(board)) {
2029                 sx_write_board_word(board, cc_int_count, sx_maxints);
2030         } else {
2031                 if (sx_maxints)
2032                         sx_write_board_word(board, cc_int_count,
2033                                         SI_PROCESSOR_CLOCK / 8 / sx_maxints);
2034         }
2035
2036         /* grab the first module type... */
2037         /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2038         board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2039                                 mc_chip));
2040
2041         /* XXX byteorder */
2042         for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2043                 type = sx_read_module_byte(board, addr, mc_chip);
2044                 sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2045                                 addr, read_sx_byte(board, addr + 2));
2046
2047                 chans += sx_read_module_byte(board, addr, mc_type);
2048
2049                 sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2050                                 "panels\n",
2051                                 mod_type_s(type),
2052                                 pan_type_s(sx_read_module_byte(board, addr,
2053                                                 mc_mods) & 0xf),
2054                                 pan_type_s(sx_read_module_byte(board, addr,
2055                                                 mc_mods) >> 4));
2056
2057                 sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2058                         "version: %x\n",
2059                         sx_read_module_byte(board, addr, mc_rev1),
2060                         sx_read_module_byte(board, addr, mc_rev2),
2061                         sx_read_module_byte(board, addr, mc_mtaasic_rev));
2062
2063                 /* The following combinations are illegal: It should theoretically
2064                    work, but timing problems make the bus HANG. */
2065
2066                 if (mod_compat_type(type) != board->ta_type) {
2067                         printk(KERN_ERR "sx: This is an invalid "
2068                                 "configuration.\nDon't mix TA/MTA/SXDC on the "
2069                                 "same hostadapter.\n");
2070                         chans = 0;
2071                         break;
2072                 }
2073                 if ((IS_EISA_BOARD(board) ||
2074                                 IS_SI_BOARD(board)) &&
2075                                 (mod_compat_type(type) == 4)) {
2076                         printk(KERN_ERR "sx: This is an invalid "
2077                                 "configuration.\nDon't use SXDCs on an SI/XIO "
2078                                 "adapter.\n");
2079                         chans = 0;
2080                         break;
2081                 }
2082 #if 0                           /* Problem fixed: firmware 3.05 */
2083                 if (IS_SX_BOARD(board) && (type == TA8)) {
2084                         /* There are some issues with the firmware and the DCD/RTS
2085                            lines. It might work if you tie them together or something.
2086                            It might also work if you get a newer sx_firmware.   Therefore
2087                            this is just a warning. */
2088                         printk(KERN_WARNING
2089                                "sx: The SX host doesn't work too well "
2090                                "with the TA8 adapters.\nSpecialix is working on it.\n");
2091                 }
2092 #endif
2093         }
2094
2095         if (chans) {
2096                 if (board->irq > 0) {
2097                         /* fixed irq, probably PCI */
2098                         if (sx_irqmask & (1 << board->irq)) {   /* may we use this irq? */
2099                                 if (request_irq(board->irq, sx_interrupt,
2100                                                 IRQF_SHARED | IRQF_DISABLED,
2101                                                 "sx", board)) {
2102                                         printk(KERN_ERR "sx: Cannot allocate "
2103                                                 "irq %d.\n", board->irq);
2104                                         board->irq = 0;
2105                                 }
2106                         } else
2107                                 board->irq = 0;
2108                 } else if (board->irq < 0 && sx_irqmask) {
2109                         /* auto-allocate irq */
2110                         int irqnr;
2111                         int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2112                                         SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2113                         for (irqnr = 15; irqnr > 0; irqnr--)
2114                                 if (irqmask & (1 << irqnr))
2115                                         if (!request_irq(irqnr, sx_interrupt,
2116                                                 IRQF_SHARED | IRQF_DISABLED,
2117                                                 "sx", board))
2118                                                 break;
2119                         if (!irqnr)
2120                                 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2121                         board->irq = irqnr;
2122                 } else
2123                         board->irq = 0;
2124
2125                 if (board->irq) {
2126                         /* Found a valid interrupt, start up interrupts! */
2127                         sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2128                                         board->irq);
2129                         sx_start_interrupts(board);
2130                         board->poll = sx_slowpoll;
2131                         board->flags |= SX_IRQ_ALLOCATED;
2132                 } else {
2133                         /* no irq: setup board for polled operation */
2134                         board->poll = sx_poll;
2135                         sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2136                                         board->poll);
2137                 }
2138
2139                 /* The timer should be initialized anyway: That way we can
2140                    safely del_timer it when the module is unloaded. */
2141                 setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
2142
2143                 if (board->poll)
2144                         mod_timer(&board->timer, jiffies + board->poll);
2145         } else {
2146                 board->irq = 0;
2147         }
2148
2149         board->nports = chans;
2150         sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
2151
2152         func_exit();
2153         return chans;
2154 }
2155
2156 static void __devinit printheader(void)
2157 {
2158         static int header_printed;
2159
2160         if (!header_printed) {
2161                 printk(KERN_INFO "Specialix SX driver "
2162                         "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2163                 printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
2164                 header_printed = 1;
2165         }
2166 }
2167
2168 static int __devinit probe_sx(struct sx_board *board)
2169 {
2170         struct vpd_prom vpdp;
2171         char *p;
2172         int i;
2173
2174         func_enter();
2175
2176         if (!IS_CF_BOARD(board)) {
2177                 sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2178                                 board->base + SX_VPD_ROM);
2179
2180                 if (sx_debug & SX_DEBUG_PROBE)
2181                         my_hd_io(board->base + SX_VPD_ROM, 0x40);
2182
2183                 p = (char *)&vpdp;
2184                 for (i = 0; i < sizeof(struct vpd_prom); i++)
2185                         *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
2186
2187                 if (sx_debug & SX_DEBUG_PROBE)
2188                         my_hd(&vpdp, 0x20);
2189
2190                 sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
2191
2192                 if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2193                         sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2194                                         "'%s'\n", vpdp.identifier);
2195                         return 0;
2196                 }
2197         }
2198
2199         printheader();
2200
2201         if (!IS_CF_BOARD(board)) {
2202                 printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2203                         board->hw_base);
2204                 printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2205                                 "uniq ID:%08x, ",
2206                                 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2207                 printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
2208
2209                 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2210                                 SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2211                                 SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2212                         /* This might be a bit harsh. This was the primary
2213                            reason the SX/ISA card didn't work at first... */
2214                         printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2215                                         "card. Sorry: giving up.\n");
2216                         return (0);
2217                 }
2218
2219                 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2220                                 SX_ISA_UNIQUEID1) {
2221                         if (((unsigned long)board->hw_base) & 0x8000) {
2222                                 printk(KERN_WARNING "sx: Warning: There may be "
2223                                         "hardware problems with the card at "
2224                                         "%lx.\n", board->hw_base);
2225                                 printk(KERN_WARNING "sx: Read sx.txt for more "
2226                                                 "info.\n");
2227                         }
2228                 }
2229         }
2230
2231         board->nports = -1;
2232
2233         /* This resets the processor, and keeps it off the bus. */
2234         if (!sx_reset(board))
2235                 return 0;
2236         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2237
2238         func_exit();
2239         return 1;
2240 }
2241
2242 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2243
2244 /* Specialix probes for this card at 32k increments from 640k to 16M.
2245    I consider machines with less than 16M unlikely nowadays, so I'm
2246    not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2247    card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2248    0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2249
2250 static int __devinit probe_si(struct sx_board *board)
2251 {
2252         int i;
2253
2254         func_enter();
2255         sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2256                 "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
2257
2258         if (sx_debug & SX_DEBUG_PROBE)
2259                 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2260
2261         if (!IS_EISA_BOARD(board)) {
2262                 if (IS_SI1_BOARD(board)) {
2263                         for (i = 0; i < 8; i++) {
2264                                 write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2265                         }
2266                 }
2267                 for (i = 0; i < 8; i++) {
2268                         if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2269                                         != i) {
2270                                 func_exit();
2271                                 return 0;
2272                         }
2273                 }
2274         }
2275
2276         /* Now we're pretty much convinced that there is an SI board here,
2277            but to prevent trouble, we'd better double check that we don't
2278            have an SI1 board when we're probing for an SI2 board.... */
2279
2280         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2281         if (IS_SI1_BOARD(board)) {
2282                 /* This should be an SI1 board, which has this
2283                    location writable... */
2284                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2285                         func_exit();
2286                         return 0;
2287                 }
2288         } else {
2289                 /* This should be an SI2 board, which has the bottom
2290                    3 bits non-writable... */
2291                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2292                         func_exit();
2293                         return 0;
2294                 }
2295         }
2296
2297         /* Now we're pretty much convinced that there is an SI board here,
2298            but to prevent trouble, we'd better double check that we don't
2299            have an SI1 board when we're probing for an SI2 board.... */
2300
2301         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2302         if (IS_SI1_BOARD(board)) {
2303                 /* This should be an SI1 board, which has this
2304                    location writable... */
2305                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2306                         func_exit();
2307                         return 0;
2308                 }
2309         } else {
2310                 /* This should be an SI2 board, which has the bottom
2311                    3 bits non-writable... */
2312                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2313                         func_exit();
2314                         return 0;
2315                 }
2316         }
2317
2318         printheader();
2319
2320         printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2321         /* Compared to the SX boards, it is a complete guess as to what
2322            this card is up to... */
2323
2324         board->nports = -1;
2325
2326         /* This resets the processor, and keeps it off the bus. */
2327         if (!sx_reset(board))
2328                 return 0;
2329         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2330
2331         func_exit();
2332         return 1;
2333 }
2334 #endif
2335
2336 static const struct tty_operations sx_ops = {
2337         .break_ctl = sx_break,
2338         .open = sx_open,
2339         .close = gs_close,
2340         .write = gs_write,
2341         .put_char = gs_put_char,
2342         .flush_chars = gs_flush_chars,
2343         .write_room = gs_write_room,
2344         .chars_in_buffer = gs_chars_in_buffer,
2345         .flush_buffer = gs_flush_buffer,
2346         .ioctl = sx_ioctl,
2347         .throttle = sx_throttle,
2348         .unthrottle = sx_unthrottle,
2349         .set_termios = gs_set_termios,
2350         .stop = gs_stop,
2351         .start = gs_start,
2352         .hangup = gs_hangup,
2353         .tiocmget = sx_tiocmget,
2354         .tiocmset = sx_tiocmset,
2355 };
2356
2357 static int sx_init_drivers(void)
2358 {
2359         int error;
2360
2361         func_enter();
2362
2363         sx_driver = alloc_tty_driver(sx_nports);
2364         if (!sx_driver)
2365                 return 1;
2366         sx_driver->owner = THIS_MODULE;
2367         sx_driver->driver_name = "specialix_sx";
2368         sx_driver->name = "ttyX";
2369         sx_driver->major = SX_NORMAL_MAJOR;
2370         sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2371         sx_driver->subtype = SERIAL_TYPE_NORMAL;
2372         sx_driver->init_termios = tty_std_termios;
2373         sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2374         sx_driver->init_termios.c_ispeed = 9600;
2375         sx_driver->init_termios.c_ospeed = 9600;
2376         sx_driver->flags = TTY_DRIVER_REAL_RAW;
2377         tty_set_operations(sx_driver, &sx_ops);
2378
2379         if ((error = tty_register_driver(sx_driver))) {
2380                 put_tty_driver(sx_driver);
2381                 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2382                         error);
2383                 return 1;
2384         }
2385         func_exit();
2386         return 0;
2387 }
2388
2389 static int sx_init_portstructs(int nboards, int nports)
2390 {
2391         struct sx_board *board;
2392         struct sx_port *port;
2393         int i, j;
2394         int addr, chans;
2395         int portno;
2396
2397         func_enter();
2398
2399         /* Many drivers statically allocate the maximum number of ports
2400            There is no reason not to allocate them dynamically.
2401            Is there? -- REW */
2402         sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2403         if (!sx_ports)
2404                 return -ENOMEM;
2405
2406         port = sx_ports;
2407         for (i = 0; i < nboards; i++) {
2408                 board = &boards[i];
2409                 board->ports = port;
2410                 for (j = 0; j < boards[i].nports; j++) {
2411                         sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
2412                         tty_port_init(&port->gs.port);
2413                         port->gs.magic = SX_MAGIC;
2414                         port->gs.close_delay = HZ / 2;
2415                         port->gs.closing_wait = 30 * HZ;
2416                         port->board = board;
2417                         port->gs.rd = &sx_real_driver;
2418 #ifdef NEW_WRITE_LOCKING
2419                         port->gs.port_write_mutex = MUTEX;
2420 #endif
2421                         spin_lock_init(&port->gs.driver_lock);
2422                         /*
2423                          * Initializing wait queue
2424                          */
2425                         port++;
2426                 }
2427         }
2428
2429         port = sx_ports;
2430         portno = 0;
2431         for (i = 0; i < nboards; i++) {
2432                 board = &boards[i];
2433                 board->port_base = portno;
2434                 /* Possibly the configuration was rejected. */
2435                 sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2436                                 board->nports);
2437                 if (board->nports <= 0)
2438                         continue;
2439                 /* XXX byteorder ?? */
2440                 for (addr = 0x80; addr != 0;
2441                                 addr = read_sx_word(board, addr) & 0x7fff) {
2442                         chans = sx_read_module_byte(board, addr, mc_type);
2443                         sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2444                                         "channels\n", addr, chans);
2445                         sx_dprintk(SX_DEBUG_PROBE, "Port at");
2446                         for (j = 0; j < chans; j++) {
2447                                 /* The "sx-way" is the way it SHOULD be done.
2448                                    That way in the future, the firmware may for
2449                                    example pack the structures a bit more
2450                                    efficient. Neil tells me it isn't going to
2451                                    happen anytime soon though. */
2452                                 if (IS_SX_BOARD(board))
2453                                         port->ch_base = sx_read_module_word(
2454                                                         board, addr + j * 2,
2455                                                         mc_chan_pointer);
2456                                 else
2457                                         port->ch_base = addr + 0x100 + 0x300 *j;
2458
2459                                 sx_dprintk(SX_DEBUG_PROBE, " %x",
2460                                                 port->ch_base);
2461                                 port->line = portno++;
2462                                 port++;
2463                         }
2464                         sx_dprintk(SX_DEBUG_PROBE, "\n");
2465                 }
2466                 /* This has to be done earlier. */
2467                 /* board->flags |= SX_BOARD_INITIALIZED; */
2468         }
2469
2470         func_exit();
2471         return 0;
2472 }
2473
2474 static unsigned int sx_find_free_board(void)
2475 {
2476         unsigned int i;
2477
2478         for (i = 0; i < SX_NBOARDS; i++)
2479                 if (!(boards[i].flags & SX_BOARD_PRESENT))
2480                         break;
2481
2482         return i;
2483 }
2484
2485 static void __exit sx_release_drivers(void)
2486 {
2487         func_enter();
2488         tty_unregister_driver(sx_driver);
2489         put_tty_driver(sx_driver);
2490         func_exit();
2491 }
2492
2493 static void __devexit sx_remove_card(struct sx_board *board,
2494                 struct pci_dev *pdev)
2495 {
2496         if (board->flags & SX_BOARD_INITIALIZED) {
2497                 /* The board should stop messing with us. (actually I mean the
2498                    interrupt) */
2499                 sx_reset(board);
2500                 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2501                         free_irq(board->irq, board);
2502
2503                 /* It is safe/allowed to del_timer a non-active timer */
2504                 del_timer(&board->timer);
2505                 if (pdev) {
2506 #ifdef CONFIG_PCI
2507                         iounmap(board->base2);
2508                         pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
2509 #endif
2510                 } else {
2511                         iounmap(board->base);
2512                         release_region(board->hw_base, board->hw_len);
2513                 }
2514
2515                 board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
2516         }
2517 }
2518
2519 #ifdef CONFIG_EISA
2520
2521 static int __devinit sx_eisa_probe(struct device *dev)
2522 {
2523         struct eisa_device *edev = to_eisa_device(dev);
2524         struct sx_board *board;
2525         unsigned long eisa_slot = edev->base_addr;
2526         unsigned int i;
2527         int retval = -EIO;
2528
2529         mutex_lock(&sx_boards_lock);
2530         i = sx_find_free_board();
2531         if (i == SX_NBOARDS) {
2532                 mutex_unlock(&sx_boards_lock);
2533                 goto err;
2534         }
2535         board = &boards[i];
2536         board->flags |= SX_BOARD_PRESENT;
2537         mutex_unlock(&sx_boards_lock);
2538
2539         dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2540                  "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2541                  eisa_slot >> 12,
2542                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2543                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
2544
2545         board->eisa_base = eisa_slot;
2546         board->flags &= ~SX_BOARD_TYPE;
2547         board->flags |= SI_EISA_BOARD;
2548
2549         board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
2550                           inb(eisa_slot + 0xc00)) << 16;
2551         board->hw_len = SI2_EISA_WINDOW_LEN;
2552         if (!request_region(board->hw_base, board->hw_len, "sx")) {
2553                 dev_err(dev, "can't request region\n");
2554                 goto err_flag;
2555         }
2556         board->base2 =
2557         board->base = ioremap_nocache(board->hw_base, SI2_EISA_WINDOW_LEN);
2558         if (!board->base) {
2559                 dev_err(dev, "can't remap memory\n");
2560                 goto err_reg;
2561         }
2562
2563         sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2564         sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2565         board->irq = inb(eisa_slot + 0xc02) >> 4;
2566         sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2567
2568         if (!probe_si(board))
2569                 goto err_unmap;
2570
2571         dev_set_drvdata(dev, board);
2572
2573         return 0;
2574 err_unmap:
2575         iounmap(board->base);
2576 err_reg:
2577         release_region(board->hw_base, board->hw_len);
2578 err_flag:
2579         board->flags &= ~SX_BOARD_PRESENT;
2580 err:
2581         return retval;
2582 }
2583
2584 static int __devexit sx_eisa_remove(struct device *dev)
2585 {
2586         struct sx_board *board = dev_get_drvdata(dev);
2587
2588         sx_remove_card(board, NULL);
2589
2590         return 0;
2591 }
2592
2593 static struct eisa_device_id sx_eisa_tbl[] = {
2594         { "SLX" },
2595         { "" }
2596 };
2597
2598 MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2599
2600 static struct eisa_driver sx_eisadriver = {
2601         .id_table = sx_eisa_tbl,
2602         .driver = {
2603                 .name = "sx",
2604                 .probe = sx_eisa_probe,
2605                 .remove = __devexit_p(sx_eisa_remove),
2606         }
2607 };
2608
2609 #endif
2610
2611 #ifdef CONFIG_PCI
2612  /********************************************************
2613  * Setting bit 17 in the CNTRL register of the PLX 9050  *
2614  * chip forces a retry on writes while a read is pending.*
2615  * This is to prevent the card locking up on Intel Xeon  *
2616  * multiprocessor systems with the NX chipset.    -- NV  *
2617  ********************************************************/
2618
2619 /* Newer cards are produced with this bit set from the configuration
2620    EEprom.  As the bit is read/write for the CPU, we can fix it here,
2621    if we detect that it isn't set correctly. -- REW */
2622
2623 static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2624 {
2625         unsigned int hwbase;
2626         void __iomem *rebase;
2627         unsigned int t;
2628
2629 #define CNTRL_REG_OFFSET        0x50
2630 #define CNTRL_REG_GOODVALUE     0x18260000
2631
2632         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2633         hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2634         rebase = ioremap_nocache(hwbase, 0x80);
2635         t = readl(rebase + CNTRL_REG_OFFSET);
2636         if (t != CNTRL_REG_GOODVALUE) {
2637                 printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2638                         "%08x\n", t, CNTRL_REG_GOODVALUE);
2639                 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2640         }
2641         iounmap(rebase);
2642 }
2643 #endif
2644
2645 static int __devinit sx_pci_probe(struct pci_dev *pdev,
2646                                   const struct pci_device_id *ent)
2647 {
2648 #ifdef CONFIG_PCI
2649         struct sx_board *board;
2650         unsigned int i, reg;
2651         int retval = -EIO;
2652
2653         mutex_lock(&sx_boards_lock);
2654         i = sx_find_free_board();
2655         if (i == SX_NBOARDS) {
2656                 mutex_unlock(&sx_boards_lock);
2657                 goto err;
2658         }
2659         board = &boards[i];
2660         board->flags |= SX_BOARD_PRESENT;
2661         mutex_unlock(&sx_boards_lock);
2662
2663         retval = pci_enable_device(pdev);
2664         if (retval)
2665                 goto err_flag;
2666
2667         board->flags &= ~SX_BOARD_TYPE;
2668         board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2669                 SX_CFPCI_BOARD;
2670
2671         /* CF boards use base address 3.... */
2672         reg = IS_CF_BOARD(board) ? 3 : 2;
2673         retval = pci_request_region(pdev, reg, "sx");
2674         if (retval) {
2675                 dev_err(&pdev->dev, "can't request region\n");
2676                 goto err_flag;
2677         }
2678         board->hw_base = pci_resource_start(pdev, reg);
2679         board->base2 =
2680         board->base = ioremap_nocache(board->hw_base, WINDOW_LEN(board));
2681         if (!board->base) {
2682                 dev_err(&pdev->dev, "ioremap failed\n");
2683                 goto err_reg;
2684         }
2685
2686         /* Most of the stuff on the CF board is offset by 0x18000 ....  */
2687         if (IS_CF_BOARD(board))
2688                 board->base += 0x18000;
2689
2690         board->irq = pdev->irq;
2691
2692         dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
2693                  board->irq, board->flags);
2694
2695         if (!probe_sx(board)) {
2696                 retval = -EIO;
2697                 goto err_unmap;
2698         }
2699
2700         fix_sx_pci(pdev, board);
2701
2702         pci_set_drvdata(pdev, board);
2703
2704         return 0;
2705 err_unmap:
2706         iounmap(board->base2);
2707 err_reg:
2708         pci_release_region(pdev, reg);
2709 err_flag:
2710         board->flags &= ~SX_BOARD_PRESENT;
2711 err:
2712         return retval;
2713 #else
2714         return -ENODEV;
2715 #endif
2716 }
2717
2718 static void __devexit sx_pci_remove(struct pci_dev *pdev)
2719 {
2720         struct sx_board *board = pci_get_drvdata(pdev);
2721
2722         sx_remove_card(board, pdev);
2723 }
2724
2725 /* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2726    its because the standard requires it. So check for SUBVENDOR_ID. */
2727 static struct pci_device_id sx_pci_tbl[] = {
2728         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2729                 .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
2730         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2731                 .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
2732         { 0 }
2733 };
2734
2735 MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2736
2737 static struct pci_driver sx_pcidriver = {
2738         .name = "sx",
2739         .id_table = sx_pci_tbl,
2740         .probe = sx_pci_probe,
2741         .remove = __devexit_p(sx_pci_remove)
2742 };
2743
2744 static int __init sx_init(void)
2745 {
2746 #ifdef CONFIG_EISA
2747         int retval1;
2748 #endif
2749 #ifdef CONFIG_ISA
2750         struct sx_board *board;
2751         unsigned int i;
2752 #endif
2753         unsigned int found = 0;
2754         int retval;
2755
2756         func_enter();
2757         sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2758                         sx_debug);
2759         if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2760                 printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2761                                 "value. Assuming -1.\n(%p)\n", &sx_debug);
2762                 sx_debug = -1;
2763         }
2764
2765         if (misc_register(&sx_fw_device) < 0) {
2766                 printk(KERN_ERR "SX: Unable to register firmware loader "
2767                                 "driver.\n");
2768                 return -EIO;
2769         }
2770 #ifdef CONFIG_ISA
2771         for (i = 0; i < NR_SX_ADDRS; i++) {
2772                 board = &boards[found];
2773                 board->hw_base = sx_probe_addrs[i];
2774                 board->hw_len = SX_WINDOW_LEN;
2775                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2776                         continue;
2777                 board->base2 =
2778                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2779                 if (!board->base)
2780                         goto err_sx_reg;
2781                 board->flags &= ~SX_BOARD_TYPE;
2782                 board->flags |= SX_ISA_BOARD;
2783                 board->irq = sx_irqmask ? -1 : 0;
2784
2785                 if (probe_sx(board)) {
2786                         board->flags |= SX_BOARD_PRESENT;
2787                         found++;
2788                 } else {
2789                         iounmap(board->base);
2790 err_sx_reg:
2791                         release_region(board->hw_base, board->hw_len);
2792                 }
2793         }
2794
2795         for (i = 0; i < NR_SI_ADDRS; i++) {
2796                 board = &boards[found];
2797                 board->hw_base = si_probe_addrs[i];
2798                 board->hw_len = SI2_ISA_WINDOW_LEN;
2799                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2800                         continue;
2801                 board->base2 =
2802                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2803                 if (!board->base)
2804                         goto err_si_reg;
2805                 board->flags &= ~SX_BOARD_TYPE;
2806                 board->flags |= SI_ISA_BOARD;
2807                 board->irq = sx_irqmask ? -1 : 0;
2808
2809                 if (probe_si(board)) {
2810                         board->flags |= SX_BOARD_PRESENT;
2811                         found++;
2812                 } else {
2813                         iounmap(board->base);
2814 err_si_reg:
2815                         release_region(board->hw_base, board->hw_len);
2816                 }
2817         }
2818         for (i = 0; i < NR_SI1_ADDRS; i++) {
2819                 board = &boards[found];
2820                 board->hw_base = si1_probe_addrs[i];
2821                 board->hw_len = SI1_ISA_WINDOW_LEN;
2822                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2823                         continue;
2824                 board->base2 =
2825                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2826                 if (!board->base)
2827                         goto err_si1_reg;
2828                 board->flags &= ~SX_BOARD_TYPE;
2829                 board->flags |= SI1_ISA_BOARD;
2830                 board->irq = sx_irqmask ? -1 : 0;
2831
2832                 if (probe_si(board)) {
2833                         board->flags |= SX_BOARD_PRESENT;
2834                         found++;
2835                 } else {
2836                         iounmap(board->base);
2837 err_si1_reg:
2838                         release_region(board->hw_base, board->hw_len);
2839                 }
2840         }
2841 #endif
2842 #ifdef CONFIG_EISA
2843         retval1 = eisa_driver_register(&sx_eisadriver);
2844 #endif
2845         retval = pci_register_driver(&sx_pcidriver);
2846
2847         if (found) {
2848                 printk(KERN_INFO "sx: total of %d boards detected.\n", found);
2849                 retval = 0;
2850         } else if (retval) {
2851 #ifdef CONFIG_EISA
2852                 retval = retval1;
2853                 if (retval1)
2854 #endif
2855                         misc_deregister(&sx_fw_device);
2856         }
2857
2858         func_exit();
2859         return retval;
2860 }
2861
2862 static void __exit sx_exit(void)
2863 {
2864         int i;
2865
2866         func_enter();
2867 #ifdef CONFIG_EISA
2868         eisa_driver_unregister(&sx_eisadriver);
2869 #endif
2870         pci_unregister_driver(&sx_pcidriver);
2871
2872         for (i = 0; i < SX_NBOARDS; i++)
2873                 sx_remove_card(&boards[i], NULL);
2874
2875         if (misc_deregister(&sx_fw_device) < 0) {
2876                 printk(KERN_INFO "sx: couldn't deregister firmware loader "
2877                                 "device\n");
2878         }
2879         sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2880                         sx_initialized);
2881         if (sx_initialized)
2882                 sx_release_drivers();
2883
2884         kfree(sx_ports);
2885         func_exit();
2886 }
2887
2888 module_init(sx_init);
2889 module_exit(sx_exit);