err.no Git - linux-2.6/blob - 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",__func__)
 388 #define func_exit()     sx_dprintk(SX_DEBUG_FLOW, "sx: exit  %s\n",__func__)
 389
 390 #define func_enter2()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
 391                                 __func__, 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                                 __func__, 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         lock_kernel();
1848
1849         if (flag)
1850                 rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
1851         else
1852                 rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
1853         if (rv != 1)
1854                 printk(KERN_ERR "sx: couldn't send break (%x).\n",
1855                         read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
1856         unlock_kernel();
1857         func_exit();
1858 }
1859
1860 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
1861 {
1862         struct sx_port *port = tty->driver_data;
1863         return sx_getsignals(port);
1864 }
1865
1866 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
1867                 unsigned int set, unsigned int clear)
1868 {
1869         struct sx_port *port = tty->driver_data;
1870         int rts = -1, dtr = -1;
1871
1872         if (set & TIOCM_RTS)
1873                 rts = 1;
1874         if (set & TIOCM_DTR)
1875                 dtr = 1;
1876         if (clear & TIOCM_RTS)
1877                 rts = 0;
1878         if (clear & TIOCM_DTR)
1879                 dtr = 0;
1880
1881         sx_setsignals(port, dtr, rts);
1882         sx_reconfigure_port(port);
1883         return 0;
1884 }
1885
1886 static int sx_ioctl(struct tty_struct *tty, struct file *filp,
1887                 unsigned int cmd, unsigned long arg)
1888 {
1889         int rc;
1890         struct sx_port *port = tty->driver_data;
1891         void __user *argp = (void __user *)arg;
1892
1893         /* func_enter2(); */
1894
1895         rc = 0;
1896         lock_kernel();
1897         switch (cmd) {
1898         case TIOCGSERIAL:
1899                 rc = gs_getserial(&port->gs, argp);
1900                 break;
1901         case TIOCSSERIAL:
1902                 rc = gs_setserial(&port->gs, argp);
1903                 break;
1904         default:
1905                 rc = -ENOIOCTLCMD;
1906                 break;
1907         }
1908         unlock_kernel();
1909
1910         /* func_exit(); */
1911         return rc;
1912 }
1913
1914 /* The throttle/unthrottle scheme for the Specialix card is different
1915  * from other drivers and deserves some explanation.
1916  * The Specialix hardware takes care of XON/XOFF
1917  * and CTS/RTS flow control itself.  This means that all we have to
1918  * do when signalled by the upper tty layer to throttle/unthrottle is
1919  * to make a note of it here.  When we come to read characters from the
1920  * rx buffers on the card (sx_receive_chars()) we look to see if the
1921  * upper layer can accept more (as noted here in sx_rx_throt[]).
1922  * If it can't we simply don't remove chars from the cards buffer.
1923  * When the tty layer can accept chars, we again note that here and when
1924  * sx_receive_chars() is called it will remove them from the cards buffer.
1925  * The card will notice that a ports buffer has drained below some low
1926  * water mark and will unflow control the line itself, using whatever
1927  * flow control scheme is in use for that port. -- Simon Allen
1928  */
1929
1930 static void sx_throttle(struct tty_struct *tty)
1931 {
1932         struct sx_port *port = (struct sx_port *)tty->driver_data;
1933
1934         func_enter2();
1935         /* If the port is using any type of input flow
1936          * control then throttle the port.
1937          */
1938         if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
1939                 port->gs.flags |= SX_RX_THROTTLE;
1940         }
1941         func_exit();
1942 }
1943
1944 static void sx_unthrottle(struct tty_struct *tty)
1945 {
1946         struct sx_port *port = (struct sx_port *)tty->driver_data;
1947
1948         func_enter2();
1949         /* Always unthrottle even if flow control is not enabled on
1950          * this port in case we disabled flow control while the port
1951          * was throttled
1952          */
1953         port->gs.flags &= ~SX_RX_THROTTLE;
1954         func_exit();
1955         return;
1956 }
1957
1958 /* ********************************************************************** *
1959  *                    Here are the initialization routines.               *
1960  * ********************************************************************** */
1961
1962 static int sx_init_board(struct sx_board *board)
1963 {
1964         int addr;
1965         int chans;
1966         int type;
1967
1968         func_enter();
1969
1970         /* This is preceded by downloading the download code. */
1971
1972         board->flags |= SX_BOARD_INITIALIZED;
1973
1974         if (read_sx_byte(board, 0))
1975                 /* CF boards may need this. */
1976                 write_sx_byte(board, 0, 0);
1977
1978         /* This resets the processor again, to make sure it didn't do any
1979            foolish things while we were downloading the image */
1980         if (!sx_reset(board))
1981                 return 0;
1982
1983         sx_start_board(board);
1984         udelay(10);
1985         if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
1986                 printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
1987                 return 0;
1988         }
1989
1990         /* Ok. So now the processor on the card is running. It gathered
1991            some info for us... */
1992         sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
1993         if (sx_debug & SX_DEBUG_INIT)
1994                 my_hd_io(board->base, 0x10);
1995         sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
1996         if (sx_debug & SX_DEBUG_INIT)
1997                 my_hd_io(board->base + 0x80, 0x30);
1998
1999         sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
2000                         "V%x.%02x,\n",
2001                         read_sx_byte(board, 0), read_sx_byte(board, 1),
2002                         read_sx_byte(board, 5), read_sx_byte(board, 4));
2003
2004         if (read_sx_byte(board, 0) == 0xff) {
2005                 printk(KERN_INFO "sx: No modules found. Sorry.\n");
2006                 board->nports = 0;
2007                 return 0;
2008         }
2009
2010         chans = 0;
2011
2012         if (IS_SX_BOARD(board)) {
2013                 sx_write_board_word(board, cc_int_count, sx_maxints);
2014         } else {
2015                 if (sx_maxints)
2016                         sx_write_board_word(board, cc_int_count,
2017                                         SI_PROCESSOR_CLOCK / 8 / sx_maxints);
2018         }
2019
2020         /* grab the first module type... */
2021         /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
2022         board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
2023                                 mc_chip));
2024
2025         /* XXX byteorder */
2026         for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
2027                 type = sx_read_module_byte(board, addr, mc_chip);
2028                 sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
2029                                 addr, read_sx_byte(board, addr + 2));
2030
2031                 chans += sx_read_module_byte(board, addr, mc_type);
2032
2033                 sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
2034                                 "panels\n",
2035                                 mod_type_s(type),
2036                                 pan_type_s(sx_read_module_byte(board, addr,
2037                                                 mc_mods) & 0xf),
2038                                 pan_type_s(sx_read_module_byte(board, addr,
2039                                                 mc_mods) >> 4));
2040
2041                 sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
2042                         "version: %x\n",
2043                         sx_read_module_byte(board, addr, mc_rev1),
2044                         sx_read_module_byte(board, addr, mc_rev2),
2045                         sx_read_module_byte(board, addr, mc_mtaasic_rev));
2046
2047                 /* The following combinations are illegal: It should theoretically
2048                    work, but timing problems make the bus HANG. */
2049
2050                 if (mod_compat_type(type) != board->ta_type) {
2051                         printk(KERN_ERR "sx: This is an invalid "
2052                                 "configuration.\nDon't mix TA/MTA/SXDC on the "
2053                                 "same hostadapter.\n");
2054                         chans = 0;
2055                         break;
2056                 }
2057                 if ((IS_EISA_BOARD(board) ||
2058                                 IS_SI_BOARD(board)) &&
2059                                 (mod_compat_type(type) == 4)) {
2060                         printk(KERN_ERR "sx: This is an invalid "
2061                                 "configuration.\nDon't use SXDCs on an SI/XIO "
2062                                 "adapter.\n");
2063                         chans = 0;
2064                         break;
2065                 }
2066 #if 0                           /* Problem fixed: firmware 3.05 */
2067                 if (IS_SX_BOARD(board) && (type == TA8)) {
2068                         /* There are some issues with the firmware and the DCD/RTS
2069                            lines. It might work if you tie them together or something.
2070                            It might also work if you get a newer sx_firmware.   Therefore
2071                            this is just a warning. */
2072                         printk(KERN_WARNING
2073                                "sx: The SX host doesn't work too well "
2074                                "with the TA8 adapters.\nSpecialix is working on it.\n");
2075                 }
2076 #endif
2077         }
2078
2079         if (chans) {
2080                 if (board->irq > 0) {
2081                         /* fixed irq, probably PCI */
2082                         if (sx_irqmask & (1 << board->irq)) {   /* may we use this irq? */
2083                                 if (request_irq(board->irq, sx_interrupt,
2084                                                 IRQF_SHARED | IRQF_DISABLED,
2085                                                 "sx", board)) {
2086                                         printk(KERN_ERR "sx: Cannot allocate "
2087                                                 "irq %d.\n", board->irq);
2088                                         board->irq = 0;
2089                                 }
2090                         } else
2091                                 board->irq = 0;
2092                 } else if (board->irq < 0 && sx_irqmask) {
2093                         /* auto-allocate irq */
2094                         int irqnr;
2095                         int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
2096                                         SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
2097                         for (irqnr = 15; irqnr > 0; irqnr--)
2098                                 if (irqmask & (1 << irqnr))
2099                                         if (!request_irq(irqnr, sx_interrupt,
2100                                                 IRQF_SHARED | IRQF_DISABLED,
2101                                                 "sx", board))
2102                                                 break;
2103                         if (!irqnr)
2104                                 printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
2105                         board->irq = irqnr;
2106                 } else
2107                         board->irq = 0;
2108
2109                 if (board->irq) {
2110                         /* Found a valid interrupt, start up interrupts! */
2111                         sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
2112                                         board->irq);
2113                         sx_start_interrupts(board);
2114                         board->poll = sx_slowpoll;
2115                         board->flags |= SX_IRQ_ALLOCATED;
2116                 } else {
2117                         /* no irq: setup board for polled operation */
2118                         board->poll = sx_poll;
2119                         sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
2120                                         board->poll);
2121                 }
2122
2123                 /* The timer should be initialized anyway: That way we can
2124                    safely del_timer it when the module is unloaded. */
2125                 setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
2126
2127                 if (board->poll)
2128                         mod_timer(&board->timer, jiffies + board->poll);
2129         } else {
2130                 board->irq = 0;
2131         }
2132
2133         board->nports = chans;
2134         sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
2135
2136         func_exit();
2137         return chans;
2138 }
2139
2140 static void __devinit printheader(void)
2141 {
2142         static int header_printed;
2143
2144         if (!header_printed) {
2145                 printk(KERN_INFO "Specialix SX driver "
2146                         "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
2147                 printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
2148                 header_printed = 1;
2149         }
2150 }
2151
2152 static int __devinit probe_sx(struct sx_board *board)
2153 {
2154         struct vpd_prom vpdp;
2155         char *p;
2156         int i;
2157
2158         func_enter();
2159
2160         if (!IS_CF_BOARD(board)) {
2161                 sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
2162                                 board->base + SX_VPD_ROM);
2163
2164                 if (sx_debug & SX_DEBUG_PROBE)
2165                         my_hd_io(board->base + SX_VPD_ROM, 0x40);
2166
2167                 p = (char *)&vpdp;
2168                 for (i = 0; i < sizeof(struct vpd_prom); i++)
2169                         *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
2170
2171                 if (sx_debug & SX_DEBUG_PROBE)
2172                         my_hd(&vpdp, 0x20);
2173
2174                 sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
2175
2176                 if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
2177                         sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
2178                                         "'%s'\n", vpdp.identifier);
2179                         return 0;
2180                 }
2181         }
2182
2183         printheader();
2184
2185         if (!IS_CF_BOARD(board)) {
2186                 printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
2187                         board->hw_base);
2188                 printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
2189                                 "uniq ID:%08x, ",
2190                                 vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
2191                 printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
2192
2193                 if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
2194                                 SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
2195                                 SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
2196                         /* This might be a bit harsh. This was the primary
2197                            reason the SX/ISA card didn't work at first... */
2198                         printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
2199                                         "card. Sorry: giving up.\n");
2200                         return (0);
2201                 }
2202
2203                 if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
2204                                 SX_ISA_UNIQUEID1) {
2205                         if (((unsigned long)board->hw_base) & 0x8000) {
2206                                 printk(KERN_WARNING "sx: Warning: There may be "
2207                                         "hardware problems with the card at "
2208                                         "%lx.\n", board->hw_base);
2209                                 printk(KERN_WARNING "sx: Read sx.txt for more "
2210                                                 "info.\n");
2211                         }
2212                 }
2213         }
2214
2215         board->nports = -1;
2216
2217         /* This resets the processor, and keeps it off the bus. */
2218         if (!sx_reset(board))
2219                 return 0;
2220         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2221
2222         func_exit();
2223         return 1;
2224 }
2225
2226 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
2227
2228 /* Specialix probes for this card at 32k increments from 640k to 16M.
2229    I consider machines with less than 16M unlikely nowadays, so I'm
2230    not probing above 1Mb. Also, 0xa0000, 0xb0000, are taken by the VGA
2231    card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves
2232    0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
2233
2234 static int __devinit probe_si(struct sx_board *board)
2235 {
2236         int i;
2237
2238         func_enter();
2239         sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
2240                 "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
2241
2242         if (sx_debug & SX_DEBUG_PROBE)
2243                 my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
2244
2245         if (!IS_EISA_BOARD(board)) {
2246                 if (IS_SI1_BOARD(board)) {
2247                         for (i = 0; i < 8; i++) {
2248                                 write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
2249                         }
2250                 }
2251                 for (i = 0; i < 8; i++) {
2252                         if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
2253                                         != i) {
2254                                 func_exit();
2255                                 return 0;
2256                         }
2257                 }
2258         }
2259
2260         /* Now we're pretty much convinced that there is an SI board here,
2261            but to prevent trouble, we'd better double check that we don't
2262            have an SI1 board when we're probing for an SI2 board.... */
2263
2264         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2265         if (IS_SI1_BOARD(board)) {
2266                 /* This should be an SI1 board, which has this
2267                    location writable... */
2268                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2269                         func_exit();
2270                         return 0;
2271                 }
2272         } else {
2273                 /* This should be an SI2 board, which has the bottom
2274                    3 bits non-writable... */
2275                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2276                         func_exit();
2277                         return 0;
2278                 }
2279         }
2280
2281         /* Now we're pretty much convinced that there is an SI board here,
2282            but to prevent trouble, we'd better double check that we don't
2283            have an SI1 board when we're probing for an SI2 board.... */
2284
2285         write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
2286         if (IS_SI1_BOARD(board)) {
2287                 /* This should be an SI1 board, which has this
2288                    location writable... */
2289                 if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
2290                         func_exit();
2291                         return 0;
2292                 }
2293         } else {
2294                 /* This should be an SI2 board, which has the bottom
2295                    3 bits non-writable... */
2296                 if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
2297                         func_exit();
2298                         return 0;
2299                 }
2300         }
2301
2302         printheader();
2303
2304         printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
2305         /* Compared to the SX boards, it is a complete guess as to what
2306            this card is up to... */
2307
2308         board->nports = -1;
2309
2310         /* This resets the processor, and keeps it off the bus. */
2311         if (!sx_reset(board))
2312                 return 0;
2313         sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
2314
2315         func_exit();
2316         return 1;
2317 }
2318 #endif
2319
2320 static const struct tty_operations sx_ops = {
2321         .break_ctl = sx_break,
2322         .open = sx_open,
2323         .close = gs_close,
2324         .write = gs_write,
2325         .put_char = gs_put_char,
2326         .flush_chars = gs_flush_chars,
2327         .write_room = gs_write_room,
2328         .chars_in_buffer = gs_chars_in_buffer,
2329         .flush_buffer = gs_flush_buffer,
2330         .ioctl = sx_ioctl,
2331         .throttle = sx_throttle,
2332         .unthrottle = sx_unthrottle,
2333         .set_termios = gs_set_termios,
2334         .stop = gs_stop,
2335         .start = gs_start,
2336         .hangup = gs_hangup,
2337         .tiocmget = sx_tiocmget,
2338         .tiocmset = sx_tiocmset,
2339 };
2340
2341 static int sx_init_drivers(void)
2342 {
2343         int error;
2344
2345         func_enter();
2346
2347         sx_driver = alloc_tty_driver(sx_nports);
2348         if (!sx_driver)
2349                 return 1;
2350         sx_driver->owner = THIS_MODULE;
2351         sx_driver->driver_name = "specialix_sx";
2352         sx_driver->name = "ttyX";
2353         sx_driver->major = SX_NORMAL_MAJOR;
2354         sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
2355         sx_driver->subtype = SERIAL_TYPE_NORMAL;
2356         sx_driver->init_termios = tty_std_termios;
2357         sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2358         sx_driver->init_termios.c_ispeed = 9600;
2359         sx_driver->init_termios.c_ospeed = 9600;
2360         sx_driver->flags = TTY_DRIVER_REAL_RAW;
2361         tty_set_operations(sx_driver, &sx_ops);
2362
2363         if ((error = tty_register_driver(sx_driver))) {
2364                 put_tty_driver(sx_driver);
2365                 printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
2366                         error);
2367                 return 1;
2368         }
2369         func_exit();
2370         return 0;
2371 }
2372
2373 static int sx_init_portstructs(int nboards, int nports)
2374 {
2375         struct sx_board *board;
2376         struct sx_port *port;
2377         int i, j;
2378         int addr, chans;
2379         int portno;
2380
2381         func_enter();
2382
2383         /* Many drivers statically allocate the maximum number of ports
2384            There is no reason not to allocate them dynamically.
2385            Is there? -- REW */
2386         sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
2387         if (!sx_ports)
2388                 return -ENOMEM;
2389
2390         port = sx_ports;
2391         for (i = 0; i < nboards; i++) {
2392                 board = &boards[i];
2393                 board->ports = port;
2394                 for (j = 0; j < boards[i].nports; j++) {
2395                         sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
2396                         port->gs.magic = SX_MAGIC;
2397                         port->gs.close_delay = HZ / 2;
2398                         port->gs.closing_wait = 30 * HZ;
2399                         port->board = board;
2400                         port->gs.rd = &sx_real_driver;
2401 #ifdef NEW_WRITE_LOCKING
2402                         port->gs.port_write_mutex = MUTEX;
2403 #endif
2404                         spin_lock_init(&port->gs.driver_lock);
2405                         /*
2406                          * Initializing wait queue
2407                          */
2408                         init_waitqueue_head(&port->gs.open_wait);
2409                         init_waitqueue_head(&port->gs.close_wait);
2410
2411                         port++;
2412                 }
2413         }
2414
2415         port = sx_ports;
2416         portno = 0;
2417         for (i = 0; i < nboards; i++) {
2418                 board = &boards[i];
2419                 board->port_base = portno;
2420                 /* Possibly the configuration was rejected. */
2421                 sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
2422                                 board->nports);
2423                 if (board->nports <= 0)
2424                         continue;
2425                 /* XXX byteorder ?? */
2426                 for (addr = 0x80; addr != 0;
2427                                 addr = read_sx_word(board, addr) & 0x7fff) {
2428                         chans = sx_read_module_byte(board, addr, mc_type);
2429                         sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
2430                                         "channels\n", addr, chans);
2431                         sx_dprintk(SX_DEBUG_PROBE, "Port at");
2432                         for (j = 0; j < chans; j++) {
2433                                 /* The "sx-way" is the way it SHOULD be done.
2434                                    That way in the future, the firmware may for
2435                                    example pack the structures a bit more
2436                                    efficient. Neil tells me it isn't going to
2437                                    happen anytime soon though. */
2438                                 if (IS_SX_BOARD(board))
2439                                         port->ch_base = sx_read_module_word(
2440                                                         board, addr + j * 2,
2441                                                         mc_chan_pointer);
2442                                 else
2443                                         port->ch_base = addr + 0x100 + 0x300 *j;
2444
2445                                 sx_dprintk(SX_DEBUG_PROBE, " %x",
2446                                                 port->ch_base);
2447                                 port->line = portno++;
2448                                 port++;
2449                         }
2450                         sx_dprintk(SX_DEBUG_PROBE, "\n");
2451                 }
2452                 /* This has to be done earlier. */
2453                 /* board->flags |= SX_BOARD_INITIALIZED; */
2454         }
2455
2456         func_exit();
2457         return 0;
2458 }
2459
2460 static unsigned int sx_find_free_board(void)
2461 {
2462         unsigned int i;
2463
2464         for (i = 0; i < SX_NBOARDS; i++)
2465                 if (!(boards[i].flags & SX_BOARD_PRESENT))
2466                         break;
2467
2468         return i;
2469 }
2470
2471 static void __exit sx_release_drivers(void)
2472 {
2473         func_enter();
2474         tty_unregister_driver(sx_driver);
2475         put_tty_driver(sx_driver);
2476         func_exit();
2477 }
2478
2479 static void __devexit sx_remove_card(struct sx_board *board,
2480                 struct pci_dev *pdev)
2481 {
2482         if (board->flags & SX_BOARD_INITIALIZED) {
2483                 /* The board should stop messing with us. (actually I mean the
2484                    interrupt) */
2485                 sx_reset(board);
2486                 if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
2487                         free_irq(board->irq, board);
2488
2489                 /* It is safe/allowed to del_timer a non-active timer */
2490                 del_timer(&board->timer);
2491                 if (pdev) {
2492 #ifdef CONFIG_PCI
2493                         pci_iounmap(pdev, board->base);
2494                         pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
2495 #endif
2496                 } else {
2497                         iounmap(board->base);
2498                         release_region(board->hw_base, board->hw_len);
2499                 }
2500
2501                 board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
2502         }
2503 }
2504
2505 #ifdef CONFIG_EISA
2506
2507 static int __devinit sx_eisa_probe(struct device *dev)
2508 {
2509         struct eisa_device *edev = to_eisa_device(dev);
2510         struct sx_board *board;
2511         unsigned long eisa_slot = edev->base_addr;
2512         unsigned int i;
2513         int retval = -EIO;
2514
2515         mutex_lock(&sx_boards_lock);
2516         i = sx_find_free_board();
2517         if (i == SX_NBOARDS) {
2518                 mutex_unlock(&sx_boards_lock);
2519                 goto err;
2520         }
2521         board = &boards[i];
2522         board->flags |= SX_BOARD_PRESENT;
2523         mutex_unlock(&sx_boards_lock);
2524
2525         dev_info(dev, "XIO : Signature found in EISA slot %lu, "
2526                  "Product %d Rev %d (REPORT THIS TO LKLM)\n",
2527                  eisa_slot >> 12,
2528                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
2529                  inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
2530
2531         board->eisa_base = eisa_slot;
2532         board->flags &= ~SX_BOARD_TYPE;
2533         board->flags |= SI_EISA_BOARD;
2534
2535         board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
2536                           inb(eisa_slot + 0xc00)) << 16;
2537         board->hw_len = SI2_EISA_WINDOW_LEN;
2538         if (!request_region(board->hw_base, board->hw_len, "sx")) {
2539                 dev_err(dev, "can't request region\n");
2540                 goto err_flag;
2541         }
2542         board->base2 =
2543         board->base = ioremap_nocache(board->hw_base, SI2_EISA_WINDOW_LEN);
2544         if (!board->base) {
2545                 dev_err(dev, "can't remap memory\n");
2546                 goto err_reg;
2547         }
2548
2549         sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
2550         sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
2551         board->irq = inb(eisa_slot + 0xc02) >> 4;
2552         sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
2553
2554         if (!probe_si(board))
2555                 goto err_unmap;
2556
2557         dev_set_drvdata(dev, board);
2558
2559         return 0;
2560 err_unmap:
2561         iounmap(board->base);
2562 err_reg:
2563         release_region(board->hw_base, board->hw_len);
2564 err_flag:
2565         board->flags &= ~SX_BOARD_PRESENT;
2566 err:
2567         return retval;
2568 }
2569
2570 static int __devexit sx_eisa_remove(struct device *dev)
2571 {
2572         struct sx_board *board = dev_get_drvdata(dev);
2573
2574         sx_remove_card(board, NULL);
2575
2576         return 0;
2577 }
2578
2579 static struct eisa_device_id sx_eisa_tbl[] = {
2580         { "SLX" },
2581         { "" }
2582 };
2583
2584 MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
2585
2586 static struct eisa_driver sx_eisadriver = {
2587         .id_table = sx_eisa_tbl,
2588         .driver = {
2589                 .name = "sx",
2590                 .probe = sx_eisa_probe,
2591                 .remove = __devexit_p(sx_eisa_remove),
2592         }
2593 };
2594
2595 #endif
2596
2597 #ifdef CONFIG_PCI
2598  /********************************************************
2599  * Setting bit 17 in the CNTRL register of the PLX 9050  *
2600  * chip forces a retry on writes while a read is pending.*
2601  * This is to prevent the card locking up on Intel Xeon  *
2602  * multiprocessor systems with the NX chipset.    -- NV  *
2603  ********************************************************/
2604
2605 /* Newer cards are produced with this bit set from the configuration
2606    EEprom.  As the bit is read/write for the CPU, we can fix it here,
2607    if we detect that it isn't set correctly. -- REW */
2608
2609 static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
2610 {
2611         unsigned int hwbase;
2612         void __iomem *rebase;
2613         unsigned int t;
2614
2615 #define CNTRL_REG_OFFSET        0x50
2616 #define CNTRL_REG_GOODVALUE     0x18260000
2617
2618         pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
2619         hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
2620         rebase = ioremap_nocache(hwbase, 0x80);
2621         t = readl(rebase + CNTRL_REG_OFFSET);
2622         if (t != CNTRL_REG_GOODVALUE) {
2623                 printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
2624                         "%08x\n", t, CNTRL_REG_GOODVALUE);
2625                 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
2626         }
2627         iounmap(rebase);
2628 }
2629 #endif
2630
2631 static int __devinit sx_pci_probe(struct pci_dev *pdev,
2632                                   const struct pci_device_id *ent)
2633 {
2634 #ifdef CONFIG_PCI
2635         struct sx_board *board;
2636         unsigned int i, reg;
2637         int retval = -EIO;
2638
2639         mutex_lock(&sx_boards_lock);
2640         i = sx_find_free_board();
2641         if (i == SX_NBOARDS) {
2642                 mutex_unlock(&sx_boards_lock);
2643                 goto err;
2644         }
2645         board = &boards[i];
2646         board->flags |= SX_BOARD_PRESENT;
2647         mutex_unlock(&sx_boards_lock);
2648
2649         retval = pci_enable_device(pdev);
2650         if (retval)
2651                 goto err_flag;
2652
2653         board->flags &= ~SX_BOARD_TYPE;
2654         board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
2655                 SX_CFPCI_BOARD;
2656
2657         /* CF boards use base address 3.... */
2658         reg = IS_CF_BOARD(board) ? 3 : 2;
2659         retval = pci_request_region(pdev, reg, "sx");
2660         if (retval) {
2661                 dev_err(&pdev->dev, "can't request region\n");
2662                 goto err_flag;
2663         }
2664         board->hw_base = pci_resource_start(pdev, reg);
2665         board->base2 =
2666         board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
2667         if (!board->base) {
2668                 dev_err(&pdev->dev, "ioremap failed\n");
2669                 goto err_reg;
2670         }
2671
2672         /* Most of the stuff on the CF board is offset by 0x18000 ....  */
2673         if (IS_CF_BOARD(board))
2674                 board->base += 0x18000;
2675
2676         board->irq = pdev->irq;
2677
2678         dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
2679                  board->irq, board->flags);
2680
2681         if (!probe_sx(board)) {
2682                 retval = -EIO;
2683                 goto err_unmap;
2684         }
2685
2686         fix_sx_pci(pdev, board);
2687
2688         pci_set_drvdata(pdev, board);
2689
2690         return 0;
2691 err_unmap:
2692         pci_iounmap(pdev, board->base);
2693 err_reg:
2694         pci_release_region(pdev, reg);
2695 err_flag:
2696         board->flags &= ~SX_BOARD_PRESENT;
2697 err:
2698         return retval;
2699 #else
2700         return -ENODEV;
2701 #endif
2702 }
2703
2704 static void __devexit sx_pci_remove(struct pci_dev *pdev)
2705 {
2706         struct sx_board *board = pci_get_drvdata(pdev);
2707
2708         sx_remove_card(board, pdev);
2709 }
2710
2711 /* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
2712    its because the standard requires it. So check for SUBVENDOR_ID. */
2713 static struct pci_device_id sx_pci_tbl[] = {
2714         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2715                 .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
2716         { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
2717                 .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
2718         { 0 }
2719 };
2720
2721 MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
2722
2723 static struct pci_driver sx_pcidriver = {
2724         .name = "sx",
2725         .id_table = sx_pci_tbl,
2726         .probe = sx_pci_probe,
2727         .remove = __devexit_p(sx_pci_remove)
2728 };
2729
2730 static int __init sx_init(void)
2731 {
2732 #ifdef CONFIG_EISA
2733         int retval1;
2734 #endif
2735 #ifdef CONFIG_ISA
2736         struct sx_board *board;
2737         unsigned int i;
2738 #endif
2739         unsigned int found = 0;
2740         int retval;
2741
2742         func_enter();
2743         sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
2744                         sx_debug);
2745         if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
2746                 printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
2747                                 "value. Assuming -1.\n(%p)\n", &sx_debug);
2748                 sx_debug = -1;
2749         }
2750
2751         if (misc_register(&sx_fw_device) < 0) {
2752                 printk(KERN_ERR "SX: Unable to register firmware loader "
2753                                 "driver.\n");
2754                 return -EIO;
2755         }
2756 #ifdef CONFIG_ISA
2757         for (i = 0; i < NR_SX_ADDRS; i++) {
2758                 board = &boards[found];
2759                 board->hw_base = sx_probe_addrs[i];
2760                 board->hw_len = SX_WINDOW_LEN;
2761                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2762                         continue;
2763                 board->base2 =
2764                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2765                 if (!board->base)
2766                         goto err_sx_reg;
2767                 board->flags &= ~SX_BOARD_TYPE;
2768                 board->flags |= SX_ISA_BOARD;
2769                 board->irq = sx_irqmask ? -1 : 0;
2770
2771                 if (probe_sx(board)) {
2772                         board->flags |= SX_BOARD_PRESENT;
2773                         found++;
2774                 } else {
2775                         iounmap(board->base);
2776 err_sx_reg:
2777                         release_region(board->hw_base, board->hw_len);
2778                 }
2779         }
2780
2781         for (i = 0; i < NR_SI_ADDRS; i++) {
2782                 board = &boards[found];
2783                 board->hw_base = si_probe_addrs[i];
2784                 board->hw_len = SI2_ISA_WINDOW_LEN;
2785                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2786                         continue;
2787                 board->base2 =
2788                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2789                 if (!board->base)
2790                         goto err_si_reg;
2791                 board->flags &= ~SX_BOARD_TYPE;
2792                 board->flags |= SI_ISA_BOARD;
2793                 board->irq = sx_irqmask ? -1 : 0;
2794
2795                 if (probe_si(board)) {
2796                         board->flags |= SX_BOARD_PRESENT;
2797                         found++;
2798                 } else {
2799                         iounmap(board->base);
2800 err_si_reg:
2801                         release_region(board->hw_base, board->hw_len);
2802                 }
2803         }
2804         for (i = 0; i < NR_SI1_ADDRS; i++) {
2805                 board = &boards[found];
2806                 board->hw_base = si1_probe_addrs[i];
2807                 board->hw_len = SI1_ISA_WINDOW_LEN;
2808                 if (!request_region(board->hw_base, board->hw_len, "sx"))
2809                         continue;
2810                 board->base2 =
2811                 board->base = ioremap_nocache(board->hw_base, board->hw_len);
2812                 if (!board->base)
2813                         goto err_si1_reg;
2814                 board->flags &= ~SX_BOARD_TYPE;
2815                 board->flags |= SI1_ISA_BOARD;
2816                 board->irq = sx_irqmask ? -1 : 0;
2817
2818                 if (probe_si(board)) {
2819                         board->flags |= SX_BOARD_PRESENT;
2820                         found++;
2821                 } else {
2822                         iounmap(board->base);
2823 err_si1_reg:
2824                         release_region(board->hw_base, board->hw_len);
2825                 }
2826         }
2827 #endif
2828 #ifdef CONFIG_EISA
2829         retval1 = eisa_driver_register(&sx_eisadriver);
2830 #endif
2831         retval = pci_register_driver(&sx_pcidriver);
2832
2833         if (found) {
2834                 printk(KERN_INFO "sx: total of %d boards detected.\n", found);
2835                 retval = 0;
2836         } else if (retval) {
2837 #ifdef CONFIG_EISA
2838                 retval = retval1;
2839                 if (retval1)
2840 #endif
2841                         misc_deregister(&sx_fw_device);
2842         }
2843
2844         func_exit();
2845         return retval;
2846 }
2847
2848 static void __exit sx_exit(void)
2849 {
2850         int i;
2851
2852         func_enter();
2853 #ifdef CONFIG_EISA
2854         eisa_driver_unregister(&sx_eisadriver);
2855 #endif
2856         pci_unregister_driver(&sx_pcidriver);
2857
2858         for (i = 0; i < SX_NBOARDS; i++)
2859                 sx_remove_card(&boards[i], NULL);
2860
2861         if (misc_deregister(&sx_fw_device) < 0) {
2862                 printk(KERN_INFO "sx: couldn't deregister firmware loader "
2863                                 "device\n");
2864         }
2865         sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
2866                         sx_initialized);
2867         if (sx_initialized)
2868                 sx_release_drivers();
2869
2870         kfree(sx_ports);
2871         func_exit();
2872 }
2873
2874 module_init(sx_init);
2875 module_exit(sx_exit);