readahead: combine file_ra_state.prev_index/prev_offset into prev_pos
[linux-2.6.git] / drivers / char / sx.c
index 5fb79f5..85a2328 100644 (file)
 #include <linux/fcntl.h>
 #include <linux/major.h>
 #include <linux/delay.h>
+#include <linux/eisa.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/generic_serial.h>
 #include "sx.h"
 
-
 /* I don't think that this driver can handle more than 256 ports on
    one machine. You'll have to increase the number of boards in sx.h
    if you want more than 4 boards.  */
 /* Am I paranoid or not ? ;-) */
 #undef SX_PARANOIA_CHECK
 
-
 /* 20 -> 2000 per second. The card should rate-limit interrupts at 100
    Hz, but it is user configurable. I don't recommend going above 1000
    Hz. The interrupt ratelimit might trigger if the interrupt is
    interrupt. Use polling. */
 #undef IRQ_RATE_LIMIT
 
-
 #if 0
 /* Not implemented */
 /* 
  */
 #define SX_REPORT_FIFO
 #define SX_REPORT_OVERRUN
-#endif 
-
+#endif
 
 /* Function prototypes */
-static void sx_disable_tx_interrupts (void * ptr); 
-static void sx_enable_tx_interrupts (void * ptr); 
-static void sx_disable_rx_interrupts (void * ptr); 
-static void sx_enable_rx_interrupts (void * ptr); 
-static int  sx_get_CD (void * ptr); 
-static void sx_shutdown_port (void * ptr);
-static int  sx_set_real_termios (void  *ptr);
-static void sx_close (void  *ptr);
-static int sx_chars_in_buffer (void * ptr);
-static int sx_init_board (struct sx_board *board);
-static int sx_init_portstructs (int nboards, int nports);
-static int sx_fw_ioctl (struct inode *inode, struct file *filp,
-                        unsigned int cmd, unsigned long arg);
+static void sx_disable_tx_interrupts(void *ptr);
+static void sx_enable_tx_interrupts(void *ptr);
+static void sx_disable_rx_interrupts(void *ptr);
+static void sx_enable_rx_interrupts(void *ptr);
+static int sx_get_CD(void *ptr);
+static void sx_shutdown_port(void *ptr);
+static int sx_set_real_termios(void *ptr);
+static void sx_close(void *ptr);
+static int sx_chars_in_buffer(void *ptr);
+static int sx_init_board(struct sx_board *board);
+static int sx_init_portstructs(int nboards, int nports);
+static int sx_fw_ioctl(struct inode *inode, struct file *filp,
+               unsigned int cmd, unsigned long arg);
 static int sx_init_drivers(void);
 
-
 static struct tty_driver *sx_driver;
 
+static DEFINE_MUTEX(sx_boards_lock);
 static struct sx_board boards[SX_NBOARDS];
 static struct sx_port *sx_ports;
 static int sx_initialized;
 static int sx_nports;
 static int sx_debug;
 
-
 /* You can have the driver poll your card. 
     - Set sx_poll to 1 to poll every timer tick (10ms on Intel). 
       This is used when the card cannot use an interrupt for some reason.
@@ -322,27 +318,36 @@ static int sx_slowpoll;
 
 static int sx_maxints = 100;
 
+#ifdef CONFIG_ISA
+
 /* These are the only open spaces in my computer. Yours may have more
    or less.... -- REW 
    duh: Card at 0xa0000 is possible on HP Netserver?? -- pvdl
 */
-static int sx_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000, 
-                              0xc8000, 0xd8000, 0xe8000};
-static int si_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000, 
-                              0xc8000, 0xd8000, 0xe8000, 0xa0000};
-static int si1_probe_addrs[]= { 0xd0000};
+static int sx_probe_addrs[] = {
+       0xc0000, 0xd0000, 0xe0000,
+       0xc8000, 0xd8000, 0xe8000
+};
+static int si_probe_addrs[] = {
+       0xc0000, 0xd0000, 0xe0000,
+       0xc8000, 0xd8000, 0xe8000, 0xa0000
+};
+static int si1_probe_addrs[] = {
+       0xd0000
+};
 
 #define NR_SX_ADDRS ARRAY_SIZE(sx_probe_addrs)
 #define NR_SI_ADDRS ARRAY_SIZE(si_probe_addrs)
 #define NR_SI1_ADDRS ARRAY_SIZE(si1_probe_addrs)
 
+module_param_array(sx_probe_addrs, int, NULL, 0);
+module_param_array(si_probe_addrs, int, NULL, 0);
+#endif
 
 /* Set the mask to all-ones. This alas, only supports 32 interrupts. 
    Some architectures may need more. */
 static int sx_irqmask = -1;
 
-module_param_array(sx_probe_addrs, int, NULL, 0);
-module_param_array(si_probe_addrs, int, NULL, 0);
 module_param(sx_poll, int, 0);
 module_param(sx_slowpoll, int, 0);
 module_param(sx_maxints, int, 0);
@@ -357,13 +362,12 @@ static struct real_driver sx_real_driver = {
        sx_disable_rx_interrupts,
        sx_enable_rx_interrupts,
        sx_get_CD,
-       sx_shutdown_port, 
-       sx_set_real_termios, 
+       sx_shutdown_port,
+       sx_set_real_termios,
        sx_chars_in_buffer,
        sx_close,
 };
 
-
 /* 
    This driver can spew a whole lot of debugging output at you. If you
    need maximum performance, you should disable the DEBUG define. To
@@ -374,23 +378,17 @@ static struct real_driver sx_real_driver = {
 */
 #define DEBUG
 
-
 #ifdef DEBUG
-#define sx_dprintk(f, str...) if (sx_debug & f) printk (str)
+#define sx_dprintk(f, str...)  if (sx_debug & f) printk (str)
 #else
-#define sx_dprintk(f, str...) /* nothing */
+#define sx_dprintk(f, str...)  /* nothing */
 #endif
 
+#define func_enter()   sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__)
+#define func_exit()    sx_dprintk(SX_DEBUG_FLOW, "sx: exit  %s\n",__FUNCTION__)
 
-
-#define func_enter() sx_dprintk (SX_DEBUG_FLOW, "sx: enter %s\n",__FUNCTION__)
-#define func_exit()  sx_dprintk (SX_DEBUG_FLOW, "sx: exit  %s\n", __FUNCTION__)
-
-#define func_enter2() sx_dprintk (SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
-                                       __FUNCTION__, port->line)
-
-
-
+#define func_enter2()  sx_dprintk(SX_DEBUG_FLOW, "sx: enter %s (port %d)\n", \
+                               __FUNCTION__, port->line)
 
 /* 
  *  Firmware loader driver specific routines
@@ -398,31 +396,26 @@ static struct real_driver sx_real_driver = {
  */
 
 static const struct file_operations sx_fw_fops = {
-       .owner          = THIS_MODULE,
-       .ioctl          = sx_fw_ioctl,
+       .owner = THIS_MODULE,
+       .ioctl = sx_fw_ioctl,
 };
 
 static struct miscdevice sx_fw_device = {
        SXCTL_MISC_MINOR, "sxctl", &sx_fw_fops
 };
 
-
-
-
-
 #ifdef SX_PARANOIA_CHECK
 
 /* This doesn't work. Who's paranoid around here? Not me! */
 
-static inline int sx_paranoia_check(struct sx_port const * port,
+static inline int sx_paranoia_check(struct sx_port const *port,
                                    char *name, const char *routine)
 {
+       static const char *badmagic = KERN_ERR "sx: Warning: bad sx port magic "
+                       "number for device %s in %s\n";
+       static const char *badinfo = KERN_ERR "sx: Warning: null sx port for "
+                       "device %s in %s\n";
 
-       static const char *badmagic =
-         KERN_ERR "sx: Warning: bad sx port magic number for device %s in %s\n";
-       static const char *badinfo =
-         KERN_ERR "sx: Warning: null sx port for device %s in %s\n";
        if (!port) {
                printk(badinfo, name, routine);
                return 1;
@@ -445,23 +438,24 @@ static inline int sx_paranoia_check(struct sx_port const * port,
 #define TIMEOUT_1 30
 #define TIMEOUT_2 1000000
 
-
 #ifdef DEBUG
 static void my_hd_io(void __iomem *p, int len)
 {
        int i, j, ch;
        unsigned char __iomem *addr = p;
 
-       for (i=0;i<len;i+=16) {
-               printk ("%p ", addr+i);
-               for (j=0;j<16;j++) {
-                       printk ("%02x %s", readb(addr+j+i), (j==7)?" ":"");
+       for (i = 0; i < len; i += 16) {
+               printk("%p ", addr + i);
+               for (j = 0; j < 16; j++) {
+                       printk("%02x %s", readb(addr + j + i),
+                                       (j == 7) ? " " : "");
                }
-               for (j=0;j<16;j++) {
-                       ch = readb(addr+j+i);
-                       printk ("%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
+               for (j = 0; j < 16; j++) {
+                       ch = readb(addr + j + i);
+                       printk("%c", (ch < 0x20) ? '.' :
+                                       ((ch > 0x7f) ? '.' : ch));
                }
-               printk ("\n");
+               printk("\n");
        }
 }
 static void my_hd(void *p, int len)
@@ -469,419 +463,468 @@ static void my_hd(void *p, int len)
        int i, j, ch;
        unsigned char *addr = p;
 
-       for (i=0;i<len;i+=16) {
-               printk ("%p ", addr+i);
-               for (j=0;j<16;j++) {
-                       printk ("%02x %s", addr[j+i], (j==7)?" ":"");
+       for (i = 0; i < len; i += 16) {
+               printk("%p ", addr + i);
+               for (j = 0; j < 16; j++) {
+                       printk("%02x %s", addr[j + i], (j == 7) ? " " : "");
                }
-               for (j=0;j<16;j++) {
-                       ch = addr[j+i];
-                       printk ("%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
+               for (j = 0; j < 16; j++) {
+                       ch = addr[j + i];
+                       printk("%c", (ch < 0x20) ? '.' :
+                                       ((ch > 0x7f) ? '.' : ch));
                }
-               printk ("\n");
+               printk("\n");
        }
 }
 #endif
 
-
-
 /* This needs redoing for Alpha -- REW -- Done. */
 
-static inline void write_sx_byte (struct sx_board *board, int offset, u8 byte)
+static inline void write_sx_byte(struct sx_board *board, int offset, u8 byte)
 {
-       writeb (byte, board->base+offset);
+       writeb(byte, board->base + offset);
 }
 
-static inline u8 read_sx_byte (struct sx_board *board, int offset)
+static inline u8 read_sx_byte(struct sx_board *board, int offset)
 {
-       return readb (board->base+offset);
+       return readb(board->base + offset);
 }
 
-
-static inline void write_sx_word (struct sx_board *board, int offset, u16 word)
+static inline void write_sx_word(struct sx_board *board, int offset, u16 word)
 {
-       writew (word, board->base+offset);
+       writew(word, board->base + offset);
 }
 
-static inline u16 read_sx_word (struct sx_board *board, int offset)
+static inline u16 read_sx_word(struct sx_board *board, int offset)
 {
-       return readw (board->base + offset);
+       return readw(board->base + offset);
 }
 
-
-static int sx_busy_wait_eq (struct sx_board *board, 
-                           int offset, int mask, int correctval)
+static int sx_busy_wait_eq(struct sx_board *board,
+               int offset, int mask, int correctval)
 {
        int i;
 
-       func_enter ();
+       func_enter();
 
-       for (i=0; i < TIMEOUT_1 ;i++)
-               if ((read_sx_byte (board, offset) & mask) == correctval) {
-                       func_exit ();
+       for (i = 0; i < TIMEOUT_1; i++)
+               if ((read_sx_byte(board, offset) & mask) == correctval) {
+                       func_exit();
                        return 1;
                }
 
-       for (i=0; i < TIMEOUT_2 ;i++) {
-               if ((read_sx_byte (board, offset) & mask) == correctval) {
-                       func_exit ();
+       for (i = 0; i < TIMEOUT_2; i++) {
+               if ((read_sx_byte(board, offset) & mask) == correctval) {
+                       func_exit();
                        return 1;
                }
-               udelay (1);
+               udelay(1);
        }
 
-       func_exit ();
+       func_exit();
        return 0;
 }
 
-
-static int sx_busy_wait_neq (struct sx_board *board, 
-                            int offset, int mask, int badval)
+static int sx_busy_wait_neq(struct sx_board *board,
+               int offset, int mask, int badval)
 {
        int i;
 
-       func_enter ();
+       func_enter();
 
-       for (i=0; i < TIMEOUT_1 ;i++)
-               if ((read_sx_byte (board, offset) & mask) != badval) {
-                       func_exit ();
+       for (i = 0; i < TIMEOUT_1; i++)
+               if ((read_sx_byte(board, offset) & mask) != badval) {
+                       func_exit();
                        return 1;
                }
 
-       for (i=0; i < TIMEOUT_2 ;i++) {
-               if ((read_sx_byte (board, offset) & mask) != badval) {
-                       func_exit ();
+       for (i = 0; i < TIMEOUT_2; i++) {
+               if ((read_sx_byte(board, offset) & mask) != badval) {
+                       func_exit();
                        return 1;
                }
-               udelay (1);
+               udelay(1);
        }
 
-       func_exit ();
+       func_exit();
        return 0;
 }
 
-
-
 /* 5.6.4 of 6210028 r2.3 */
-static int sx_reset (struct sx_board *board)
+static int sx_reset(struct sx_board *board)
 {
-       func_enter ();
+       func_enter();
 
-       if (IS_SX_BOARD (board)) {
+       if (IS_SX_BOARD(board)) {
 
-               write_sx_byte (board, SX_CONFIG, 0);
-               write_sx_byte (board, SX_RESET, 1); /* Value doesn't matter */
+               write_sx_byte(board, SX_CONFIG, 0);
+               write_sx_byte(board, SX_RESET, 1); /* Value doesn't matter */
 
-               if (!sx_busy_wait_eq (board, SX_RESET_STATUS, 1, 0)) {
-                       printk (KERN_INFO "sx: Card doesn't respond to reset....\n");
+               if (!sx_busy_wait_eq(board, SX_RESET_STATUS, 1, 0)) {
+                       printk(KERN_INFO "sx: Card doesn't respond to "
+                                       "reset...\n");
                        return 0;
                }
        } else if (IS_EISA_BOARD(board)) {
-               outb(board->irq<<4, board->eisa_base+0xc02);
+               outb(board->irq << 4, board->eisa_base + 0xc02);
        } else if (IS_SI1_BOARD(board)) {
-               write_sx_byte (board, SI1_ISA_RESET,   0); // value does not matter
+               write_sx_byte(board, SI1_ISA_RESET, 0); /*value doesn't matter*/
        } else {
                /* Gory details of the SI/ISA board */
-               write_sx_byte (board, SI2_ISA_RESET,    SI2_ISA_RESET_SET);
-               write_sx_byte (board, SI2_ISA_IRQ11,    SI2_ISA_IRQ11_CLEAR);
-               write_sx_byte (board, SI2_ISA_IRQ12,    SI2_ISA_IRQ12_CLEAR);
-               write_sx_byte (board, SI2_ISA_IRQ15,    SI2_ISA_IRQ15_CLEAR);
-               write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
-               write_sx_byte (board, SI2_ISA_IRQSET,   SI2_ISA_IRQSET_CLEAR);
+               write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_SET);
+               write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_CLEAR);
+               write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_CLEAR);
+               write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_CLEAR);
+               write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
+               write_sx_byte(board, SI2_ISA_IRQSET, SI2_ISA_IRQSET_CLEAR);
        }
 
-       func_exit ();
+       func_exit();
        return 1;
 }
 
-
 /* This doesn't work on machines where "NULL" isn't 0 */
 /* If you have one of those, someone will need to write 
    the equivalent of this, which will amount to about 3 lines. I don't
    want to complicate this right now. -- REW
    (See, I do write comments every now and then :-) */
-#define OFFSETOF(strct, elem) ((long)&(((struct strct *)NULL)->elem))
-
-
-#define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
-#define MODU_OFFSET(board,addr,elem)    (addr + OFFSETOF (_SXMODULE, elem))
-#define  BRD_OFFSET(board,elem)                (OFFSETOF (_SXCARD, elem))
+#define OFFSETOF(strct, elem)  ((long)&(((struct strct *)NULL)->elem))
 
+#define CHAN_OFFSET(port,elem) (port->ch_base + OFFSETOF (_SXCHANNEL, elem))
+#define MODU_OFFSET(board,addr,elem)   (addr + OFFSETOF (_SXMODULE, elem))
+#define  BRD_OFFSET(board,elem)        (OFFSETOF (_SXCARD, elem))
 
 #define sx_write_channel_byte(port, elem, val) \
-   write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
+       write_sx_byte (port->board, CHAN_OFFSET (port, elem), val)
 
 #define sx_read_channel_byte(port, elem) \
-   read_sx_byte (port->board, CHAN_OFFSET (port, elem))
+       read_sx_byte (port->board, CHAN_OFFSET (port, elem))
 
 #define sx_write_channel_word(port, elem, val) \
-   write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
+       write_sx_word (port->board, CHAN_OFFSET (port, elem), val)
 
 #define sx_read_channel_word(port, elem) \
-   read_sx_word (port->board, CHAN_OFFSET (port, elem))
-
+       read_sx_word (port->board, CHAN_OFFSET (port, elem))
 
 #define sx_write_module_byte(board, addr, elem, val) \
-   write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
+       write_sx_byte (board, MODU_OFFSET (board, addr, elem), val)
 
 #define sx_read_module_byte(board, addr, elem) \
-   read_sx_byte (board, MODU_OFFSET (board, addr, elem))
+       read_sx_byte (board, MODU_OFFSET (board, addr, elem))
 
 #define sx_write_module_word(board, addr, elem, val) \
-   write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
+       write_sx_word (board, MODU_OFFSET (board, addr, elem), val)
 
 #define sx_read_module_word(board, addr, elem) \
-   read_sx_word (board, MODU_OFFSET (board, addr, elem))
-
+       read_sx_word (board, MODU_OFFSET (board, addr, elem))
 
 #define sx_write_board_byte(board, elem, val) \
-   write_sx_byte (board, BRD_OFFSET (board, elem), val)
+       write_sx_byte (board, BRD_OFFSET (board, elem), val)
 
 #define sx_read_board_byte(board, elem) \
-   read_sx_byte (board, BRD_OFFSET (board, elem))
+       read_sx_byte (board, BRD_OFFSET (board, elem))
 
 #define sx_write_board_word(board, elem, val) \
-   write_sx_word (board, BRD_OFFSET (board, elem), val)
+       write_sx_word (board, BRD_OFFSET (board, elem), val)
 
 #define sx_read_board_word(board, elem) \
-   read_sx_word (board, BRD_OFFSET (board, elem))
-
+       read_sx_word (board, BRD_OFFSET (board, elem))
 
-static int sx_start_board (struct sx_board *board)
+static int sx_start_board(struct sx_board *board)
 {
-       if (IS_SX_BOARD (board)) {
-               write_sx_byte (board, SX_CONFIG, SX_CONF_BUSEN);
+       if (IS_SX_BOARD(board)) {
+               write_sx_byte(board, SX_CONFIG, SX_CONF_BUSEN);
        } else if (IS_EISA_BOARD(board)) {
                write_sx_byte(board, SI2_EISA_OFF, SI2_EISA_VAL);
-               outb((board->irq<<4)|4, board->eisa_base+0xc02);
+               outb((board->irq << 4) | 4, board->eisa_base + 0xc02);
        } else if (IS_SI1_BOARD(board)) {
-               write_sx_byte (board, SI1_ISA_RESET_CLEAR, 0);
-               write_sx_byte (board, SI1_ISA_INTCL, 0);
+               write_sx_byte(board, SI1_ISA_RESET_CLEAR, 0);
+               write_sx_byte(board, SI1_ISA_INTCL, 0);
        } else {
                /* Don't bug me about the clear_set. 
                   I haven't the foggiest idea what it's about -- REW */
-               write_sx_byte (board, SI2_ISA_RESET,    SI2_ISA_RESET_CLEAR);
-               write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
+               write_sx_byte(board, SI2_ISA_RESET, SI2_ISA_RESET_CLEAR);
+               write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
        }
        return 1;
 }
 
 #define SX_IRQ_REG_VAL(board) \
-        ((board->flags & SX_ISA_BOARD)?(board->irq << 4):0)
+       ((board->flags & SX_ISA_BOARD) ? (board->irq << 4) : 0)
 
 /* Note. The SX register is write-only. Therefore, we have to enable the
    bus too. This is a no-op, if you don't mess with this driver... */
-static int sx_start_interrupts (struct sx_board *board)
+static int sx_start_interrupts(struct sx_board *board)
 {
 
        /* Don't call this with board->irq == 0 */
 
        if (IS_SX_BOARD(board)) {
-               write_sx_byte (board, SX_CONFIG, SX_IRQ_REG_VAL (board) | 
-                                                SX_CONF_BUSEN | 
-                                                SX_CONF_HOSTIRQ);
+               write_sx_byte(board, SX_CONFIG, SX_IRQ_REG_VAL(board) |
+                               SX_CONF_BUSEN | SX_CONF_HOSTIRQ);
        } else if (IS_EISA_BOARD(board)) {
-               inb(board->eisa_base+0xc03);  
+               inb(board->eisa_base + 0xc03);
        } else if (IS_SI1_BOARD(board)) {
-              write_sx_byte (board, SI1_ISA_INTCL,0);
-              write_sx_byte (board, SI1_ISA_INTCL_CLEAR,0);
+               write_sx_byte(board, SI1_ISA_INTCL, 0);
+               write_sx_byte(board, SI1_ISA_INTCL_CLEAR, 0);
        } else {
                switch (board->irq) {
-               case 11:write_sx_byte (board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);break;
-               case 12:write_sx_byte (board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);break;
-               case 15:write_sx_byte (board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);break;
-               default:printk (KERN_INFO "sx: SI/XIO card doesn't support interrupt %d.\n", 
-                               board->irq);
-               return 0;
+               case 11:
+                       write_sx_byte(board, SI2_ISA_IRQ11, SI2_ISA_IRQ11_SET);
+                       break;
+               case 12:
+                       write_sx_byte(board, SI2_ISA_IRQ12, SI2_ISA_IRQ12_SET);
+                       break;
+               case 15:
+                       write_sx_byte(board, SI2_ISA_IRQ15, SI2_ISA_IRQ15_SET);
+                       break;
+               default:
+                       printk(KERN_INFO "sx: SI/XIO card doesn't support "
+                                       "interrupt %d.\n", board->irq);
+                       return 0;
                }
-               write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
+               write_sx_byte(board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
        }
 
        return 1;
 }
 
-
-static int sx_send_command (struct sx_port *port, 
-                           int command, int mask, int newstat)
+static int sx_send_command(struct sx_port *port,
+               int command, int mask, int newstat)
 {
-       func_enter2 ();
-       write_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat), command);
-       func_exit ();
-       return sx_busy_wait_eq (port->board, CHAN_OFFSET (port, hi_hstat), mask, newstat);
+       func_enter2();
+       write_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat), command);
+       func_exit();
+       return sx_busy_wait_eq(port->board, CHAN_OFFSET(port, hi_hstat), mask,
+                       newstat);
 }
 
-
-static char *mod_type_s (int module_type)
+static char *mod_type_s(int module_type)
 {
        switch (module_type) {
-       case TA4:       return "TA4";
-       case TA8:       return "TA8";
-       case TA4_ASIC:  return "TA4_ASIC";
-       case TA8_ASIC:  return "TA8_ASIC";
-       case MTA_CD1400:return "MTA_CD1400";
-       case SXDC:      return "SXDC";
-       default:return "Unknown/invalid";
+       case TA4:
+               return "TA4";
+       case TA8:
+               return "TA8";
+       case TA4_ASIC:
+               return "TA4_ASIC";
+       case TA8_ASIC:
+               return "TA8_ASIC";
+       case MTA_CD1400:
+               return "MTA_CD1400";
+       case SXDC:
+               return "SXDC";
+       default:
+               return "Unknown/invalid";
        }
 }
 
-
-static char *pan_type_s (int pan_type)
+static char *pan_type_s(int pan_type)
 {
        switch (pan_type) {
-       case MOD_RS232DB25:     return "MOD_RS232DB25";
-       case MOD_RS232RJ45:     return "MOD_RS232RJ45";
-       case MOD_RS422DB25:     return "MOD_RS422DB25";
-       case MOD_PARALLEL:      return "MOD_PARALLEL";
-       case MOD_2_RS232DB25:   return "MOD_2_RS232DB25";
-       case MOD_2_RS232RJ45:   return "MOD_2_RS232RJ45";
-       case MOD_2_RS422DB25:   return "MOD_2_RS422DB25";
-       case MOD_RS232DB25MALE: return "MOD_RS232DB25MALE";
-       case MOD_2_PARALLEL:    return "MOD_2_PARALLEL";
-       case MOD_BLANK:         return "empty";
-       default:return "invalid";
+       case MOD_RS232DB25:
+               return "MOD_RS232DB25";
+       case MOD_RS232RJ45:
+               return "MOD_RS232RJ45";
+       case MOD_RS422DB25:
+               return "MOD_RS422DB25";
+       case MOD_PARALLEL:
+               return "MOD_PARALLEL";
+       case MOD_2_RS232DB25:
+               return "MOD_2_RS232DB25";
+       case MOD_2_RS232RJ45:
+               return "MOD_2_RS232RJ45";
+       case MOD_2_RS422DB25:
+               return "MOD_2_RS422DB25";
+       case MOD_RS232DB25MALE:
+               return "MOD_RS232DB25MALE";
+       case MOD_2_PARALLEL:
+               return "MOD_2_PARALLEL";
+       case MOD_BLANK:
+               return "empty";
+       default:
+               return "invalid";
        }
 }
 
-
-static int mod_compat_type (int module_type)
+static int mod_compat_type(int module_type)
 {
        return module_type >> 4;
 }
 
 static void sx_reconfigure_port(struct sx_port *port)
 {
-       if (sx_read_channel_byte (port, hi_hstat) == HS_IDLE_OPEN) {
-               if (sx_send_command (port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
-                       printk (KERN_WARNING "sx: Sent reconfigure command, but card didn't react.\n");
+       if (sx_read_channel_byte(port, hi_hstat) == HS_IDLE_OPEN) {
+               if (sx_send_command(port, HS_CONFIG, -1, HS_IDLE_OPEN) != 1) {
+                       printk(KERN_WARNING "sx: Sent reconfigure command, but "
+                                       "card didn't react.\n");
                }
        } else {
-               sx_dprintk (SX_DEBUG_TERMIOS, 
-                           "sx: Not sending reconfigure: port isn't open (%02x).\n", 
-                           sx_read_channel_byte (port, hi_hstat));
-       }       
+               sx_dprintk(SX_DEBUG_TERMIOS, "sx: Not sending reconfigure: "
+                               "port isn't open (%02x).\n",
+                               sx_read_channel_byte(port, hi_hstat));
+       }
 }
 
-static void sx_setsignals (struct sx_port *port, int dtr, int rts)
+static void sx_setsignals(struct sx_port *port, int dtr, int rts)
 {
        int t;
-       func_enter2 ();
+       func_enter2();
 
-       t = sx_read_channel_byte (port, hi_op);
-       if (dtr >= 0) t = dtr? (t | OP_DTR): (t & ~OP_DTR);
-       if (rts >= 0) t = rts? (t | OP_RTS): (t & ~OP_RTS);
-       sx_write_channel_byte (port, hi_op, t);
-       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
+       t = sx_read_channel_byte(port, hi_op);
+       if (dtr >= 0)
+               t = dtr ? (t | OP_DTR) : (t & ~OP_DTR);
+       if (rts >= 0)
+               t = rts ? (t | OP_RTS) : (t & ~OP_RTS);
+       sx_write_channel_byte(port, hi_op, t);
+       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "setsignals: %d/%d\n", dtr, rts);
 
-       func_exit ();
+       func_exit();
 }
 
-
-
-static int sx_getsignals (struct sx_port *port)
+static int sx_getsignals(struct sx_port *port)
 {
-       int i_stat,o_stat;
-
-       o_stat = sx_read_channel_byte (port, hi_op);
-       i_stat = sx_read_channel_byte (port, hi_ip);
-
-       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) %02x/%02x\n",
-                   (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
-                   port->c_dcd, sx_get_CD (port),
-                   sx_read_channel_byte (port, hi_ip),
-                   sx_read_channel_byte (port, hi_state));
-
-       return (((o_stat & OP_DTR)?TIOCM_DTR:0) |
-               ((o_stat & OP_RTS)?TIOCM_RTS:0) |
-               ((i_stat & IP_CTS)?TIOCM_CTS:0) |
-               ((i_stat & IP_DCD)?TIOCM_CAR:0) |
-               ((i_stat & IP_DSR)?TIOCM_DSR:0) |
-               ((i_stat & IP_RI)?TIOCM_RNG:0)
-               );
+       int i_stat, o_stat;
+
+       o_stat = sx_read_channel_byte(port, hi_op);
+       i_stat = sx_read_channel_byte(port, hi_ip);
+
+       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "getsignals: %d/%d  (%d/%d) "
+                       "%02x/%02x\n",
+                       (o_stat & OP_DTR) != 0, (o_stat & OP_RTS) != 0,
+                       port->c_dcd, sx_get_CD(port),
+                       sx_read_channel_byte(port, hi_ip),
+                       sx_read_channel_byte(port, hi_state));
+
+       return (((o_stat & OP_DTR) ? TIOCM_DTR : 0) |
+               ((o_stat & OP_RTS) ? TIOCM_RTS : 0) |
+               ((i_stat & IP_CTS) ? TIOCM_CTS : 0) |
+               ((i_stat & IP_DCD) ? TIOCM_CAR : 0) |
+               ((i_stat & IP_DSR) ? TIOCM_DSR : 0) |
+               ((i_stat & IP_RI) ? TIOCM_RNG : 0));
 }
 
-
-static void sx_set_baud (struct sx_port *port)
+static void sx_set_baud(struct sx_port *port)
 {
        int t;
 
        if (port->board->ta_type == MOD_SXDC) {
                switch (port->gs.baud) {
-                 /* Save some typing work... */
-#define e(x) case x:t= BAUD_ ## x ; break
-                       e(50);e(75);e(110);e(150);e(200);e(300);e(600);
-                        e(1200);e(1800);e(2000);e(2400);e(4800);e(7200);
-                        e(9600);e(14400);e(19200);e(28800);e(38400);
-                        e(56000);e(57600);e(64000);e(76800);e(115200);
-                       e(128000);e(150000);e(230400);e(256000);e(460800);
-                        e(921600);
-               case 134    :t = BAUD_134_5;   break;
-               case 0      :t = -1;
-                                                                break;
+                       /* Save some typing work... */
+#define e(x) case x: t = BAUD_ ## x; break
+                       e(50);
+                       e(75);
+                       e(110);
+                       e(150);
+                       e(200);
+                       e(300);
+                       e(600);
+                       e(1200);
+                       e(1800);
+                       e(2000);
+                       e(2400);
+                       e(4800);
+                       e(7200);
+                       e(9600);
+                       e(14400);
+                       e(19200);
+                       e(28800);
+                       e(38400);
+                       e(56000);
+                       e(57600);
+                       e(64000);
+                       e(76800);
+                       e(115200);
+                       e(128000);
+                       e(150000);
+                       e(230400);
+                       e(256000);
+                       e(460800);
+                       e(921600);
+               case 134:
+                       t = BAUD_134_5;
+                       break;
+               case 0:
+                       t = -1;
+                       break;
                default:
                        /* Can I return "invalid"? */
                        t = BAUD_9600;
-                       printk (KERN_INFO "sx: unsupported baud rate: %d.\n", port->gs.baud);
+                       printk(KERN_INFO "sx: unsupported baud rate: %d.\n",
+                                       port->gs.baud);
                        break;
                }
 #undef e
                if (t > 0) {
-                       /* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
-                       sx_setsignals (port, 1, -1); 
+/* The baud rate is not set to 0, so we're enabeling DTR... -- REW */
+                       sx_setsignals(port, 1, -1);
                        /* XXX This is not TA & MTA compatible */
-                       sx_write_channel_byte (port, hi_csr, 0xff);
+                       sx_write_channel_byte(port, hi_csr, 0xff);
 
-                       sx_write_channel_byte (port, hi_txbaud, t);
-                       sx_write_channel_byte (port, hi_rxbaud, t);
+                       sx_write_channel_byte(port, hi_txbaud, t);
+                       sx_write_channel_byte(port, hi_rxbaud, t);
                } else {
-                       sx_setsignals (port, 0, -1);
+                       sx_setsignals(port, 0, -1);
                }
        } else {
                switch (port->gs.baud) {
-#define e(x) case x:t= CSR_ ## x ; break
-                       e(75);e(150);e(300);e(600);e(1200);e(2400);e(4800);
-                        e(1800);e(9600);
-                       e(19200);e(57600);e(38400);
-                       /* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
-               case 110: 
+#define e(x) case x: t = CSR_ ## x; break
+                       e(75);
+                       e(150);
+                       e(300);
+                       e(600);
+                       e(1200);
+                       e(2400);
+                       e(4800);
+                       e(1800);
+                       e(9600);
+                       e(19200);
+                       e(57600);
+                       e(38400);
+/* TA supports 110, but not 115200, MTA supports 115200, but not 110 */
+               case 110:
                        if (port->board->ta_type == MOD_TA) {
                                t = CSR_110;
                                break;
                        } else {
                                t = CSR_9600;
-                               printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
+                               printk(KERN_INFO "sx: Unsupported baud rate: "
+                                               "%d.\n", port->gs.baud);
                                break;
                        }
-               case 115200: 
+               case 115200:
                        if (port->board->ta_type == MOD_TA) {
                                t = CSR_9600;
-                               printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
+                               printk(KERN_INFO "sx: Unsupported baud rate: "
+                                               "%d.\n", port->gs.baud);
                                break;
                        } else {
                                t = CSR_110;
                                break;
                        }
-               case 0      :t = -1;
-                                                                break;
+               case 0:
+                       t = -1;
+                       break;
                default:
                        t = CSR_9600;
-                       printk (KERN_INFO "sx: Unsupported baud rate: %d.\n", port->gs.baud);
+                       printk(KERN_INFO "sx: Unsupported baud rate: %d.\n",
+                                       port->gs.baud);
                        break;
                }
 #undef e
                if (t >= 0) {
-                       sx_setsignals (port, 1, -1);
-                       sx_write_channel_byte (port, hi_csr, t * 0x11);
+                       sx_setsignals(port, 1, -1);
+                       sx_write_channel_byte(port, hi_csr, t * 0x11);
                } else {
-                       sx_setsignals (port, 0, -1);
+                       sx_setsignals(port, 0, -1);
                }
        }
 }
 
-
 /* Simon Allen's version of this routine was 225 lines long. 85 is a lot
    better. -- REW */
 
-static int sx_set_real_termios (void *ptr)
+static int sx_set_real_termios(void *ptr)
 {
        struct sx_port *port = ptr;
 
@@ -896,80 +939,83 @@ static int sx_set_real_termios (void *ptr)
           belongs (next to the drop dtr if baud == 0) -- REW */
        /* sx_setsignals (port, 1, -1); */
 
-       sx_set_baud (port);
+       sx_set_baud(port);
 
 #define CFLAG port->gs.tty->termios->c_cflag
-       sx_write_channel_byte (port, hi_mr1,
-                              (C_PARENB (port->gs.tty)? MR1_WITH:MR1_NONE) |
-                              (C_PARODD (port->gs.tty)? MR1_ODD:MR1_EVEN) |
-                              (C_CRTSCTS(port->gs.tty)? MR1_RTS_RXFLOW:0) |
-                              (((CFLAG & CSIZE)==CS8) ? MR1_8_BITS:0) |
-                              (((CFLAG & CSIZE)==CS7) ? MR1_7_BITS:0) |
-                              (((CFLAG & CSIZE)==CS6) ? MR1_6_BITS:0) |
-                              (((CFLAG & CSIZE)==CS5) ? MR1_5_BITS:0) );
-
-       sx_write_channel_byte (port, hi_mr2,
-                              (C_CRTSCTS(port->gs.tty)?MR2_CTS_TXFLOW:0) |
-                              (C_CSTOPB (port->gs.tty)?MR2_2_STOP:MR2_1_STOP));
+       sx_write_channel_byte(port, hi_mr1,
+                       (C_PARENB(port->gs.tty) ? MR1_WITH : MR1_NONE) |
+                       (C_PARODD(port->gs.tty) ? MR1_ODD : MR1_EVEN) |
+                       (C_CRTSCTS(port->gs.tty) ? MR1_RTS_RXFLOW : 0) |
+                       (((CFLAG & CSIZE) == CS8) ? MR1_8_BITS : 0) |
+                       (((CFLAG & CSIZE) == CS7) ? MR1_7_BITS : 0) |
+                       (((CFLAG & CSIZE) == CS6) ? MR1_6_BITS : 0) |
+                       (((CFLAG & CSIZE) == CS5) ? MR1_5_BITS : 0));
+
+       sx_write_channel_byte(port, hi_mr2,
+                       (C_CRTSCTS(port->gs.tty) ? MR2_CTS_TXFLOW : 0) |
+                       (C_CSTOPB(port->gs.tty) ? MR2_2_STOP :
+                       MR2_1_STOP));
 
        switch (CFLAG & CSIZE) {
-       case CS8:sx_write_channel_byte (port, hi_mask, 0xff);break;
-       case CS7:sx_write_channel_byte (port, hi_mask, 0x7f);break;
-       case CS6:sx_write_channel_byte (port, hi_mask, 0x3f);break;
-       case CS5:sx_write_channel_byte (port, hi_mask, 0x1f);break;
+       case CS8:
+               sx_write_channel_byte(port, hi_mask, 0xff);
+               break;
+       case CS7:
+               sx_write_channel_byte(port, hi_mask, 0x7f);
+               break;
+       case CS6:
+               sx_write_channel_byte(port, hi_mask, 0x3f);
+               break;
+       case CS5:
+               sx_write_channel_byte(port, hi_mask, 0x1f);
+               break;
        default:
-               printk (KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
+               printk(KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
                break;
        }
 
-       sx_write_channel_byte (port, hi_prtcl, 
-                              (I_IXON   (port->gs.tty)?SP_TXEN:0) |
-                              (I_IXOFF  (port->gs.tty)?SP_RXEN:0) |
-                              (I_IXANY  (port->gs.tty)?SP_TANY:0) |
-                              SP_DCEN);
+       sx_write_channel_byte(port, hi_prtcl,
+                       (I_IXON(port->gs.tty) ? SP_TXEN : 0) |
+                       (I_IXOFF(port->gs.tty) ? SP_RXEN : 0) |
+                       (I_IXANY(port->gs.tty) ? SP_TANY : 0) | SP_DCEN);
 
-       sx_write_channel_byte (port, hi_break, 
-                              (I_IGNBRK(port->gs.tty)?BR_IGN:0 |
-                               I_BRKINT(port->gs.tty)?BR_INT:0));
+       sx_write_channel_byte(port, hi_break,
+                       (I_IGNBRK(port->gs.tty) ? BR_IGN : 0 |
+                       I_BRKINT(port->gs.tty) ? BR_INT : 0));
 
-       sx_write_channel_byte (port, hi_txon,  START_CHAR (port->gs.tty));
-       sx_write_channel_byte (port, hi_rxon,  START_CHAR (port->gs.tty));
-       sx_write_channel_byte (port, hi_txoff, STOP_CHAR  (port->gs.tty));
-       sx_write_channel_byte (port, hi_rxoff, STOP_CHAR  (port->gs.tty));
+       sx_write_channel_byte(port, hi_txon, START_CHAR(port->gs.tty));
+       sx_write_channel_byte(port, hi_rxon, START_CHAR(port->gs.tty));
+       sx_write_channel_byte(port, hi_txoff, STOP_CHAR(port->gs.tty));
+       sx_write_channel_byte(port, hi_rxoff, STOP_CHAR(port->gs.tty));
 
        sx_reconfigure_port(port);
 
        /* Tell line discipline whether we will do input cooking */
-       if(I_OTHER(port->gs.tty)) {
+       if (I_OTHER(port->gs.tty)) {
                clear_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
        } else {
                set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
        }
-       sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
-                   port->gs.tty->termios->c_iflag, 
-                   I_OTHER(port->gs.tty));
-
+       sx_dprintk(SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
+                       port->gs.tty->termios->c_iflag, I_OTHER(port->gs.tty));
 
 /* Tell line discipline whether we will do output cooking.
  * If OPOST is set and no other output flags are set then we can do output
  * processing.  Even if only *one* other flag in the O_OTHER group is set
  * we do cooking in software.
  */
-       if(O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
+       if (O_OPOST(port->gs.tty) && !O_OTHER(port->gs.tty)) {
                set_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
        } else {
                clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
        }
-       sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
-                   port->gs.tty->termios->c_oflag, 
-                   O_OTHER(port->gs.tty));
+       sx_dprintk(SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
+                       port->gs.tty->termios->c_oflag, O_OTHER(port->gs.tty));
        /* port->c_dcd = sx_get_CD (port); */
-       func_exit ();
+       func_exit();
        return 0;
 }
 
-
-
 /* ********************************************************************** *
  *                   the interrupt related routines                       *
  * ********************************************************************** */
@@ -985,245 +1031,260 @@ static int sx_set_real_termios (void *ptr)
    know I'm dead against that, but I think it is required in this
    case.  */
 
-
-static void sx_transmit_chars (struct sx_port *port)
+static void sx_transmit_chars(struct sx_port *port)
 {
        int c;
        int tx_ip;
        int txroom;
 
-       func_enter2 ();
-       sx_dprintk (SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n", 
-                   port, port->gs.xmit_cnt);
+       func_enter2();
+       sx_dprintk(SX_DEBUG_TRANSMIT, "Port %p: transmit %d chars\n",
+                       port, port->gs.xmit_cnt);
 
-       if (test_and_set_bit (SX_PORT_TRANSMIT_LOCK, &port->locks)) {
+       if (test_and_set_bit(SX_PORT_TRANSMIT_LOCK, &port->locks)) {
                return;
        }
 
        while (1) {
                c = port->gs.xmit_cnt;
 
-               sx_dprintk (SX_DEBUG_TRANSMIT, "Copying %d ", c);
-               tx_ip  = sx_read_channel_byte (port, hi_txipos);
+               sx_dprintk(SX_DEBUG_TRANSMIT, "Copying %d ", c);
+               tx_ip = sx_read_channel_byte(port, hi_txipos);
 
                /* Took me 5 minutes to deduce this formula. 
                   Luckily it is literally in the manual in section 6.5.4.3.5 */
-               txroom = (sx_read_channel_byte (port, hi_txopos) - tx_ip - 1) & 0xff;
+               txroom = (sx_read_channel_byte(port, hi_txopos) - tx_ip - 1) &
+                               0xff;
 
                /* Don't copy more bytes than there is room for in the buffer */
                if (c > txroom)
                        c = txroom;
-               sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom );
+               sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, txroom);
 
                /* Don't copy past the end of the hardware transmit buffer */
-               if (c > 0x100 - tx_ip) 
+               if (c > 0x100 - tx_ip)
                        c = 0x100 - tx_ip;
 
-               sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100-tx_ip );
+               sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%d) ", c, 0x100 - tx_ip);
 
                /* Don't copy pas the end of the source buffer */
-               if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail) 
+               if (c > SERIAL_XMIT_SIZE - port->gs.xmit_tail)
                        c = SERIAL_XMIT_SIZE - port->gs.xmit_tail;
 
-               sx_dprintk (SX_DEBUG_TRANSMIT, " %d(%ld) \n", 
-                           c, SERIAL_XMIT_SIZE- port->gs.xmit_tail);
-
-               /* If for one reason or another, we can't copy more data, we're done! */
-               if (c == 0) break;
+               sx_dprintk(SX_DEBUG_TRANSMIT, " %d(%ld) \n",
+                               c, SERIAL_XMIT_SIZE - port->gs.xmit_tail);
 
+               /* If for one reason or another, we can't copy more data, we're
+                  done! */
+               if (c == 0)
+                       break;
 
-               memcpy_toio (port->board->base + CHAN_OFFSET(port,hi_txbuf) + tx_ip, 
-                            port->gs.xmit_buf + port->gs.xmit_tail, c);
+               memcpy_toio(port->board->base + CHAN_OFFSET(port, hi_txbuf) +
+                       tx_ip, port->gs.xmit_buf + port->gs.xmit_tail, c);
 
                /* Update the pointer in the card */
-               sx_write_channel_byte (port, hi_txipos, (tx_ip+c) & 0xff);
+               sx_write_channel_byte(port, hi_txipos, (tx_ip + c) & 0xff);
 
                /* Update the kernel buffer end */
-               port->gs.xmit_tail = (port->gs.xmit_tail + c) & (SERIAL_XMIT_SIZE-1);
+               port->gs.xmit_tail = (port->gs.xmit_tail + c) &
+                               (SERIAL_XMIT_SIZE - 1);
 
                /* This one last. (this is essential)
-                  It would allow others to start putting more data into the buffer! */
+                  It would allow others to start putting more data into the
+                  buffer! */
                port->gs.xmit_cnt -= c;
        }
 
        if (port->gs.xmit_cnt == 0) {
-               sx_disable_tx_interrupts (port);
+               sx_disable_tx_interrupts(port);
        }
 
        if ((port->gs.xmit_cnt <= port->gs.wakeup_chars) && port->gs.tty) {
                tty_wakeup(port->gs.tty);
-               sx_dprintk (SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
-                           port->gs.wakeup_chars); 
+               sx_dprintk(SX_DEBUG_TRANSMIT, "Waking up.... ldisc (%d)....\n",
+                               port->gs.wakeup_chars);
        }
 
-       clear_bit (SX_PORT_TRANSMIT_LOCK, &port->locks);
-       func_exit ();
+       clear_bit(SX_PORT_TRANSMIT_LOCK, &port->locks);
+       func_exit();
 }
 
-
 /* Note the symmetry between receiving chars and transmitting them!
    Note: The kernel should have implemented both a receive buffer and
    a transmit buffer. */
 
 /* Inlined: Called only once. Remove the inline when you add another call */
-static inline void sx_receive_chars (struct sx_port *port)
+static inline void sx_receive_chars(struct sx_port *port)
 {
        int c;
        int rx_op;
        struct tty_struct *tty;
-       int copied=0;
+       int copied = 0;
        unsigned char *rp;
 
-       func_enter2 ();
+       func_enter2();
        tty = port->gs.tty;
        while (1) {
-               rx_op = sx_read_channel_byte (port, hi_rxopos);
-               c = (sx_read_channel_byte (port, hi_rxipos) - rx_op) & 0xff;
+               rx_op = sx_read_channel_byte(port, hi_rxopos);
+               c = (sx_read_channel_byte(port, hi_rxipos) - rx_op) & 0xff;
 
-               sx_dprintk (SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c); 
+               sx_dprintk(SX_DEBUG_RECEIVE, "rxop=%d, c = %d.\n", rx_op, c);
 
                /* Don't copy past the end of the hardware receive buffer */
-               if (rx_op + c > 0x100) c = 0x100 - rx_op;
+               if (rx_op + c > 0x100)
+                       c = 0x100 - rx_op;
 
-               sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c);
+               sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
 
                /* Don't copy more bytes than there is room for in the buffer */
 
                c = tty_prepare_flip_string(tty, &rp, c);
 
-               sx_dprintk (SX_DEBUG_RECEIVE, "c = %d.\n", c); 
+               sx_dprintk(SX_DEBUG_RECEIVE, "c = %d.\n", c);
 
                /* If for one reason or another, we can't copy more data, we're done! */
-               if (c == 0) break;
+               if (c == 0)
+                       break;
 
-               sx_dprintk (SX_DEBUG_RECEIVE , "Copying over %d chars. First is %d at %lx\n", c, 
-                           read_sx_byte (port->board, CHAN_OFFSET(port,hi_rxbuf) + rx_op),
-                           CHAN_OFFSET(port, hi_rxbuf)); 
-               memcpy_fromio (rp,
-                              port->board->base + CHAN_OFFSET(port,hi_rxbuf) + rx_op, c);
+               sx_dprintk(SX_DEBUG_RECEIVE, "Copying over %d chars. First is "
+                               "%d at %lx\n", c, read_sx_byte(port->board,
+                                       CHAN_OFFSET(port, hi_rxbuf) + rx_op),
+                               CHAN_OFFSET(port, hi_rxbuf));
+               memcpy_fromio(rp, port->board->base +
+                               CHAN_OFFSET(port, hi_rxbuf) + rx_op, c);
 
                /* This one last. ( Not essential.)
-                  It allows the card to start putting more data into the buffer! 
+                  It allows the card to start putting more data into the
+                  buffer!
                   Update the pointer in the card */
-               sx_write_channel_byte (port, hi_rxopos, (rx_op + c) & 0xff);
+               sx_write_channel_byte(port, hi_rxopos, (rx_op + c) & 0xff);
 
                copied += c;
        }
        if (copied) {
                struct timeval tv;
 
-               do_gettimeofday (&tv);
-               sx_dprintk (SX_DEBUG_RECEIVE, 
-                           "pushing flipq port %d (%3d chars): %d.%06d  (%d/%d)\n", 
-                           port->line, copied, 
-                           (int) (tv.tv_sec % 60), (int)tv.tv_usec, tty->raw, tty->real_raw);
+               do_gettimeofday(&tv);
+               sx_dprintk(SX_DEBUG_RECEIVE, "pushing flipq port %d (%3d "
+                               "chars): %d.%06d  (%d/%d)\n", port->line,
+                               copied, (int)(tv.tv_sec % 60), (int)tv.tv_usec,
+                               tty->raw, tty->real_raw);
 
-               /* Tell the rest of the system the news. Great news. New characters! */
-               tty_flip_buffer_push (tty);
+               /* Tell the rest of the system the news. Great news. New
+                  characters! */
+               tty_flip_buffer_push(tty);
                /*    tty_schedule_flip (tty); */
        }
 
-       func_exit ();
+       func_exit();
 }
 
 /* Inlined: it is called only once. Remove the inline if you add another 
    call */
-static inline void sx_check_modem_signals (struct sx_port *port)
+static inline void sx_check_modem_signals(struct sx_port *port)
 {
        int hi_state;
        int c_dcd;
 
-       hi_state = sx_read_channel_byte (port, hi_state);
-       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
-                   port->c_dcd, sx_get_CD (port));
+       hi_state = sx_read_channel_byte(port, hi_state);
+       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Checking modem signals (%d/%d)\n",
+                       port->c_dcd, sx_get_CD(port));
 
        if (hi_state & ST_BREAK) {
                hi_state &= ~ST_BREAK;
-               sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a break.\n");
-               sx_write_channel_byte (port, hi_state, hi_state);
-               gs_got_break (&port->gs);
+               sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a break.\n");
+               sx_write_channel_byte(port, hi_state, hi_state);
+               gs_got_break(&port->gs);
        }
        if (hi_state & ST_DCD) {
                hi_state &= ~ST_DCD;
-               sx_dprintk (SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
-               sx_write_channel_byte (port, hi_state, hi_state);
-               c_dcd = sx_get_CD (port);
-               sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
+               sx_dprintk(SX_DEBUG_MODEMSIGNALS, "got a DCD change.\n");
+               sx_write_channel_byte(port, hi_state, hi_state);
+               c_dcd = sx_get_CD(port);
+               sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD is now %d\n", c_dcd);
                if (c_dcd != port->c_dcd) {
                        port->c_dcd = c_dcd;
-                       if (sx_get_CD (port)) {
+                       if (sx_get_CD(port)) {
                                /* DCD went UP */
-                               if ((sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) &&
-                                               !(port->gs.tty->termios->c_cflag & CLOCAL) ) {
-                                       /* Are we blocking in open?*/
-                                       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD active, unblocking open\n");
-                                       wake_up_interruptible(&port->gs.open_wait);
+                               if ((sx_read_channel_byte(port, hi_hstat) !=
+                                               HS_IDLE_CLOSED) &&
+                                               !(port->gs.tty->termios->
+                                                       c_cflag & CLOCAL)) {
+                                       /* Are we blocking in open? */
+                                       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                               "active, unblocking open\n");
+                                       wake_up_interruptible(&port->gs.
+                                                       open_wait);
                                } else {
-                                       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD raised. Ignoring.\n");
+                                       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                               "raised. Ignoring.\n");
                                }
                        } else {
                                /* DCD went down! */
-                               if (!(port->gs.tty->termios->c_cflag & CLOCAL) ) {
-                                       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. hanging up....\n");
-                                       tty_hangup (port->gs.tty);
+                               if (!(port->gs.tty->termios->c_cflag & CLOCAL)){
+                                       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                               "dropped. hanging up....\n");
+                                       tty_hangup(port->gs.tty);
                                } else {
-                                       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "DCD dropped. ignoring.\n");
+                                       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "DCD "
+                                               "dropped. ignoring.\n");
                                }
                        }
                } else {
-                       sx_dprintk (SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us DCD changed, but it didn't.\n");
+                       sx_dprintk(SX_DEBUG_MODEMSIGNALS, "Hmmm. card told us "
+                               "DCD changed, but it didn't.\n");
                }
        }
 }
 
-
 /* This is what an interrupt routine should look like. 
  * Small, elegant, clear.
  */
 
-static irqreturn_t sx_interrupt (int irq, void *ptr)
+static irqreturn_t sx_interrupt(int irq, void *ptr)
 {
        struct sx_board *board = ptr;
        struct sx_port *port;
        int i;
 
-       func_enter ();
-       sx_dprintk (SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq, board->irq); 
+       func_enter();
+       sx_dprintk(SX_DEBUG_FLOW, "sx: enter sx_interrupt (%d/%d)\n", irq,
+                       board->irq);
 
        /* AAargh! The order in which to do these things is essential and
           not trivial. 
 
           - Rate limit goes before "recursive". Otherwise a series of
-            recursive calls will hang the machine in the interrupt routine. 
+          recursive calls will hang the machine in the interrupt routine.
 
           - hardware twiddling goes before "recursive". Otherwise when we
-            poll the card, and a recursive interrupt happens, we won't
-            ack the card, so it might keep on interrupting us. (especially
-            level sensitive interrupt systems like PCI).
+          poll the card, and a recursive interrupt happens, we won't
+          ack the card, so it might keep on interrupting us. (especially
+          level sensitive interrupt systems like PCI).
 
           - Rate limit goes before hardware twiddling. Otherwise we won't
-            catch a card that has gone bonkers.
+          catch a card that has gone bonkers.
 
           - The "initialized" test goes after the hardware twiddling. Otherwise
-            the card will stick us in the interrupt routine again.
+          the card will stick us in the interrupt routine again.
 
           - The initialized test goes before recursive. 
-       */
-
-
+        */
 
 #ifdef IRQ_RATE_LIMIT
        /* Aaargh! I'm ashamed. This costs more lines-of-code than the
-          actual interrupt routine!. (Well, used to when I wrote that comment) */
+          actual interrupt routine!. (Well, used to when I wrote that
+          comment) */
        {
                static int lastjif;
-               static int nintr=0;
+               static int nintr = 0;
 
                if (lastjif == jiffies) {
                        if (++nintr > IRQ_RATE_LIMIT) {
-                               free_irq (board->irq, board);
-                               printk (KERN_ERR "sx: Too many interrupts. Turning off interrupt %d.\n", 
-                                             board->irq);
+                               free_irq(board->irq, board);
+                               printk(KERN_ERR "sx: Too many interrupts. "
+                                               "Turning off interrupt %d.\n",
+                                               board->irq);
                        }
                } else {
                        lastjif = jiffies;
@@ -1232,19 +1293,20 @@ static irqreturn_t sx_interrupt (int irq, void *ptr)
        }
 #endif
 
-
        if (board->irq == irq) {
                /* Tell the card we've noticed the interrupt. */
 
-               sx_write_board_word (board, cc_int_pending, 0);
-               if (IS_SX_BOARD (board)) {
-                       write_sx_byte (board, SX_RESET_IRQ, 1);
+               sx_write_board_word(board, cc_int_pending, 0);
+               if (IS_SX_BOARD(board)) {
+                       write_sx_byte(board, SX_RESET_IRQ, 1);
                } else if (IS_EISA_BOARD(board)) {
-                       inb(board->eisa_base+0xc03);
-                       write_sx_word(board, 8, 0); 
+                       inb(board->eisa_base + 0xc03);
+                       write_sx_word(board, 8, 0);
                } else {
-                       write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_CLEAR);
-                       write_sx_byte (board, SI2_ISA_INTCLEAR, SI2_ISA_INTCLEAR_SET);
+                       write_sx_byte(board, SI2_ISA_INTCLEAR,
+                                       SI2_ISA_INTCLEAR_CLEAR);
+                       write_sx_byte(board, SI2_ISA_INTCLEAR,
+                                       SI2_ISA_INTCLEAR_SET);
                }
        }
 
@@ -1253,53 +1315,48 @@ static irqreturn_t sx_interrupt (int irq, void *ptr)
        if (!(board->flags & SX_BOARD_INITIALIZED))
                return IRQ_HANDLED;
 
-       if (test_and_set_bit (SX_BOARD_INTR_LOCK, &board->locks)) {
-               printk (KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
+       if (test_and_set_bit(SX_BOARD_INTR_LOCK, &board->locks)) {
+               printk(KERN_ERR "Recursive interrupt! (%d)\n", board->irq);
                return IRQ_HANDLED;
        }
 
-        for (i=0;i<board->nports;i++) {
+       for (i = 0; i < board->nports; i++) {
                port = &board->ports[i];
                if (port->gs.flags & GS_ACTIVE) {
-                       if (sx_read_channel_byte (port, hi_state)) {
-                               sx_dprintk (SX_DEBUG_INTERRUPTS, 
-                                           "Port %d: modem signal change?... \n", i);
-                               sx_check_modem_signals (port); 
+                       if (sx_read_channel_byte(port, hi_state)) {
+                               sx_dprintk(SX_DEBUG_INTERRUPTS, "Port %d: "
+                                               "modem signal change?... \n",i);
+                               sx_check_modem_signals(port);
                        }
                        if (port->gs.xmit_cnt) {
-                               sx_transmit_chars (port);
+                               sx_transmit_chars(port);
                        }
                        if (!(port->gs.flags & SX_RX_THROTTLE)) {
-                               sx_receive_chars (port);
+                               sx_receive_chars(port);
                        }
                }
        }
 
-       clear_bit (SX_BOARD_INTR_LOCK, &board->locks);
+       clear_bit(SX_BOARD_INTR_LOCK, &board->locks);
 
-       sx_dprintk (SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq, board->irq); 
-        func_exit ();
+       sx_dprintk(SX_DEBUG_FLOW, "sx: exit sx_interrupt (%d/%d)\n", irq,
+                       board->irq);
+       func_exit();
        return IRQ_HANDLED;
 }
 
-
-static void sx_pollfunc (unsigned long data)
+static void sx_pollfunc(unsigned long data)
 {
-       struct sx_board *board = (struct sx_board *) data;
+       struct sx_board *board = (struct sx_board *)data;
 
-       func_enter ();
-
-       sx_interrupt (0, board);
+       func_enter();
 
-       init_timer(&board->timer);
+       sx_interrupt(0, board);
 
-       board->timer.expires = jiffies + sx_poll;
-       add_timer (&board->timer);
-       func_exit ();
+       mod_timer(&board->timer, jiffies + sx_poll);
+       func_exit();
 }
 
-
-
 /* ********************************************************************** *
  *                Here are the routines that actually                     *
  *              interface with the generic_serial driver                  *
@@ -1308,9 +1365,9 @@ static void sx_pollfunc (unsigned long data)
 /* Ehhm. I don't know how to fiddle with interrupts on the SX card. --REW */
 /* Hmm. Ok I figured it out. You don't.  */
 
-static void sx_disable_tx_interrupts (void * ptr) 
+static void sx_disable_tx_interrupts(void *ptr)
 {
-       struct sx_port *port = ptr; 
+       struct sx_port *port = ptr;
        func_enter2();
 
        port->gs.flags &= ~GS_TX_INTEN;
@@ -1318,30 +1375,28 @@ static void sx_disable_tx_interrupts (void * ptr)
        func_exit();
 }
 
-
-static void sx_enable_tx_interrupts (void * ptr) 
+static void sx_enable_tx_interrupts(void *ptr)
 {
-       struct sx_port *port = ptr; 
+       struct sx_port *port = ptr;
        int data_in_buffer;
        func_enter2();
 
        /* First transmit the characters that we're supposed to */
-       sx_transmit_chars (port);
+       sx_transmit_chars(port);
 
        /* The sx card will never interrupt us if we don't fill the buffer
           past 25%. So we keep considering interrupts off if that's the case. */
-       data_in_buffer = (sx_read_channel_byte (port, hi_txipos) - 
-                         sx_read_channel_byte (port, hi_txopos)) & 0xff;
+       data_in_buffer = (sx_read_channel_byte(port, hi_txipos) -
+                         sx_read_channel_byte(port, hi_txopos)) & 0xff;
 
        /* XXX Must be "HIGH_WATER" for SI card according to doc. */
-       if (data_in_buffer < LOW_WATER) 
+       if (data_in_buffer < LOW_WATER)
                port->gs.flags &= ~GS_TX_INTEN;
 
        func_exit();
 }
 
-
-static void sx_disable_rx_interrupts (void * ptr) 
+static void sx_disable_rx_interrupts(void *ptr)
 {
        /*  struct sx_port *port = ptr; */
        func_enter();
@@ -1349,7 +1404,7 @@ static void sx_disable_rx_interrupts (void * ptr)
        func_exit();
 }
 
-static void sx_enable_rx_interrupts (void * ptr) 
+static void sx_enable_rx_interrupts(void *ptr)
 {
        /*  struct sx_port *port = ptr; */
        func_enter();
@@ -1357,55 +1412,48 @@ static void sx_enable_rx_interrupts (void * ptr)
        func_exit();
 }
 
-
 /* Jeez. Isn't this simple? */
-static int sx_get_CD (void * ptr) 
+static int sx_get_CD(void *ptr)
 {
        struct sx_port *port = ptr;
        func_enter2();
 
        func_exit();
-       return ((sx_read_channel_byte (port, hi_ip) & IP_DCD) != 0);
+       return ((sx_read_channel_byte(port, hi_ip) & IP_DCD) != 0);
 }
 
-
 /* Jeez. Isn't this simple? */
-static int sx_chars_in_buffer (void * ptr) 
+static int sx_chars_in_buffer(void *ptr)
 {
        struct sx_port *port = ptr;
        func_enter2();
 
        func_exit();
-       return ((sx_read_channel_byte (port, hi_txipos) - 
-                sx_read_channel_byte (port, hi_txopos)) & 0xff);
+       return ((sx_read_channel_byte(port, hi_txipos) -
+                sx_read_channel_byte(port, hi_txopos)) & 0xff);
 }
 
-
-static void sx_shutdown_port (void * ptr) 
+static void sx_shutdown_port(void *ptr)
 {
-       struct sx_port *port = ptr; 
+       struct sx_port *port = ptr;
 
        func_enter();
 
-       port->gs.flags &= ~ GS_ACTIVE;
+       port->gs.flags &= ~GS_ACTIVE;
        if (port->gs.tty && (port->gs.tty->termios->c_cflag & HUPCL)) {
-               sx_setsignals (port, 0, 0);
+               sx_setsignals(port, 0, 0);
                sx_reconfigure_port(port);
        }
 
        func_exit();
 }
 
-
-
-
-
 /* ********************************************************************** *
  *                Here are the routines that actually                     *
  *               interface with the rest of the system                    *
  * ********************************************************************** */
 
-static int sx_open  (struct tty_struct * tty, struct file * filp)
+static int sx_open(struct tty_struct *tty, struct file *filp)
 {
        struct sx_port *port;
        int retval, line;
@@ -1418,18 +1466,18 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
        }
 
        line = tty->index;
-       sx_dprintk (SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, np=%d)\n", 
-                   current->pid, line, tty, current->signal->tty, sx_nports);
+       sx_dprintk(SX_DEBUG_OPEN, "%d: opening line %d. tty=%p ctty=%p, "
+                       "np=%d)\n", current->pid, line, tty,
+                       current->signal->tty, sx_nports);
 
        if ((line < 0) || (line >= SX_NPORTS) || (line >= sx_nports))
                return -ENODEV;
 
-       port = & sx_ports[line];
+       port = &sx_ports[line];
        port->c_dcd = 0; /* Make sure that the first interrupt doesn't detect a
-                           1 -> 0 transition. */
+                           1 -> 0 transition. */
 
-
-       sx_dprintk (SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
+       sx_dprintk(SX_DEBUG_OPEN, "port = %p c_dcd = %d\n", port, port->c_dcd);
 
        spin_lock_irqsave(&port->gs.driver_lock, flags);
 
@@ -1438,13 +1486,13 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
        port->gs.count++;
        spin_unlock_irqrestore(&port->gs.driver_lock, flags);
 
-       sx_dprintk (SX_DEBUG_OPEN, "starting port\n");
+       sx_dprintk(SX_DEBUG_OPEN, "starting port\n");
 
        /*
         * Start up serial port
         */
        retval = gs_init_port(&port->gs);
-       sx_dprintk (SX_DEBUG_OPEN, "done gs_init\n");
+       sx_dprintk(SX_DEBUG_OPEN, "done gs_init\n");
        if (retval) {
                port->gs.count--;
                return retval;
@@ -1452,19 +1500,20 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
 
        port->gs.flags |= GS_ACTIVE;
        if (port->gs.count <= 1)
-               sx_setsignals (port, 1,1);
+               sx_setsignals(port, 1, 1);
 
 #if 0
        if (sx_debug & SX_DEBUG_OPEN)
-               my_hd (port, sizeof (*port));
+               my_hd(port, sizeof(*port));
 #else
        if (sx_debug & SX_DEBUG_OPEN)
-               my_hd_io (port->board->base + port->ch_base, sizeof (*port));
+               my_hd_io(port->board->base + port->ch_base, sizeof(*port));
 #endif
 
        if (port->gs.count <= 1) {
-               if (sx_send_command (port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
-                       printk (KERN_ERR "sx: Card didn't respond to LOPEN command.\n");
+               if (sx_send_command(port, HS_LOPEN, -1, HS_IDLE_OPEN) != 1) {
+                       printk(KERN_ERR "sx: Card didn't respond to LOPEN "
+                                       "command.\n");
                        spin_lock_irqsave(&port->gs.driver_lock, flags);
                        port->gs.count--;
                        spin_unlock_irqrestore(&port->gs.driver_lock, flags);
@@ -1473,75 +1522,76 @@ static int sx_open  (struct tty_struct * tty, struct file * filp)
        }
 
        retval = gs_block_til_ready(port, filp);
-       sx_dprintk (SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n", 
-                   retval, port->gs.count);
+       sx_dprintk(SX_DEBUG_OPEN, "Block til ready returned %d. Count=%d\n",
+                       retval, port->gs.count);
 
        if (retval) {
-               /* 
-                * Don't lower gs.count here because sx_close() will be called later
-                */ 
+/*
+ * Don't lower gs.count here because sx_close() will be called later
+ */
 
                return retval;
        }
        /* tty->low_latency = 1; */
 
-       port->c_dcd = sx_get_CD (port);
-       sx_dprintk (SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
+       port->c_dcd = sx_get_CD(port);
+       sx_dprintk(SX_DEBUG_OPEN, "at open: cd=%d\n", port->c_dcd);
 
        func_exit();
        return 0;
 
 }
 
-
-static void sx_close (void *ptr)
+static void sx_close(void *ptr)
 {
-       struct sx_port *port = ptr; 
+       struct sx_port *port = ptr;
        /* Give the port 5 seconds to close down. */
-       int to = 5 * HZ; 
+       int to = 5 * HZ;
 
-       func_enter ();
+       func_enter();
 
-       sx_setsignals (port, 0, 0);
-       sx_reconfigure_port(port);      
-       sx_send_command (port, HS_CLOSE, 0, 0);
+       sx_setsignals(port, 0, 0);
+       sx_reconfigure_port(port);
+       sx_send_command(port, HS_CLOSE, 0, 0);
 
-       while (to-- && (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED))
+       while (to-- && (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED))
                if (msleep_interruptible(10))
                        break;
-       if (sx_read_channel_byte (port, hi_hstat) != HS_IDLE_CLOSED) {
-               if (sx_send_command (port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED) != 1) {
-                       printk (KERN_ERR 
-                               "sx: sent the force_close command, but card didn't react\n");
+       if (sx_read_channel_byte(port, hi_hstat) != HS_IDLE_CLOSED) {
+               if (sx_send_command(port, HS_FORCE_CLOSED, -1, HS_IDLE_CLOSED)
+                               != 1) {
+                       printk(KERN_ERR "sx: sent the force_close command, but "
+                                       "card didn't react\n");
                } else
-                       sx_dprintk (SX_DEBUG_CLOSE, "sent the force_close command.\n");
+                       sx_dprintk(SX_DEBUG_CLOSE, "sent the force_close "
+                                       "command.\n");
        }
 
-       sx_dprintk (SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n", 
-                   5 * HZ - to - 1, port->gs.count);
+       sx_dprintk(SX_DEBUG_CLOSE, "waited %d jiffies for close. count=%d\n",
+                       5 * HZ - to - 1, port->gs.count);
 
-       if(port->gs.count) {
-               sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n", port->gs.count);
-               //printk ("%s SETTING port count to zero: %p count: %d\n", __FUNCTION__, port, port->gs.count);
-               //port->gs.count = 0;
+       if (port->gs.count) {
+               sx_dprintk(SX_DEBUG_CLOSE, "WARNING port count:%d\n",
+                               port->gs.count);
+               /*printk("%s SETTING port count to zero: %p count: %d\n",
+                               __FUNCTION__, port, port->gs.count);
+               port->gs.count = 0;*/
        }
 
-       func_exit ();
+       func_exit();
 }
 
-
-
 /* This is relatively thorough. But then again it is only 20 lines. */
-#define MARCHUP    for (i=min;i<max;i++) 
-#define MARCHDOWN  for (i=max-1;i>=min;i--)
-#define W0         write_sx_byte (board, i, 0x55)
-#define W1         write_sx_byte (board, i, 0xaa)
-#define R0         if (read_sx_byte (board, i) != 0x55) return 1
-#define R1         if (read_sx_byte (board, i) != 0xaa) return 1
+#define MARCHUP                for (i = min; i < max; i++)
+#define MARCHDOWN      for (i = max - 1; i >= min; i--)
+#define W0             write_sx_byte(board, i, 0x55)
+#define W1             write_sx_byte(board, i, 0xaa)
+#define R0             if (read_sx_byte(board, i) != 0x55) return 1
+#define R1             if (read_sx_byte(board, i) != 0xaa) return 1
 
 /* This memtest takes a human-noticable time. You normally only do it
    once a boot, so I guess that it is worth it. */
-static int do_memtest (struct sx_board *board, int min, int max)
+static int do_memtest(struct sx_board *board, int min, int max)
 {
        int i;
 
@@ -1550,16 +1600,37 @@ static int do_memtest (struct sx_board *board, int min, int max)
           intermittent errors. -- REW
           (For the theory behind memory testing see: 
           Testing Semiconductor Memories by A.J. van de Goor.) */
-       MARCHUP  {W0;}
-       MARCHUP   {R0;W1;R1;W0;R0;W1;}
-       MARCHUP   {R1;W0;W1;}
-       MARCHDOWN {R1;W0;W1;W0;}
-       MARCHDOWN {R0;W1;W0;}
+       MARCHUP {
+               W0;
+       }
+       MARCHUP {
+               R0;
+               W1;
+               R1;
+               W0;
+               R0;
+               W1;
+       }
+       MARCHUP {
+               R1;
+               W0;
+               W1;
+       }
+       MARCHDOWN {
+               R1;
+               W0;
+               W1;
+               W0;
+       }
+       MARCHDOWN {
+               R0;
+               W1;
+               W0;
+       }
 
        return 0;
 }
 
-
 #undef MARCHUP
 #undef MARCHDOWN
 #undef W0
@@ -1567,33 +1638,54 @@ static int do_memtest (struct sx_board *board, int min, int max)
 #undef R0
 #undef R1
 
-#define MARCHUP    for (i=min;i<max;i+=2) 
-#define MARCHDOWN  for (i=max-1;i>=min;i-=2)
-#define W0         write_sx_word (board, i, 0x55aa)
-#define W1         write_sx_word (board, i, 0xaa55)
-#define R0         if (read_sx_word (board, i) != 0x55aa) return 1
-#define R1         if (read_sx_word (board, i) != 0xaa55) return 1
+#define MARCHUP                for (i = min; i < max; i += 2)
+#define MARCHDOWN      for (i = max - 1; i >= min; i -= 2)
+#define W0             write_sx_word(board, i, 0x55aa)
+#define W1             write_sx_word(board, i, 0xaa55)
+#define R0             if (read_sx_word(board, i) != 0x55aa) return 1
+#define R1             if (read_sx_word(board, i) != 0xaa55) return 1
 
 #if 0
 /* This memtest takes a human-noticable time. You normally only do it
    once a boot, so I guess that it is worth it. */
-static int do_memtest_w (struct sx_board *board, int min, int max)
+static int do_memtest_w(struct sx_board *board, int min, int max)
 {
        int i;
 
-       MARCHUP   {W0;}
-       MARCHUP   {R0;W1;R1;W0;R0;W1;}
-       MARCHUP   {R1;W0;W1;}
-       MARCHDOWN {R1;W0;W1;W0;}
-       MARCHDOWN {R0;W1;W0;}
+       MARCHUP {
+               W0;
+       }
+       MARCHUP {
+               R0;
+               W1;
+               R1;
+               W0;
+               R0;
+               W1;
+       }
+       MARCHUP {
+               R1;
+               W0;
+               W1;
+       }
+       MARCHDOWN {
+               R1;
+               W0;
+               W1;
+               W0;
+       }
+       MARCHDOWN {
+               R0;
+               W1;
+               W0;
+       }
 
        return 0;
 }
 #endif
 
-
-static int sx_fw_ioctl (struct inode *inode, struct file *filp,
-                        unsigned int cmd, unsigned long arg)
+static int sx_fw_ioctl(struct inode *inode, struct file *filp,
+               unsigned int cmd, unsigned long arg)
 {
        int rc = 0;
        int __user *descr = (int __user *)arg;
@@ -1605,7 +1697,7 @@ static int sx_fw_ioctl (struct inode *inode, struct file *filp,
 
        func_enter();
 
-#if 0 
+#if 0
        /* Removed superuser check: Sysops can use the permissions on the device
           file to restrict access. Recommendation: Root only. (root.root 600) */
        if (!capable(CAP_SYS_ADMIN)) {
@@ -1613,103 +1705,115 @@ static int sx_fw_ioctl (struct inode *inode, struct file *filp,
        }
 #endif
 
-       sx_dprintk (SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
+       sx_dprintk(SX_DEBUG_FIRMWARE, "IOCTL %x: %lx\n", cmd, arg);
 
-       if (!board) board = &boards[0];
+       if (!board)
+               board = &boards[0];
        if (board->flags & SX_BOARD_PRESENT) {
-               sx_dprintk (SX_DEBUG_FIRMWARE, "Board present! (%x)\n", 
-                           board->flags);
+               sx_dprintk(SX_DEBUG_FIRMWARE, "Board present! (%x)\n",
+                               board->flags);
        } else {
-               sx_dprintk (SX_DEBUG_FIRMWARE, "Board not present! (%x) all:", 
-                           board->flags);
-               for (i=0;i< SX_NBOARDS;i++)
-                       sx_dprintk (SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
-               sx_dprintk (SX_DEBUG_FIRMWARE, "\n");
+               sx_dprintk(SX_DEBUG_FIRMWARE, "Board not present! (%x) all:",
+                               board->flags);
+               for (i = 0; i < SX_NBOARDS; i++)
+                       sx_dprintk(SX_DEBUG_FIRMWARE, "<%x> ", boards[i].flags);
+               sx_dprintk(SX_DEBUG_FIRMWARE, "\n");
                return -EIO;
        }
 
        switch (cmd) {
        case SXIO_SET_BOARD:
-               sx_dprintk (SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
-               if (arg >= SX_NBOARDS) return -EIO;
-               sx_dprintk (SX_DEBUG_FIRMWARE, "not out of range\n");
-               if (!(boards[arg].flags & SX_BOARD_PRESENT)) return -EIO;
-               sx_dprintk (SX_DEBUG_FIRMWARE, ".. and present!\n");
+               sx_dprintk(SX_DEBUG_FIRMWARE, "set board to %ld\n", arg);
+               if (arg >= SX_NBOARDS)
+                       return -EIO;
+               sx_dprintk(SX_DEBUG_FIRMWARE, "not out of range\n");
+               if (!(boards[arg].flags & SX_BOARD_PRESENT))
+                       return -EIO;
+               sx_dprintk(SX_DEBUG_FIRMWARE, ".. and present!\n");
                board = &boards[arg];
                break;
        case SXIO_GET_TYPE:
-               rc = -ENOENT; /* If we manage to miss one, return error. */
-               if (IS_SX_BOARD (board)) rc = SX_TYPE_SX;
-               if (IS_CF_BOARD (board)) rc = SX_TYPE_CF;
-               if (IS_SI_BOARD (board)) rc = SX_TYPE_SI;
-               if (IS_SI1_BOARD (board)) rc = SX_TYPE_SI;
-               if (IS_EISA_BOARD (board)) rc = SX_TYPE_SI;
-               sx_dprintk (SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
+               rc = -ENOENT;   /* If we manage to miss one, return error. */
+               if (IS_SX_BOARD(board))
+                       rc = SX_TYPE_SX;
+               if (IS_CF_BOARD(board))
+                       rc = SX_TYPE_CF;
+               if (IS_SI_BOARD(board))
+                       rc = SX_TYPE_SI;
+               if (IS_SI1_BOARD(board))
+                       rc = SX_TYPE_SI;
+               if (IS_EISA_BOARD(board))
+                       rc = SX_TYPE_SI;
+               sx_dprintk(SX_DEBUG_FIRMWARE, "returning type= %d\n", rc);
                break;
        case SXIO_DO_RAMTEST:
-               if (sx_initialized) /* Already initialized: better not ramtest the board.  */
+               if (sx_initialized)     /* Already initialized: better not ramtest the board.  */
                        return -EPERM;
-               if (IS_SX_BOARD (board)) {
-                       rc          = do_memtest   (board, 0, 0x7000);
-                       if (!rc) rc = do_memtest   (board, 0, 0x7000);
-                       /*if (!rc) rc = do_memtest_w (board, 0, 0x7000);*/
+               if (IS_SX_BOARD(board)) {
+                       rc = do_memtest(board, 0, 0x7000);
+                       if (!rc)
+                               rc = do_memtest(board, 0, 0x7000);
+                       /*if (!rc) rc = do_memtest_w (board, 0, 0x7000); */
                } else {
-                       rc             = do_memtest   (board, 0, 0x7ff8);
+                       rc = do_memtest(board, 0, 0x7ff8);
                        /* if (!rc) rc = do_memtest_w (board, 0, 0x7ff8); */
                }
-               sx_dprintk (SX_DEBUG_FIRMWARE, "returning memtest result= %d\n", rc);
+               sx_dprintk(SX_DEBUG_FIRMWARE, "returning memtest result= %d\n",
+                          rc);
                break;
        case SXIO_DOWNLOAD:
-               if (sx_initialized) /* Already initialized */
+               if (sx_initialized)     /* Already initialized */
                        return -EEXIST;
-               if (!sx_reset (board)) 
+               if (!sx_reset(board))
                        return -EIO;
-               sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
-
-               tmp = kmalloc (SX_CHUNK_SIZE, GFP_USER);
-               if (!tmp) return -ENOMEM;
-               get_user (nbytes, descr++);
-               get_user (offset, descr++); 
-               get_user (data,  descr++);
+               sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
+
+               tmp = kmalloc(SX_CHUNK_SIZE, GFP_USER);
+               if (!tmp)
+                       return -ENOMEM;
+               get_user(nbytes, descr++);
+               get_user(offset, descr++);
+               get_user(data, descr++);
                while (nbytes && data) {
-                       for (i=0;i<nbytes;i += SX_CHUNK_SIZE) {
-                               if (copy_from_user(tmp, (char __user *)data+i, 
-                                                  (i + SX_CHUNK_SIZE >
-                                                   nbytes) ? nbytes - i :
-                                                             SX_CHUNK_SIZE)) {
-                                       kfree (tmp);
+                       for (i = 0; i < nbytes; i += SX_CHUNK_SIZE) {
+                               if (copy_from_user(tmp, (char __user *)data + i,
+                                               (i + SX_CHUNK_SIZE > nbytes) ?
+                                               nbytes - i : SX_CHUNK_SIZE)) {
+                                       kfree(tmp);
                                        return -EFAULT;
                                }
-                               memcpy_toio(board->base2 + offset + i, tmp, 
-                                               (i+SX_CHUNK_SIZE>nbytes)?nbytes-i:SX_CHUNK_SIZE);
+                               memcpy_toio(board->base2 + offset + i, tmp,
+                                               (i + SX_CHUNK_SIZE > nbytes) ?
+                                               nbytes - i : SX_CHUNK_SIZE);
                        }
 
-                       get_user (nbytes, descr++);
-                       get_user (offset, descr++); 
-                       get_user (data,   descr++);
+                       get_user(nbytes, descr++);
+                       get_user(offset, descr++);
+                       get_user(data, descr++);
                }
-               kfree (tmp);
-               sx_nports += sx_init_board (board);
+               kfree(tmp);
+               sx_nports += sx_init_board(board);
                rc = sx_nports;
                break;
        case SXIO_INIT:
-               if (sx_initialized) /* Already initialized */
+               if (sx_initialized)     /* Already initialized */
                        return -EEXIST;
                /* This is not allowed until all boards are initialized... */
-               for (i=0;i<SX_NBOARDS;i++) {
-                       if ( (boards[i].flags & SX_BOARD_PRESENT) &&
-                            !(boards[i].flags & SX_BOARD_INITIALIZED))
+               for (i = 0; i < SX_NBOARDS; i++) {
+                       if ((boards[i].flags & SX_BOARD_PRESENT) &&
+                               !(boards[i].flags & SX_BOARD_INITIALIZED))
                                return -EIO;
                }
-               for (i=0;i<SX_NBOARDS;i++)
-                       if (!(boards[i].flags & SX_BOARD_PRESENT)) break;
-
-               sx_dprintk (SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
-                           "%d channels, first board: %d ports\n", 
-                           i, sx_nports, boards[0].nports);
-               rc = sx_init_portstructs (i, sx_nports);
-               sx_init_drivers ();
-               if (rc >= 0) 
+               for (i = 0; i < SX_NBOARDS; i++)
+                       if (!(boards[i].flags & SX_BOARD_PRESENT))
+                               break;
+
+               sx_dprintk(SX_DEBUG_FIRMWARE, "initing portstructs, %d boards, "
+                               "%d channels, first board: %d ports\n",
+                               i, sx_nports, boards[0].nports);
+               rc = sx_init_portstructs(i, sx_nports);
+               sx_init_drivers();
+               if (rc >= 0)
                        sx_initialized++;
                break;
        case SXIO_SETDEBUG:
@@ -1726,32 +1830,32 @@ static int sx_fw_ioctl (struct inode *inode, struct file *filp,
                rc = sx_nports;
                break;
        default:
-               printk (KERN_WARNING "Unknown ioctl on firmware device (%x).\n", cmd);
+               printk(KERN_WARNING "Unknown ioctl on firmware device (%x).\n",
+                               cmd);
                break;
        }
-       func_exit ();
+       func_exit();
        return rc;
 }
 
-
-static void sx_break (struct tty_struct * tty, int flag)
+static void sx_break(struct tty_struct *tty, int flag)
 {
        struct sx_port *port = tty->driver_data;
        int rv;
 
-       func_enter ();
+       func_enter();
 
-       if (flag) 
-               rv = sx_send_command (port, HS_START, -1, HS_IDLE_BREAK);
-       else 
-               rv = sx_send_command (port, HS_STOP, -1, HS_IDLE_OPEN);
-       if (rv != 1) printk (KERN_ERR "sx: couldn't send break (%x).\n",
-                       read_sx_byte (port->board, CHAN_OFFSET (port, hi_hstat)));
+       if (flag)
+               rv = sx_send_command(port, HS_START, -1, HS_IDLE_BREAK);
+       else
+               rv = sx_send_command(port, HS_STOP, -1, HS_IDLE_OPEN);
+       if (rv != 1)
+               printk(KERN_ERR "sx: couldn't send break (%x).\n",
+                       read_sx_byte(port->board, CHAN_OFFSET(port, hi_hstat)));
 
-       func_exit ();
+       func_exit();
 }
 
-
 static int sx_tiocmget(struct tty_struct *tty, struct file *file)
 {
        struct sx_port *port = tty->driver_data;
@@ -1759,7 +1863,7 @@ static int sx_tiocmget(struct tty_struct *tty, struct file *file)
 }
 
 static int sx_tiocmset(struct tty_struct *tty, struct file *file,
-                      unsigned int set, unsigned int clear)
+               unsigned int set, unsigned int clear)
 {
        struct sx_port *port = tty->driver_data;
        int rts = -1, dtr = -1;
@@ -1778,8 +1882,8 @@ static int sx_tiocmset(struct tty_struct *tty, struct file *file,
        return 0;
 }
 
-static int sx_ioctl (struct tty_struct * tty, struct file * filp, 
-                     unsigned int cmd, unsigned long arg)
+static int sx_ioctl(struct tty_struct *tty, struct file *filp,
+               unsigned int cmd, unsigned long arg)
 {
        int rc;
        struct sx_port *port = tty->driver_data;
@@ -1792,10 +1896,10 @@ static int sx_ioctl (struct tty_struct * tty, struct file * filp,
        switch (cmd) {
        case TIOCGSOFTCAR:
                rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
-                             (unsigned __user *) argp);
+                               (unsigned __user *)argp);
                break;
        case TIOCSSOFTCAR:
-               if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
+               if ((rc = get_user(ival, (unsigned __user *)argp)) == 0) {
                        tty->termios->c_cflag =
                                (tty->termios->c_cflag & ~CLOCAL) |
                                (ival ? CLOCAL : 0);
@@ -1816,7 +1920,6 @@ static int sx_ioctl (struct tty_struct * tty, struct file * filp,
        return rc;
 }
 
-
 /* The throttle/unthrottle scheme for the Specialix card is different
  * from other drivers and deserves some explanation. 
  * The Specialix hardware takes care of XON/XOFF
@@ -1833,7 +1936,7 @@ static int sx_ioctl (struct tty_struct * tty, struct file * filp,
  * flow control scheme is in use for that port. -- Simon Allen
  */
 
-static void sx_throttle (struct tty_struct * tty)
+static void sx_throttle(struct tty_struct *tty)
 {
        struct sx_port *port = (struct sx_port *)tty->driver_data;
 
@@ -1841,14 +1944,13 @@ static void sx_throttle (struct tty_struct * tty)
        /* If the port is using any type of input flow
         * control then throttle the port.
         */
-       if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
+       if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
                port->gs.flags |= SX_RX_THROTTLE;
        }
        func_exit();
 }
 
-
-static void sx_unthrottle (struct tty_struct * tty)
+static void sx_unthrottle(struct tty_struct *tty)
 {
        struct sx_port *port = (struct sx_port *)tty->driver_data;
 
@@ -1862,15 +1964,11 @@ static void sx_unthrottle (struct tty_struct * tty)
        return;
 }
 
-
 /* ********************************************************************** *
  *                    Here are the initialization routines.               *
  * ********************************************************************** */
 
-
-
-
-static int sx_init_board (struct sx_board *board)
+static int sx_init_board(struct sx_board *board)
 {
        int addr;
        int chans;
@@ -1882,36 +1980,38 @@ static int sx_init_board (struct sx_board *board)
 
        board->flags |= SX_BOARD_INITIALIZED;
 
-       if (read_sx_byte (board, 0))
+       if (read_sx_byte(board, 0))
                /* CF boards may need this. */
-               write_sx_byte(board,0, 0);
+               write_sx_byte(board, 0, 0);
 
        /* This resets the processor again, to make sure it didn't do any
           foolish things while we were downloading the image */
-       if (!sx_reset (board))
+       if (!sx_reset(board))
                return 0;
 
-       sx_start_board (board);
-       udelay (10);
-       if (!sx_busy_wait_neq (board, 0, 0xff, 0)) {
-               printk (KERN_ERR "sx: Ooops. Board won't initialize.\n");
+       sx_start_board(board);
+       udelay(10);
+       if (!sx_busy_wait_neq(board, 0, 0xff, 0)) {
+               printk(KERN_ERR "sx: Ooops. Board won't initialize.\n");
                return 0;
        }
 
        /* Ok. So now the processor on the card is running. It gathered
           some info for us... */
-       sx_dprintk (SX_DEBUG_INIT, "The sxcard structure:\n");
-       if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base, 0x10);
-       sx_dprintk (SX_DEBUG_INIT, "the first sx_module structure:\n");
-       if (sx_debug & SX_DEBUG_INIT) my_hd_io (board->base + 0x80, 0x30);
-
-       sx_dprintk (SX_DEBUG_INIT, 
-                   "init_status: %x, %dk memory, firmware V%x.%02x,\n", 
-                   read_sx_byte (board, 0), read_sx_byte(board, 1), 
-                   read_sx_byte (board, 5), read_sx_byte(board, 4));
-
-       if (read_sx_byte (board, 0) == 0xff) {
-               printk (KERN_INFO "sx: No modules found. Sorry.\n");
+       sx_dprintk(SX_DEBUG_INIT, "The sxcard structure:\n");
+       if (sx_debug & SX_DEBUG_INIT)
+               my_hd_io(board->base, 0x10);
+       sx_dprintk(SX_DEBUG_INIT, "the first sx_module structure:\n");
+       if (sx_debug & SX_DEBUG_INIT)
+               my_hd_io(board->base + 0x80, 0x30);
+
+       sx_dprintk(SX_DEBUG_INIT, "init_status: %x, %dk memory, firmware "
+                       "V%x.%02x,\n",
+                       read_sx_byte(board, 0), read_sx_byte(board, 1),
+                       read_sx_byte(board, 5), read_sx_byte(board, 4));
+
+       if (read_sx_byte(board, 0) == 0xff) {
+               printk(KERN_INFO "sx: No modules found. Sorry.\n");
                board->nports = 0;
                return 0;
        }
@@ -1919,82 +2019,97 @@ static int sx_init_board (struct sx_board *board)
        chans = 0;
 
        if (IS_SX_BOARD(board)) {
-               sx_write_board_word (board, cc_int_count, sx_maxints);
+               sx_write_board_word(board, cc_int_count, sx_maxints);
        } else {
                if (sx_maxints)
-                       sx_write_board_word (board, cc_int_count, SI_PROCESSOR_CLOCK/8/sx_maxints);
+                       sx_write_board_word(board, cc_int_count,
+                                       SI_PROCESSOR_CLOCK / 8 / sx_maxints);
        }
 
        /* grab the first module type... */
-       /*  board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
-       board->ta_type = mod_compat_type (sx_read_module_byte (board, 0x80, mc_chip));
+       /* board->ta_type = mod_compat_type (read_sx_byte (board, 0x80 + 0x08)); */
+       board->ta_type = mod_compat_type(sx_read_module_byte(board, 0x80,
+                               mc_chip));
 
        /* XXX byteorder */
-       for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
-               type = sx_read_module_byte (board, addr, mc_chip);
-               sx_dprintk (SX_DEBUG_INIT, "Module at %x: %d channels\n", 
-                           addr, read_sx_byte (board, addr + 2));
-
-               chans += sx_read_module_byte (board, addr, mc_type);
-
-               sx_dprintk (SX_DEBUG_INIT, "module is an %s, which has %s/%s panels\n", 
-                           mod_type_s (type),
-                           pan_type_s (sx_read_module_byte (board, addr, mc_mods) & 0xf),
-                           pan_type_s (sx_read_module_byte (board, addr, mc_mods) >> 4));
-
-               sx_dprintk (SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC version: %x\n", 
-                           sx_read_module_byte (board, addr, mc_rev1),
-                           sx_read_module_byte (board, addr, mc_rev2),
-                           sx_read_module_byte (board, addr, mc_mtaasic_rev));
+       for (addr = 0x80; addr != 0; addr = read_sx_word(board, addr) & 0x7fff){
+               type = sx_read_module_byte(board, addr, mc_chip);
+               sx_dprintk(SX_DEBUG_INIT, "Module at %x: %d channels\n",
+                               addr, read_sx_byte(board, addr + 2));
+
+               chans += sx_read_module_byte(board, addr, mc_type);
+
+               sx_dprintk(SX_DEBUG_INIT, "module is an %s, which has %s/%s "
+                               "panels\n",
+                               mod_type_s(type),
+                               pan_type_s(sx_read_module_byte(board, addr,
+                                               mc_mods) & 0xf),
+                               pan_type_s(sx_read_module_byte(board, addr,
+                                               mc_mods) >> 4));
+
+               sx_dprintk(SX_DEBUG_INIT, "CD1400 versions: %x/%x, ASIC "
+                       "version: %x\n",
+                       sx_read_module_byte(board, addr, mc_rev1),
+                       sx_read_module_byte(board, addr, mc_rev2),
+                       sx_read_module_byte(board, addr, mc_mtaasic_rev));
 
                /* The following combinations are illegal: It should theoretically
                   work, but timing problems make the bus HANG. */
 
-               if (mod_compat_type (type) != board->ta_type) {
-                       printk (KERN_ERR "sx: This is an invalid configuration.\n"
-                               "Don't mix TA/MTA/SXDC on the same hostadapter.\n");
-                       chans=0;
+               if (mod_compat_type(type) != board->ta_type) {
+                       printk(KERN_ERR "sx: This is an invalid "
+                               "configuration.\nDon't mix TA/MTA/SXDC on the "
+                               "same hostadapter.\n");
+                       chans = 0;
                        break;
                }
-               if ((IS_EISA_BOARD(board) || 
-                    IS_SI_BOARD(board)) && (mod_compat_type(type) == 4)) {
-                       printk (KERN_ERR "sx: This is an invalid configuration.\n"
-                               "Don't use SXDCs on an SI/XIO adapter.\n");
-                       chans=0;
+               if ((IS_EISA_BOARD(board) ||
+                               IS_SI_BOARD(board)) &&
+                               (mod_compat_type(type) == 4)) {
+                       printk(KERN_ERR "sx: This is an invalid "
+                               "configuration.\nDon't use SXDCs on an SI/XIO "
+                               "adapter.\n");
+                       chans = 0;
                        break;
                }
-#if 0 /* Problem fixed: firmware 3.05 */
+#if 0                          /* Problem fixed: firmware 3.05 */
                if (IS_SX_BOARD(board) && (type == TA8)) {
                        /* There are some issues with the firmware and the DCD/RTS
                           lines. It might work if you tie them together or something.
-                          It might also work if you get a newer sx_firmware.   Therefore
+                          It might also work if you get a newer sx_firmware.   Therefore
                           this is just a warning. */
-                       printk (KERN_WARNING "sx: The SX host doesn't work too well "
-                               "with the TA8 adapters.\nSpecialix is working on it.\n");
+                       printk(KERN_WARNING
+                              "sx: The SX host doesn't work too well "
+                              "with the TA8 adapters.\nSpecialix is working on it.\n");
                }
 #endif
        }
 
        if (chans) {
-               /* board->flags |= SX_BOARD_PRESENT; */
-               if(board->irq > 0) {
+               if (board->irq > 0) {
                        /* fixed irq, probably PCI */
-                       if(sx_irqmask & (1 << board->irq)) { /* may we use this irq? */
-                               if(request_irq(board->irq, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board)) {
-                                       printk(KERN_ERR "sx: Cannot allocate irq %d.\n", board->irq);
+                       if (sx_irqmask & (1 << board->irq)) {   /* may we use this irq? */
+                               if (request_irq(board->irq, sx_interrupt,
+                                               IRQF_SHARED | IRQF_DISABLED,
+                                               "sx", board)) {
+                                       printk(KERN_ERR "sx: Cannot allocate "
+                                               "irq %d.\n", board->irq);
                                        board->irq = 0;
                                }
                        } else
                                board->irq = 0;
-               } else if(board->irq < 0 && sx_irqmask) {
+               } else if (board->irq < 0 && sx_irqmask) {
                        /* auto-allocate irq */
                        int irqnr;
-                       int irqmask = sx_irqmask & (IS_SX_BOARD(board) ? SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
-                       for(irqnr = 15; irqnr > 0; irqnr--)
-                               if(irqmask & (1 << irqnr))
-                                       if(! request_irq(irqnr, sx_interrupt, IRQF_SHARED | IRQF_DISABLED, "sx", board))
+                       int irqmask = sx_irqmask & (IS_SX_BOARD(board) ?
+                                       SX_ISA_IRQ_MASK : SI2_ISA_IRQ_MASK);
+                       for (irqnr = 15; irqnr > 0; irqnr--)
+                               if (irqmask & (1 << irqnr))
+                                       if (!request_irq(irqnr, sx_interrupt,
+                                               IRQF_SHARED | IRQF_DISABLED,
+                                               "sx", board))
                                                break;
-                       if(! irqnr)
+                       if (!irqnr)
                                printk(KERN_ERR "sx: Cannot allocate IRQ.\n");
                        board->irq = irqnr;
                } else
@@ -2002,52 +2117,48 @@ static int sx_init_board (struct sx_board *board)
 
                if (board->irq) {
                        /* Found a valid interrupt, start up interrupts! */
-                       sx_dprintk (SX_DEBUG_INIT, "Using irq %d.\n", board->irq);
-                       sx_start_interrupts (board);
+                       sx_dprintk(SX_DEBUG_INIT, "Using irq %d.\n",
+                                       board->irq);
+                       sx_start_interrupts(board);
                        board->poll = sx_slowpoll;
                        board->flags |= SX_IRQ_ALLOCATED;
                } else {
                        /* no irq: setup board for polled operation */
                        board->poll = sx_poll;
-                       sx_dprintk (SX_DEBUG_INIT, "Using poll-interval %d.\n", board->poll);
+                       sx_dprintk(SX_DEBUG_INIT, "Using poll-interval %d.\n",
+                                       board->poll);
                }
 
-               /* The timer should be initialized anyway: That way we can safely
-                        del_timer it when the module is unloaded. */
-               init_timer (&board->timer);
+               /* The timer should be initialized anyway: That way we can
+                  safely del_timer it when the module is unloaded. */
+               setup_timer(&board->timer, sx_pollfunc, (unsigned long)board);
 
-               if (board->poll) {
-                       board->timer.data = (unsigned long) board;
-                       board->timer.function = sx_pollfunc;
-                       board->timer.expires = jiffies + board->poll;
-                       add_timer (&board->timer);
-               }
+               if (board->poll)
+                       mod_timer(&board->timer, jiffies + board->poll);
        } else {
                board->irq = 0;
        }
 
        board->nports = chans;
-       sx_dprintk (SX_DEBUG_INIT, "returning %d ports.", board->nports);
+       sx_dprintk(SX_DEBUG_INIT, "returning %d ports.", board->nports);
 
        func_exit();
        return chans;
 }
 
-
-static void printheader(void)
+static void __devinit printheader(void)
 {
        static int header_printed;
 
        if (!header_printed) {
-               printk (KERN_INFO "Specialix SX driver "
-                       "(C) 1998/1999 R.E.Wolff@BitWizard.nl \n");
-               printk (KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
+               printk(KERN_INFO "Specialix SX driver "
+                       "(C) 1998/1999 R.E.Wolff@BitWizard.nl\n");
+               printk(KERN_INFO "sx: version " __stringify(SX_VERSION) "\n");
                header_printed = 1;
        }
 }
 
-
-static int probe_sx (struct sx_board *board)
+static int __devinit probe_sx(struct sx_board *board)
 {
        struct vpd_prom vpdp;
        char *p;
@@ -2055,51 +2166,57 @@ static int probe_sx (struct sx_board *board)
 
        func_enter();
 
-       if (!IS_CF_BOARD (board)) {    
-               sx_dprintk (SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n", 
-                           board->base + SX_VPD_ROM);
+       if (!IS_CF_BOARD(board)) {
+               sx_dprintk(SX_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
+                               board->base + SX_VPD_ROM);
 
                if (sx_debug & SX_DEBUG_PROBE)
                        my_hd_io(board->base + SX_VPD_ROM, 0x40);
 
-               p = (char *) &vpdp;
-               for (i=0;i< sizeof (struct vpd_prom);i++)
-                       *p++ = read_sx_byte (board, SX_VPD_ROM + i*2);
+               p = (char *)&vpdp;
+               for (i = 0; i < sizeof(struct vpd_prom); i++)
+                       *p++ = read_sx_byte(board, SX_VPD_ROM + i * 2);
 
                if (sx_debug & SX_DEBUG_PROBE)
-                       my_hd (&vpdp, 0x20);
+                       my_hd(&vpdp, 0x20);
 
-               sx_dprintk (SX_DEBUG_PROBE, "checking identifier...\n");
+               sx_dprintk(SX_DEBUG_PROBE, "checking identifier...\n");
 
-               if (strncmp (vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
-                       sx_dprintk (SX_DEBUG_PROBE, "Got non-SX identifier: '%s'\n", 
-                                   vpdp.identifier); 
+               if (strncmp(vpdp.identifier, SX_VPD_IDENT_STRING, 16) != 0) {
+                       sx_dprintk(SX_DEBUG_PROBE, "Got non-SX identifier: "
+                                       "'%s'\n", vpdp.identifier);
                        return 0;
                }
        }
 
-       printheader ();
-
-       if (!IS_CF_BOARD (board)) {
-               printk (KERN_DEBUG "sx: Found an SX board at %lx\n", board->hw_base);
-               printk (KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, uniq ID:%08x, ", 
-                       vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
-               printk (           "Manufactured: %d/%d\n", 
-                       1970 + vpdp.myear, vpdp.mweek);
+       printheader();
 
+       if (!IS_CF_BOARD(board)) {
+               printk(KERN_DEBUG "sx: Found an SX board at %lx\n",
+                       board->hw_base);
+               printk(KERN_DEBUG "sx: hw_rev: %d, assembly level: %d, "
+                               "uniq ID:%08x, ",
+                               vpdp.hwrev, vpdp.hwass, vpdp.uniqid);
+               printk("Manufactured: %d/%d\n", 1970 + vpdp.myear, vpdp.mweek);
 
-               if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_PCI_UNIQUEID1) &&
-                   (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
-                       /* This might be a bit harsh. This was the primary reason the
-                          SX/ISA card didn't work at first... */
-                       printk (KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA card. Sorry: giving up.\n");
+               if ((((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) !=
+                               SX_PCI_UNIQUEID1) && (((vpdp.uniqid >> 24) &
+                               SX_UNIQUEID_MASK) != SX_ISA_UNIQUEID1)) {
+                       /* This might be a bit harsh. This was the primary
+                          reason the SX/ISA card didn't work at first... */
+                       printk(KERN_ERR "sx: Hmm. Not an SX/PCI or SX/ISA "
+                                       "card. Sorry: giving up.\n");
                        return (0);
                }
 
-               if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) == SX_ISA_UNIQUEID1) {
+               if (((vpdp.uniqid >> 24) & SX_UNIQUEID_MASK) ==
+                               SX_ISA_UNIQUEID1) {
                        if (((unsigned long)board->hw_base) & 0x8000) {
-                               printk (KERN_WARNING "sx: Warning: There may be hardware problems with the card at %lx.\n", board->hw_base);
-                               printk (KERN_WARNING "sx: Read sx.txt for more info.\n");
+                               printk(KERN_WARNING "sx: Warning: There may be "
+                                       "hardware problems with the card at "
+                                       "%lx.\n", board->hw_base);
+                               printk(KERN_WARNING "sx: Read sx.txt for more "
+                                               "info.\n");
                        }
                }
        }
@@ -2107,17 +2224,15 @@ static int probe_sx (struct sx_board *board)
        board->nports = -1;
 
        /* This resets the processor, and keeps it off the bus. */
-       if (!sx_reset (board)) 
+       if (!sx_reset(board))
                return 0;
-       sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
-
-       board->flags |= SX_BOARD_PRESENT;
+       sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
 
        func_exit();
        return 1;
 }
 
-
+#if defined(CONFIG_ISA) || defined(CONFIG_EISA)
 
 /* Specialix probes for this card at 32k increments from 640k to 16M.
    I consider machines with less than 16M unlikely nowadays, so I'm
@@ -2125,28 +2240,27 @@ static int probe_sx (struct sx_board *board)
    card. 0xe0000 and 0xf0000 are taken by the BIOS. That only leaves 
    0xc0000, 0xc8000, 0xd0000 and 0xd8000 . */
 
-static int probe_si (struct sx_board *board)
+static int __devinit probe_si(struct sx_board *board)
 {
        int i;
 
        func_enter();
-       sx_dprintk (SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at %p.\n", board->hw_base,
-                   board->base + SI2_ISA_ID_BASE);
+       sx_dprintk(SX_DEBUG_PROBE, "Going to verify SI signature hw %lx at "
+               "%p.\n", board->hw_base, board->base + SI2_ISA_ID_BASE);
 
        if (sx_debug & SX_DEBUG_PROBE)
                my_hd_io(board->base + SI2_ISA_ID_BASE, 0x8);
 
        if (!IS_EISA_BOARD(board)) {
-         if( IS_SI1_BOARD(board) ) 
-           {
-               for (i=0;i<8;i++) {
-                 write_sx_byte (board, SI2_ISA_ID_BASE+7-i,i); 
-
+               if (IS_SI1_BOARD(board)) {
+                       for (i = 0; i < 8; i++) {
+                               write_sx_byte(board, SI2_ISA_ID_BASE + 7 - i,i);
+                       }
                }
-           }
-               for (i=0;i<8;i++) {
-                       if ((read_sx_byte (board, SI2_ISA_ID_BASE+7-i) & 7) != i) {
-                               func_exit ();
+               for (i = 0; i < 8; i++) {
+                       if ((read_sx_byte(board, SI2_ISA_ID_BASE + 7 - i) & 7)
+                                       != i) {
+                               func_exit();
                                return 0;
                        }
                }
@@ -2156,20 +2270,20 @@ static int probe_si (struct sx_board *board)
           but to prevent trouble, we'd better double check that we don't
           have an SI1 board when we're probing for an SI2 board.... */
 
-       write_sx_byte (board, SI2_ISA_ID_BASE,0x10); 
-       if ( IS_SI1_BOARD(board)) {
+       write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
+       if (IS_SI1_BOARD(board)) {
                /* This should be an SI1 board, which has this
                   location writable... */
-               if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
-                       func_exit ();
-                       return 0; 
+               if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
+                       func_exit();
+                       return 0;
                }
        } else {
                /* This should be an SI2 board, which has the bottom
                   3 bits non-writable... */
-               if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
-                       func_exit ();
-                       return 0; 
+               if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
+                       func_exit();
+                       return 0;
                }
        }
 
@@ -2177,45 +2291,44 @@ static int probe_si (struct sx_board *board)
           but to prevent trouble, we'd better double check that we don't
           have an SI1 board when we're probing for an SI2 board.... */
 
-       write_sx_byte (board, SI2_ISA_ID_BASE,0x10); 
-       if ( IS_SI1_BOARD(board)) {
+       write_sx_byte(board, SI2_ISA_ID_BASE, 0x10);
+       if (IS_SI1_BOARD(board)) {
                /* This should be an SI1 board, which has this
                   location writable... */
-               if (read_sx_byte (board, SI2_ISA_ID_BASE) != 0x10) {
+               if (read_sx_byte(board, SI2_ISA_ID_BASE) != 0x10) {
                        func_exit();
-                       return 0; 
+                       return 0;
                }
        } else {
                /* This should be an SI2 board, which has the bottom
                   3 bits non-writable... */
-               if (read_sx_byte (board, SI2_ISA_ID_BASE) == 0x10) {
-                       func_exit ();
-                       return 0; 
+               if (read_sx_byte(board, SI2_ISA_ID_BASE) == 0x10) {
+                       func_exit();
+                       return 0;
                }
        }
 
-       printheader ();
+       printheader();
 
-       printk (KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
+       printk(KERN_DEBUG "sx: Found an SI board at %lx\n", board->hw_base);
        /* Compared to the SX boards, it is a complete guess as to what
-                this card is up to... */
+          this card is up to... */
 
        board->nports = -1;
 
        /* This resets the processor, and keeps it off the bus. */
-       if (!sx_reset (board)) 
+       if (!sx_reset(board))
                return 0;
-       sx_dprintk (SX_DEBUG_INIT, "reset the board...\n");
-
-       board->flags |= SX_BOARD_PRESENT;
+       sx_dprintk(SX_DEBUG_INIT, "reset the board...\n");
 
        func_exit();
        return 1;
 }
+#endif
 
 static const struct tty_operations sx_ops = {
        .break_ctl = sx_break,
-       .open   = sx_open,
+       .open = sx_open,
        .close = gs_close,
        .write = gs_write,
        .put_char = gs_put_char,
@@ -2250,8 +2363,7 @@ static int sx_init_drivers(void)
        sx_driver->type = TTY_DRIVER_TYPE_SERIAL;
        sx_driver->subtype = SERIAL_TYPE_NORMAL;
        sx_driver->init_termios = tty_std_termios;
-       sx_driver->init_termios.c_cflag =
-         B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+       sx_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
        sx_driver->init_termios.c_ispeed = 9600;
        sx_driver->init_termios.c_ospeed = 9600;
        sx_driver->flags = TTY_DRIVER_REAL_RAW;
@@ -2260,14 +2372,14 @@ static int sx_init_drivers(void)
        if ((error = tty_register_driver(sx_driver))) {
                put_tty_driver(sx_driver);
                printk(KERN_ERR "sx: Couldn't register sx driver, error = %d\n",
-                      error);
+                       error);
                return 1;
        }
        func_exit();
        return 0;
 }
 
-static int sx_init_portstructs (int nboards, int nports)
+static int sx_init_portstructs(int nboards, int nports)
 {
        struct sx_board *board;
        struct sx_port *port;
@@ -2278,7 +2390,8 @@ static int sx_init_portstructs (int nboards, int nports)
        func_enter();
 
        /* Many drivers statically allocate the maximum number of ports
-          There is no reason not to allocate them dynamically. Is there? -- REW */
+          There is no reason not to allocate them dynamically.
+          Is there? -- REW */
        sx_ports = kcalloc(nports, sizeof(struct sx_port), GFP_KERNEL);
        if (!sx_ports)
                return -ENOMEM;
@@ -2287,10 +2400,10 @@ static int sx_init_portstructs (int nboards, int nports)
        for (i = 0; i < nboards; i++) {
                board = &boards[i];
                board->ports = port;
-               for (j=0; j < boards[i].nports;j++) {
-                       sx_dprintk (SX_DEBUG_INIT, "initing port %d\n", j);
+               for (j = 0; j < boards[i].nports; j++) {
+                       sx_dprintk(SX_DEBUG_INIT, "initing port %d\n", j);
                        port->gs.magic = SX_MAGIC;
-                       port->gs.close_delay = HZ/2;
+                       port->gs.close_delay = HZ / 2;
                        port->gs.closing_wait = 30 * HZ;
                        port->board = board;
                        port->gs.rd = &sx_real_driver;
@@ -2302,8 +2415,8 @@ static int sx_init_portstructs (int nboards, int nports)
                         * Initializing wait queue
                         */
                        init_waitqueue_head(&port->gs.open_wait);
-                       init_waitqueue_head(&port->gs.close_wait);              
-                       
+                       init_waitqueue_head(&port->gs.close_wait);
+
                        port++;
                }
        }
@@ -2314,28 +2427,36 @@ static int sx_init_portstructs (int nboards, int nports)
                board = &boards[i];
                board->port_base = portno;
                /* Possibly the configuration was rejected. */
-               sx_dprintk (SX_DEBUG_PROBE, "Board has %d channels\n", board->nports);
-               if (board->nports <= 0) continue;
+               sx_dprintk(SX_DEBUG_PROBE, "Board has %d channels\n",
+                               board->nports);
+               if (board->nports <= 0)
+                       continue;
                /* XXX byteorder ?? */
-               for (addr = 0x80;addr != 0;addr = read_sx_word (board, addr) & 0x7fff) {
-                       chans = sx_read_module_byte (board, addr, mc_type); 
-                       sx_dprintk (SX_DEBUG_PROBE, "Module at %x: %d channels\n", addr, chans);
-                       sx_dprintk (SX_DEBUG_PROBE, "Port at");
-                       for (j=0;j<chans;j++) {
-                               /* The "sx-way" is the way it SHOULD be done. That way in the 
-                                  future, the firmware may for example pack the structures a bit
-                                  more efficient. Neil tells me it isn't going to happen anytime
-                                  soon though. */
+               for (addr = 0x80; addr != 0;
+                               addr = read_sx_word(board, addr) & 0x7fff) {
+                       chans = sx_read_module_byte(board, addr, mc_type);
+                       sx_dprintk(SX_DEBUG_PROBE, "Module at %x: %d "
+                                       "channels\n", addr, chans);
+                       sx_dprintk(SX_DEBUG_PROBE, "Port at");
+                       for (j = 0; j < chans; j++) {
+                               /* The "sx-way" is the way it SHOULD be done.
+                                  That way in the future, the firmware may for
+                                  example pack the structures a bit more
+                                  efficient. Neil tells me it isn't going to
+                                  happen anytime soon though. */
                                if (IS_SX_BOARD(board))
-                                       port->ch_base = sx_read_module_word (board, addr+j*2, mc_chan_pointer);
+                                       port->ch_base = sx_read_module_word(
+                                                       board, addr + j * 2,
+                                                       mc_chan_pointer);
                                else
-                                       port->ch_base = addr + 0x100 + 0x300*j;
+                                       port->ch_base = addr + 0x100 + 0x300 *j;
 
-                               sx_dprintk (SX_DEBUG_PROBE, " %x", port->ch_base);
+                               sx_dprintk(SX_DEBUG_PROBE, " %x",
+                                               port->ch_base);
                                port->line = portno++;
                                port++;
                        }
-                       sx_dprintk (SX_DEBUG_PROBE, "\n");
+                       sx_dprintk(SX_DEBUG_PROBE, "\n");
                }
                /* This has to be done earlier. */
                /* board->flags |= SX_BOARD_INITIALIZED; */
@@ -2345,6 +2466,17 @@ static int sx_init_portstructs (int nboards, int nports)
        return 0;
 }
 
+static unsigned int sx_find_free_board(void)
+{
+       unsigned int i;
+
+       for (i = 0; i < SX_NBOARDS; i++)
+               if (!(boards[i].flags & SX_BOARD_PRESENT))
+                       break;
+
+       return i;
+}
+
 static void __exit sx_release_drivers(void)
 {
        func_enter();
@@ -2353,6 +2485,125 @@ static void __exit sx_release_drivers(void)
        func_exit();
 }
 
+static void __devexit sx_remove_card(struct sx_board *board,
+               struct pci_dev *pdev)
+{
+       if (board->flags & SX_BOARD_INITIALIZED) {
+               /* The board should stop messing with us. (actually I mean the
+                  interrupt) */
+               sx_reset(board);
+               if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
+                       free_irq(board->irq, board);
+
+               /* It is safe/allowed to del_timer a non-active timer */
+               del_timer(&board->timer);
+               if (pdev) {
+#ifdef CONFIG_PCI
+                       pci_iounmap(pdev, board->base);
+                       pci_release_region(pdev, IS_CF_BOARD(board) ? 3 : 2);
+#endif
+               } else {
+                       iounmap(board->base);
+                       release_region(board->hw_base, board->hw_len);
+               }
+
+               board->flags &= ~(SX_BOARD_INITIALIZED | SX_BOARD_PRESENT);
+       }
+}
+
+#ifdef CONFIG_EISA
+
+static int __devinit sx_eisa_probe(struct device *dev)
+{
+       struct eisa_device *edev = to_eisa_device(dev);
+       struct sx_board *board;
+       unsigned long eisa_slot = edev->base_addr;
+       unsigned int i;
+       int retval = -EIO;
+
+       mutex_lock(&sx_boards_lock);
+       i = sx_find_free_board();
+       if (i == SX_NBOARDS) {
+               mutex_unlock(&sx_boards_lock);
+               goto err;
+       }
+       board = &boards[i];
+       board->flags |= SX_BOARD_PRESENT;
+       mutex_unlock(&sx_boards_lock);
+
+       dev_info(dev, "XIO : Signature found in EISA slot %lu, "
+                "Product %d Rev %d (REPORT THIS TO LKLM)\n",
+                eisa_slot >> 12,
+                inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 2),
+                inb(eisa_slot + EISA_VENDOR_ID_OFFSET + 3));
+
+       board->eisa_base = eisa_slot;
+       board->flags &= ~SX_BOARD_TYPE;
+       board->flags |= SI_EISA_BOARD;
+
+       board->hw_base = ((inb(eisa_slot + 0xc01) << 8) +
+                         inb(eisa_slot + 0xc00)) << 16;
+       board->hw_len = SI2_EISA_WINDOW_LEN;
+       if (!request_region(board->hw_base, board->hw_len, "sx")) {
+               dev_err(dev, "can't request region\n");
+               goto err_flag;
+       }
+       board->base2 =
+       board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
+       if (!board->base) {
+               dev_err(dev, "can't remap memory\n");
+               goto err_reg;
+       }
+
+       sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
+       sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
+       board->irq = inb(eisa_slot + 0xc02) >> 4;
+       sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
+
+       if (!probe_si(board))
+               goto err_unmap;
+
+       dev_set_drvdata(dev, board);
+
+       return 0;
+err_unmap:
+       iounmap(board->base);
+err_reg:
+       release_region(board->hw_base, board->hw_len);
+err_flag:
+       board->flags &= ~SX_BOARD_PRESENT;
+err:
+       return retval;
+}
+
+static int __devexit sx_eisa_remove(struct device *dev)
+{
+       struct sx_board *board = dev_get_drvdata(dev);
+
+       sx_remove_card(board, NULL);
+
+       return 0;
+}
+
+static struct eisa_device_id sx_eisa_tbl[] = {
+       { "SLX" },
+       { "" }
+};
+
+MODULE_DEVICE_TABLE(eisa, sx_eisa_tbl);
+
+static struct eisa_driver sx_eisadriver = {
+       .id_table = sx_eisa_tbl,
+       .driver = {
+               .name = "sx",
+               .probe = sx_eisa_probe,
+               .remove = __devexit_p(sx_eisa_remove),
+       }
+};
+
+#endif
+
+#ifdef CONFIG_PCI
  /******************************************************** 
  * Setting bit 17 in the CNTRL register of the PLX 9050  * 
  * chip forces a retry on writes while a read is pending.*
@@ -2364,70 +2615,77 @@ static void __exit sx_release_drivers(void)
    EEprom.  As the bit is read/write for the CPU, we can fix it here,
    if we detect that it isn't set correctly. -- REW */
 
-static void fix_sx_pci (struct pci_dev *pdev, struct sx_board *board)
+static void __devinit fix_sx_pci(struct pci_dev *pdev, struct sx_board *board)
 {
        unsigned int hwbase;
        void __iomem *rebase;
        unsigned int t;
 
-#define CNTRL_REG_OFFSET        0x50
-#define CNTRL_REG_GOODVALUE     0x18260000
+#define CNTRL_REG_OFFSET       0x50
+#define CNTRL_REG_GOODVALUE    0x18260000
 
        pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
        hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
        rebase = ioremap(hwbase, 0x80);
-       t = readl (rebase + CNTRL_REG_OFFSET);
+       t = readl(rebase + CNTRL_REG_OFFSET);
        if (t != CNTRL_REG_GOODVALUE) {
-               printk (KERN_DEBUG "sx: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE); 
-               writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
+               printk(KERN_DEBUG "sx: performing cntrl reg fix: %08x -> "
+                       "%08x\n", t, CNTRL_REG_GOODVALUE);
+               writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
        }
        iounmap(rebase);
 }
+#endif
 
 static int __devinit sx_pci_probe(struct pci_dev *pdev,
-       const struct pci_device_id *ent)
+                                 const struct pci_device_id *ent)
 {
+#ifdef CONFIG_PCI
        struct sx_board *board;
-       unsigned int i;
+       unsigned int i, reg;
        int retval = -EIO;
 
-       for (i = 0; i < SX_NBOARDS; i++)
-               if (!(boards[i].flags & SX_BOARD_PRESENT))
-                       break;
-
-       if (i == SX_NBOARDS)
+       mutex_lock(&sx_boards_lock);
+       i = sx_find_free_board();
+       if (i == SX_NBOARDS) {
+               mutex_unlock(&sx_boards_lock);
                goto err;
+       }
+       board = &boards[i];
+       board->flags |= SX_BOARD_PRESENT;
+       mutex_unlock(&sx_boards_lock);
 
        retval = pci_enable_device(pdev);
        if (retval)
-               goto err;
-
-       board = &boards[i];
+               goto err_flag;
 
        board->flags &= ~SX_BOARD_TYPE;
        board->flags |= (pdev->subsystem_vendor == 0x200) ? SX_PCI_BOARD :
-                               SX_CFPCI_BOARD;
+               SX_CFPCI_BOARD;
 
        /* CF boards use base address 3.... */
-       if (IS_CF_BOARD (board))
-               board->hw_base = pci_resource_start(pdev, 3);
-       else
-               board->hw_base = pci_resource_start(pdev, 2);
+       reg = IS_CF_BOARD(board) ? 3 : 2;
+       retval = pci_request_region(pdev, reg, "sx");
+       if (retval) {
+               dev_err(&pdev->dev, "can't request region\n");
+               goto err_flag;
+       }
+       board->hw_base = pci_resource_start(pdev, reg);
        board->base2 =
-       board->base = ioremap(board->hw_base, WINDOW_LEN (board));
+       board->base = pci_iomap(pdev, reg, WINDOW_LEN(board));
        if (!board->base) {
                dev_err(&pdev->dev, "ioremap failed\n");
-               goto err;
+               goto err_reg;
        }
 
        /* Most of the stuff on the CF board is offset by 0x18000 ....  */
-       if (IS_CF_BOARD (board))
+       if (IS_CF_BOARD(board))
                board->base += 0x18000;
 
        board->irq = pdev->irq;
 
        dev_info(&pdev->dev, "Got a specialix card: %p(%d) %x.\n", board->base,
-                       board->irq, board->flags);
+                board->irq, board->flags);
 
        if (!probe_sx(board)) {
                retval = -EIO;
@@ -2440,39 +2698,35 @@ static int __devinit sx_pci_probe(struct pci_dev *pdev,
 
        return 0;
 err_unmap:
-       iounmap(board->base2);
+       pci_iounmap(pdev, board->base);
+err_reg:
+       pci_release_region(pdev, reg);
+err_flag:
+       board->flags &= ~SX_BOARD_PRESENT;
 err:
        return retval;
+#else
+       return -ENODEV;
+#endif
 }
 
 static void __devexit sx_pci_remove(struct pci_dev *pdev)
 {
        struct sx_board *board = pci_get_drvdata(pdev);
 
-       if (board->flags & SX_BOARD_INITIALIZED) {
-               /* The board should stop messing with us. (actually I mean the
-                  interrupt) */
-               sx_reset(board);
-               if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
-                       free_irq(board->irq, board);
-
-               /* It is safe/allowed to del_timer a non-active timer */
-               del_timer(&board->timer);
-               iounmap(board->base);
-
-               board->flags &= ~(SX_BOARD_INITIALIZED|SX_BOARD_PRESENT);
-       }
+       sx_remove_card(board, pdev);
 }
 
 /* Specialix has a whole bunch of cards with 0x2000 as the device ID. They say
    its because the standard requires it. So check for SUBVENDOR_ID. */
 static struct pci_device_id sx_pci_tbl[] = {
        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
-                       .subvendor = 0x0200, .subdevice = PCI_ANY_ID },
+               .subvendor = PCI_ANY_ID, .subdevice = 0x0200 },
        { PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
-                       .subvendor = 0x0300, .subdevice = PCI_ANY_ID },
+               .subvendor = PCI_ANY_ID, .subdevice = 0x0300 },
        { 0 }
 };
+
 MODULE_DEVICE_TABLE(pci, sx_pci_tbl);
 
 static struct pci_driver sx_pcidriver = {
@@ -2482,151 +2736,149 @@ static struct pci_driver sx_pcidriver = {
        .remove = __devexit_p(sx_pci_remove)
 };
 
-static int __init sx_init(void) 
+static int __init sx_init(void)
 {
-       int retval, i;
-       int found = 0;
-       int eisa_slot;
+#ifdef CONFIG_EISA
+       int retval1;
+#endif
+#ifdef CONFIG_ISA
        struct sx_board *board;
+       unsigned int i;
+#endif
+       unsigned int found = 0;
+       int retval;
 
        func_enter();
-       sx_dprintk (SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n", sx_debug);
-       if (abs ((long) (&sx_debug) - sx_debug) < 0x10000) {
-               printk (KERN_WARNING "sx: sx_debug is an address, instead of a value. "
-                       "Assuming -1.\n");
-               printk ("(%p)\n", &sx_debug);
-               sx_debug=-1;
+       sx_dprintk(SX_DEBUG_INIT, "Initing sx module... (sx_debug=%d)\n",
+                       sx_debug);
+       if (abs((long)(&sx_debug) - sx_debug) < 0x10000) {
+               printk(KERN_WARNING "sx: sx_debug is an address, instead of a "
+                               "value. Assuming -1.\n(%p)\n", &sx_debug);
+               sx_debug = -1;
        }
 
        if (misc_register(&sx_fw_device) < 0) {
-               printk(KERN_ERR "SX: Unable to register firmware loader driver.\n");
+               printk(KERN_ERR "SX: Unable to register firmware loader "
+                               "driver.\n");
                return -EIO;
        }
-
-       for (i=0;i<NR_SX_ADDRS;i++) {
+#ifdef CONFIG_ISA
+       for (i = 0; i < NR_SX_ADDRS; i++) {
                board = &boards[found];
                board->hw_base = sx_probe_addrs[i];
+               board->hw_len = SX_WINDOW_LEN;
+               if (!request_region(board->hw_base, board->hw_len, "sx"))
+                       continue;
                board->base2 =
-               board->base = ioremap(board->hw_base, SX_WINDOW_LEN);
+               board->base = ioremap(board->hw_base, board->hw_len);
+               if (!board->base)
+                       goto err_sx_reg;
                board->flags &= ~SX_BOARD_TYPE;
-               board->flags |= SX_ISA_BOARD;
-               board->irq = sx_irqmask?-1:0;
+               board->flags |= SX_ISA_BOARD;
+               board->irq = sx_irqmask ? -1 : 0;
 
-               if (probe_sx (board)) {
+               if (probe_sx(board)) {
+                       board->flags |= SX_BOARD_PRESENT;
                        found++;
                } else {
                        iounmap(board->base);
+err_sx_reg:
+                       release_region(board->hw_base, board->hw_len);
                }
        }
 
-       for (i=0;i<NR_SI_ADDRS;i++) {
+       for (i = 0; i < NR_SI_ADDRS; i++) {
                board = &boards[found];
                board->hw_base = si_probe_addrs[i];
+               board->hw_len = SI2_ISA_WINDOW_LEN;
+               if (!request_region(board->hw_base, board->hw_len, "sx"))
+                       continue;
                board->base2 =
-               board->base = ioremap(board->hw_base, SI2_ISA_WINDOW_LEN);
+               board->base = ioremap(board->hw_base, board->hw_len);
+               if (!board->base)
+                       goto err_si_reg;
                board->flags &= ~SX_BOARD_TYPE;
-               board->flags |=  SI_ISA_BOARD;
-               board->irq = sx_irqmask ?-1:0;
+               board->flags |= SI_ISA_BOARD;
+               board->irq = sx_irqmask ? -1 : 0;
 
-               if (probe_si (board)) {
+               if (probe_si(board)) {
+                       board->flags |= SX_BOARD_PRESENT;
                        found++;
                } else {
-                       iounmap (board->base);
+                       iounmap(board->base);
+err_si_reg:
+                       release_region(board->hw_base, board->hw_len);
                }
        }
-       for (i=0;i<NR_SI1_ADDRS;i++) {
+       for (i = 0; i < NR_SI1_ADDRS; i++) {
                board = &boards[found];
                board->hw_base = si1_probe_addrs[i];
+               board->hw_len = SI1_ISA_WINDOW_LEN;
+               if (!request_region(board->hw_base, board->hw_len, "sx"))
+                       continue;
                board->base2 =
-               board->base = ioremap(board->hw_base, SI1_ISA_WINDOW_LEN);
+               board->base = ioremap(board->hw_base, board->hw_len);
+               if (!board->base)
+                       goto err_si1_reg;
                board->flags &= ~SX_BOARD_TYPE;
-               board->flags |=  SI1_ISA_BOARD;
-               board->irq = sx_irqmask ?-1:0;
+               board->flags |= SI1_ISA_BOARD;
+               board->irq = sx_irqmask ? -1 : 0;
 
-               if (probe_si (board)) {
+               if (probe_si(board)) {
+                       board->flags |= SX_BOARD_PRESENT;
                        found++;
                } else {
-                       iounmap (board->base);
-               }
-       }
-
-        sx_dprintk(SX_DEBUG_PROBE, "Probing for EISA cards\n");
-        for(eisa_slot=0x1000; eisa_slot<0x10000; eisa_slot+=0x1000)
-        {
-                if((inb(eisa_slot+0xc80)==0x4d) &&
-                   (inb(eisa_slot+0xc81)==0x98))
-                {
-                       sx_dprintk(SX_DEBUG_PROBE, "%s : Signature found in EISA slot %d, Product %d Rev %d\n",
-                                               "XIO", (eisa_slot>>12), inb(eisa_slot+0xc82), inb(eisa_slot+0xc83));
-
-                       board = &boards[found];
-                       board->eisa_base = eisa_slot;
-                       board->flags &= ~SX_BOARD_TYPE;
-                       board->flags |= SI_EISA_BOARD;
-
-                       board->hw_base = (((inb(0xc01+eisa_slot) << 8) + inb(0xc00+eisa_slot)) << 16);
-                       board->base2 =
-                       board->base = ioremap(board->hw_base, SI2_EISA_WINDOW_LEN);
-
-                       sx_dprintk(SX_DEBUG_PROBE, "IO hw_base address: %lx\n", board->hw_base);
-                       sx_dprintk(SX_DEBUG_PROBE, "base: %p\n", board->base);
-                       board->irq = inb(board->eisa_base+0xc02)>>4; 
-                       sx_dprintk(SX_DEBUG_PROBE, "IRQ: %d\n", board->irq);
-                       
-                       probe_si(board);
-
-                       found++;
+                       iounmap(board->base);
+err_si1_reg:
+                       release_region(board->hw_base, board->hw_len);
                }
        }
-
+#endif
+#ifdef CONFIG_EISA
+       retval1 = eisa_driver_register(&sx_eisadriver);
+#endif
        retval = pci_register_driver(&sx_pcidriver);
 
        if (found) {
-               printk (KERN_INFO "sx: total of %d boards detected.\n", found);
+               printk(KERN_INFO "sx: total of %d boards detected.\n", found);
                retval = 0;
        } else if (retval) {
-               misc_deregister(&sx_fw_device);
+#ifdef CONFIG_EISA
+               retval = retval1;
+               if (retval1)
+#endif
+                       misc_deregister(&sx_fw_device);
        }
 
        func_exit();
        return retval;
 }
 
-
-static void __exit sx_exit (void)
+static void __exit sx_exit(void)
 {
-       int i; 
-       struct sx_board *board;
+       int i;
 
        func_enter();
+#ifdef CONFIG_EISA
+       eisa_driver_unregister(&sx_eisadriver);
+#endif
        pci_unregister_driver(&sx_pcidriver);
-       for (i = 0; i < SX_NBOARDS; i++) {
-               board = &boards[i];
-               if (board->flags & SX_BOARD_INITIALIZED) {
-                       sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up board at %p\n", board->base);
-                       /* The board should stop messing with us.
-                          (actually I mean the interrupt) */
-                       sx_reset (board);
-                       if ((board->irq) && (board->flags & SX_IRQ_ALLOCATED))
-                               free_irq (board->irq, board);
-
-                       /* It is safe/allowed to del_timer a non-active timer */
-                       del_timer (& board->timer);
-                       iounmap(board->base);
-               }
-       }
+
+       for (i = 0; i < SX_NBOARDS; i++)
+               sx_remove_card(&boards[i], NULL);
+
        if (misc_deregister(&sx_fw_device) < 0) {
-               printk (KERN_INFO "sx: couldn't deregister firmware loader device\n");
+               printk(KERN_INFO "sx: couldn't deregister firmware loader "
+                               "device\n");
        }
-       sx_dprintk (SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n", sx_initialized);
+       sx_dprintk(SX_DEBUG_CLEANUP, "Cleaning up drivers (%d)\n",
+                       sx_initialized);
        if (sx_initialized)
-               sx_release_drivers ();
+               sx_release_drivers();
 
-       kfree (sx_ports);
+       kfree(sx_ports);
        func_exit();
 }
 
 module_init(sx_init);
 module_exit(sx_exit);
-
-