drivers/char/sx.c

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