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