cyclades: remove custom types
[linux-2.6.git] / drivers / char / cyclades.c
index 3bb4e53..29b5375 100644 (file)
@@ -1,8 +1,6 @@
 #undef BLOCKMOVE
 #define        Z_WAKE
 #undef Z_EXT_CHARS_IN_BUFFER
-static char rcsid[] =
-"$Revision: 2.3.2.20 $$Date: 2004/02/25 18:14:16 $";
 
 /*
  *  linux/drivers/char/cyclades.c
@@ -593,18 +591,20 @@ static char rcsid[] =
  *
  */
 
+#define CY_VERSION     "2.4"
+
 /* If you need to install more boards than NR_CARDS, change the constant
    in the definition below. No other change is necessary to support up to
    eight boards. Beyond that you'll have to extend cy_isa_addresses. */
 
-#define NR_CARDS        4
+#define NR_CARDS       4
 
 /*
    If the total number of ports is larger than NR_PORTS, change this
    constant in the definition below. No other change is necessary to
    support more boards/ports. */
 
-#define NR_PORTS        256
+#define NR_PORTS       256
 
 #define ZE_V1_NPORTS   64
 #define ZO_V1  0
@@ -625,9 +625,9 @@ static char rcsid[] =
 #undef CY_PCI_DEBUG
 
 #if 0
-#define PAUSE __asm__("nop");
+#define PAUSE __asm__("nop")
 #else
-#define PAUSE ;
+#define PAUSE do {} while (0)
 #endif
 
 /*
@@ -663,27 +663,26 @@ static char rcsid[] =
                do {                                            \
                spin_lock_irqsave(&cy_card[info->card].card_lock, flags); \
                } while (0)
-               
+
 #define        CY_UNLOCK(info,flags)                                   \
                do {                                            \
                spin_unlock_irqrestore(&cy_card[info->card].card_lock, flags); \
                } while (0)
 
-#include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/pci.h>
 
 #include <linux/stat.h>
 #include <linux/proc_fs.h>
 
-static void cy_throttle (struct tty_struct *tty);
-static void cy_send_xchar (struct tty_struct *tty, char ch);
+static void cy_throttle(struct tty_struct *tty);
+static void cy_send_xchar(struct tty_struct *tty, char ch);
 
 #define IS_CYC_Z(card) ((card).num_chips == -1)
 
 #define Z_FPGA_CHECK(card) \
-    ((cy_readl(&((struct RUNTIME_9060 __iomem *) \
-                ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
+       ((cy_readl(&((struct RUNTIME_9060 __iomem *) \
+               ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
 
 #define ISZLOADED(card)        (((ZO_V1==cy_readl(&((struct RUNTIME_9060 __iomem *) \
                        ((card).ctl_addr))->mail_box_0)) || \
@@ -698,8 +697,6 @@ static void cy_send_xchar (struct tty_struct *tty, char ch);
 
 #define STD_COM_FLAGS (0)
 
-#define        JIFFIES_DIFF(n, j)      ((j) - (n))
-
 static struct tty_driver *cy_serial_driver;
 
 #ifdef CONFIG_ISA
@@ -713,27 +710,28 @@ static struct tty_driver *cy_serial_driver;
 */
 
 static unsigned int cy_isa_addresses[] = {
-        0xD0000,
-        0xD2000,
-        0xD4000,
-        0xD6000,
-        0xD8000,
-        0xDA000,
-        0xDC000,
-        0xDE000,
-        0,0,0,0,0,0,0,0
+       0xD0000,
+       0xD2000,
+       0xD4000,
+       0xD6000,
+       0xD8000,
+       0xDA000,
+       0xDC000,
+       0xDE000,
+       0, 0, 0, 0, 0, 0, 0, 0
 };
+
 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 
 #ifdef MODULE
 static long maddr[NR_CARDS] = { 0, };
-static int irq[NR_CARDS]  = { 0, };
+static int irq[NR_CARDS] = { 0, };
 
 module_param_array(maddr, long, NULL, 0);
 module_param_array(irq, int, NULL, 0);
 #endif
 
-#endif /* CONFIG_ISA */
+#endif                         /* CONFIG_ISA */
 
 /* This is the per-card data structure containing address, irq, number of
    channels, etc. This driver supports a maximum of NR_CARDS cards.
@@ -745,7 +743,7 @@ static struct cyclades_card cy_card[NR_CARDS];
 */
 static struct cyclades_port cy_port[NR_PORTS];
 
-static int cy_next_channel; /* next minor available */
+static int cy_next_channel;    /* next minor available */
 
 /*
  * This is used to look up the divisor speeds and the timeouts
@@ -757,36 +755,42 @@ static int cy_next_channel; /* next minor available */
  *     20
  */
 static int baud_table[] = {
-       0,    50,    75,   110,   134,   150,   200,   300,   600,  1200,
-    1800,  2400,  4800,  9600, 19200, 38400, 57600, 76800,115200,150000,
-  230400,     0};
-
-static char baud_co_25[] = {  /* 25 MHz clock option table */
-    /* value =>    00    01   02    03    04 */
-    /* divide by    8    32   128   512  2048 */
-    0x00,  0x04,  0x04,  0x04,  0x04,  0x04,  0x03,  0x03,  0x03,  0x02,
-    0x02,  0x02,  0x01,  0x01,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00};
-
-static char baud_bpr_25[] = {  /* 25 MHz baud rate period table */
-    0x00,  0xf5,  0xa3,  0x6f,  0x5c,  0x51,  0xf5,  0xa3,  0x51,  0xa3,
-    0x6d,  0x51,  0xa3,  0x51,  0xa3,  0x51,  0x36,  0x29,  0x1b,  0x15};
-
-static char baud_co_60[] = {  /* 60 MHz clock option table (CD1400 J) */
-    /* value =>    00    01   02    03    04 */
-    /* divide by    8    32   128   512  2048 */
-    0x00,  0x00,  0x00,  0x04,  0x04,  0x04,  0x04,  0x04,  0x03,  0x03,
-    0x03,  0x02,  0x02,  0x01,  0x01,  0x00,  0x00,  0x00,  0x00,  0x00,
-    0x00};
-
-static char baud_bpr_60[] = {  /* 60 MHz baud rate period table (CD1400 J) */
-    0x00,  0x82,  0x21,  0xff,  0xdb,  0xc3,  0x92,  0x62,  0xc3,  0x62,
-    0x41,  0xc3,  0x62,  0xc3,  0x62,  0xc3,  0x82,  0x62,  0x41,  0x32,
-    0x21};
-
-static char baud_cor3[] = {  /* receive threshold */
-    0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,
-    0x0a,  0x0a,  0x0a,  0x09,  0x09,  0x08,  0x08,  0x08,  0x08,  0x07,
-    0x07};
+       0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
+       1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
+       230400, 0
+};
+
+static char baud_co_25[] = {   /* 25 MHz clock option table */
+       /* value =>    00    01   02    03    04 */
+       /* divide by    8    32   128   512  2048 */
+       0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
+       0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static char baud_bpr_25[] = {  /* 25 MHz baud rate period table */
+       0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
+       0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
+};
+
+static char baud_co_60[] = {   /* 60 MHz clock option table (CD1400 J) */
+       /* value =>    00    01   02    03    04 */
+       /* divide by    8    32   128   512  2048 */
+       0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
+       0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+       0x00
+};
+
+static char baud_bpr_60[] = {  /* 60 MHz baud rate period table (CD1400 J) */
+       0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
+       0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
+       0x21
+};
+
+static char baud_cor3[] = {    /* receive threshold */
+       0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+       0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
+       0x07
+};
 
 /*
  * The Cyclades driver implements HW flow control as any serial driver.
@@ -799,52 +803,53 @@ static char baud_cor3[] = {  /* receive threshold */
  * cables.
  */
 
-static char rflow_thr[] = {  /* rflow threshold */
-    0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
-    0x00,  0x00,  0x00,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,  0x0a,
-    0x0a};
+static char rflow_thr[] = {    /* rflow threshold */
+       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+       0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
+       0x0a
+};
 
 /*  The Cyclom-Ye has placed the sequential chips in non-sequential
  *  address order.  This look-up table overcomes that problem.
  */
-static int cy_chip_offset [] =
-    { 0x0000,
-      0x0400,
-      0x0800,
-      0x0C00,
-      0x0200,
-      0x0600,
-      0x0A00,
-      0x0E00
-    };
+static int cy_chip_offset[] = { 0x0000,
+       0x0400,
+       0x0800,
+       0x0C00,
+       0x0200,
+       0x0600,
+       0x0A00,
+       0x0E00
+};
 
 /* PCI related definitions */
 
-static unsigned short  cy_pci_nboard;
-static unsigned short  cy_isa_nboard;
-static unsigned short  cy_nboard;
+static unsigned short cy_pci_nboard;
+static unsigned short cy_isa_nboard;
+static unsigned short cy_nboard;
 #ifdef CONFIG_PCI
-static unsigned short  cy_pci_dev_id[] = {
-                           PCI_DEVICE_ID_CYCLOM_Y_Lo,  /* PCI < 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_Y_Hi,  /* PCI > 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_4Y_Lo, /* 4Y PCI < 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_4Y_Hi, /* 4Y PCI > 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_8Y_Lo, /* 8Y PCI < 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_8Y_Hi, /* 8Y PCI > 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_Z_Lo,  /* Z PCI < 1Mb */
-                           PCI_DEVICE_ID_CYCLOM_Z_Hi,  /* Z PCI > 1Mb */
-                           0                           /* end of table */
-                       };
+static struct pci_device_id cy_pci_dev_id[] __devinitdata = {
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },      /* PCI < 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },      /* PCI > 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },     /* 4Y PCI < 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },     /* 4Y PCI > 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },     /* 8Y PCI < 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },     /* 8Y PCI > 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },      /* Z PCI < 1Mb */
+       { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },      /* Z PCI > 1Mb */
+       { }                     /* end of table */
+};
+MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
 #endif
 
 static void cy_start(struct tty_struct *);
 static void set_line_char(struct cyclades_port *);
-static int cyz_issue_cmd(struct cyclades_card *, uclong, ucchar, uclong);
+static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
 #ifdef CONFIG_ISA
 static unsigned detect_isa_irq(void __iomem *);
-#endif /* CONFIG_ISA */
+#endif                         /* CONFIG_ISA */
 
-static int cyclades_get_proc_info(char *, char **, off_t , int , int *, void *);
+static int cyclades_get_proc_info(char *, char **, off_t, int, int *, void *);
 
 #ifndef CONFIG_CYZ_INTR
 static void cyz_poll(unsigned long);
@@ -855,41 +860,36 @@ static long cyz_polling_cycle = CZ_DEF_POLL;
 static int cyz_timeron = 0;
 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
 
-#else /* CONFIG_CYZ_INTR */
+#else                          /* CONFIG_CYZ_INTR */
 static void cyz_rx_restart(unsigned long);
 static struct timer_list cyz_rx_full_timer[NR_PORTS];
-#endif /* CONFIG_CYZ_INTR */
+#endif                         /* CONFIG_CYZ_INTR */
 
-static inline int
-serial_paranoia_check(struct cyclades_port *info,
-                        char *name, const char *routine)
+static inline int serial_paranoia_check(struct cyclades_port *info,
+               char *name, const char *routine)
 {
 #ifdef SERIAL_PARANOIA_CHECK
-    static const char *badmagic =
-        "cyc Warning: bad magic number for serial struct (%s) in %s\n";
-    static const char *badinfo =
-        "cyc Warning: null cyclades_port for (%s) in %s\n";
-    static const char *badrange =
-        "cyc Warning: cyclades_port out of range for (%s) in %s\n";
-
-    if (!info) {
-        printk(badinfo, name, routine);
-        return 1;
-    }
-
-    if( (long)info < (long)(&cy_port[0])
-    || (long)(&cy_port[NR_PORTS]) < (long)info ){
-        printk(badrange, name, routine);
-        return 1;
-    }
-
-    if (info->magic != CYCLADES_MAGIC) {
-        printk(badmagic, name, routine);
-        return 1;
-    }
+       if (!info) {
+               printk("cyc Warning: null cyclades_port for (%s) in %s\n",
+                               name, routine);
+               return 1;
+       }
+
+       if ((long)info < (long)(&cy_port[0]) ||
+                       (long)(&cy_port[NR_PORTS]) < (long)info) {
+               printk("cyc Warning: cyclades_port out of range for (%s) in "
+                               "%s\n", name, routine);
+               return 1;
+       }
+
+       if (info->magic != CYCLADES_MAGIC) {
+               printk("cyc Warning: bad magic number for serial struct (%s) "
+                               "in %s\n", name, routine);
+               return 1;
+       }
 #endif
-        return 0;
-} /* serial_paranoia_check */
+       return 0;
+}                              /* serial_paranoia_check */
 
 /*
  * This routine is used by the interrupt handler to schedule
@@ -897,13 +897,11 @@ serial_paranoia_check(struct cyclades_port *info,
  * (also known as the "bottom half").  This can be called any
  * number of times for any channel without harm.
  */
-static inline void
-cy_sched_event(struct cyclades_port *info, int event)
+static inline void cy_sched_event(struct cyclades_port *info, int event)
 {
-    info->event |= 1 << event; /* remember what kind of event and who */
-    schedule_work(&info->tqueue);
-} /* cy_sched_event */
-
+       info->event |= 1 << event; /* remember what kind of event and who */
+       schedule_work(&info->tqueue);
+}                              /* cy_sched_event */
 
 /*
  * This routine is used to handle the "bottom half" processing for the
@@ -930,41 +928,36 @@ do_softint(struct work_struct *work)
 {
        struct cyclades_port *info =
                container_of(work, struct cyclades_port, tqueue);
-  struct tty_struct    *tty;
-
-    tty = info->tty;
-    if (!tty)
-        return;
-
-    if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
-        tty_hangup(info->tty);
-        wake_up_interruptible(&info->open_wait);
-        info->flags &= ~ASYNC_NORMAL_ACTIVE;
-    }
-    if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event)) {
-        wake_up_interruptible(&info->open_wait);
-    }
+       struct tty_struct    *tty;
+
+       tty = info->tty;
+       if (!tty)
+               return;
+
+       if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
+               tty_hangup(info->tty);
+               wake_up_interruptible(&info->open_wait);
+                       info->flags &= ~ASYNC_NORMAL_ACTIVE;
+       }
+       if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
+               wake_up_interruptible(&info->open_wait);
 #ifdef CONFIG_CYZ_INTR
-    if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
-       if (cyz_rx_full_timer[info->line].function == NULL) {
-           cyz_rx_full_timer[info->line].expires = jiffies + 1;
-           cyz_rx_full_timer[info->line].function = cyz_rx_restart;
-           cyz_rx_full_timer[info->line].data = (unsigned long)info;
-           add_timer(&cyz_rx_full_timer[info->line]);
+       if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
+               if (cyz_rx_full_timer[info->line].function == NULL) {
+                       cyz_rx_full_timer[info->line].expires = jiffies + 1;
+                       cyz_rx_full_timer[info->line].function = cyz_rx_restart;
+                       cyz_rx_full_timer[info->line].data =
+                                               (unsigned long)info;
+                       add_timer(&cyz_rx_full_timer[info->line]);
+               }
        }
-    }
 #endif
-    if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event)) {
-       wake_up_interruptible(&info->delta_msr_wait);
-    }
-    if (test_and_clear_bit(Cy_EVENT_WRITE_WAKEUP, &info->event)) {
-        tty_wakeup(tty);
-        wake_up_interruptible(&tty->write_wait);
-    }
+       if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
+               wake_up_interruptible(&info->delta_msr_wait);
+       tty_wakeup(tty);
 #ifdef Z_WAKE
-    if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event)) {
-        wake_up_interruptible(&info->shutdown_wait);
-    }
+       if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
+               wake_up_interruptible(&info->shutdown_wait);
 #endif
 } /* do_softint */
 
@@ -979,341 +972,339 @@ do_softint(struct work_struct *work)
 
    This function is only called from inside spinlock-protected code.
  */
-static int
-cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index)
+static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
 {
-  volatile int  i;
+       volatile int i;
 
-    /* Check to see that the previous command has completed */
-    for(i = 0 ; i < 100 ; i++){
-       if (cy_readb(base_addr+(CyCCR<<index)) == 0){
-           break;
+       /* Check to see that the previous command has completed */
+       for (i = 0; i < 100; i++) {
+               if (cy_readb(base_addr + (CyCCR << index)) == 0) {
+                       break;
+               }
+               udelay(10L);
        }
-       udelay(10L);
-    }
-    /* if the CCR never cleared, the previous command
-       didn't finish within the "reasonable time" */
-    if (i == 100)      return (-1);
+       /* if the CCR never cleared, the previous command
+          didn't finish within the "reasonable time" */
+       if (i == 100)
+               return -1;
 
-    /* Issue the new command */
-    cy_writeb(base_addr+(CyCCR<<index), cmd);
+       /* Issue the new command */
+       cy_writeb(base_addr + (CyCCR << index), cmd);
 
-    return(0);
-} /* cyy_issue_cmd */
+       return 0;
+}                              /* cyy_issue_cmd */
 
 #ifdef CONFIG_ISA
 /* ISA interrupt detection code */
-static unsigned 
-detect_isa_irq(void __iomem *address)
+static unsigned detect_isa_irq(void __iomem * address)
 {
-  int irq;
-  unsigned long irqs, flags;
-  int save_xir, save_car;
-  int index = 0; /* IRQ probing is only for ISA */
-
-    /* forget possible initially masked and pending IRQ */
-    irq = probe_irq_off(probe_irq_on());
-
-    /* Clear interrupts on the board first */
-    cy_writeb(address + (Cy_ClrIntr<<index), 0);
-                             /* Cy_ClrIntr is 0x1800 */
-
-    irqs = probe_irq_on();
-    /* Wait ... */
-    udelay(5000L);
-
-    /* Enable the Tx interrupts on the CD1400 */
-    local_irq_save(flags);
-       cy_writeb(address + (CyCAR<<index), 0);
-       cyy_issue_cmd(address, CyCHAN_CTL|CyENB_XMTR, index);
-
-       cy_writeb(address + (CyCAR<<index), 0);
-       cy_writeb(address + (CySRER<<index), 
-               cy_readb(address + (CySRER<<index)) | CyTxRdy);
-    local_irq_restore(flags);
-
-    /* Wait ... */
-    udelay(5000L);
-
-    /* Check which interrupt is in use */
-    irq = probe_irq_off(irqs);
-
-    /* Clean up */
-    save_xir = (u_char) cy_readb(address + (CyTIR<<index));
-    save_car = cy_readb(address + (CyCAR<<index));
-    cy_writeb(address + (CyCAR<<index), (save_xir & 0x3));
-    cy_writeb(address + (CySRER<<index),
-       cy_readb(address + (CySRER<<index)) & ~CyTxRdy);
-    cy_writeb(address + (CyTIR<<index), (save_xir & 0x3f));
-    cy_writeb(address + (CyCAR<<index), (save_car));
-    cy_writeb(address + (Cy_ClrIntr<<index), 0);
-                             /* Cy_ClrIntr is 0x1800 */
-
-    return (irq > 0)? irq : 0;
+       int irq;
+       unsigned long irqs, flags;
+       int save_xir, save_car;
+       int index = 0;          /* IRQ probing is only for ISA */
+
+       /* forget possible initially masked and pending IRQ */
+       irq = probe_irq_off(probe_irq_on());
+
+       /* Clear interrupts on the board first */
+       cy_writeb(address + (Cy_ClrIntr << index), 0);
+       /* Cy_ClrIntr is 0x1800 */
+
+       irqs = probe_irq_on();
+       /* Wait ... */
+       udelay(5000L);
+
+       /* Enable the Tx interrupts on the CD1400 */
+       local_irq_save(flags);
+       cy_writeb(address + (CyCAR << index), 0);
+       cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
+
+       cy_writeb(address + (CyCAR << index), 0);
+       cy_writeb(address + (CySRER << index),
+                 cy_readb(address + (CySRER << index)) | CyTxRdy);
+       local_irq_restore(flags);
+
+       /* Wait ... */
+       udelay(5000L);
+
+       /* Check which interrupt is in use */
+       irq = probe_irq_off(irqs);
+
+       /* Clean up */
+       save_xir = (u_char) cy_readb(address + (CyTIR << index));
+       save_car = cy_readb(address + (CyCAR << index));
+       cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
+       cy_writeb(address + (CySRER << index),
+                 cy_readb(address + (CySRER << index)) & ~CyTxRdy);
+       cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
+       cy_writeb(address + (CyCAR << index), (save_car));
+       cy_writeb(address + (Cy_ClrIntr << index), 0);
+       /* Cy_ClrIntr is 0x1800 */
+
+       return (irq > 0) ? irq : 0;
 }
-#endif /* CONFIG_ISA */
+#endif                         /* CONFIG_ISA */
 
-/* The real interrupt service routine is called
-   whenever the card wants its hand held--chars
-   received, out buffer empty, modem change, etc.
- */
-static irqreturn_t
-cyy_interrupt(int irq, void *dev_id)
+static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
+                       void __iomem * base_addr, int status, int index)
 {
-  struct tty_struct *tty;
-  int status;
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info;
-  void __iomem *base_addr, *card_base_addr;
-  int chip;
-  int save_xir, channel, save_car;
-  char data;
-  volatile int char_count;
-  int outch;
-  int i,j,index;
-  int too_many;
-  int had_work;
-  int mdm_change;
-  int mdm_status;
-  int len;
-    if((cinfo = (struct cyclades_card *)dev_id) == 0){
-#ifdef CY_DEBUG_INTERRUPTS
-       printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
-#endif
-        return IRQ_NONE; /* spurious interrupt */
-    }
-
-    card_base_addr = cinfo->base_addr;
-    index = cinfo->bus_index;
-
-
-    /* This loop checks all chips in the card.  Make a note whenever
-       _any_ chip had some work to do, as this is considered an
-       indication that there will be more to do.  Only when no chip
-       has any work does this outermost loop exit.
-     */
-    do{
-        had_work = 0;
-        for ( chip = 0 ; chip < cinfo->num_chips ; chip ++) {
-            base_addr = cinfo->base_addr + (cy_chip_offset[chip]<<index);
-            too_many = 0;
-            while ( (status = cy_readb(base_addr+(CySVRR<<index))) != 0x00) {
-                had_work++;
-                /* The purpose of the following test is to ensure that
-                   no chip can monopolize the driver.  This forces the
-                   chips to be checked in a round-robin fashion (after
-                   draining each of a bunch (1000) of characters).
-                 */
-                if(1000<too_many++){
-                    break;
-                }
-                if (status & CySRReceive) { /* reception interrupt */
+       struct cyclades_port *info;
+       struct tty_struct *tty;
+       volatile int char_count;
+       int i, j, len, mdm_change, mdm_status, outch;
+       int save_xir, channel, save_car;
+       char data;
+
+       if (status & CySRReceive) {     /* reception interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-                   printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
+               printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
 #endif
-                    /* determine the channel & change to that context */
-                   spin_lock(&cinfo->card_lock);
-                    save_xir = (u_char) cy_readb(base_addr+(CyRIR<<index));
-                    channel = (u_short ) (save_xir & CyIRChannel);
-                    i = channel + chip * 4 + cinfo->first_line;
-                    info = &cy_port[i];
-                    info->last_active = jiffies;
-                    save_car = cy_readb(base_addr+(CyCAR<<index));
-                    cy_writeb(base_addr+(CyCAR<<index), save_xir);
-
-                    /* if there is nowhere to put the data, discard it */
-                    if(info->tty == 0){
-                        j = (cy_readb(base_addr+(CyRIVR<<index)) & CyIVRMask);
-                        if ( j == CyIVRRxEx ) { /* exception */
-                            data = cy_readb(base_addr+(CyRDSR<<index));
-                        } else { /* normal character reception */
-                            char_count = cy_readb(base_addr+(CyRDCR<<index));
-                            while(char_count--){
-                                data = cy_readb(base_addr+(CyRDSR<<index));
-                            }
-                        }
-                    }else{ /* there is an open port for this data */
-                        tty = info->tty;
-                        j = (cy_readb(base_addr+(CyRIVR<<index)) & CyIVRMask);
-                        if ( j == CyIVRRxEx ) { /* exception */
-                            data = cy_readb(base_addr+(CyRDSR<<index));
-
-                           /* For statistics only */
-                           if (data & CyBREAK)
-                               info->icount.brk++;
-                           else if(data & CyFRAME)
-                               info->icount.frame++;
-                           else if(data & CyPARITY)
-                               info->icount.parity++;
-                           else if(data & CyOVERRUN)
-                               info->icount.overrun++;
-
-                            if(data & info->ignore_status_mask){
-                               info->icount.rx++;
-                                continue;
-                            }
-                            if (tty_buffer_request_room(tty, 1)) {
-                                if (data & info->read_status_mask){
-                                    if(data & CyBREAK){
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_BREAK);
-                                       info->icount.rx++;
-                                        if (info->flags & ASYNC_SAK){
-                                            do_SAK(tty);
-                                        }
-                                    }else if(data & CyFRAME){
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
-                                       info->icount.rx++;
-                                       info->idle_stats.frame_errs++;
-                                    }else if(data & CyPARITY){
-                                       /* Pieces of seven... */
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_PARITY);
-                                       info->icount.rx++;
-                                       info->idle_stats.parity_errs++;
-                                    }else if(data & CyOVERRUN){
-                                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
+               /* determine the channel & change to that context */
+               spin_lock(&cinfo->card_lock);
+               save_xir = (u_char) cy_readb(base_addr + (CyRIR << index));
+               channel = (u_short) (save_xir & CyIRChannel);
+               i = channel + chip * 4 + cinfo->first_line;
+               info = &cy_port[i];
+               info->last_active = jiffies;
+               save_car = cy_readb(base_addr + (CyCAR << index));
+               cy_writeb(base_addr + (CyCAR << index), save_xir);
+
+               /* if there is nowhere to put the data, discard it */
+               if (info->tty == 0) {
+                       j = (cy_readb(base_addr + (CyRIVR << index)) &
+                               CyIVRMask);
+                       if (j == CyIVRRxEx) {   /* exception */
+                               data = cy_readb(base_addr + (CyRDSR << index));
+                       } else {        /* normal character reception */
+                               char_count = cy_readb(base_addr +
+                                               (CyRDCR << index));
+                               while (char_count--) {
+                                       data = cy_readb(base_addr +
+                                               (CyRDSR << index));
+                               }
+                       }
+               } else {        /* there is an open port for this data */
+                       tty = info->tty;
+                       j = (cy_readb(base_addr + (CyRIVR << index)) &
+                                       CyIVRMask);
+                       if (j == CyIVRRxEx) {   /* exception */
+                               data = cy_readb(base_addr + (CyRDSR << index));
+
+                               /* For statistics only */
+                               if (data & CyBREAK)
+                                       info->icount.brk++;
+                               else if (data & CyFRAME)
+                                       info->icount.frame++;
+                               else if (data & CyPARITY)
+                                       info->icount.parity++;
+                               else if (data & CyOVERRUN)
+                                       info->icount.overrun++;
+
+                               if (data & info->ignore_status_mask) {
                                        info->icount.rx++;
-                                        /* If the flip buffer itself is
-                                           overflowing, we still lose
-                                           the next incoming character.
-                                         */
-                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
-                                       info->icount.rx++;
+                                       return;
+                               }
+                               if (tty_buffer_request_room(tty, 1)) {
+                                       if (data & info->read_status_mask) {
+                                               if (data & CyBREAK) {
+                                                       tty_insert_flip_char(
+                                                               tty,
+                                                               cy_readb(
+                                                               base_addr +
+                                                               (CyRDSR <<
+                                                                       index)),
+                                                               TTY_BREAK);
+                                                       info->icount.rx++;
+                                                       if (info->flags &
+                                                           ASYNC_SAK) {
+                                                               do_SAK(tty);
+                                                       }
+                                               } else if (data & CyFRAME) {
+                                                       tty_insert_flip_char(
+                                                               tty,
+                                                               cy_readb(
+                                                               base_addr +
+                                                               (CyRDSR <<
+                                                                       index)),
+                                                               TTY_FRAME);
+                                                       info->icount.rx++;
+                                                       info->idle_stats.
+                                                               frame_errs++;
+                                               } else if (data & CyPARITY) {
+                                                       /* Pieces of seven... */
+                                                       tty_insert_flip_char(
+                                                               tty,
+                                                               cy_readb(
+                                                               base_addr +
+                                                               (CyRDSR <<
+                                                                       index)),
+                                                               TTY_PARITY);
+                                                       info->icount.rx++;
+                                                       info->idle_stats.
+                                                               parity_errs++;
+                                               } else if (data & CyOVERRUN) {
+                                                       tty_insert_flip_char(
+                                                               tty, 0,
+                                                               TTY_OVERRUN);
+                                                       info->icount.rx++;
+                                               /* If the flip buffer itself is
+                                                  overflowing, we still lose
+                                                  the next incoming character.
+                                                */
+                                                       tty_insert_flip_char(
+                                                               tty,
+                                                               cy_readb(
+                                                               base_addr +
+                                                               (CyRDSR <<
+                                                                       index)),
+                                                               TTY_FRAME);
+                                                       info->icount.rx++;
+                                                       info->idle_stats.
+                                                               overruns++;
+                                       /* These two conditions may imply */
+                                       /* a normal read should be done. */
+                                       /* }else if(data & CyTIMEOUT){ */
+                                       /* }else if(data & CySPECHAR){ */
+                                               } else {
+                                                       tty_insert_flip_char(
+                                                               tty, 0,
+                                                               TTY_NORMAL);
+                                                       info->icount.rx++;
+                                               }
+                                       } else {
+                                               tty_insert_flip_char(tty, 0,
+                                                               TTY_NORMAL);
+                                               info->icount.rx++;
+                                       }
+                               } else {
+                                       /* there was a software buffer
+                                          overrun and nothing could be
+                                          done about it!!! */
+                                       info->icount.buf_overrun++;
                                        info->idle_stats.overruns++;
-                                    /* These two conditions may imply */
-                                    /* a normal read should be done. */
-                                    /* }else if(data & CyTIMEOUT){ */
-                                    /* }else if(data & CySPECHAR){ */
-                                    }else {
-                                       tty_insert_flip_char(tty, 0, TTY_NORMAL);
-                                       info->icount.rx++;
-                                    }
-                                }else{
-                                   tty_insert_flip_char(tty, 0, TTY_NORMAL);
-                                   info->icount.rx++;
-                                }
-                            }else{
-                                /* there was a software buffer
-                                  overrun and nothing could be
-                                  done about it!!! */
-                               info->icount.buf_overrun++;
-                               info->idle_stats.overruns++;
-                            }
-                        } else { /* normal character reception */
-                            /* load # chars available from the chip */
-                            char_count = cy_readb(base_addr+(CyRDCR<<index));
+                               }
+                       } else {        /* normal character reception */
+                               /* load # chars available from the chip */
+                               char_count = cy_readb(base_addr +
+                                               (CyRDCR << index));
 
 #ifdef CY_ENABLE_MONITORING
-                            ++info->mon.int_count;
-                            info->mon.char_count += char_count;
-                            if (char_count > info->mon.char_max)
-                               info->mon.char_max = char_count;
-                            info->mon.char_last = char_count;
+                               ++info->mon.int_count;
+                               info->mon.char_count += char_count;
+                               if (char_count > info->mon.char_max)
+                                       info->mon.char_max = char_count;
+                               info->mon.char_last = char_count;
 #endif
-                           len = tty_buffer_request_room(tty, char_count);
-                            while(len--){
-                                data = cy_readb(base_addr+(CyRDSR<<index));
-                               tty_insert_flip_char(tty, data, TTY_NORMAL);
-                               info->idle_stats.recv_bytes++;
-                               info->icount.rx++;
+                               len = tty_buffer_request_room(tty, char_count);
+                               while (len--) {
+                                       data = cy_readb(base_addr +
+                                                       (CyRDSR << index));
+                                       tty_insert_flip_char(tty, data,
+                                                       TTY_NORMAL);
+                                       info->idle_stats.recv_bytes++;
+                                       info->icount.rx++;
 #ifdef CY_16Y_HACK
-                                udelay(10L);
+                                       udelay(10L);
 #endif
-                            }
-                             info->idle_stats.recv_idle = jiffies;
-                        }
+                               }
+                               info->idle_stats.recv_idle = jiffies;
+                       }
                        tty_schedule_flip(tty);
-                    }
-                    /* end of service */
-                    cy_writeb(base_addr+(CyRIR<<index), (save_xir & 0x3f));
-                    cy_writeb(base_addr+(CyCAR<<index), (save_car));
-                   spin_unlock(&cinfo->card_lock);
-                }
-
-
-                if (status & CySRTransmit) { /* transmission interrupt */
-                    /* Since we only get here when the transmit buffer
-                       is empty, we know we can always stuff a dozen
-                       characters. */
+               }
+               /* end of service */
+               cy_writeb(base_addr + (CyRIR << index), (save_xir & 0x3f));
+               cy_writeb(base_addr + (CyCAR << index), (save_car));
+               spin_unlock(&cinfo->card_lock);
+       }
+
+       if (status & CySRTransmit) {    /* transmission interrupt */
+               /* Since we only get here when the transmit buffer
+                  is empty, we know we can always stuff a dozen
+                  characters. */
 #ifdef CY_DEBUG_INTERRUPTS
-                   printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
+               printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
 #endif
 
-                    /* determine the channel & change to that context */
-                   spin_lock(&cinfo->card_lock);
-                    save_xir = (u_char) cy_readb(base_addr+(CyTIR<<index));
-                    channel = (u_short ) (save_xir & CyIRChannel);
-                    i = channel + chip * 4 + cinfo->first_line;
-                    save_car = cy_readb(base_addr+(CyCAR<<index));
-                    cy_writeb(base_addr+(CyCAR<<index), save_xir);
-
-                    /* validate the port# (as configured and open) */
-                    if( (i < 0) || (NR_PORTS <= i) ){
-                        cy_writeb(base_addr+(CySRER<<index),
-                             cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
-                        goto txend;
-                    }
-                    info = &cy_port[i];
-                    info->last_active = jiffies;
-                    if(info->tty == 0){
-                        cy_writeb(base_addr+(CySRER<<index),
-                             cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
-                        goto txdone;
-                    }
-
-                    /* load the on-chip space for outbound data */
-                    char_count = info->xmit_fifo_size;
-
-                    if(info->x_char) { /* send special char */
-                        outch = info->x_char;
-                        cy_writeb(base_addr+(CyTDR<<index), outch);
-                        char_count--;
+               /* determine the channel & change to that context */
+               spin_lock(&cinfo->card_lock);
+               save_xir = (u_char) cy_readb(base_addr + (CyTIR << index));
+               channel = (u_short) (save_xir & CyIRChannel);
+               i = channel + chip * 4 + cinfo->first_line;
+               save_car = cy_readb(base_addr + (CyCAR << index));
+               cy_writeb(base_addr + (CyCAR << index), save_xir);
+
+               /* validate the port# (as configured and open) */
+               if ((i < 0) || (NR_PORTS <= i)) {
+                       cy_writeb(base_addr + (CySRER << index),
+                                 cy_readb(base_addr + (CySRER << index)) &
+                                 ~CyTxRdy);
+                       goto txend;
+               }
+               info = &cy_port[i];
+               info->last_active = jiffies;
+               if (info->tty == 0) {
+                       cy_writeb(base_addr + (CySRER << index),
+                                 cy_readb(base_addr + (CySRER << index)) &
+                                 ~CyTxRdy);
+                       goto txdone;
+               }
+
+               /* load the on-chip space for outbound data */
+               char_count = info->xmit_fifo_size;
+
+               if (info->x_char) {     /* send special char */
+                       outch = info->x_char;
+                       cy_writeb(base_addr + (CyTDR << index), outch);
+                       char_count--;
                        info->icount.tx++;
-                        info->x_char = 0;
-                    }
+                       info->x_char = 0;
+               }
 
-                    if (info->breakon || info->breakoff) {
+               if (info->breakon || info->breakoff) {
                        if (info->breakon) {
-                           cy_writeb(base_addr + (CyTDR<<index), 0); 
-                           cy_writeb(base_addr + (CyTDR<<index), 0x81);
-                           info->breakon = 0;
-                            char_count -= 2;
+                               cy_writeb(base_addr + (CyTDR << index), 0);
+                               cy_writeb(base_addr + (CyTDR << index), 0x81);
+                               info->breakon = 0;
+                               char_count -= 2;
                        }
                        if (info->breakoff) {
-                           cy_writeb(base_addr + (CyTDR<<index), 0); 
-                           cy_writeb(base_addr + (CyTDR<<index), 0x83);
-                           info->breakoff = 0;
-                            char_count -= 2;
+                               cy_writeb(base_addr + (CyTDR << index), 0);
+                               cy_writeb(base_addr + (CyTDR << index), 0x83);
+                               info->breakoff = 0;
+                               char_count -= 2;
                        }
-                    }
-
-                    while (char_count-- > 0){
-                       if (!info->xmit_cnt){
-                           if (cy_readb(base_addr+(CySRER<<index))&CyTxMpty) {
-                               cy_writeb(base_addr+(CySRER<<index),
-                                         cy_readb(base_addr+(CySRER<<index)) &
-                                         ~CyTxMpty);
-                           } else {
-                               cy_writeb(base_addr+(CySRER<<index),
-                                         ((cy_readb(base_addr+(CySRER<<index))
-                                           & ~CyTxRdy)
-                                          | CyTxMpty));
-                           }
-                           goto txdone;
+               }
+
+               while (char_count-- > 0) {
+                       if (!info->xmit_cnt) {
+                               if (cy_readb(base_addr + (CySRER << index)) &
+                                               CyTxMpty) {
+                                       cy_writeb(base_addr + (CySRER << index),
+                                               cy_readb(base_addr +
+                                                       (CySRER << index)) &
+                                               ~CyTxMpty);
+                               } else {
+                                       cy_writeb(base_addr + (CySRER << index),
+                                               (cy_readb(base_addr +
+                                                       (CySRER << index)) &
+                                               ~CyTxRdy) | CyTxMpty);
+                               }
+                               goto txdone;
                        }
-                       if (info->xmit_buf == 0){
-                            cy_writeb(base_addr+(CySRER<<index),
-                               cy_readb(base_addr+(CySRER<<index)) & 
+                       if (info->xmit_buf == 0) {
+                               cy_writeb(base_addr + (CySRER << index),
+                                       cy_readb(base_addr + (CySRER << index))&
                                        ~CyTxRdy);
-                            goto txdone;
+                               goto txdone;
                        }
-                       if (info->tty->stopped || info->tty->hw_stopped){
-                            cy_writeb(base_addr+(CySRER<<index),
-                               cy_readb(base_addr+(CySRER<<index)) & 
+                       if (info->tty->stopped || info->tty->hw_stopped) {
+                               cy_writeb(base_addr + (CySRER << index),
+                                       cy_readb(base_addr + (CySRER << index))&
                                        ~CyTxRdy);
-                            goto txdone;
+                               goto txdone;
                        }
-                        /* Because the Embedded Transmit Commands have
-                           been enabled, we must check to see if the
+                       /* Because the Embedded Transmit Commands have
+                          been enabled, we must check to see if the
                           escape character, NULL, is being sent.  If it
                           is, we must ensure that there is room for it
                           to be doubled in the output stream.  Therefore
@@ -1322,125 +1313,182 @@ cyy_interrupt(int irq, void *dev_id)
                           after the check for a NULL output character.
                           This is necessary because there may not be
                           room for the two chars needed to send a NULL.)
-                         */
-                        outch = info->xmit_buf[info->xmit_tail];
-                        if( outch ){
-                            info->xmit_cnt--;
-                            info->xmit_tail = (info->xmit_tail + 1)
-                                                      & (SERIAL_XMIT_SIZE - 1);
-                            cy_writeb(base_addr+(CyTDR<<index), outch);
-                           info->icount.tx++;
-                        }else{
-                            if(char_count > 1){
-                                info->xmit_cnt--;
-                                info->xmit_tail = (info->xmit_tail + 1)
-                                                     & (SERIAL_XMIT_SIZE - 1);
-                                cy_writeb(base_addr+(CyTDR<<index), 
-                                         outch);
-                                cy_writeb(base_addr+(CyTDR<<index), 0);
+                        */
+                       outch = info->xmit_buf[info->xmit_tail];
+                       if (outch) {
+                               info->xmit_cnt--;
+                               info->xmit_tail = (info->xmit_tail + 1) &
+                                               (SERIAL_XMIT_SIZE - 1);
+                               cy_writeb(base_addr + (CyTDR << index), outch);
                                info->icount.tx++;
-                                char_count--;
-                            }else{
-                            }
-                        }
-                    }
-
-        txdone:
-                    if (info->xmit_cnt < WAKEUP_CHARS) {
-                        cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
-                    }
-        txend:
-                    /* end of service */
-                    cy_writeb(base_addr+(CyTIR<<index), 
-                             (save_xir & 0x3f));
-                    cy_writeb(base_addr+(CyCAR<<index), (save_car));
-                   spin_unlock(&cinfo->card_lock);
-                }
-
-                if (status & CySRModem) {        /* modem interrupt */
-
-                    /* determine the channel & change to that context */
-                   spin_lock(&cinfo->card_lock);
-                    save_xir = (u_char) cy_readb(base_addr+(CyMIR<<index));
-                    channel = (u_short ) (save_xir & CyIRChannel);
-                    info = &cy_port[channel + chip * 4
-                                          + cinfo->first_line];
-                    info->last_active = jiffies;
-                    save_car = cy_readb(base_addr+(CyCAR<<index));
-                    cy_writeb(base_addr+(CyCAR<<index), save_xir);
-
-                    mdm_change = cy_readb(base_addr+(CyMISR<<index));
-                    mdm_status = cy_readb(base_addr+(CyMSVR1<<index));
-
-                    if(info->tty == 0){/* no place for data, ignore it*/
-                        ;
-                    }else{
+                       } else {
+                               if (char_count > 1) {
+                                       info->xmit_cnt--;
+                                       info->xmit_tail = (info->xmit_tail + 1)&
+                                               (SERIAL_XMIT_SIZE - 1);
+                                       cy_writeb(base_addr + (CyTDR << index),
+                                               outch);
+                                       cy_writeb(base_addr + (CyTDR << index),
+                                               0);
+                                       info->icount.tx++;
+                                       char_count--;
+                               } else {
+                               }
+                       }
+               }
+
+txdone:
+               if (info->xmit_cnt < WAKEUP_CHARS) {
+                       cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
+               }
+txend:
+               /* end of service */
+               cy_writeb(base_addr + (CyTIR << index), (save_xir & 0x3f));
+               cy_writeb(base_addr + (CyCAR << index), (save_car));
+               spin_unlock(&cinfo->card_lock);
+       }
+
+       if (status & CySRModem) {       /* modem interrupt */
+
+               /* determine the channel & change to that context */
+               spin_lock(&cinfo->card_lock);
+               save_xir = (u_char) cy_readb(base_addr + (CyMIR << index));
+               channel = (u_short) (save_xir & CyIRChannel);
+               info = &cy_port[channel + chip * 4 + cinfo->first_line];
+               info->last_active = jiffies;
+               save_car = cy_readb(base_addr + (CyCAR << index));
+               cy_writeb(base_addr + (CyCAR << index), save_xir);
+
+               mdm_change = cy_readb(base_addr + (CyMISR << index));
+               mdm_status = cy_readb(base_addr + (CyMSVR1 << index));
+
+               if (info->tty == 0) {   /* no place for data, ignore it */
+                       ;
+               } else {
                        if (mdm_change & CyANY_DELTA) {
-                           /* For statistics only */
-                           if (mdm_change & CyDCD)     info->icount.dcd++;
-                           if (mdm_change & CyCTS)     info->icount.cts++;
-                           if (mdm_change & CyDSR)     info->icount.dsr++;
-                           if (mdm_change & CyRI)      info->icount.rng++;
+                               /* For statistics only */
+                               if (mdm_change & CyDCD)
+                                       info->icount.dcd++;
+                               if (mdm_change & CyCTS)
+                                       info->icount.cts++;
+                               if (mdm_change & CyDSR)
+                                       info->icount.dsr++;
+                               if (mdm_change & CyRI)
+                                       info->icount.rng++;
+
+                               cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
+                       }
+
+                       if ((mdm_change & CyDCD) &&
+                                       (info->flags & ASYNC_CHECK_CD)) {
+                               if (mdm_status & CyDCD) {
+                                       cy_sched_event(info,
+                                                       Cy_EVENT_OPEN_WAKEUP);
+                               } else {
+                                       cy_sched_event(info, Cy_EVENT_HANGUP);
+                               }
+                       }
+                       if ((mdm_change & CyCTS) &&
+                                       (info->flags & ASYNC_CTS_FLOW)) {
+                               if (info->tty->hw_stopped) {
+                                       if (mdm_status & CyCTS) {
+                                               /* cy_start isn't used
+                                                  because... !!! */
+                                               info->tty->hw_stopped = 0;
+                                               cy_writeb(base_addr +
+                                                       (CySRER << index),
+                                                       cy_readb(base_addr +
+                                                               (CySRER <<
+                                                                       index))|
+                                                       CyTxRdy);
+                                               cy_sched_event(info,
+                                                       Cy_EVENT_WRITE_WAKEUP);
+                                       }
+                               } else {
+                                       if (!(mdm_status & CyCTS)) {
+                                               /* cy_stop isn't used
+                                                  because ... !!! */
+                                               info->tty->hw_stopped = 1;
+                                               cy_writeb(base_addr +
+                                                       (CySRER << index),
+                                                       cy_readb(base_addr +
+                                                               (CySRER <<
+                                                               index)) &
+                                                       ~CyTxRdy);
+                                       }
+                               }
+                       }
+                       if (mdm_change & CyDSR) {
+                       }
+                       if (mdm_change & CyRI) {
+                       }
+               }
+               /* end of service */
+               cy_writeb(base_addr + (CyMIR << index), (save_xir & 0x3f));
+               cy_writeb(base_addr + (CyCAR << index), save_car);
+               spin_unlock(&cinfo->card_lock);
+       }
+}
+
+/* The real interrupt service routine is called
+   whenever the card wants its hand held--chars
+   received, out buffer empty, modem change, etc.
+ */
+static irqreturn_t cyy_interrupt(int irq, void *dev_id)
+{
+       int status;
+       struct cyclades_card *cinfo;
+       void __iomem *base_addr, *card_base_addr;
+       int chip;
+       int index;
+       int too_many;
+       int had_work;
+
+       if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
+#ifdef CY_DEBUG_INTERRUPTS
+               printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
+#endif
+               return IRQ_NONE;        /* spurious interrupt */
+       }
+
+       card_base_addr = cinfo->base_addr;
+       index = cinfo->bus_index;
 
-                           cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
+       /* This loop checks all chips in the card.  Make a note whenever
+          _any_ chip had some work to do, as this is considered an
+          indication that there will be more to do.  Only when no chip
+          has any work does this outermost loop exit.
+        */
+       do {
+               had_work = 0;
+               for (chip = 0; chip < cinfo->num_chips; chip++) {
+                       base_addr = cinfo->base_addr +
+                                       (cy_chip_offset[chip] << index);
+                       too_many = 0;
+                       while ((status = cy_readb(base_addr +
+                                               (CySVRR << index))) != 0x00) {
+                               had_work++;
+                       /* The purpose of the following test is to ensure that
+                          no chip can monopolize the driver.  This forces the
+                          chips to be checked in a round-robin fashion (after
+                          draining each of a bunch (1000) of characters).
+                        */
+                               if (1000 < too_many++) {
+                                       break;
+                               }
+                               cyy_intr_chip(cinfo, chip, base_addr, status,
+                                               index);
                        }
+               }
+       } while (had_work);
 
-                        if((mdm_change & CyDCD)
-                        && (info->flags & ASYNC_CHECK_CD)){
-                            if(mdm_status & CyDCD){
-                                cy_sched_event(info,
-                                   Cy_EVENT_OPEN_WAKEUP);
-                            }else{
-                                cy_sched_event(info,
-                                   Cy_EVENT_HANGUP);
-                            }
-                        }
-                        if((mdm_change & CyCTS)
-                        && (info->flags & ASYNC_CTS_FLOW)){
-                            if(info->tty->hw_stopped){
-                                if(mdm_status & CyCTS){
-                                    /* cy_start isn't used
-                                        because... !!! */
-                                    info->tty->hw_stopped = 0;
-                                  cy_writeb(base_addr+(CySRER<<index),
-                                       cy_readb(base_addr+(CySRER<<index)) | 
-                                       CyTxRdy);
-                                    cy_sched_event(info,
-                                       Cy_EVENT_WRITE_WAKEUP);
-                                }
-                            }else{
-                                if(!(mdm_status & CyCTS)){
-                                    /* cy_stop isn't used
-                                        because ... !!! */
-                                    info->tty->hw_stopped = 1;
-                                  cy_writeb(base_addr+(CySRER<<index),
-                                       cy_readb(base_addr+(CySRER<<index)) & 
-                                       ~CyTxRdy);
-                                }
-                            }
-                        }
-                        if(mdm_change & CyDSR){
-                        }
-                        if(mdm_change & CyRI){
-                        }
-                    }
-                    /* end of service */
-                    cy_writeb(base_addr+(CyMIR<<index), 
-                             (save_xir & 0x3f));
-                    cy_writeb(base_addr+(CyCAR<<index), save_car);
-                   spin_unlock(&cinfo->card_lock);
-                }
-            }          /* end while status != 0 */
-        }            /* end loop for chips... */
-    } while(had_work);
-
-   /* clear interrupts */
-   spin_lock(&cinfo->card_lock);
-   cy_writeb(card_base_addr + (Cy_ClrIntr<<index), 0);
-                                /* Cy_ClrIntr is 0x1800 */
-   spin_unlock(&cinfo->card_lock);
-   return IRQ_HANDLED;
-} /* cyy_interrupt */
+       /* clear interrupts */
+       spin_lock(&cinfo->card_lock);
+       cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
+       /* Cy_ClrIntr is 0x1800 */
+       spin_unlock(&cinfo->card_lock);
+       return IRQ_HANDLED;
+}                              /* cyy_interrupt */
 
 /***********************************************************/
 /********* End of block of Cyclom-Y specific code **********/
@@ -1448,643 +1496,655 @@ cyy_interrupt(int irq, void *dev_id)
 /***********************************************************/
 
 static int
-cyz_fetch_msg( struct cyclades_card *cinfo,
-           uclong *channel, ucchar *cmd, uclong *param)
+cyz_fetch_msg(struct cyclades_card *cinfo,
+               __u32 * channel, __u8 * cmd, __u32 * param)
 {
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  unsigned long loc_doorbell;
-
-    firm_id = cinfo->base_addr + ID_ADDRESS;
-    if (!ISZLOADED(*cinfo)){
-       return (-1);
-    }
-    zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-    board_ctrl = &zfw_ctrl->board_ctrl;
-
-    loc_doorbell = cy_readl(&((struct RUNTIME_9060 __iomem *)
-                     (cinfo->ctl_addr))->loc_doorbell);
-    if (loc_doorbell){
-       *cmd = (char)(0xff & loc_doorbell);
-       *channel = cy_readl(&board_ctrl->fwcmd_channel);
-       *param = (uclong)cy_readl(&board_ctrl->fwcmd_param);
-       cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->loc_doorbell, 
-                 0xffffffff);
-       return 1;
-    }
-    return 0;
-} /* cyz_fetch_msg */
+       struct FIRM_ID __iomem *firm_id;
+       struct ZFW_CTRL __iomem *zfw_ctrl;
+       struct BOARD_CTRL __iomem *board_ctrl;
+       unsigned long loc_doorbell;
+
+       firm_id = cinfo->base_addr + ID_ADDRESS;
+       if (!ISZLOADED(*cinfo)) {
+               return -1;
+       }
+       zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                       0xfffff);
+       board_ctrl = &zfw_ctrl->board_ctrl;
+
+       loc_doorbell = cy_readl(&((struct RUNTIME_9060 __iomem *)
+                                 (cinfo->ctl_addr))->loc_doorbell);
+       if (loc_doorbell) {
+               *cmd = (char)(0xff & loc_doorbell);
+               *channel = cy_readl(&board_ctrl->fwcmd_channel);
+               *param = (__u32) cy_readl(&board_ctrl->fwcmd_param);
+               cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
+                         loc_doorbell, 0xffffffff);
+               return 1;
+       }
+       return 0;
+}                              /* cyz_fetch_msg */
 
 static int
-cyz_issue_cmd( struct cyclades_card *cinfo,
-           uclong channel, ucchar cmd, uclong param)
+cyz_issue_cmd(struct cyclades_card *cinfo,
+               __u32 channel, __u8 cmd, __u32 param)
 {
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  unsigned long __iomem *pci_doorbell;
-  int index;
-
-    firm_id = cinfo->base_addr + ID_ADDRESS;
-    if (!ISZLOADED(*cinfo)){
-       return (-1);
-    }
-    zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-    board_ctrl = &zfw_ctrl->board_ctrl;
-
-    index = 0;
-    pci_doorbell = &((struct RUNTIME_9060 __iomem *) (cinfo->ctl_addr))->pci_doorbell;
-    while( (cy_readl(pci_doorbell) & 0xff) != 0){
-        if (index++ == 1000){
-           return((int)(cy_readl(pci_doorbell) & 0xff));
-        }
-       udelay(50L);
-    }
-    cy_writel(&board_ctrl->hcmd_channel, channel);
-    cy_writel(&board_ctrl->hcmd_param , param);
-    cy_writel(pci_doorbell, (long)cmd);
-
-    return(0);
-} /* cyz_issue_cmd */
+       struct FIRM_ID __iomem *firm_id;
+       struct ZFW_CTRL __iomem *zfw_ctrl;
+       struct BOARD_CTRL __iomem *board_ctrl;
+       __u32 __iomem *pci_doorbell;
+       int index;
+
+       firm_id = cinfo->base_addr + ID_ADDRESS;
+       if (!ISZLOADED(*cinfo)) {
+               return -1;
+       }
+       zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                       0xfffff);
+       board_ctrl = &zfw_ctrl->board_ctrl;
+
+       index = 0;
+       pci_doorbell =
+           &((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->pci_doorbell;
+       while ((cy_readl(pci_doorbell) & 0xff) != 0) {
+               if (index++ == 1000) {
+                       return (int)(cy_readl(pci_doorbell) & 0xff);
+               }
+               udelay(50L);
+       }
+       cy_writel(&board_ctrl->hcmd_channel, channel);
+       cy_writel(&board_ctrl->hcmd_param, param);
+       cy_writel(pci_doorbell, (long)cmd);
+
+       return 0;
+}                              /* cyz_issue_cmd */
 
 static void
 cyz_handle_rx(struct cyclades_port *info,
-             volatile struct CH_CTRL __iomem *ch_ctrl,
-             volatile struct BUF_CTRL __iomem *buf_ctrl)
+               volatile struct CH_CTRL __iomem * ch_ctrl,
+               volatile struct BUF_CTRL __iomem * buf_ctrl)
 {
-  struct cyclades_card *cinfo = &cy_card[info->card];
-  struct tty_struct *tty = info->tty;
-  volatile int char_count;
-  int len;
+       struct cyclades_card *cinfo = &cy_card[info->card];
+       struct tty_struct *tty = info->tty;
+       volatile int char_count;
+       int len;
 #ifdef BLOCKMOVE
-  int small_count;
+       int small_count;
 #else
-  char data;
+       char data;
 #endif
-  volatile uclong rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
+       volatile __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
 
-    rx_get = new_rx_get = cy_readl(&buf_ctrl->rx_get);
-    rx_put = cy_readl(&buf_ctrl->rx_put);
-    rx_bufsize = cy_readl(&buf_ctrl->rx_bufsize);
-    rx_bufaddr = cy_readl(&buf_ctrl->rx_bufaddr);
-    if (rx_put >= rx_get)
-       char_count = rx_put - rx_get;
-    else
-       char_count = rx_put - rx_get + rx_bufsize;
+       rx_get = new_rx_get = cy_readl(&buf_ctrl->rx_get);
+       rx_put = cy_readl(&buf_ctrl->rx_put);
+       rx_bufsize = cy_readl(&buf_ctrl->rx_bufsize);
+       rx_bufaddr = cy_readl(&buf_ctrl->rx_bufaddr);
+       if (rx_put >= rx_get)
+               char_count = rx_put - rx_get;
+       else
+               char_count = rx_put - rx_get + rx_bufsize;
 
-    if ( char_count ) {
-       info->last_active = jiffies;
-       info->jiffies[1] = jiffies;
+       if (char_count) {
+               info->last_active = jiffies;
+               info->jiffies[1] = jiffies;
 
 #ifdef CY_ENABLE_MONITORING
-       info->mon.int_count++;
-       info->mon.char_count += char_count;
-       if (char_count > info->mon.char_max)
-           info->mon.char_max = char_count;
-       info->mon.char_last = char_count;
+               info->mon.int_count++;
+               info->mon.char_count += char_count;
+               if (char_count > info->mon.char_max)
+                       info->mon.char_max = char_count;
+               info->mon.char_last = char_count;
 #endif
-       if(tty == 0){
-           /* flush received characters */
-           new_rx_get = (new_rx_get + char_count) & (rx_bufsize - 1);
-           info->rflush_count++;
-       }else{
+               if (tty == 0) {
+                       /* flush received characters */
+                       new_rx_get = (new_rx_get + char_count) &
+                                       (rx_bufsize - 1);
+                       info->rflush_count++;
+               } else {
 #ifdef BLOCKMOVE
-           /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
-              for performance, but because of buffer boundaries, there
-              may be several steps to the operation */
-           while(0 < (small_count = 
-                      min_t(unsigned int, (rx_bufsize - new_rx_get),
-                      min_t(unsigned int, (TTY_FLIPBUF_SIZE - tty->flip.count), char_count))
-                )) {
-               memcpy_fromio(tty->flip.char_buf_ptr,
-                             (char *)(cinfo->base_addr
-                                      + rx_bufaddr + new_rx_get),
-                             small_count);
-
-               tty->flip.char_buf_ptr += small_count;
-               memset(tty->flip.flag_buf_ptr, TTY_NORMAL, small_count);
-               tty->flip.flag_buf_ptr += small_count;
-               new_rx_get = (new_rx_get + small_count) & (rx_bufsize - 1);
-               char_count -= small_count;
-               info->icount.rx += small_count;
-               info->idle_stats.recv_bytes += small_count;
-               tty->flip.count += small_count;
-           }
+               /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
+                  for performance, but because of buffer boundaries, there
+                  may be several steps to the operation */
+                       while (0 < (small_count = min_t(unsigned int,
+                                       rx_bufsize - new_rx_get,
+                                       min_t(unsigned int, TTY_FLIPBUF_SIZE -
+                                               tty->flip.count, char_count)))){
+                               memcpy_fromio(tty->flip.char_buf_ptr,
+                                       (char *)(cinfo->base_addr + rx_bufaddr +
+                                               new_rx_get),
+                                       small_count);
+
+                               tty->flip.char_buf_ptr += small_count;
+                               memset(tty->flip.flag_buf_ptr, TTY_NORMAL,
+                                       small_count);
+                               tty->flip.flag_buf_ptr += small_count;
+                               new_rx_get = (new_rx_get + small_count) &
+                                               (rx_bufsize - 1);
+                               char_count -= small_count;
+                               info->icount.rx += small_count;
+                               info->idle_stats.recv_bytes += small_count;
+                               tty->flip.count += small_count;
+                       }
 #else
-           len = tty_buffer_request_room(tty, char_count);
-           while(len--){
-               data = cy_readb(cinfo->base_addr + rx_bufaddr + new_rx_get);
-               new_rx_get = (new_rx_get + 1) & (rx_bufsize - 1);
-               tty_insert_flip_char(tty, data, TTY_NORMAL);
-               info->idle_stats.recv_bytes++;
-               info->icount.rx++;
-           }
+                       len = tty_buffer_request_room(tty, char_count);
+                       while (len--) {
+                               data = cy_readb(cinfo->base_addr + rx_bufaddr +
+                                               new_rx_get);
+                               new_rx_get = (new_rx_get + 1)& (rx_bufsize - 1);
+                               tty_insert_flip_char(tty, data, TTY_NORMAL);
+                               info->idle_stats.recv_bytes++;
+                               info->icount.rx++;
+                       }
 #endif
 #ifdef CONFIG_CYZ_INTR
-           /* Recalculate the number of chars in the RX buffer and issue
-              a cmd in case it's higher than the RX high water mark */
-           rx_put = cy_readl(&buf_ctrl->rx_put);
-           if (rx_put >= rx_get)
-               char_count = rx_put - rx_get;
-           else
-               char_count = rx_put - rx_get + rx_bufsize;
-           if(char_count >= cy_readl(&buf_ctrl->rx_threshold)) {
-               cy_sched_event(info, Cy_EVENT_Z_RX_FULL);
-           }
+               /* Recalculate the number of chars in the RX buffer and issue
+                  a cmd in case it's higher than the RX high water mark */
+                       rx_put = cy_readl(&buf_ctrl->rx_put);
+                       if (rx_put >= rx_get)
+                               char_count = rx_put - rx_get;
+                       else
+                               char_count = rx_put - rx_get + rx_bufsize;
+                       if (char_count >= (int)cy_readl(&buf_ctrl->
+                                       rx_threshold)) {
+                               cy_sched_event(info, Cy_EVENT_Z_RX_FULL);
+                       }
 #endif
-           info->idle_stats.recv_idle = jiffies;
-           tty_schedule_flip(tty);
+                       info->idle_stats.recv_idle = jiffies;
+                       tty_schedule_flip(tty);
+               }
+               /* Update rx_get */
+               cy_writel(&buf_ctrl->rx_get, new_rx_get);
        }
-       /* Update rx_get */
-       cy_writel(&buf_ctrl->rx_get, new_rx_get);
-    }
 }
 
 static void
 cyz_handle_tx(struct cyclades_port *info,
-             volatile struct CH_CTRL __iomem *ch_ctrl,
-             volatile struct BUF_CTRL __iomem *buf_ctrl)
+               volatile struct CH_CTRL __iomem * ch_ctrl,
+               volatile struct BUF_CTRL __iomem * buf_ctrl)
 {
-  struct cyclades_card *cinfo = &cy_card[info->card];
-  struct tty_struct *tty = info->tty;
-  char data;
-  volatile int char_count;
+       struct cyclades_card *cinfo = &cy_card[info->card];
+       struct tty_struct *tty = info->tty;
+       char data;
+       volatile int char_count;
 #ifdef BLOCKMOVE
-  int small_count;
+       int small_count;
 #endif
-  volatile uclong tx_put, tx_get, tx_bufsize, tx_bufaddr;
+       volatile __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
 
-    if (info->xmit_cnt <= 0)   /* Nothing to transmit */
-       return;
+       if (info->xmit_cnt <= 0)        /* Nothing to transmit */
+               return;
 
-    tx_get = cy_readl(&buf_ctrl->tx_get);
-    tx_put = cy_readl(&buf_ctrl->tx_put);
-    tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
-    tx_bufaddr = cy_readl(&buf_ctrl->tx_bufaddr);
-    if (tx_put >= tx_get)
-       char_count = tx_get - tx_put - 1 + tx_bufsize;
-    else
-       char_count = tx_get - tx_put - 1;
+       tx_get = cy_readl(&buf_ctrl->tx_get);
+       tx_put = cy_readl(&buf_ctrl->tx_put);
+       tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
+       tx_bufaddr = cy_readl(&buf_ctrl->tx_bufaddr);
+       if (tx_put >= tx_get)
+               char_count = tx_get - tx_put - 1 + tx_bufsize;
+       else
+               char_count = tx_get - tx_put - 1;
 
-    if ( char_count ) {
+       if (char_count) {
 
-       if( tty == 0 ){
-           goto ztxdone;
-       }
+               if (tty == 0) {
+                       goto ztxdone;
+               }
 
-       if(info->x_char) { /* send special char */
-           data = info->x_char;
+               if (info->x_char) {     /* send special char */
+                       data = info->x_char;
 
-           cy_writeb((cinfo->base_addr + tx_bufaddr + tx_put), data);
-           tx_put = (tx_put + 1) & (tx_bufsize - 1);
-           info->x_char = 0;
-           char_count--;
-           info->icount.tx++;
-           info->last_active = jiffies;
-           info->jiffies[2] = jiffies;
-       }
+                       cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
+                       tx_put = (tx_put + 1) & (tx_bufsize - 1);
+                       info->x_char = 0;
+                       char_count--;
+                       info->icount.tx++;
+                       info->last_active = jiffies;
+                       info->jiffies[2] = jiffies;
+               }
 #ifdef BLOCKMOVE
-       while(0 < (small_count = 
-                  min_t(unsigned int, (tx_bufsize - tx_put),
-                      min_t(unsigned int, (SERIAL_XMIT_SIZE - info->xmit_tail),
-                          min_t(unsigned int, info->xmit_cnt, char_count))))) {
-
-           memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr + tx_put),
-                       &info->xmit_buf[info->xmit_tail],
-                       small_count);
-
-           tx_put = (tx_put + small_count) & (tx_bufsize - 1);
-           char_count -= small_count;
-           info->icount.tx += small_count;
-           info->xmit_cnt -= small_count;
-           info->xmit_tail = 
-               (info->xmit_tail + small_count) & (SERIAL_XMIT_SIZE - 1);
-           info->last_active = jiffies;
-           info->jiffies[2] = jiffies;
-       }
+               while (0 < (small_count = min_t(unsigned int,
+                               tx_bufsize - tx_put, min_t(unsigned int,
+                                       (SERIAL_XMIT_SIZE - info->xmit_tail),
+                                       min_t(unsigned int, info->xmit_cnt,
+                                               char_count))))) {
+
+                       memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
+                                       tx_put),
+                                       &info->xmit_buf[info->xmit_tail],
+                                       small_count);
+
+                       tx_put = (tx_put + small_count) & (tx_bufsize - 1);
+                       char_count -= small_count;
+                       info->icount.tx += small_count;
+                       info->xmit_cnt -= small_count;
+                       info->xmit_tail = (info->xmit_tail + small_count) &
+                                       (SERIAL_XMIT_SIZE - 1);
+                       info->last_active = jiffies;
+                       info->jiffies[2] = jiffies;
+               }
 #else
-       while (info->xmit_cnt && char_count){
-           data = info->xmit_buf[info->xmit_tail];
-           info->xmit_cnt--;
-           info->xmit_tail = (info->xmit_tail + 1) & (SERIAL_XMIT_SIZE - 1);
-
-           cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
-           tx_put = (tx_put + 1) & (tx_bufsize - 1);
-           char_count--;
-           info->icount.tx++;
-           info->last_active = jiffies;
-           info->jiffies[2] = jiffies;
-       }
+               while (info->xmit_cnt && char_count) {
+                       data = info->xmit_buf[info->xmit_tail];
+                       info->xmit_cnt--;
+                       info->xmit_tail = (info->xmit_tail + 1) &
+                                       (SERIAL_XMIT_SIZE - 1);
+
+                       cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
+                       tx_put = (tx_put + 1) & (tx_bufsize - 1);
+                       char_count--;
+                       info->icount.tx++;
+                       info->last_active = jiffies;
+                       info->jiffies[2] = jiffies;
+               }
 #endif
-    ztxdone:
-       if (info->xmit_cnt < WAKEUP_CHARS) {
-           cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
+ztxdone:
+               if (info->xmit_cnt < WAKEUP_CHARS) {
+                       cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
+               }
+               /* Update tx_put */
+               cy_writel(&buf_ctrl->tx_put, tx_put);
        }
-       /* Update tx_put */
-       cy_writel(&buf_ctrl->tx_put, tx_put);
-    }
 }
 
-static void
-cyz_handle_cmd(struct cyclades_card *cinfo)
+static void cyz_handle_cmd(struct cyclades_card *cinfo)
 {
-  struct tty_struct *tty;
-  struct cyclades_port *info;
-  static volatile struct FIRM_ID __iomem *firm_id;
-  static volatile struct ZFW_CTRL __iomem *zfw_ctrl;
-  static volatile struct BOARD_CTRL __iomem *board_ctrl;
-  static volatile struct CH_CTRL __iomem *ch_ctrl;
-  static volatile struct BUF_CTRL __iomem *buf_ctrl;
-  uclong channel;
-  ucchar cmd;
-  uclong param;
-  uclong hw_ver, fw_ver;
-  int special_count;
-  int delta_count;
-
-    firm_id = cinfo->base_addr + ID_ADDRESS;
-    zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-    board_ctrl = &zfw_ctrl->board_ctrl;
-    fw_ver = cy_readl(&board_ctrl->fw_version);
-    hw_ver = cy_readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->mail_box_0);
-
-
-    while(cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
-       special_count = 0;
-       delta_count = 0;
-       info = &cy_port[channel + cinfo->first_line];
-       if((tty = info->tty) == 0) {
-           continue;
-       }
-       ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-       buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
-
-       switch(cmd) {
-           case C_CM_PR_ERROR:
-               tty_insert_flip_char(tty, 0, TTY_PARITY);
-               info->icount.rx++;
-               special_count++;
-               break;
-           case C_CM_FR_ERROR:
-               tty_insert_flip_char(tty, 0, TTY_FRAME);
-               info->icount.rx++;
-               special_count++;
-               break;
-           case C_CM_RXBRK:
-               tty_insert_flip_char(tty, 0, TTY_BREAK);
-               info->icount.rx++;
-               special_count++;
-               break;
-           case C_CM_MDCD:
-               info->icount.dcd++;
-               delta_count++;
-               if (info->flags & ASYNC_CHECK_CD){
-                   if ((fw_ver > 241 ? 
-                         ((u_long)param) : 
-                         cy_readl(&ch_ctrl->rs_status)) & C_RS_DCD) {
-                       cy_sched_event(info, Cy_EVENT_OPEN_WAKEUP);
-                   }else{
-                       cy_sched_event(info, Cy_EVENT_HANGUP);
-                   }
+       struct tty_struct *tty;
+       struct cyclades_port *info;
+       static volatile struct FIRM_ID __iomem *firm_id;
+       static volatile struct ZFW_CTRL __iomem *zfw_ctrl;
+       static volatile struct BOARD_CTRL __iomem *board_ctrl;
+       static volatile struct CH_CTRL __iomem *ch_ctrl;
+       static volatile struct BUF_CTRL __iomem *buf_ctrl;
+       __u32 channel;
+       __u8 cmd;
+       __u32 param;
+       __u32 hw_ver, fw_ver;
+       int special_count;
+       int delta_count;
+
+       firm_id = cinfo->base_addr + ID_ADDRESS;
+       zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                       0xfffff);
+       board_ctrl = &zfw_ctrl->board_ctrl;
+       fw_ver = cy_readl(&board_ctrl->fw_version);
+       hw_ver = cy_readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
+                       mail_box_0);
+
+       while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
+               special_count = 0;
+               delta_count = 0;
+               info = &cy_port[channel + cinfo->first_line];
+               if ((tty = info->tty) == 0) {
+                       continue;
                }
-               break;
-           case C_CM_MCTS:
-               info->icount.cts++;
-               delta_count++;
-               break;
-           case C_CM_MRI:
-               info->icount.rng++;
-               delta_count++;
-               break;
-           case C_CM_MDSR:
-               info->icount.dsr++;
-               delta_count++;
-               break;
+               ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
+               buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
+
+               switch (cmd) {
+               case C_CM_PR_ERROR:
+                       tty_insert_flip_char(tty, 0, TTY_PARITY);
+                       info->icount.rx++;
+                       special_count++;
+                       break;
+               case C_CM_FR_ERROR:
+                       tty_insert_flip_char(tty, 0, TTY_FRAME);
+                       info->icount.rx++;
+                       special_count++;
+                       break;
+               case C_CM_RXBRK:
+                       tty_insert_flip_char(tty, 0, TTY_BREAK);
+                       info->icount.rx++;
+                       special_count++;
+                       break;
+               case C_CM_MDCD:
+                       info->icount.dcd++;
+                       delta_count++;
+                       if (info->flags & ASYNC_CHECK_CD) {
+                               if ((fw_ver > 241 ? ((u_long) param) :
+                                               cy_readl(&ch_ctrl->rs_status)) &
+                                               C_RS_DCD) {
+                                       cy_sched_event(info,
+                                                       Cy_EVENT_OPEN_WAKEUP);
+                               } else {
+                                       cy_sched_event(info, Cy_EVENT_HANGUP);
+                               }
+                       }
+                       break;
+               case C_CM_MCTS:
+                       info->icount.cts++;
+                       delta_count++;
+                       break;
+               case C_CM_MRI:
+                       info->icount.rng++;
+                       delta_count++;
+                       break;
+               case C_CM_MDSR:
+                       info->icount.dsr++;
+                       delta_count++;
+                       break;
 #ifdef Z_WAKE
-           case C_CM_IOCTLW:
-               cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
-               break;
+               case C_CM_IOCTLW:
+                       cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
+                       break;
 #endif
 #ifdef CONFIG_CYZ_INTR
-           case C_CM_RXHIWM:
-           case C_CM_RXNNDT:
-           case C_CM_INTBACK2:
-               /* Reception Interrupt */
+               case C_CM_RXHIWM:
+               case C_CM_RXNNDT:
+               case C_CM_INTBACK2:
+                       /* Reception Interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-               printk("cyz_interrupt: rcvd intr, card %d, port %ld\n\r", 
-                       info->card, channel);
+                       printk("cyz_interrupt: rcvd intr, card %d, "
+                                       "port %ld\n\r", info->card, channel);
 #endif
-               cyz_handle_rx(info, ch_ctrl, buf_ctrl);
-               break;
-           case C_CM_TXBEMPTY:
-           case C_CM_TXLOWWM:
-           case C_CM_INTBACK:
-               /* Transmission Interrupt */
+                       cyz_handle_rx(info, ch_ctrl, buf_ctrl);
+                       break;
+               case C_CM_TXBEMPTY:
+               case C_CM_TXLOWWM:
+               case C_CM_INTBACK:
+                       /* Transmission Interrupt */
 #ifdef CY_DEBUG_INTERRUPTS
-               printk("cyz_interrupt: xmit intr, card %d, port %ld\n\r", 
-                       info->card, channel);
+                       printk("cyz_interrupt: xmit intr, card %d, "
+                                       "port %ld\n\r", info->card, channel);
 #endif
-               cyz_handle_tx(info, ch_ctrl, buf_ctrl);
-               break;
-#endif /* CONFIG_CYZ_INTR */
-           case C_CM_FATAL:
-               /* should do something with this !!! */
-               break;
-           default:
-               break;
+                       cyz_handle_tx(info, ch_ctrl, buf_ctrl);
+                       break;
+#endif                         /* CONFIG_CYZ_INTR */
+               case C_CM_FATAL:
+                       /* should do something with this !!! */
+                       break;
+               default:
+                       break;
+               }
+               if (delta_count)
+                       cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
+               if (special_count)
+                       tty_schedule_flip(tty);
        }
-       if(delta_count)
-           cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
-       if(special_count)
-           tty_schedule_flip(tty);
-    }
 }
 
 #ifdef CONFIG_CYZ_INTR
-static irqreturn_t
-cyz_interrupt(int irq, void *dev_id)
+static irqreturn_t cyz_interrupt(int irq, void *dev_id)
 {
-  struct cyclades_card *cinfo;
+       struct cyclades_card *cinfo;
 
-    if((cinfo = (struct cyclades_card *)dev_id) == 0){
+       if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
 #ifdef CY_DEBUG_INTERRUPTS
-       printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
+               printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
 #endif
-        return IRQ_NONE; /* spurious interrupt */
-    }
+               return IRQ_NONE;        /* spurious interrupt */
+       }
 
-    if (!ISZLOADED(*cinfo)) {
+       if (!ISZLOADED(*cinfo)) {
 #ifdef CY_DEBUG_INTERRUPTS
-       printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
+               printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
 #endif
-       return IRQ_NONE;
-    }
+               return IRQ_NONE;
+       }
 
-    /* Handle the interrupts */
-    cyz_handle_cmd(cinfo);
+       /* Handle the interrupts */
+       cyz_handle_cmd(cinfo);
 
-    return IRQ_HANDLED;
-} /* cyz_interrupt */
+       return IRQ_HANDLED;
+}                              /* cyz_interrupt */
 
-static void
-cyz_rx_restart(unsigned long arg)
+static void cyz_rx_restart(unsigned long arg)
 {
-    struct cyclades_port *info = (struct cyclades_port *)arg;
-    int retval;
-    int card = info->card;
-    uclong channel = (info->line) - (cy_card[card].first_line);
-    unsigned long flags;
-
-    CY_LOCK(info, flags);
-    retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
-    if (retval != 0){
-       printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n", 
-              info->line, retval);
-    }
-    cyz_rx_full_timer[info->line].function = NULL;
-    CY_UNLOCK(info, flags);
+       struct cyclades_port *info = (struct cyclades_port *)arg;
+       int retval;
+       int card = info->card;
+       __u32 channel = (info->line) - (cy_card[card].first_line);
+       unsigned long flags;
+
+       CY_LOCK(info, flags);
+       retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
+       if (retval != 0) {
+               printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n",
+                       info->line, retval);
+       }
+       cyz_rx_full_timer[info->line].function = NULL;
+       CY_UNLOCK(info, flags);
 }
 
-#else /* CONFIG_CYZ_INTR */
+#else                          /* CONFIG_CYZ_INTR */
 
-static void
-cyz_poll(unsigned long arg)
+static void cyz_poll(unsigned long arg)
 {
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info;
-  struct tty_struct *tty;
-  static volatile struct FIRM_ID *firm_id;
-  static volatile struct ZFW_CTRL *zfw_ctrl;
-  static volatile struct BOARD_CTRL *board_ctrl;
-  static volatile struct CH_CTRL *ch_ctrl;
-  static volatile struct BUF_CTRL *buf_ctrl;
-  int card, port;
-
-    cyz_timerlist.expires = jiffies + (HZ);
-    for (card = 0 ; card < NR_CARDS ; card++){
-       cinfo = &cy_card[card];
-
-       if (!IS_CYC_Z(*cinfo)) continue;
-       if (!ISZLOADED(*cinfo)) continue;
+       struct cyclades_card *cinfo;
+       struct cyclades_port *info;
+       struct tty_struct *tty;
+       static volatile struct FIRM_ID *firm_id;
+       static volatile struct ZFW_CTRL *zfw_ctrl;
+       static volatile struct BOARD_CTRL *board_ctrl;
+       static volatile struct CH_CTRL *ch_ctrl;
+       static volatile struct BUF_CTRL *buf_ctrl;
+       int card, port;
 
-       firm_id = cinfo->base_addr + ID_ADDRESS;
-       zfw_ctrl = cinfo->base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       board_ctrl = &(zfw_ctrl->board_ctrl);
+       cyz_timerlist.expires = jiffies + (HZ);
+       for (card = 0; card < NR_CARDS; card++) {
+               cinfo = &cy_card[card];
+
+               if (!IS_CYC_Z(*cinfo))
+                       continue;
+               if (!ISZLOADED(*cinfo))
+                       continue;
+
+               firm_id = cinfo->base_addr + ID_ADDRESS;
+               zfw_ctrl = cinfo->base_addr +
+                               (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+               board_ctrl = &(zfw_ctrl->board_ctrl);
 
        /* Skip first polling cycle to avoid racing conditions with the FW */
-       if (!cinfo->intr_enabled) {
-           cinfo->nports = (int) cy_readl(&board_ctrl->n_channel);
-           cinfo->intr_enabled = 1;
-           continue;
-       }
+               if (!cinfo->intr_enabled) {
+                       cinfo->nports = (int)cy_readl(&board_ctrl->n_channel);
+                       cinfo->intr_enabled = 1;
+                       continue;
+               }
 
-       cyz_handle_cmd(cinfo);
+               cyz_handle_cmd(cinfo);
 
-       for (port = 0 ; port < cinfo->nports ; port++) {
-           info = &cy_port[ port + cinfo->first_line ];
-            tty = info->tty;
-           ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
-           buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
+               for (port = 0; port < cinfo->nports; port++) {
+                       info = &cy_port[port + cinfo->first_line];
+                       tty = info->tty;
+                       ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
+                       buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
 
-           if (!info->throttle)
-               cyz_handle_rx(info, ch_ctrl, buf_ctrl);
-           cyz_handle_tx(info, ch_ctrl, buf_ctrl);
+                       if (!info->throttle)
+                               cyz_handle_rx(info, ch_ctrl, buf_ctrl);
+                       cyz_handle_tx(info, ch_ctrl, buf_ctrl);
+               }
+               /* poll every 'cyz_polling_cycle' period */
+               cyz_timerlist.expires = jiffies + cyz_polling_cycle;
        }
-       /* poll every 'cyz_polling_cycle' period */
-       cyz_timerlist.expires = jiffies + cyz_polling_cycle;
-    }
-    add_timer(&cyz_timerlist);
+       add_timer(&cyz_timerlist);
+}                              /* cyz_poll */
 
-    return;
-} /* cyz_poll */
-
-#endif /* CONFIG_CYZ_INTR */
+#endif                         /* CONFIG_CYZ_INTR */
 
 /********** End of block of Cyclades-Z specific code *********/
 /***********************************************************/
 
-
 /* This is called whenever a port becomes active;
    interrupts are enabled and DTR & RTS are turned on.
  */
-static int
-startup(struct cyclades_port * info)
+static int startup(struct cyclades_port *info)
 {
-  unsigned long flags;
-  int retval = 0;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-  unsigned long page;
+       unsigned long flags;
+       int retval = 0;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
+       unsigned long page;
 
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
 
-    page = get_zeroed_page(GFP_KERNEL);
-    if (!page)
-       return -ENOMEM;
+       page = get_zeroed_page(GFP_KERNEL);
+       if (!page)
+               return -ENOMEM;
 
-    CY_LOCK(info, flags);
+       CY_LOCK(info, flags);
 
-    if (info->flags & ASYNC_INITIALIZED){
-       free_page(page);
-       goto errout;
-    }
+       if (info->flags & ASYNC_INITIALIZED) {
+               free_page(page);
+               goto errout;
+       }
 
-    if (!info->type){
-        if (info->tty){
-            set_bit(TTY_IO_ERROR, &info->tty->flags);
-        }
-       free_page(page);
-       goto errout;
-    }
+       if (!info->type) {
+               if (info->tty) {
+                       set_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
+               free_page(page);
+               goto errout;
+       }
 
-    if (info->xmit_buf)
-       free_page(page);
-    else
-       info->xmit_buf = (unsigned char *) page;
+       if (info->xmit_buf)
+               free_page(page);
+       else
+               info->xmit_buf = (unsigned char *)page;
 
-    CY_UNLOCK(info, flags);
+       CY_UNLOCK(info, flags);
 
-    set_line_char(info);
+       set_line_char(info);
 
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr = cy_card[card].base_addr +
+                               (cy_chip_offset[chip] << index);
 
 #ifdef CY_DEBUG_OPEN
-       printk("cyc startup card %d, chip %d, channel %d, base_addr %lx\n",
-            card, chip, channel, (long)base_addr);/**/
+               printk("cyc startup card %d, chip %d, channel %d, "
+                               "base_addr %lx\n",
+                               card, chip, channel, (long)base_addr);
+               /**/
 #endif
+               CY_LOCK(info, flags);
 
-       CY_LOCK(info, flags);
-
-       cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
 
-       cy_writeb(base_addr+(CyRTPR<<index), (info->default_timeout
-                ? info->default_timeout : 0x02)); /* 10ms rx timeout */
+               cy_writeb(base_addr + (CyRTPR << index),
+                       (info->default_timeout ? info->default_timeout : 0x02));
+               /* 10ms rx timeout */
 
-       cyy_issue_cmd(base_addr,CyCHAN_CTL|CyENB_RCVR|CyENB_XMTR,index);
+               cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR,
+                               index);
 
-       cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-       cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-       cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+               cy_writeb(base_addr + (CyMSVR1 << index), CyRTS);
+               cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
 
 #ifdef CY_DEBUG_DTR
-       printk("cyc:startup raising DTR\n");
-       printk("     status: 0x%x, 0x%x\n",
-               cy_readb(base_addr+(CyMSVR1<<index)), 
-                cy_readb(base_addr+(CyMSVR2<<index)));
+               printk("cyc:startup raising DTR\n");
+               printk("     status: 0x%x, 0x%x\n",
+                       cy_readb(base_addr + (CyMSVR1 << index)),
+                       cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
 
-       cy_writeb(base_addr+(CySRER<<index),
-               cy_readb(base_addr+(CySRER<<index)) | CyRxData);
-       info->flags |= ASYNC_INITIALIZED;
+               cy_writeb(base_addr + (CySRER << index),
+                       cy_readb(base_addr + (CySRER << index)) | CyRxData);
+               info->flags |= ASYNC_INITIALIZED;
 
-       if (info->tty){
-           clear_bit(TTY_IO_ERROR, &info->tty->flags);
-       }
-       info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-       info->breakon = info->breakoff = 0;
-       memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
-       info->idle_stats.in_use    =
-       info->idle_stats.recv_idle =
-       info->idle_stats.xmit_idle = jiffies;
+               if (info->tty) {
+                       clear_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
+               info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+               info->breakon = info->breakoff = 0;
+               memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
+               info->idle_stats.in_use =
+               info->idle_stats.recv_idle =
+               info->idle_stats.xmit_idle = jiffies;
 
-       CY_UNLOCK(info, flags);
+               CY_UNLOCK(info, flags);
 
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      int retval;
+       } else {
+               struct FIRM_ID __iomem *firm_id;
+               struct ZFW_CTRL __iomem *zfw_ctrl;
+               struct BOARD_CTRL __iomem *board_ctrl;
+               struct CH_CTRL __iomem *ch_ctrl;
+               int retval;
 
-       base_addr = cy_card[card].base_addr;
+               base_addr = cy_card[card].base_addr;
 
-        firm_id = base_addr + ID_ADDRESS;
-        if (!ISZLOADED(cy_card[card])){
-           return -ENODEV;
-       }
+               firm_id = base_addr + ID_ADDRESS;
+               if (!ISZLOADED(cy_card[card])) {
+                       return -ENODEV;
+               }
 
-       zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       board_ctrl = &zfw_ctrl->board_ctrl;
-       ch_ctrl = zfw_ctrl->ch_ctrl;
+               zfw_ctrl = cy_card[card].base_addr +
+                               (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+               board_ctrl = &zfw_ctrl->board_ctrl;
+               ch_ctrl = zfw_ctrl->ch_ctrl;
 
 #ifdef CY_DEBUG_OPEN
-       printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
-            card, channel, (long)base_addr);/**/
+               printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
+                       card, channel, (long)base_addr);
+               /**/
 #endif
+               CY_LOCK(info, flags);
 
-       CY_LOCK(info, flags);
-
-       cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
+               cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
 #ifdef Z_WAKE
 #ifdef CONFIG_CYZ_INTR
-       cy_writel(&ch_ctrl[channel].intr_enable, 
-                 C_IN_TXBEMPTY|C_IN_TXLOWWM|C_IN_RXHIWM|C_IN_RXNNDT|
-                 C_IN_IOCTLW|
-                 C_IN_MDCD);
+               cy_writel(&ch_ctrl[channel].intr_enable,
+                         C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
+                         C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
 #else
-       cy_writel(&ch_ctrl[channel].intr_enable, 
-                 C_IN_IOCTLW|
-                 C_IN_MDCD);
-#endif /* CONFIG_CYZ_INTR */
+               cy_writel(&ch_ctrl[channel].intr_enable,
+                         C_IN_IOCTLW | C_IN_MDCD);
+#endif                         /* CONFIG_CYZ_INTR */
 #else
 #ifdef CONFIG_CYZ_INTR
-       cy_writel(&ch_ctrl[channel].intr_enable, 
-                 C_IN_TXBEMPTY|C_IN_TXLOWWM|C_IN_RXHIWM|C_IN_RXNNDT|
-                 C_IN_MDCD);
+               cy_writel(&ch_ctrl[channel].intr_enable,
+                         C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
+                         C_IN_RXNNDT | C_IN_MDCD);
 #else
-       cy_writel(&ch_ctrl[channel].intr_enable, 
-                 C_IN_MDCD);
-#endif /* CONFIG_CYZ_INTR */
-#endif /* Z_WAKE */
-
-       retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
-       if (retval != 0){
-           printk("cyc:startup(1) retval on ttyC%d was %x\n",
-                  info->line, retval);
-       }
+               cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD);
+#endif                         /* CONFIG_CYZ_INTR */
+#endif                         /* Z_WAKE */
+
+               retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
+               if (retval != 0) {
+                       printk("cyc:startup(1) retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
 
-       /* Flush RX buffers before raising DTR and RTS */
-       retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX, 0L);
-       if (retval != 0){
-           printk("cyc:startup(2) retval on ttyC%d was %x\n",
-                  info->line, retval);
-       }
+               /* Flush RX buffers before raising DTR and RTS */
+               retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX,
+                               0L);
+               if (retval != 0) {
+                       printk("cyc:startup(2) retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
 
-       /* set timeout !!! */
-       /* set RTS and DTR !!! */
-       cy_writel(&ch_ctrl[channel].rs_control,
-             cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS | C_RS_DTR) ;
-       retval = cyz_issue_cmd(&cy_card[info->card],
-           channel, C_CM_IOCTLM, 0L);
-       if (retval != 0){
-           printk("cyc:startup(3) retval on ttyC%d was %x\n",
-                  info->line, retval);
-       }
+               /* set timeout !!! */
+               /* set RTS and DTR !!! */
+               cy_writel(&ch_ctrl[channel].rs_control,
+                       cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
+                       C_RS_DTR);
+               retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                               C_CM_IOCTLM, 0L);
+               if (retval != 0) {
+                       printk("cyc:startup(3) retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
 #ifdef CY_DEBUG_DTR
-           printk("cyc:startup raising Z DTR\n");
+               printk("cyc:startup raising Z DTR\n");
 #endif
 
-       /* enable send, recv, modem !!! */
+               /* enable send, recv, modem !!! */
 
-       info->flags |= ASYNC_INITIALIZED;
-       if (info->tty){
-           clear_bit(TTY_IO_ERROR, &info->tty->flags);
-       }
-       info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-       info->breakon = info->breakoff = 0;
-       memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
-       info->idle_stats.in_use    =
-       info->idle_stats.recv_idle =
-       info->idle_stats.xmit_idle = jiffies;
+               info->flags |= ASYNC_INITIALIZED;
+               if (info->tty) {
+                       clear_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
+               info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+               info->breakon = info->breakoff = 0;
+               memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
+               info->idle_stats.in_use =
+               info->idle_stats.recv_idle =
+               info->idle_stats.xmit_idle = jiffies;
 
-       CY_UNLOCK(info, flags);
-    }
+               CY_UNLOCK(info, flags);
+       }
 
 #ifdef CY_DEBUG_OPEN
        printk(" cyc startup done\n");
@@ -2094,165 +2154,165 @@ startup(struct cyclades_port * info)
 errout:
        CY_UNLOCK(info, flags);
        return retval;
-} /* startup */
-
+}                              /* startup */
 
-static void
-start_xmit( struct cyclades_port *info )
+static void start_xmit(struct cyclades_port *info)
 {
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+       unsigned long flags;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
 
-       CY_LOCK(info, flags);
-           cy_writeb(base_addr+(CyCAR<<index), channel);
-           cy_writeb(base_addr+(CySRER<<index), 
-               cy_readb(base_addr+(CySRER<<index)) | CyTxRdy);
-       CY_UNLOCK(info, flags);
-    } else {
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr = cy_card[card].base_addr +
+                               (cy_chip_offset[chip] << index);
+
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyCAR << index), channel);
+               cy_writeb(base_addr + (CySRER << index),
+                       cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
+               CY_UNLOCK(info, flags);
+       } else {
 #ifdef CONFIG_CYZ_INTR
-      int retval;
+               int retval;
 
-       CY_LOCK(info, flags);
-           retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK, 0L);
-           if (retval != 0){
-               printk("cyc:start_xmit retval on ttyC%d was %x\n",
-                      info->line, retval);
-           }
-       CY_UNLOCK(info, flags);
-#else /* CONFIG_CYZ_INTR */
-       /* Don't have to do anything at this time */
-#endif /* CONFIG_CYZ_INTR */
-    }
-} /* start_xmit */
+               CY_LOCK(info, flags);
+               retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK,
+                               0L);
+               if (retval != 0) {
+                       printk("cyc:start_xmit retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
+               CY_UNLOCK(info, flags);
+#else                          /* CONFIG_CYZ_INTR */
+               /* Don't have to do anything at this time */
+#endif                         /* CONFIG_CYZ_INTR */
+       }
+}                              /* start_xmit */
 
 /*
  * This routine shuts down a serial port; interrupts are disabled,
  * and DTR is dropped if the hangup on close termio flag is on.
  */
-static void
-shutdown(struct cyclades_port * info)
+static void shutdown(struct cyclades_port *info)
 {
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-
-    if (!(info->flags & ASYNC_INITIALIZED)){
-        return;
-    }
-
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+       unsigned long flags;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
+
+       if (!(info->flags & ASYNC_INITIALIZED)) {
+               return;
+       }
+
+       card = info->card;
+       channel = info->line - cy_card[card].first_line;
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr = cy_card[card].base_addr +
+                               (cy_chip_offset[chip] << index);
 
 #ifdef CY_DEBUG_OPEN
-    printk("cyc shutdown Y card %d, chip %d, channel %d, base_addr %lx\n",
-               card, chip, channel, (long)base_addr);
+               printk("cyc shutdown Y card %d, chip %d, channel %d, "
+                               "base_addr %lx\n",
+                               card, chip, channel, (long)base_addr);
 #endif
 
-       CY_LOCK(info, flags);
+               CY_LOCK(info, flags);
 
-           /* Clear delta_msr_wait queue to avoid mem leaks. */
-           wake_up_interruptible(&info->delta_msr_wait);
-
-           if (info->xmit_buf){
-               unsigned char * temp;
-               temp = info->xmit_buf;
-               info->xmit_buf = NULL;
-               free_page((unsigned long) temp);
-           }
-           cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-           if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
-               cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-               cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
+               /* Clear delta_msr_wait queue to avoid mem leaks. */
+               wake_up_interruptible(&info->delta_msr_wait);
+
+               if (info->xmit_buf) {
+                       unsigned char *temp;
+                       temp = info->xmit_buf;
+                       info->xmit_buf = NULL;
+                       free_page((unsigned long)temp);
+               }
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+               if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
+                       cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS);
+                       cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR);
 #ifdef CY_DEBUG_DTR
-               printk("cyc shutdown dropping DTR\n");
-               printk("     status: 0x%x, 0x%x\n",
-                   cy_readb(base_addr+(CyMSVR1<<index)), 
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                       printk("cyc shutdown dropping DTR\n");
+                       printk("     status: 0x%x, 0x%x\n",
+                               cy_readb(base_addr + (CyMSVR1 << index)),
+                               cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-           }
-           cyy_issue_cmd(base_addr,CyCHAN_CTL|CyDIS_RCVR,index);
-            /* it may be appropriate to clear _XMIT at
-              some later date (after testing)!!! */
-
-           if (info->tty){
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
-           }
-           info->flags &= ~ASYNC_INITIALIZED;
-       CY_UNLOCK(info, flags);
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      int retval;
-
-       base_addr = cy_card[card].base_addr;
+               }
+               cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
+               /* it may be appropriate to clear _XMIT at
+                  some later date (after testing)!!! */
+
+               if (info->tty) {
+                       set_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
+               info->flags &= ~ASYNC_INITIALIZED;
+               CY_UNLOCK(info, flags);
+       } else {
+               struct FIRM_ID __iomem *firm_id;
+               struct ZFW_CTRL __iomem *zfw_ctrl;
+               struct BOARD_CTRL __iomem *board_ctrl;
+               struct CH_CTRL __iomem *ch_ctrl;
+               int retval;
+
+               base_addr = cy_card[card].base_addr;
 #ifdef CY_DEBUG_OPEN
-    printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
-               card, channel, (long)base_addr);
+               printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
+                       card, channel, (long)base_addr);
 #endif
 
-        firm_id = base_addr + ID_ADDRESS;
-        if (!ISZLOADED(cy_card[card])) {
-           return;
-       }
+               firm_id = base_addr + ID_ADDRESS;
+               if (!ISZLOADED(cy_card[card])) {
+                       return;
+               }
 
-       zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       board_ctrl = &zfw_ctrl->board_ctrl;
-       ch_ctrl = zfw_ctrl->ch_ctrl;
+               zfw_ctrl = cy_card[card].base_addr +
+                               (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+               board_ctrl = &zfw_ctrl->board_ctrl;
+               ch_ctrl = zfw_ctrl->ch_ctrl;
 
-       CY_LOCK(info, flags);
+               CY_LOCK(info, flags);
 
-           if (info->xmit_buf){
-               unsigned char * temp;
-               temp = info->xmit_buf;
-               info->xmit_buf = NULL;
-               free_page((unsigned long) temp);
-           }
-           
-           if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
-               cy_writel(&ch_ctrl[channel].rs_control,
-                   (uclong)(cy_readl(&ch_ctrl[channel].rs_control) & 
-                   ~(C_RS_RTS | C_RS_DTR)));
-               retval = cyz_issue_cmd(&cy_card[info->card],
-                       channel, C_CM_IOCTLM, 0L);
-               if (retval != 0){
-                   printk("cyc:shutdown retval on ttyC%d was %x\n",
-                          info->line, retval);
+               if (info->xmit_buf) {
+                       unsigned char *temp;
+                       temp = info->xmit_buf;
+                       info->xmit_buf = NULL;
+                       free_page((unsigned long)temp);
                }
+
+               if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
+                       cy_writel(&ch_ctrl[channel].rs_control,
+                               (__u32)(cy_readl(&ch_ctrl[channel].rs_control)&
+                                       ~(C_RS_RTS | C_RS_DTR)));
+                       retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                                       C_CM_IOCTLM, 0L);
+                       if (retval != 0) {
+                               printk("cyc:shutdown retval on ttyC%d was %x\n",
+                                       info->line, retval);
+                       }
 #ifdef CY_DEBUG_DTR
-               printk("cyc:shutdown dropping Z DTR\n");
+                       printk("cyc:shutdown dropping Z DTR\n");
 #endif
-           }
-           
-           if (info->tty){
-               set_bit(TTY_IO_ERROR, &info->tty->flags);
-           }
-           info->flags &= ~ASYNC_INITIALIZED;
+               }
 
-       CY_UNLOCK(info, flags);
-    }
+               if (info->tty) {
+                       set_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
+               info->flags &= ~ASYNC_INITIALIZED;
+
+               CY_UNLOCK(info, flags);
+       }
 
 #ifdef CY_DEBUG_OPEN
-    printk(" cyc shutdown done\n");
+       printk(" cyc shutdown done\n");
 #endif
-    return;
-} /* shutdown */
-
+}                              /* shutdown */
 
 /*
  * ------------------------------------------------------------
@@ -2261,527 +2321,546 @@ shutdown(struct cyclades_port * info)
  */
 
 static int
-block_til_ready(struct tty_struct *tty, struct file * filp,
-                           struct cyclades_port *info)
+block_til_ready(struct tty_struct *tty, struct file *filp,
+               struct cyclades_port *info)
 {
-  DECLARE_WAITQUEUE(wait, current);
-  struct cyclades_card *cinfo;
-  unsigned long flags;
-  int chip, channel,index;
-  int retval;
-  void __iomem *base_addr;
-
-    cinfo = &cy_card[info->card];
-    channel = info->line - cinfo->first_line;
-
-    /*
-     * If the device is in the middle of being closed, then block
-     * until it's done, and then try again.
-     */
-    if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
-       if (info->flags & ASYNC_CLOSING) {
-            interruptible_sleep_on(&info->close_wait);
+       DECLARE_WAITQUEUE(wait, current);
+       struct cyclades_card *cinfo;
+       unsigned long flags;
+       int chip, channel, index;
+       int retval;
+       void __iomem *base_addr;
+
+       cinfo = &cy_card[info->card];
+       channel = info->line - cinfo->first_line;
+
+       /*
+        * If the device is in the middle of being closed, then block
+        * until it's done, and then try again.
+        */
+       if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
+               if (info->flags & ASYNC_CLOSING) {
+                       interruptible_sleep_on(&info->close_wait);
+               }
+               return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
+       }
+
+       /*
+        * If non-blocking mode is set, then make the check up front
+        * and then exit.
+        */
+       if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
+               info->flags |= ASYNC_NORMAL_ACTIVE;
+               return 0;
        }
-        return ((info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
-    }
-
-    /*
-     * If non-blocking mode is set, then make the check up front
-     * and then exit.
-     */
-    if ((filp->f_flags & O_NONBLOCK) ||
-       (tty->flags & (1 << TTY_IO_ERROR))) {
-        info->flags |= ASYNC_NORMAL_ACTIVE;
-        return 0;
-    }
-
-    /*
-     * Block waiting for the carrier detect and the line to become
-     * free (i.e., not in use by the callout).  While we are in
-     * this loop, info->count is dropped by one, so that
-     * cy_close() knows when to free things.  We restore it upon
-     * exit, either normal or abnormal.
-     */
-    retval = 0;
-    add_wait_queue(&info->open_wait, &wait);
+
+       /*
+        * Block waiting for the carrier detect and the line to become
+        * free (i.e., not in use by the callout).  While we are in
+        * this loop, info->count is dropped by one, so that
+        * cy_close() knows when to free things.  We restore it upon
+        * exit, either normal or abnormal.
+        */
+       retval = 0;
+       add_wait_queue(&info->open_wait, &wait);
 #ifdef CY_DEBUG_OPEN
-    printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
-           info->line, info->count);/**/
+       printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
+               info->line, info->count);
+       /**/
 #endif
-    CY_LOCK(info, flags);
-    if (!tty_hung_up_p(filp))
-       info->count--;
-    CY_UNLOCK(info, flags);
+       CY_LOCK(info, flags);
+       if (!tty_hung_up_p(filp))
+               info->count--;
+       CY_UNLOCK(info, flags);
 #ifdef CY_DEBUG_COUNT
-    printk("cyc block_til_ready: (%d): decrementing count to %d\n",
-        current->pid, info->count);
+       printk("cyc block_til_ready: (%d): decrementing count to %d\n",
+               current->pid, info->count);
 #endif
-    info->blocked_open++;
-
-    if (!IS_CYC_Z(*cinfo)) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cinfo->bus_index;
-       base_addr = cinfo->base_addr + (cy_chip_offset[chip]<<index);
-
-       while (1) {
-           CY_LOCK(info, flags);
-               if ((tty->termios->c_cflag & CBAUD)){
-                   cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                   cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                   cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
+       info->blocked_open++;
+
+       if (!IS_CYC_Z(*cinfo)) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cinfo->bus_index;
+               base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
+
+               while (1) {
+                       CY_LOCK(info, flags);
+                       if ((tty->termios->c_cflag & CBAUD)) {
+                               cy_writeb(base_addr + (CyCAR << index),
+                                         (u_char) channel);
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         CyRTS);
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         CyDTR);
 #ifdef CY_DEBUG_DTR
-                   printk("cyc:block_til_ready raising DTR\n");
-                   printk("     status: 0x%x, 0x%x\n",
-                       cy_readb(base_addr+(CyMSVR1<<index)), 
-                        cy_readb(base_addr+(CyMSVR2<<index)));
+                               printk("cyc:block_til_ready raising DTR\n");
+                               printk("     status: 0x%x, 0x%x\n",
+                                       cy_readb(base_addr +
+                                               (CyMSVR1 << index)),
+                                       cy_readb(base_addr +
+                                               (CyMSVR2 << index)));
 #endif
-               }
-           CY_UNLOCK(info, flags);
+                       }
+                       CY_UNLOCK(info, flags);
 
-           set_current_state(TASK_INTERRUPTIBLE);
-           if (tty_hung_up_p(filp)
-           || !(info->flags & ASYNC_INITIALIZED) ){
-               retval = ((info->flags & ASYNC_HUP_NOTIFY) ? 
-                   -EAGAIN : -ERESTARTSYS);
-               break;
-           }
+                       set_current_state(TASK_INTERRUPTIBLE);
+                       if (tty_hung_up_p(filp) ||
+                                       !(info->flags & ASYNC_INITIALIZED)) {
+                               retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
+                                         -EAGAIN : -ERESTARTSYS);
+                               break;
+                       }
 
-           CY_LOCK(info, flags);
-               cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-               if (!(info->flags & ASYNC_CLOSING)
-               && (C_CLOCAL(tty)
-                   || (cy_readb(base_addr+(CyMSVR1<<index)) & CyDCD))) {
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
+                                       (cy_readb(base_addr +
+                                               (CyMSVR1 << index)) & CyDCD))) {
+                               CY_UNLOCK(info, flags);
+                               break;
+                       }
                        CY_UNLOCK(info, flags);
-                       break;
-               }
-           CY_UNLOCK(info, flags);
 
-           if (signal_pending(current)) {
-               retval = -ERESTARTSYS;
-               break;
-           }
+                       if (signal_pending(current)) {
+                               retval = -ERESTARTSYS;
+                               break;
+                       }
 #ifdef CY_DEBUG_OPEN
-           printk("cyc block_til_ready blocking: ttyC%d, count = %d\n",
-                  info->line, info->count);/**/
+                       printk("cyc block_til_ready blocking: ttyC%d, "
+                                       "count = %d\n",
+                                       info->line, info->count);
+                       /**/
 #endif
-           schedule();
-       }
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      int retval;
-
-       base_addr = cinfo->base_addr;
-       firm_id = base_addr + ID_ADDRESS;
-        if (!ISZLOADED(*cinfo)){
-            current->state = TASK_RUNNING;
-           remove_wait_queue(&info->open_wait, &wait);
-           return -EINVAL;
-       }
-
-       zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       board_ctrl = &zfw_ctrl->board_ctrl;
-       ch_ctrl = zfw_ctrl->ch_ctrl;
-
-       while (1) {
-           if ((tty->termios->c_cflag & CBAUD)){
-               cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) |
-                       (C_RS_RTS | C_RS_DTR));
-               retval = cyz_issue_cmd(&cy_card[info->card],
-                                      channel, C_CM_IOCTLM, 0L);
-               if (retval != 0){
-                   printk("cyc:block_til_ready retval on ttyC%d was %x\n",
-                          info->line, retval);
+                       schedule();
+               }
+       } else {
+               struct FIRM_ID __iomem *firm_id;
+               struct ZFW_CTRL __iomem *zfw_ctrl;
+               struct BOARD_CTRL __iomem *board_ctrl;
+               struct CH_CTRL __iomem *ch_ctrl;
+               int retval;
+
+               base_addr = cinfo->base_addr;
+               firm_id = base_addr + ID_ADDRESS;
+               if (!ISZLOADED(*cinfo)) {
+                       current->state = TASK_RUNNING;
+                       remove_wait_queue(&info->open_wait, &wait);
+                       return -EINVAL;
                }
+
+               zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) &
+                               0xfffff);
+               board_ctrl = &zfw_ctrl->board_ctrl;
+               ch_ctrl = zfw_ctrl->ch_ctrl;
+
+               while (1) {
+                       if ((tty->termios->c_cflag & CBAUD)) {
+                               cy_writel(&ch_ctrl[channel].rs_control,
+                                         cy_readl(&ch_ctrl[channel].
+                                                  rs_control) | (C_RS_RTS |
+                                                                 C_RS_DTR));
+                               retval = cyz_issue_cmd(&cy_card[info->card],
+                                               channel, C_CM_IOCTLM, 0L);
+                               if (retval != 0) {
+                                       printk("cyc:block_til_ready retval on "
+                                               "ttyC%d was %x\n",
+                                               info->line, retval);
+                               }
 #ifdef CY_DEBUG_DTR
-               printk("cyc:block_til_ready raising Z DTR\n");
+                               printk("cyc:block_til_ready raising Z DTR\n");
 #endif
-           }
+                       }
 
-           set_current_state(TASK_INTERRUPTIBLE);
-           if (tty_hung_up_p(filp)
-           || !(info->flags & ASYNC_INITIALIZED) ){
-               retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
-                   -EAGAIN : -ERESTARTSYS);
-               break;
-           }
-           if (!(info->flags & ASYNC_CLOSING)
-           && (C_CLOCAL(tty)
-             || (cy_readl(&ch_ctrl[channel].rs_status) & C_RS_DCD))) {
-               break;
-           }
-           if (signal_pending(current)) {
-               retval = -ERESTARTSYS;
-               break;
-           }
+                       set_current_state(TASK_INTERRUPTIBLE);
+                       if (tty_hung_up_p(filp) ||
+                                       !(info->flags & ASYNC_INITIALIZED)) {
+                               retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
+                                         -EAGAIN : -ERESTARTSYS);
+                               break;
+                       }
+                       if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
+                                       (cy_readl(&ch_ctrl[channel].rs_status) &
+                                               C_RS_DCD))) {
+                               break;
+                       }
+                       if (signal_pending(current)) {
+                               retval = -ERESTARTSYS;
+                               break;
+                       }
 #ifdef CY_DEBUG_OPEN
-           printk("cyc block_til_ready blocking: ttyC%d, count = %d\n",
-                  info->line, info->count);/**/
+                       printk("cyc block_til_ready blocking: ttyC%d, "
+                                       "count = %d\n",
+                                       info->line, info->count);
+                       /**/
 #endif
-           schedule();
+                       schedule();
+               }
        }
-    }
-    current->state = TASK_RUNNING;
-    remove_wait_queue(&info->open_wait, &wait);
-    if (!tty_hung_up_p(filp)){
-       info->count++;
+       current->state = TASK_RUNNING;
+       remove_wait_queue(&info->open_wait, &wait);
+       if (!tty_hung_up_p(filp)) {
+               info->count++;
 #ifdef CY_DEBUG_COUNT
-       printk("cyc:block_til_ready (%d): incrementing count to %d\n",
-           current->pid, info->count);
+               printk("cyc:block_til_ready (%d): incrementing count to %d\n",
+                       current->pid, info->count);
 #endif
-    }
-    info->blocked_open--;
+       }
+       info->blocked_open--;
 #ifdef CY_DEBUG_OPEN
-    printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
-          info->line, info->count);/**/
+       printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
+               info->line, info->count);
+       /**/
 #endif
-    if (retval)
-       return retval;
-    info->flags |= ASYNC_NORMAL_ACTIVE;
-    return 0;
-} /* block_til_ready */
-
+       if (retval)
+               return retval;
+       info->flags |= ASYNC_NORMAL_ACTIVE;
+       return 0;
+}                              /* block_til_ready */
 
 /*
  * This routine is called whenever a serial port is opened.  It
  * performs the serial-specific initialization for the tty structure.
  */
-static int
-cy_open(struct tty_struct *tty, struct file * filp)
+static int cy_open(struct tty_struct *tty, struct file *filp)
 {
-  struct cyclades_port  *info;
-  int retval, line;
-
-    line = tty->index;
-    if ((line < 0) || (NR_PORTS <= line)){
-        return -ENODEV;
-    }
-    info = &cy_port[line];
-    if (info->line < 0){
-        return -ENODEV;
-    }
-    
-    /* If the card's firmware hasn't been loaded,
-       treat it as absent from the system.  This
-       will make the user pay attention.
-    */
-    if (IS_CYC_Z(cy_card[info->card])) {
-       struct cyclades_card *cinfo = &cy_card[info->card];
-       struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
-
-        if (!ISZLOADED(*cinfo)) {
-           if (((ZE_V1 ==cy_readl(&((struct RUNTIME_9060 __iomem *)
-               (cinfo->ctl_addr))->mail_box_0)) &&
-               Z_FPGA_CHECK (*cinfo)) &&
-               (ZFIRM_HLT == cy_readl (&firm_id->signature)))
-           {
-               printk ("cyc:Cyclades-Z Error: you need an external power supply for this number of ports.\n\rFirmware halted.\r\n");
-           } else {
-               printk("cyc:Cyclades-Z firmware not yet loaded\n");
-           }
-           return -ENODEV;
-       }
-#ifdef CONFIG_CYZ_INTR
-       else {
-           /* In case this Z board is operating in interrupt mode, its 
-              interrupts should be enabled as soon as the first open happens 
-              to one of its ports. */
-            if (!cinfo->intr_enabled) {
-               struct ZFW_CTRL __iomem *zfw_ctrl;
-               struct BOARD_CTRL __iomem *board_ctrl;
-
-               zfw_ctrl = cinfo->base_addr + (cy_readl (&firm_id->zfwctrl_addr) & 0xfffff);
+       struct cyclades_port *info;
+       int retval, line;
 
-               board_ctrl = &zfw_ctrl->board_ctrl;
+       line = tty->index;
+       if ((line < 0) || (NR_PORTS <= line)) {
+               return -ENODEV;
+       }
+       info = &cy_port[line];
+       if (info->line < 0) {
+               return -ENODEV;
+       }
 
-               /* Enable interrupts on the PLX chip */
-               cy_writew(cinfo->ctl_addr+0x68,
-                       cy_readw(cinfo->ctl_addr+0x68)|0x0900);
-               /* Enable interrupts on the FW */
-               retval = cyz_issue_cmd(cinfo,
-                                       0, C_CM_IRQ_ENBL, 0L);
-               if (retval != 0){
-                   printk("cyc:IRQ enable retval was %x\n", retval);
+       /* If the card's firmware hasn't been loaded,
+          treat it as absent from the system.  This
+          will make the user pay attention.
+        */
+       if (IS_CYC_Z(cy_card[info->card])) {
+               struct cyclades_card *cinfo = &cy_card[info->card];
+               struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
+
+               if (!ISZLOADED(*cinfo)) {
+                       if (((ZE_V1 == cy_readl(
+                                       &((struct RUNTIME_9060 __iomem *)
+                                        (cinfo->ctl_addr))->mail_box_0)) &&
+                                       Z_FPGA_CHECK(*cinfo)) &&
+                                       (ZFIRM_HLT == cy_readl(
+                                               &firm_id->signature))) {
+                               printk("cyc:Cyclades-Z Error: you need an "
+                                       "external power supply for this number "
+                                       "of ports.\n\rFirmware halted.\r\n");
+                       } else {
+                               printk("cyc:Cyclades-Z firmware not yet "
+                                       "loaded\n");
+                       }
+                       return -ENODEV;
                }
-               cinfo->nports = (int) cy_readl (&board_ctrl->n_channel);
-               cinfo->intr_enabled = 1;
-           }
+#ifdef CONFIG_CYZ_INTR
+               else {
+               /* In case this Z board is operating in interrupt mode, its
+                  interrupts should be enabled as soon as the first open
+                  happens to one of its ports. */
+                       if (!cinfo->intr_enabled) {
+                               struct ZFW_CTRL __iomem *zfw_ctrl;
+                               struct BOARD_CTRL __iomem *board_ctrl;
+
+                               zfw_ctrl = cinfo->base_addr +
+                                       (cy_readl(&firm_id->zfwctrl_addr) &
+                                               0xfffff);
+
+                               board_ctrl = &zfw_ctrl->board_ctrl;
+
+                               /* Enable interrupts on the PLX chip */
+                               cy_writew(cinfo->ctl_addr + 0x68,
+                                         cy_readw(cinfo->ctl_addr +
+                                                  0x68) | 0x0900);
+                               /* Enable interrupts on the FW */
+                               retval = cyz_issue_cmd(cinfo, 0,
+                                               C_CM_IRQ_ENBL, 0L);
+                               if (retval != 0) {
+                                       printk("cyc:IRQ enable retval was %x\n",
+                                               retval);
+                               }
+                               cinfo->nports =
+                                       (int)cy_readl(&board_ctrl->n_channel);
+                               cinfo->intr_enabled = 1;
+                       }
+               }
+#endif                         /* CONFIG_CYZ_INTR */
+               /* Make sure this Z port really exists in hardware */
+               if (info->line > (cinfo->first_line + cinfo->nports - 1))
+                       return -ENODEV;
        }
-#endif /* CONFIG_CYZ_INTR */
-       /* Make sure this Z port really exists in hardware */
-       if (info->line > (cinfo->first_line + cinfo->nports - 1))
-               return -ENODEV;
-    }
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_open ttyC%d\n", info->line); /* */
+       printk("cyc:cy_open ttyC%d\n", info->line);     /* */
 #endif
-    tty->driver_data = info;
-    info->tty = tty;
-    if (serial_paranoia_check(info, tty->name, "cy_open")){
-        return -ENODEV;
-    }
+       tty->driver_data = info;
+       info->tty = tty;
+       if (serial_paranoia_check(info, tty->name, "cy_open")) {
+               return -ENODEV;
+       }
 #ifdef CY_DEBUG_OPEN
-    printk("cyc:cy_open ttyC%d, count = %d\n",
-        info->line, info->count);/**/
+       printk("cyc:cy_open ttyC%d, count = %d\n", info->line, info->count);
+       /**/
 #endif
-    info->count++;
+       info->count++;
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cy_open (%d): incrementing count to %d\n",
-        current->pid, info->count);
+       printk("cyc:cy_open (%d): incrementing count to %d\n",
+               current->pid, info->count);
 #endif
 
-    /*
-     * If the port is the middle of closing, bail out now
-     */
-    if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
-       if (info->flags & ASYNC_CLOSING)
-           interruptible_sleep_on(&info->close_wait);
-       return ((info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN : -ERESTARTSYS);
-    }
-
-    /*
-     * Start up serial port
-     */
-    retval = startup(info);
-    if (retval){
-        return retval;
-    }
-
-    retval = block_til_ready(tty, filp, info);
-    if (retval) {
-#ifdef CY_DEBUG_OPEN
-        printk("cyc:cy_open returning after block_til_ready with %d\n",
-               retval);
-#endif
-        return retval;
-    }
+       /*
+        * If the port is the middle of closing, bail out now
+        */
+       if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
+               if (info->flags & ASYNC_CLOSING)
+                       interruptible_sleep_on(&info->close_wait);
+               return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
+       }
 
-    info->throttle = 0;
+       /*
+        * Start up serial port
+        */
+       retval = startup(info);
+       if (retval) {
+               return retval;
+       }
 
+       retval = block_til_ready(tty, filp, info);
+       if (retval) {
 #ifdef CY_DEBUG_OPEN
-    printk(" cyc:cy_open done\n");/**/
+               printk("cyc:cy_open returning after block_til_ready with %d\n",
+                       retval);
 #endif
+               return retval;
+       }
 
-    return 0;
-} /* cy_open */
+       info->throttle = 0;
 
+#ifdef CY_DEBUG_OPEN
+       printk(" cyc:cy_open done\n");
+       /**/
+#endif
+       return 0;
+}                              /* cy_open */
 
 /*
  * cy_wait_until_sent() --- wait until the transmitter is empty
  */
-static void 
-cy_wait_until_sent(struct tty_struct *tty, int timeout)
+static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-  unsigned long orig_jiffies;
-  int char_time;
-       
-    if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
-       return;
-
-    if (info->xmit_fifo_size == 0)
-       return; /* Just in case.... */
-
-
-    orig_jiffies = jiffies;
-    /*
-     * Set the check interval to be 1/5 of the estimated time to
-     * send a single character, and make it at least 1.  The check
-     * interval should also be less than the timeout.
-     * 
-     * Note: we have to use pretty tight timings here to satisfy
-     * the NIST-PCTS.
-     */
-    char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
-    char_time = char_time / 5;
-    if (char_time <= 0)
-       char_time = 1;
-    if (timeout < 0)
-       timeout = 0;
-    if (timeout)
-       char_time = min(char_time, timeout);
-    /*
-     * If the transmitter hasn't cleared in twice the approximate
-     * amount of time to send the entire FIFO, it probably won't
-     * ever clear.  This assumes the UART isn't doing flow
-     * control, which is currently the case.  Hence, if it ever
-     * takes longer than info->timeout, this is probably due to a
-     * UART bug of some kind.  So, we clamp the timeout parameter at
-     * 2*info->timeout.
-     */
-    if (!timeout || timeout > 2*info->timeout)
-       timeout = 2*info->timeout;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
+       unsigned long orig_jiffies;
+       int char_time;
+
+       if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
+               return;
+
+       if (info->xmit_fifo_size == 0)
+               return;         /* Just in case.... */
+
+       orig_jiffies = jiffies;
+       /*
+        * Set the check interval to be 1/5 of the estimated time to
+        * send a single character, and make it at least 1.  The check
+        * interval should also be less than the timeout.
+        *
+        * Note: we have to use pretty tight timings here to satisfy
+        * the NIST-PCTS.
+        */
+       char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
+       char_time = char_time / 5;
+       if (char_time <= 0)
+               char_time = 1;
+       if (timeout < 0)
+               timeout = 0;
+       if (timeout)
+               char_time = min(char_time, timeout);
+       /*
+        * If the transmitter hasn't cleared in twice the approximate
+        * amount of time to send the entire FIFO, it probably won't
+        * ever clear.  This assumes the UART isn't doing flow
+        * control, which is currently the case.  Hence, if it ever
+        * takes longer than info->timeout, this is probably due to a
+        * UART bug of some kind.  So, we clamp the timeout parameter at
+        * 2*info->timeout.
+        */
+       if (!timeout || timeout > 2 * info->timeout)
+               timeout = 2 * info->timeout;
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-    printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
-    printk("jiff=%lu...", jiffies);
+       printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
+       printk("jiff=%lu...", jiffies);
 #endif
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-       while (cy_readb(base_addr+(CySRER<<index)) & CyTxRdy) {
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+               while (cy_readb(base_addr + (CySRER << index)) & CyTxRdy) {
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-           printk("Not clean (jiff=%lu)...", jiffies);
+                       printk("Not clean (jiff=%lu)...", jiffies);
 #endif
-           if (msleep_interruptible(jiffies_to_msecs(char_time)))
-               break;
-           if (timeout && time_after(jiffies, orig_jiffies + timeout))
-               break;
+                       if (msleep_interruptible(jiffies_to_msecs(char_time)))
+                               break;
+                       if (timeout && time_after(jiffies, orig_jiffies +
+                                       timeout))
+                               break;
+               }
+       } else {
+               /* Nothing to do! */
        }
-    } else {
-       // Nothing to do!
-    }
-    /* Run one more char cycle */
-    msleep_interruptible(jiffies_to_msecs(char_time * 5));
+       /* Run one more char cycle */
+       msleep_interruptible(jiffies_to_msecs(char_time * 5));
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
-    printk("Clean (jiff=%lu)...done\n", jiffies);
+       printk("Clean (jiff=%lu)...done\n", jiffies);
 #endif
 }
 
 /*
  * This routine is called when a particular tty device is closed.
  */
-static void
-cy_close(struct tty_struct *tty, struct file *filp)
+static void cy_close(struct tty_struct *tty, struct file *filp)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_close ttyC%d\n", info->line);
+       printk("cyc:cy_close ttyC%d\n", info->line);
 #endif
 
-    if (!info || serial_paranoia_check(info, tty->name, "cy_close")){
-        return;
-    }
+       if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
+               return;
+       }
 
-    CY_LOCK(info, flags);
-    /* If the TTY is being hung up, nothing to do */
-    if (tty_hung_up_p(filp)) {
-       CY_UNLOCK(info, flags);
-        return;
-    }
-        
+       CY_LOCK(info, flags);
+       /* If the TTY is being hung up, nothing to do */
+       if (tty_hung_up_p(filp)) {
+               CY_UNLOCK(info, flags);
+               return;
+       }
 #ifdef CY_DEBUG_OPEN
-    printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
+       printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
 #endif
-    if ((tty->count == 1) && (info->count != 1)) {
-        /*
-         * Uh, oh.  tty->count is 1, which means that the tty
-         * structure will be freed.  Info->count should always
-         * be one in these conditions.  If it's greater than
-         * one, we've got real problems, since it means the
-         * serial port won't be shutdown.
-         */
-        printk("cyc:cy_close: bad serial port count; tty->count is 1, "
-           "info->count is %d\n", info->count);
-        info->count = 1;
-    }
+       if ((tty->count == 1) && (info->count != 1)) {
+               /*
+                * Uh, oh.  tty->count is 1, which means that the tty
+                * structure will be freed.  Info->count should always
+                * be one in these conditions.  If it's greater than
+                * one, we've got real problems, since it means the
+                * serial port won't be shutdown.
+                */
+               printk("cyc:cy_close: bad serial port count; tty->count is 1, "
+                       "info->count is %d\n", info->count);
+               info->count = 1;
+       }
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cy_close at (%d): decrementing count to %d\n",
-        current->pid, info->count - 1);
+       printk("cyc:cy_close at (%d): decrementing count to %d\n",
+               current->pid, info->count - 1);
 #endif
-    if (--info->count < 0) {
+       if (--info->count < 0) {
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cyc_close setting count to 0\n");
+               printk("cyc:cyc_close setting count to 0\n");
 #endif
-        info->count = 0;
-    }
-    if (info->count) {
-       CY_UNLOCK(info, flags);
-        return;
-    }
-    info->flags |= ASYNC_CLOSING;
-
-    /*
-    * Now we wait for the transmit buffer to clear; and we notify
-    * the line discipline to only process XON/XOFF characters.
-    */
-    tty->closing = 1;
-    CY_UNLOCK(info, flags);
-    if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
-       tty_wait_until_sent(tty, info->closing_wait);
-    }
-    CY_LOCK(info, flags);
-
-    if (!IS_CYC_Z(cy_card[info->card])) {
-       int channel = info->line - cy_card[info->card].first_line;
-       int index = cy_card[info->card].bus_index;
-       void __iomem *base_addr = cy_card[info->card].base_addr + (cy_chip_offset[channel>>2] << index);
-       /* Stop accepting input */
-       channel &= 0x03;
-       cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-       cy_writeb(base_addr+(CySRER<<index),
-                       cy_readb(base_addr+(CySRER<<index)) & ~CyRxData);
-       if (info->flags & ASYNC_INITIALIZED) {
-           /* Waiting for on-board buffers to be empty before closing 
-              the port */
-           CY_UNLOCK(info, flags);
-           cy_wait_until_sent(tty, info->timeout);
-           CY_LOCK(info, flags);
+               info->count = 0;
        }
-    } else {
-#ifdef Z_WAKE
-       /* Waiting for on-board buffers to be empty before closing the port */
-       void __iomem *base_addr = cy_card[info->card].base_addr;
-       struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
-       struct ZFW_CTRL __iomem *zfw_ctrl = base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
-       int channel = info->line - cy_card[info->card].first_line;
-       int retval;
+       if (info->count) {
+               CY_UNLOCK(info, flags);
+               return;
+       }
+       info->flags |= ASYNC_CLOSING;
 
-       if (cy_readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
-           retval = cyz_issue_cmd(&cy_card[info->card], channel, 
-                                  C_CM_IOCTLW, 0L);
-           if (retval != 0){
-               printk("cyc:cy_close retval on ttyC%d was %x\n",
-                      info->line, retval);
-           }
-           CY_UNLOCK(info, flags);
-           interruptible_sleep_on(&info->shutdown_wait);
-           CY_LOCK(info, flags);
+       /*
+        * Now we wait for the transmit buffer to clear; and we notify
+        * the line discipline to only process XON/XOFF characters.
+        */
+       tty->closing = 1;
+       CY_UNLOCK(info, flags);
+       if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
+               tty_wait_until_sent(tty, info->closing_wait);
        }
+       CY_LOCK(info, flags);
+
+       if (!IS_CYC_Z(cy_card[info->card])) {
+               int channel = info->line - cy_card[info->card].first_line;
+               int index = cy_card[info->card].bus_index;
+               void __iomem *base_addr = cy_card[info->card].base_addr +
+                       (cy_chip_offset[channel >> 2] << index);
+               /* Stop accepting input */
+               channel &= 0x03;
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+               cy_writeb(base_addr + (CySRER << index),
+                         cy_readb(base_addr + (CySRER << index)) & ~CyRxData);
+               if (info->flags & ASYNC_INITIALIZED) {
+                       /* Waiting for on-board buffers to be empty before closing
+                          the port */
+                       CY_UNLOCK(info, flags);
+                       cy_wait_until_sent(tty, info->timeout);
+                       CY_LOCK(info, flags);
+               }
+       } else {
+#ifdef Z_WAKE
+               /* Waiting for on-board buffers to be empty before closing the port */
+               void __iomem *base_addr = cy_card[info->card].base_addr;
+               struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
+               struct ZFW_CTRL __iomem *zfw_ctrl =
+                   base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+               struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
+               int channel = info->line - cy_card[info->card].first_line;
+               int retval;
+
+               if (cy_readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
+                       retval = cyz_issue_cmd(&cy_card[info->card], channel,
+                                               C_CM_IOCTLW, 0L);
+                       if (retval != 0) {
+                               printk("cyc:cy_close retval on ttyC%d was %x\n",
+                                       info->line, retval);
+                       }
+                       CY_UNLOCK(info, flags);
+                       interruptible_sleep_on(&info->shutdown_wait);
+                       CY_LOCK(info, flags);
+               }
 #endif
-    }
-
-    CY_UNLOCK(info, flags);
-    shutdown(info);
-    if (tty->driver->flush_buffer)
-        tty->driver->flush_buffer(tty);
-    tty_ldisc_flush(tty);        
-    CY_LOCK(info, flags);
-
-    tty->closing = 0;
-    info->event = 0;
-    info->tty = NULL;
-    if (info->blocked_open) {
+       }
+
        CY_UNLOCK(info, flags);
-        if (info->close_delay) {
-            msleep_interruptible(jiffies_to_msecs(info->close_delay));
-        }
-        wake_up_interruptible(&info->open_wait);
+       shutdown(info);
+       if (tty->driver->flush_buffer)
+               tty->driver->flush_buffer(tty);
+       tty_ldisc_flush(tty);
        CY_LOCK(info, flags);
-    }
-    info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
-    wake_up_interruptible(&info->close_wait);
+
+       tty->closing = 0;
+       info->event = 0;
+       info->tty = NULL;
+       if (info->blocked_open) {
+               CY_UNLOCK(info, flags);
+               if (info->close_delay) {
+                       msleep_interruptible(jiffies_to_msecs
+                                               (info->close_delay));
+               }
+               wake_up_interruptible(&info->open_wait);
+               CY_LOCK(info, flags);
+       }
+       info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
+       wake_up_interruptible(&info->close_wait);
 
 #ifdef CY_DEBUG_OTHER
-    printk(" cyc:cy_close done\n");
+       printk(" cyc:cy_close done\n");
 #endif
 
-    CY_UNLOCK(info, flags);
-    return;
-} /* cy_close */
-
+       CY_UNLOCK(info, flags);
+}                              /* cy_close */
 
 /* This routine gets called when tty_write has put something into
  * the write_queue.  The characters may come from user space or
@@ -2796,50 +2875,49 @@ cy_close(struct tty_struct *tty, struct file *filp)
  * If the port is already active, there is no need to kick it.
  *
  */
-static int
-cy_write(struct tty_struct * tty, const unsigned char *buf, int count)
+static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
-  int c, ret = 0;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       unsigned long flags;
+       int c, ret = 0;
 
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_write ttyC%d\n", info->line); /* */
+       printk("cyc:cy_write ttyC%d\n", info->line);    /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_write")){
-        return 0;
-    }
-        
-    if (!info->xmit_buf)
-       return 0;
+       if (serial_paranoia_check(info, tty->name, "cy_write")) {
+               return 0;
+       }
 
-    CY_LOCK(info, flags);
-    while (1) {
-       c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
-                       (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
-               
-       if (c <= 0)
-           break;
-
-       memcpy(info->xmit_buf + info->xmit_head, buf, c);
-       info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
-       info->xmit_cnt += c;
-       buf += c;
-       count -= c;
-       ret += c;
-    }
-    CY_UNLOCK(info, flags);
-
-    info->idle_stats.xmit_bytes += ret;
-    info->idle_stats.xmit_idle   = jiffies;
-
-    if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
-        start_xmit(info);
-    }
-    return ret;
-} /* cy_write */
+       if (!info->xmit_buf)
+               return 0;
 
+       CY_LOCK(info, flags);
+       while (1) {
+               c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
+                                  (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
+
+               if (c <= 0)
+                       break;
+
+               memcpy(info->xmit_buf + info->xmit_head, buf, c);
+               info->xmit_head = (info->xmit_head + c) &
+                       (SERIAL_XMIT_SIZE - 1);
+               info->xmit_cnt += c;
+               buf += c;
+               count -= c;
+               ret += c;
+       }
+       CY_UNLOCK(info, flags);
+
+       info->idle_stats.xmit_bytes += ret;
+       info->idle_stats.xmit_idle = jiffies;
+
+       if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
+               start_xmit(info);
+       }
+       return ret;
+}                              /* cy_write */
 
 /*
  * This routine is called by the kernel to write a single
@@ -2848,60 +2926,56 @@ cy_write(struct tty_struct * tty, const unsigned char *buf, int count)
  * done stuffing characters into the driver.  If there is no room
  * in the queue, the character is ignored.
  */
-static void
-cy_put_char(struct tty_struct *tty, unsigned char ch)
+static void cy_put_char(struct tty_struct *tty, unsigned char ch)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       unsigned long flags;
 
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_put_char ttyC%d\n", info->line);
+       printk("cyc:cy_put_char ttyC%d\n", info->line);
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_put_char"))
-        return;
+       if (serial_paranoia_check(info, tty->name, "cy_put_char"))
+               return;
 
-    if (!info->xmit_buf)
-        return;
+       if (!info->xmit_buf)
+               return;
 
-    CY_LOCK(info, flags);
-        if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
-           CY_UNLOCK(info, flags);
-            return;
-        }
+       CY_LOCK(info, flags);
+       if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
+               CY_UNLOCK(info, flags);
+               return;
+       }
 
-        info->xmit_buf[info->xmit_head++] = ch;
-        info->xmit_head &= SERIAL_XMIT_SIZE - 1;
-        info->xmit_cnt++;
+       info->xmit_buf[info->xmit_head++] = ch;
+       info->xmit_head &= SERIAL_XMIT_SIZE - 1;
+       info->xmit_cnt++;
        info->idle_stats.xmit_bytes++;
        info->idle_stats.xmit_idle = jiffies;
-    CY_UNLOCK(info, flags);
-} /* cy_put_char */
-
+       CY_UNLOCK(info, flags);
+}                              /* cy_put_char */
 
 /*
  * This routine is called by the kernel after it has written a
  * series of characters to the tty device using put_char().  
  */
-static void
-cy_flush_chars(struct tty_struct *tty)
+static void cy_flush_chars(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-                                
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_flush_chars ttyC%d\n", info->line); /* */
+       printk("cyc:cy_flush_chars ttyC%d\n", info->line);      /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
-        return;
-
-    if (info->xmit_cnt <= 0 || tty->stopped
-    || tty->hw_stopped || !info->xmit_buf)
-        return;
+       if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
+               return;
 
-    start_xmit(info);
-} /* cy_flush_chars */
+       if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
+                       !info->xmit_buf)
+               return;
 
+       start_xmit(info);
+}                              /* cy_flush_chars */
 
 /*
  * This routine returns the numbers of characters the tty driver
@@ -2909,75 +2983,70 @@ cy_flush_chars(struct tty_struct *tty)
  * to change as output buffers get emptied, or if the output flow
  * control is activated.
  */
-static int
-cy_write_room(struct tty_struct *tty)
+static int cy_write_room(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  int   ret;
-                                
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       int ret;
+
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_write_room ttyC%d\n", info->line); /* */
+       printk("cyc:cy_write_room ttyC%d\n", info->line);       /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_write_room"))
-        return 0;
-    ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
-    if (ret < 0)
-        ret = 0;
-    return ret;
-} /* cy_write_room */
-
+       if (serial_paranoia_check(info, tty->name, "cy_write_room"))
+               return 0;
+       ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
+       if (ret < 0)
+               ret = 0;
+       return ret;
+}                              /* cy_write_room */
 
-static int
-cy_chars_in_buffer(struct tty_struct *tty)
+static int cy_chars_in_buffer(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  int card, channel;
-                                
-    if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
-        return 0;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       int card, channel;
+
+       if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
+               return 0;
 
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
 
 #ifdef Z_EXT_CHARS_IN_BUFFER
-    if (!IS_CYC_Z(cy_card[card])) {
-#endif /* Z_EXT_CHARS_IN_BUFFER */
+       if (!IS_CYC_Z(cy_card[card])) {
+#endif                         /* Z_EXT_CHARS_IN_BUFFER */
 #ifdef CY_DEBUG_IO
-       printk("cyc:cy_chars_in_buffer ttyC%d %d\n",
-               info->line, info->xmit_cnt); /* */
+               printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt);       /* */
 #endif
-       return info->xmit_cnt;
+               return info->xmit_cnt;
 #ifdef Z_EXT_CHARS_IN_BUFFER
-    } else {
-       static volatile struct FIRM_ID *firm_id;
-       static volatile struct ZFW_CTRL *zfw_ctrl;
-       static volatile struct CH_CTRL *ch_ctrl;
-       static volatile struct BUF_CTRL *buf_ctrl;
-       int char_count;
-       volatile uclong tx_put, tx_get, tx_bufsize;
-
-       firm_id = cy_card[card].base_addr + ID_ADDRESS;
-       zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-       buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
-
-       tx_get = cy_readl(&buf_ctrl->tx_get);
-       tx_put = cy_readl(&buf_ctrl->tx_put);
-       tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
-       if (tx_put >= tx_get)
-           char_count = tx_put - tx_get;
-       else
-           char_count = tx_put - tx_get + tx_bufsize;
+       } else {
+               static volatile struct FIRM_ID *firm_id;
+               static volatile struct ZFW_CTRL *zfw_ctrl;
+               static volatile struct CH_CTRL *ch_ctrl;
+               static volatile struct BUF_CTRL *buf_ctrl;
+               int char_count;
+               volatile __u32 tx_put, tx_get, tx_bufsize;
+
+               firm_id = cy_card[card].base_addr + ID_ADDRESS;
+               zfw_ctrl = cy_card[card].base_addr +
+                       (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+               ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
+               buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
+
+               tx_get = cy_readl(&buf_ctrl->tx_get);
+               tx_put = cy_readl(&buf_ctrl->tx_put);
+               tx_bufsize = cy_readl(&buf_ctrl->tx_bufsize);
+               if (tx_put >= tx_get)
+                       char_count = tx_put - tx_get;
+               else
+                       char_count = tx_put - tx_get + tx_bufsize;
 #ifdef CY_DEBUG_IO
-       printk("cyc:cy_chars_in_buffer ttyC%d %d\n",
-               info->line, info->xmit_cnt + char_count); /* */
+               printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt + char_count);  /* */
 #endif
-       return (info->xmit_cnt + char_count);
-    }
-#endif /* Z_EXT_CHARS_IN_BUFFER */
-} /* cy_chars_in_buffer */
-
+               return info->xmit_cnt + char_count;
+       }
+#endif                         /* Z_EXT_CHARS_IN_BUFFER */
+}                              /* cy_chars_in_buffer */
 
 /*
  * ------------------------------------------------------------
@@ -2985,178 +3054,179 @@ cy_chars_in_buffer(struct tty_struct *tty)
  * ------------------------------------------------------------
  */
 
-static void
-cyy_baud_calc(struct cyclades_port *info, uclong baud)
+static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
 {
-    int co, co_val, bpr;
-    uclong cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 : 25000000);
-
-    if (baud == 0) {
-       info->tbpr = info->tco = info->rbpr = info->rco = 0;
-       return;
-    }
-
-    /* determine which prescaler to use */
-    for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
-       if (cy_clock / co_val / baud > 63)
-           break;
-    }
-
-    bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
-    if (bpr > 255)
-       bpr = 255;
-
-    info->tbpr = info->rbpr = bpr;
-    info->tco = info->rco = co;
+       int co, co_val, bpr;
+       __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
+                       25000000);
+
+       if (baud == 0) {
+               info->tbpr = info->tco = info->rbpr = info->rco = 0;
+               return;
+       }
+
+       /* determine which prescaler to use */
+       for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
+               if (cy_clock / co_val / baud > 63)
+                       break;
+       }
+
+       bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
+       if (bpr > 255)
+               bpr = 255;
+
+       info->tbpr = info->rbpr = bpr;
+       info->tco = info->rco = co;
 }
 
 /*
  * This routine finds or computes the various line characteristics.
  * It used to be called config_setup
  */
-static void
-set_line_char(struct cyclades_port * info)
+static void set_line_char(struct cyclades_port *info)
 {
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
-  unsigned cflag, iflag;
-  unsigned short chip_number;
-  int baud, baud_rate = 0;
-  int   i;
-
-
-    if (!info->tty || !info->tty->termios){
-        return;
-    }
-    if (info->line == -1){
-        return;
-    }
-    cflag = info->tty->termios->c_cflag;
-    iflag = info->tty->termios->c_iflag;
-
-    /*
-     * Set up the tty->alt_speed kludge
-     */
-    if (info->tty) {
-       if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-           info->tty->alt_speed = 57600;
-       if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-           info->tty->alt_speed = 115200;
-       if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
-           info->tty->alt_speed = 230400;
-       if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
-           info->tty->alt_speed = 460800;
-    }
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    chip_number = channel / 4;
-
-    if (!IS_CYC_Z(cy_card[card])) {
-
-       index = cy_card[card].bus_index;
-
-       /* baud rate */
-       baud = tty_get_baud_rate(info->tty);
-       if ((baud == 38400) &&
-           ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-           if (info->custom_divisor)
-               baud_rate = info->baud / info->custom_divisor;
-           else
-               baud_rate = info->baud;
-       } else if (baud > CD1400_MAX_SPEED) {
-           baud = CD1400_MAX_SPEED;
+       unsigned long flags;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
+       unsigned cflag, iflag;
+       unsigned short chip_number;
+       int baud, baud_rate = 0;
+       int i;
+
+       if (!info->tty || !info->tty->termios) {
+               return;
        }
-       /* find the baud index */
-       for (i = 0; i < 20; i++) {
-           if (baud == baud_table[i]) {
-               break;
-           }
+       if (info->line == -1) {
+               return;
        }
-       if (i == 20) {
-           i = 19; /* CD1400_MAX_SPEED */
-       } 
+       cflag = info->tty->termios->c_cflag;
+       iflag = info->tty->termios->c_iflag;
 
-       if ((baud == 38400) &&
-           ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-           cyy_baud_calc(info, baud_rate);
-       } else {
-           if(info->chip_rev >= CD1400_REV_J) {
-               /* It is a CD1400 rev. J or later */
-               info->tbpr = baud_bpr_60[i]; /* Tx BPR */
-               info->tco = baud_co_60[i]; /* Tx CO */
-               info->rbpr = baud_bpr_60[i]; /* Rx BPR */
-               info->rco = baud_co_60[i]; /* Rx CO */
-           } else {
-               info->tbpr = baud_bpr_25[i]; /* Tx BPR */
-               info->tco = baud_co_25[i]; /* Tx CO */
-               info->rbpr = baud_bpr_25[i]; /* Rx BPR */
-               info->rco = baud_co_25[i]; /* Rx CO */
-           }
-       }
-       if (baud_table[i] == 134) {
-           /* get it right for 134.5 baud */
-           info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
-       } else if ((baud == 38400) &&
-                  ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-           info->timeout = (info->xmit_fifo_size*HZ*15/baud_rate) + 2;
-       } else if (baud_table[i]) {
-           info->timeout = (info->xmit_fifo_size*HZ*15/baud_table[i]) + 2;
-           /* this needs to be propagated into the card info */
-       } else {
-           info->timeout = 0;
-       }
-       /* By tradition (is it a standard?) a baud rate of zero
-          implies the line should be/has been closed.  A bit
-          later in this routine such a test is performed. */
-
-       /* byte size and parity */
-       info->cor5 = 0;
-       info->cor4 = 0;
-       info->cor3 = (info->default_threshold
-                     ? info->default_threshold
-                     : baud_cor3[i]); /* receive threshold */
-       info->cor2 = CyETC;
-       switch(cflag & CSIZE){
-       case CS5:
-           info->cor1 = Cy_5_BITS;
-           break;
-       case CS6:
-           info->cor1 = Cy_6_BITS;
-           break;
-       case CS7:
-           info->cor1 = Cy_7_BITS;
-           break;
-       case CS8:
-           info->cor1 = Cy_8_BITS;
-           break;
-       }
-       if(cflag & CSTOPB){
-           info->cor1 |= Cy_2_STOP;
-       }
-       if (cflag & PARENB){
-           if (cflag & PARODD){
-               info->cor1 |= CyPARITY_O;
-           }else{
-               info->cor1 |= CyPARITY_E;
-           }
-       }else{
-           info->cor1 |= CyPARITY_NONE;
-       }
-           
-       /* CTS flow control flag */
-       if (cflag & CRTSCTS){
-           info->flags |= ASYNC_CTS_FLOW;
-           info->cor2 |= CyCtsAE;
-       }else{
-           info->flags &= ~ASYNC_CTS_FLOW;
-           info->cor2 &= ~CyCtsAE;
+       /*
+        * Set up the tty->alt_speed kludge
+        */
+       if (info->tty) {
+               if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
+                       info->tty->alt_speed = 57600;
+               if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
+                       info->tty->alt_speed = 115200;
+               if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
+                       info->tty->alt_speed = 230400;
+               if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
+                       info->tty->alt_speed = 460800;
        }
-       if (cflag & CLOCAL)
-           info->flags &= ~ASYNC_CHECK_CD;
-       else
-           info->flags |= ASYNC_CHECK_CD;
+
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
+       chip_number = channel / 4;
+
+       if (!IS_CYC_Z(cy_card[card])) {
+
+               index = cy_card[card].bus_index;
+
+               /* baud rate */
+               baud = tty_get_baud_rate(info->tty);
+               if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                               ASYNC_SPD_CUST) {
+                       if (info->custom_divisor)
+                               baud_rate = info->baud / info->custom_divisor;
+                       else
+                               baud_rate = info->baud;
+               } else if (baud > CD1400_MAX_SPEED) {
+                       baud = CD1400_MAX_SPEED;
+               }
+               /* find the baud index */
+               for (i = 0; i < 20; i++) {
+                       if (baud == baud_table[i]) {
+                               break;
+                       }
+               }
+               if (i == 20) {
+                       i = 19; /* CD1400_MAX_SPEED */
+               }
+
+               if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                               ASYNC_SPD_CUST) {
+                       cyy_baud_calc(info, baud_rate);
+               } else {
+                       if (info->chip_rev >= CD1400_REV_J) {
+                               /* It is a CD1400 rev. J or later */
+                               info->tbpr = baud_bpr_60[i];    /* Tx BPR */
+                               info->tco = baud_co_60[i];      /* Tx CO */
+                               info->rbpr = baud_bpr_60[i];    /* Rx BPR */
+                               info->rco = baud_co_60[i];      /* Rx CO */
+                       } else {
+                               info->tbpr = baud_bpr_25[i];    /* Tx BPR */
+                               info->tco = baud_co_25[i];      /* Tx CO */
+                               info->rbpr = baud_bpr_25[i];    /* Rx BPR */
+                               info->rco = baud_co_25[i];      /* Rx CO */
+                       }
+               }
+               if (baud_table[i] == 134) {
+                       /* get it right for 134.5 baud */
+                       info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
+                                       2;
+               } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                               ASYNC_SPD_CUST) {
+                       info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                       baud_rate) + 2;
+               } else if (baud_table[i]) {
+                       info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                       baud_table[i]) + 2;
+                       /* this needs to be propagated into the card info */
+               } else {
+                       info->timeout = 0;
+               }
+               /* By tradition (is it a standard?) a baud rate of zero
+                  implies the line should be/has been closed.  A bit
+                  later in this routine such a test is performed. */
+
+               /* byte size and parity */
+               info->cor5 = 0;
+               info->cor4 = 0;
+               /* receive threshold */
+               info->cor3 = (info->default_threshold ?
+                               info->default_threshold : baud_cor3[i]);
+               info->cor2 = CyETC;
+               switch (cflag & CSIZE) {
+               case CS5:
+                       info->cor1 = Cy_5_BITS;
+                       break;
+               case CS6:
+                       info->cor1 = Cy_6_BITS;
+                       break;
+               case CS7:
+                       info->cor1 = Cy_7_BITS;
+                       break;
+               case CS8:
+                       info->cor1 = Cy_8_BITS;
+                       break;
+               }
+               if (cflag & CSTOPB) {
+                       info->cor1 |= Cy_2_STOP;
+               }
+               if (cflag & PARENB) {
+                       if (cflag & PARODD) {
+                               info->cor1 |= CyPARITY_O;
+                       } else {
+                               info->cor1 |= CyPARITY_E;
+                       }
+               } else {
+                       info->cor1 |= CyPARITY_NONE;
+               }
+
+               /* CTS flow control flag */
+               if (cflag & CRTSCTS) {
+                       info->flags |= ASYNC_CTS_FLOW;
+                       info->cor2 |= CyCtsAE;
+               } else {
+                       info->flags &= ~ASYNC_CTS_FLOW;
+                       info->cor2 &= ~CyCtsAE;
+               }
+               if (cflag & CLOCAL)
+                       info->flags &= ~ASYNC_CHECK_CD;
+               else
+                       info->flags |= ASYNC_CHECK_CD;
 
         /***********************************************
            The hardware option, CyRtsAO, presents RTS when
@@ -3168,300 +3238,320 @@ set_line_char(struct cyclades_port * info)
            cable.  Contact Marcio Saito for details.
         ***********************************************/
 
-       chip = channel>>2;
-       channel &= 0x03;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+               chip = channel >> 2;
+               channel &= 0x03;
+               base_addr = cy_card[card].base_addr +
+                       (cy_chip_offset[chip] << index);
 
-       CY_LOCK(info, flags);
-           cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-
-          /* tx and rx baud rate */
-
-           cy_writeb(base_addr+(CyTCOR<<index), info->tco);
-           cy_writeb(base_addr+(CyTBPR<<index), info->tbpr);
-           cy_writeb(base_addr+(CyRCOR<<index), info->rco);
-           cy_writeb(base_addr+(CyRBPR<<index), info->rbpr);
-
-           /* set line characteristics  according configuration */
-
-           cy_writeb(base_addr+(CySCHR1<<index), 
-                     START_CHAR(info->tty));
-           cy_writeb(base_addr+(CySCHR2<<index), 
-                     STOP_CHAR(info->tty));
-           cy_writeb(base_addr+(CyCOR1<<index), info->cor1);
-           cy_writeb(base_addr+(CyCOR2<<index), info->cor2);
-           cy_writeb(base_addr+(CyCOR3<<index), info->cor3);
-           cy_writeb(base_addr+(CyCOR4<<index), info->cor4);
-           cy_writeb(base_addr+(CyCOR5<<index), info->cor5);
-
-           cyy_issue_cmd(base_addr,
-                    CyCOR_CHANGE|CyCOR1ch|CyCOR2ch|CyCOR3ch,index);
-
-           cy_writeb(base_addr+(CyCAR<<index), 
-                     (u_char)channel); /* !!! Is this needed? */
-           cy_writeb(base_addr+(CyRTPR<<index), (info->default_timeout
-                                                ? info->default_timeout
-                                                : 0x02)); /* 10ms rx timeout */
-
-           if (C_CLOCAL(info->tty)) {
-               /* without modem intr */
-               cy_writeb(base_addr+(CySRER<<index),
-                   cy_readb(base_addr+(CySRER<<index)) | CyMdmCh); 
-                                       /* act on 1->0 modem transitions */
-                if ((cflag & CRTSCTS) && info->rflow) {
-                        cy_writeb(base_addr+(CyMCOR1<<index), 
-                                  (CyCTS|rflow_thr[i]));
-                } else {
-                        cy_writeb(base_addr+(CyMCOR1<<index), CyCTS);
-                }
-                                       /* act on 0->1 modem transitions */
-               cy_writeb(base_addr+(CyMCOR2<<index), CyCTS);
-           } else {
-               /* without modem intr */
-               cy_writeb(base_addr+(CySRER<<index),
-                   cy_readb(base_addr+(CySRER<<index)) | CyMdmCh); 
-                                       /* act on 1->0 modem transitions */
-                if ((cflag & CRTSCTS) && info->rflow) {
-                       cy_writeb(base_addr+(CyMCOR1<<index), 
-                                 (CyDSR|CyCTS|CyRI|CyDCD|rflow_thr[i]));
-                } else {
-                       cy_writeb(base_addr+(CyMCOR1<<index), 
-                                  CyDSR|CyCTS|CyRI|CyDCD);
-                }
-                                       /* act on 0->1 modem transitions */
-               cy_writeb(base_addr+(CyMCOR2<<index), 
-                         CyDSR|CyCTS|CyRI|CyDCD);
-           }
-
-           if(i == 0){ /* baud rate is zero, turn off line */
-               if (info->rtsdtr_inv) {
-                       cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+
+               /* tx and rx baud rate */
+
+               cy_writeb(base_addr + (CyTCOR << index), info->tco);
+               cy_writeb(base_addr + (CyTBPR << index), info->tbpr);
+               cy_writeb(base_addr + (CyRCOR << index), info->rco);
+               cy_writeb(base_addr + (CyRBPR << index), info->rbpr);
+
+               /* set line characteristics  according configuration */
+
+               cy_writeb(base_addr + (CySCHR1 << index),
+                         START_CHAR(info->tty));
+               cy_writeb(base_addr + (CySCHR2 << index), STOP_CHAR(info->tty));
+               cy_writeb(base_addr + (CyCOR1 << index), info->cor1);
+               cy_writeb(base_addr + (CyCOR2 << index), info->cor2);
+               cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
+               cy_writeb(base_addr + (CyCOR4 << index), info->cor4);
+               cy_writeb(base_addr + (CyCOR5 << index), info->cor5);
+
+               cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
+                               CyCOR3ch, index);
+
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);      /* !!! Is this needed? */
+               cy_writeb(base_addr + (CyRTPR << index),
+                       (info->default_timeout ? info->default_timeout : 0x02));
+               /* 10ms rx timeout */
+
+               if (C_CLOCAL(info->tty)) {
+                       /* without modem intr */
+                       cy_writeb(base_addr + (CySRER << index),
+                                 cy_readb(base_addr +
+                                          (CySRER << index)) | CyMdmCh);
+                       /* act on 1->0 modem transitions */
+                       if ((cflag & CRTSCTS) && info->rflow) {
+                               cy_writeb(base_addr + (CyMCOR1 << index),
+                                         (CyCTS | rflow_thr[i]));
+                       } else {
+                               cy_writeb(base_addr + (CyMCOR1 << index),
+                                         CyCTS);
+                       }
+                       /* act on 0->1 modem transitions */
+                       cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
                } else {
-                        cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
+                       /* without modem intr */
+                       cy_writeb(base_addr + (CySRER << index),
+                                 cy_readb(base_addr +
+                                          (CySRER << index)) | CyMdmCh);
+                       /* act on 1->0 modem transitions */
+                       if ((cflag & CRTSCTS) && info->rflow) {
+                               cy_writeb(base_addr + (CyMCOR1 << index),
+                                         (CyDSR | CyCTS | CyRI | CyDCD |
+                                          rflow_thr[i]));
+                       } else {
+                               cy_writeb(base_addr + (CyMCOR1 << index),
+                                         CyDSR | CyCTS | CyRI | CyDCD);
+                       }
+                       /* act on 0->1 modem transitions */
+                       cy_writeb(base_addr + (CyMCOR2 << index),
+                                 CyDSR | CyCTS | CyRI | CyDCD);
                }
+
+               if (i == 0) {   /* baud rate is zero, turn off line */
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         ~CyRTS);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         ~CyDTR);
+                       }
 #ifdef CY_DEBUG_DTR
-               printk("cyc:set_line_char dropping DTR\n");
-               printk("     status: 0x%x, 0x%x\n", 
-                   cy_readb(base_addr+(CyMSVR1<<index)),
-                   cy_readb(base_addr+(CyMSVR2<<index)));
+                       printk("cyc:set_line_char dropping DTR\n");
+                       printk("     status: 0x%x, 0x%x\n",
+                               cy_readb(base_addr + (CyMSVR1 << index)),
+                               cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-           }else{
-                if (info->rtsdtr_inv) {
-                       cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                } else {
-                       cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-                }
+               } else {
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         CyRTS);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         CyDTR);
+                       }
 #ifdef CY_DEBUG_DTR
-               printk("cyc:set_line_char raising DTR\n");
-               printk("     status: 0x%x, 0x%x\n",
-                   cy_readb(base_addr+(CyMSVR1<<index)),
-                   cy_readb(base_addr+(CyMSVR2<<index)));
+                       printk("cyc:set_line_char raising DTR\n");
+                       printk("     status: 0x%x, 0x%x\n",
+                               cy_readb(base_addr + (CyMSVR1 << index)),
+                               cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-           }
-
-           if (info->tty){
-               clear_bit(TTY_IO_ERROR, &info->tty->flags);
-           }
-       CY_UNLOCK(info, flags);
+               }
 
-    } else {
-      struct FIRM_ID __iomem *firm_id;
-      struct ZFW_CTRL __iomem *zfw_ctrl;
-      struct BOARD_CTRL __iomem *board_ctrl;
-      struct CH_CTRL __iomem *ch_ctrl;
-      struct BUF_CTRL __iomem *buf_ctrl;
-      uclong sw_flow;
-      int retval;
-
-        firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        if (!ISZLOADED(cy_card[card])) {
-           return;
-       }
+               if (info->tty) {
+                       clear_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
+               CY_UNLOCK(info, flags);
 
-       zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-       board_ctrl = &zfw_ctrl->board_ctrl;
-       ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-       buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
-
-       /* baud rate */
-       baud = tty_get_baud_rate(info->tty);
-       if ((baud == 38400) &&
-           ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-           if (info->custom_divisor)
-               baud_rate = info->baud / info->custom_divisor;
-           else
-               baud_rate = info->baud;
-       } else if (baud > CYZ_MAX_SPEED) {
-           baud = CYZ_MAX_SPEED;
-       }
-       cy_writel(&ch_ctrl->comm_baud , baud);
-
-       if (baud == 134) {
-           /* get it right for 134.5 baud */
-           info->timeout = (info->xmit_fifo_size*HZ*30/269) + 2;
-       } else if ((baud == 38400) &&
-                  ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) {
-           info->timeout = (info->xmit_fifo_size*HZ*15/baud_rate) + 2;
-       } else if (baud) {
-           info->timeout = (info->xmit_fifo_size*HZ*15/baud) + 2;
-           /* this needs to be propagated into the card info */
        } else {
-           info->timeout = 0;
-       }
+               struct FIRM_ID __iomem *firm_id;
+               struct ZFW_CTRL __iomem *zfw_ctrl;
+               struct BOARD_CTRL __iomem *board_ctrl;
+               struct CH_CTRL __iomem *ch_ctrl;
+               struct BUF_CTRL __iomem *buf_ctrl;
+               __u32 sw_flow;
+               int retval;
+
+               firm_id = cy_card[card].base_addr + ID_ADDRESS;
+               if (!ISZLOADED(cy_card[card])) {
+                       return;
+               }
 
-       /* byte size and parity */
-       switch(cflag & CSIZE){
-       case CS5: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS5); break;
-       case CS6: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS6); break;
-       case CS7: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS7); break;
-       case CS8: cy_writel(&ch_ctrl->comm_data_l , C_DL_CS8); break;
-       }
-       if(cflag & CSTOPB){
-           cy_writel(&ch_ctrl->comm_data_l,
-               cy_readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
-       }else{
-           cy_writel(&ch_ctrl->comm_data_l,
-               cy_readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
-       }
-       if (cflag & PARENB){
-           if (cflag & PARODD){
-               cy_writel(&ch_ctrl->comm_parity , C_PR_ODD);
-           }else{
-               cy_writel(&ch_ctrl->comm_parity , C_PR_EVEN);
-           }
-       }else{
-           cy_writel(&ch_ctrl->comm_parity , C_PR_NONE);
-       }
+               zfw_ctrl = cy_card[card].base_addr +
+                       (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+               board_ctrl = &zfw_ctrl->board_ctrl;
+               ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
+               buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
+
+               /* baud rate */
+               baud = tty_get_baud_rate(info->tty);
+               if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                               ASYNC_SPD_CUST) {
+                       if (info->custom_divisor)
+                               baud_rate = info->baud / info->custom_divisor;
+                       else
+                               baud_rate = info->baud;
+               } else if (baud > CYZ_MAX_SPEED) {
+                       baud = CYZ_MAX_SPEED;
+               }
+               cy_writel(&ch_ctrl->comm_baud, baud);
+
+               if (baud == 134) {
+                       /* get it right for 134.5 baud */
+                       info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
+                                       2;
+               } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
+                               ASYNC_SPD_CUST) {
+                       info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                       baud_rate) + 2;
+               } else if (baud) {
+                       info->timeout = (info->xmit_fifo_size * HZ * 15 /
+                                       baud) + 2;
+                       /* this needs to be propagated into the card info */
+               } else {
+                       info->timeout = 0;
+               }
 
-       /* CTS flow control flag */
-       if (cflag & CRTSCTS){
-           cy_writel(&ch_ctrl->hw_flow,
-               cy_readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
-       }else{
-           cy_writel(&ch_ctrl->hw_flow,
-               cy_readl(&ch_ctrl->hw_flow) & ~(C_RS_CTS | C_RS_RTS));
-       }
-       /* As the HW flow control is done in firmware, the driver doesn't
-          need to care about it */
-       info->flags &= ~ASYNC_CTS_FLOW;
-
-       /* XON/XOFF/XANY flow control flags */
-       sw_flow = 0;
-       if (iflag & IXON){
-           sw_flow |= C_FL_OXX;
-           if (iflag & IXANY)
-               sw_flow |= C_FL_OIXANY;
-       }
-       cy_writel(&ch_ctrl->sw_flow, sw_flow);
+               /* byte size and parity */
+               switch (cflag & CSIZE) {
+               case CS5:
+                       cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
+                       break;
+               case CS6:
+                       cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
+                       break;
+               case CS7:
+                       cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
+                       break;
+               case CS8:
+                       cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
+                       break;
+               }
+               if (cflag & CSTOPB) {
+                       cy_writel(&ch_ctrl->comm_data_l,
+                                 cy_readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
+               } else {
+                       cy_writel(&ch_ctrl->comm_data_l,
+                                 cy_readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
+               }
+               if (cflag & PARENB) {
+                       if (cflag & PARODD) {
+                               cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
+                       } else {
+                               cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
+                       }
+               } else {
+                       cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
+               }
 
-       retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
-       if (retval != 0){
-           printk("cyc:set_line_char retval on ttyC%d was %x\n",
-                  info->line, retval);
-       }
+               /* CTS flow control flag */
+               if (cflag & CRTSCTS) {
+                       cy_writel(&ch_ctrl->hw_flow,
+                                 cy_readl(&ch_ctrl->
+                                          hw_flow) | C_RS_CTS | C_RS_RTS);
+               } else {
+                       cy_writel(&ch_ctrl->hw_flow,
+                                 cy_readl(&ch_ctrl->
+                                          hw_flow) & ~(C_RS_CTS | C_RS_RTS));
+               }
+               /* As the HW flow control is done in firmware, the driver
+                  doesn't need to care about it */
+               info->flags &= ~ASYNC_CTS_FLOW;
+
+               /* XON/XOFF/XANY flow control flags */
+               sw_flow = 0;
+               if (iflag & IXON) {
+                       sw_flow |= C_FL_OXX;
+                       if (iflag & IXANY)
+                               sw_flow |= C_FL_OIXANY;
+               }
+               cy_writel(&ch_ctrl->sw_flow, sw_flow);
 
-       /* CD sensitivity */
-       if (cflag & CLOCAL){
-           info->flags &= ~ASYNC_CHECK_CD;
-       }else{
-           info->flags |= ASYNC_CHECK_CD;
-       }
+               retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
+               if (retval != 0) {
+                       printk("cyc:set_line_char retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
+
+               /* CD sensitivity */
+               if (cflag & CLOCAL) {
+                       info->flags &= ~ASYNC_CHECK_CD;
+               } else {
+                       info->flags |= ASYNC_CHECK_CD;
+               }
 
-       if(baud == 0){ /* baud rate is zero, turn off line */
-           cy_writel(&ch_ctrl->rs_control,
-               cy_readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
+               if (baud == 0) {        /* baud rate is zero, turn off line */
+                       cy_writel(&ch_ctrl->rs_control,
+                                 cy_readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-           printk("cyc:set_line_char dropping Z DTR\n");
+                       printk("cyc:set_line_char dropping Z DTR\n");
 #endif
-       }else{
-           cy_writel(&ch_ctrl->rs_control,
-               cy_readl(&ch_ctrl->rs_control) | C_RS_DTR);
+               } else {
+                       cy_writel(&ch_ctrl->rs_control,
+                                 cy_readl(&ch_ctrl->rs_control) | C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-           printk("cyc:set_line_char raising Z DTR\n");
+                       printk("cyc:set_line_char raising Z DTR\n");
 #endif
-       }
+               }
 
-       retval = cyz_issue_cmd( &cy_card[card], channel, C_CM_IOCTLM, 0L);
-       if (retval != 0){
-           printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
-                  info->line, retval);
-       }
+               retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTLM,0L);
+               if (retval != 0) {
+                       printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
 
-       if (info->tty){
-           clear_bit(TTY_IO_ERROR, &info->tty->flags);
+               if (info->tty) {
+                       clear_bit(TTY_IO_ERROR, &info->tty->flags);
+               }
        }
-    }
-} /* set_line_char */
-
+}                              /* set_line_char */
 
 static int
-get_serial_info(struct cyclades_port * info,
-                           struct serial_struct __user * retinfo)
+get_serial_info(struct cyclades_port *info,
+               struct serial_struct __user * retinfo)
 {
-  struct serial_struct tmp;
-  struct cyclades_card *cinfo = &cy_card[info->card];
-
-    if (!retinfo)
-            return -EFAULT;
-    memset(&tmp, 0, sizeof(tmp));
-    tmp.type = info->type;
-    tmp.line = info->line;
-    tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
-    tmp.irq = cinfo->irq;
-    tmp.flags = info->flags;
-    tmp.close_delay = info->close_delay;
-    tmp.baud_base = info->baud;
-    tmp.custom_divisor = info->custom_divisor;
-    tmp.hub6 = 0;               /*!!!*/
-    return copy_to_user(retinfo,&tmp,sizeof(*retinfo))?-EFAULT:0;
-} /* get_serial_info */
+       struct serial_struct tmp;
+       struct cyclades_card *cinfo = &cy_card[info->card];
 
+       if (!retinfo)
+               return -EFAULT;
+       memset(&tmp, 0, sizeof(tmp));
+       tmp.type = info->type;
+       tmp.line = info->line;
+       tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
+       tmp.irq = cinfo->irq;
+       tmp.flags = info->flags;
+       tmp.close_delay = info->close_delay;
+       tmp.closing_wait = info->closing_wait;
+       tmp.baud_base = info->baud;
+       tmp.custom_divisor = info->custom_divisor;
+       tmp.hub6 = 0;           /*!!! */
+       return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
+}                              /* get_serial_info */
 
 static int
-set_serial_info(struct cyclades_port * info,
-                           struct serial_struct __user * new_info)
+set_serial_info(struct cyclades_port *info,
+               struct serial_struct __user * new_info)
 {
-  struct serial_struct new_serial;
-  struct cyclades_port old_info;
-
-    if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
-       return -EFAULT;
-    old_info = *info;
-
-    if (!capable(CAP_SYS_ADMIN)) {
-            if ((new_serial.close_delay != info->close_delay) ||
-               (new_serial.baud_base != info->baud) ||
-               ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
-                (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
-                    return -EPERM;
-            info->flags = ((info->flags & ~ASYNC_USR_MASK) |
-                           (new_serial.flags & ASYNC_USR_MASK));
-            info->baud = new_serial.baud_base;
-           info->custom_divisor = new_serial.custom_divisor;
-            goto check_and_exit;
-    }
-
-
-    /*
-     * OK, past this point, all the error checking has been done.
-     * At this point, we start making changes.....
-     */
-
-    info->baud = new_serial.baud_base;
-    info->custom_divisor = new_serial.custom_divisor;
-    info->flags = ((info->flags & ~ASYNC_FLAGS) |
-                    (new_serial.flags & ASYNC_FLAGS));
-    info->close_delay = new_serial.close_delay * HZ/100;
-    info->closing_wait = new_serial.closing_wait * HZ/100;
+       struct serial_struct new_serial;
+       struct cyclades_port old_info;
+
+       if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
+               return -EFAULT;
+       old_info = *info;
+
+       if (!capable(CAP_SYS_ADMIN)) {
+               if (new_serial.close_delay != info->close_delay ||
+                               new_serial.baud_base != info->baud ||
+                               (new_serial.flags & ASYNC_FLAGS &
+                                       ~ASYNC_USR_MASK) !=
+                               (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
+                       return -EPERM;
+               info->flags = (info->flags & ~ASYNC_USR_MASK) |
+                               (new_serial.flags & ASYNC_USR_MASK);
+               info->baud = new_serial.baud_base;
+               info->custom_divisor = new_serial.custom_divisor;
+               goto check_and_exit;
+       }
+
+       /*
+        * OK, past this point, all the error checking has been done.
+        * At this point, we start making changes.....
+        */
+
+       info->baud = new_serial.baud_base;
+       info->custom_divisor = new_serial.custom_divisor;
+       info->flags = (info->flags & ~ASYNC_FLAGS) |
+                       (new_serial.flags & ASYNC_FLAGS);
+       info->close_delay = new_serial.close_delay * HZ / 100;
+       info->closing_wait = new_serial.closing_wait * HZ / 100;
 
 check_and_exit:
-    if (info->flags & ASYNC_INITIALIZED){
-        set_line_char(info);
-        return 0;
-    }else{
-        return startup(info);
-    }
-} /* set_serial_info */
+       if (info->flags & ASYNC_INITIALIZED) {
+               set_line_char(info);
+               return 0;
+       } else {
+               return startup(info);
+       }
+}                              /* set_serial_info */
 
 /*
  * get_lsr_info - get line status register info
@@ -3473,441 +3563,452 @@ check_and_exit:
  *         transmit holding register is empty.  This functionality
  *         allows an RS485 driver to be written in user space.
  */
-static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
+static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
 {
-    int card, chip, channel, index;
-    unsigned char status;
-    unsigned int result;
-    unsigned long flags;
-    void __iomem *base_addr;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+       int card, chip, channel, index;
+       unsigned char status;
+       unsigned int result;
+       unsigned long flags;
+       void __iomem *base_addr;
 
-       CY_LOCK(info, flags);
-       status = cy_readb(base_addr+(CySRER<<index)) & (CyTxRdy|CyTxMpty);
-       CY_UNLOCK(info, flags);
-       result = (status ? 0 : TIOCSER_TEMT);
-    } else {
-       /* Not supported yet */
-       return -EINVAL;
-    }
-    return put_user(result, (unsigned long __user *) value);
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+               CY_LOCK(info, flags);
+               status = cy_readb(base_addr + (CySRER << index)) &
+                               (CyTxRdy | CyTxMpty);
+               CY_UNLOCK(info, flags);
+               result = (status ? 0 : TIOCSER_TEMT);
+       } else {
+               /* Not supported yet */
+               return -EINVAL;
+       }
+       return put_user(result, (unsigned long __user *)value);
 }
 
-static int
-cy_tiocmget(struct tty_struct *tty, struct file *file)
+static int cy_tiocmget(struct tty_struct *tty, struct file *file)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  int card,chip,channel,index;
-  void __iomem *base_addr;
-  unsigned long flags;
-  unsigned char status;
-  unsigned long lstatus;
-  unsigned int result;
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  struct CH_CTRL __iomem *ch_ctrl;
-
-    if (serial_paranoia_check(info, tty->name, __FUNCTION__))
-       return -ENODEV;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       int card, chip, channel, index;
+       void __iomem *base_addr;
+       unsigned long flags;
+       unsigned char status;
+       unsigned long lstatus;
+       unsigned int result;
+       struct FIRM_ID __iomem *firm_id;
+       struct ZFW_CTRL __iomem *zfw_ctrl;
+       struct BOARD_CTRL __iomem *board_ctrl;
+       struct CH_CTRL __iomem *ch_ctrl;
+
+       if (serial_paranoia_check(info, tty->name, __FUNCTION__))
+               return -ENODEV;
 
-       CY_LOCK(info, flags);
-           cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-           status = cy_readb(base_addr+(CyMSVR1<<index));
-           status |= cy_readb(base_addr+(CyMSVR2<<index));
-       CY_UNLOCK(info, flags);
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
 
-        if (info->rtsdtr_inv) {
-           result =  ((status  & CyRTS) ? TIOCM_DTR : 0)
-                   | ((status  & CyDTR) ? TIOCM_RTS : 0);
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+               status = cy_readb(base_addr + (CyMSVR1 << index));
+               status |= cy_readb(base_addr + (CyMSVR2 << index));
+               CY_UNLOCK(info, flags);
+
+               if (info->rtsdtr_inv) {
+                       result = ((status & CyRTS) ? TIOCM_DTR : 0) |
+                               ((status & CyDTR) ? TIOCM_RTS : 0);
+               } else {
+                       result = ((status & CyRTS) ? TIOCM_RTS : 0) |
+                               ((status & CyDTR) ? TIOCM_DTR : 0);
+               }
+               result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
+                       ((status & CyRI) ? TIOCM_RNG : 0) |
+                       ((status & CyDSR) ? TIOCM_DSR : 0) |
+                       ((status & CyCTS) ? TIOCM_CTS : 0);
        } else {
-           result =  ((status  & CyRTS) ? TIOCM_RTS : 0)
-                   | ((status  & CyDTR) ? TIOCM_DTR : 0);
-       }
-       result |=  ((status  & CyDCD) ? TIOCM_CAR : 0)
-                | ((status  & CyRI) ? TIOCM_RNG : 0)
-                | ((status  & CyDSR) ? TIOCM_DSR : 0)
-                | ((status  & CyCTS) ? TIOCM_CTS : 0);
-    } else {
-       base_addr = cy_card[card].base_addr;
-
-        if (cy_card[card].num_chips != -1){
-           return -EINVAL;
-       }
+               base_addr = cy_card[card].base_addr;
 
-       firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        if (ISZLOADED(cy_card[card])) {
-           zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-           board_ctrl = &zfw_ctrl->board_ctrl;
-           ch_ctrl = zfw_ctrl->ch_ctrl;
-           lstatus = cy_readl(&ch_ctrl[channel].rs_status);
-           result =  ((lstatus  & C_RS_RTS) ? TIOCM_RTS : 0)
-                   | ((lstatus  & C_RS_DTR) ? TIOCM_DTR : 0)
-                   | ((lstatus  & C_RS_DCD) ? TIOCM_CAR : 0)
-                   | ((lstatus  & C_RS_RI) ? TIOCM_RNG : 0)
-                   | ((lstatus  & C_RS_DSR) ? TIOCM_DSR : 0)
-                   | ((lstatus  & C_RS_CTS) ? TIOCM_CTS : 0);
-       }else{
-           result = 0;
-           return -ENODEV;
-       }
+               if (cy_card[card].num_chips != -1) {
+                       return -EINVAL;
+               }
 
-    }
-    return result;
-} /* cy_tiomget */
+               firm_id = cy_card[card].base_addr + ID_ADDRESS;
+               if (ISZLOADED(cy_card[card])) {
+                       zfw_ctrl = cy_card[card].base_addr +
+                               (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                       board_ctrl = &zfw_ctrl->board_ctrl;
+                       ch_ctrl = zfw_ctrl->ch_ctrl;
+                       lstatus = cy_readl(&ch_ctrl[channel].rs_status);
+                       result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
+                               ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
+                               ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
+                               ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
+                               ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
+                               ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
+               } else {
+                       result = 0;
+                       return -ENODEV;
+               }
 
+       }
+       return result;
+}                              /* cy_tiomget */
 
 static int
 cy_tiocmset(struct tty_struct *tty, struct file *file,
-            unsigned int set, unsigned int clear)
+               unsigned int set, unsigned int clear)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  int card,chip,channel,index;
-  void __iomem *base_addr;
-  unsigned long flags;
-  struct FIRM_ID __iomem *firm_id;
-  struct ZFW_CTRL __iomem *zfw_ctrl;
-  struct BOARD_CTRL __iomem *board_ctrl;
-  struct CH_CTRL __iomem *ch_ctrl;
-  int retval;
-
-    if (serial_paranoia_check(info, tty->name, __FUNCTION__))
-       return -ENODEV;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-       if (set & TIOCM_RTS){
-               CY_LOCK(info, flags);
-               cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                       cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-                } else {
-                       cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                }
-               CY_UNLOCK(info, flags);
-       }
-       if (clear & TIOCM_RTS) {
-               CY_LOCK(info, flags);
-               cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                       cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
-                } else {
-                       cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-                }
-               CY_UNLOCK(info, flags);
-       }
-       if (set & TIOCM_DTR){
-               CY_LOCK(info, flags);
-               cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                       cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-                } else {
-                       cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-                }
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       int card, chip, channel, index;
+       void __iomem *base_addr;
+       unsigned long flags;
+       struct FIRM_ID __iomem *firm_id;
+       struct ZFW_CTRL __iomem *zfw_ctrl;
+       struct BOARD_CTRL __iomem *board_ctrl;
+       struct CH_CTRL __iomem *ch_ctrl;
+       int retval;
+
+       if (serial_paranoia_check(info, tty->name, __FUNCTION__))
+               return -ENODEV;
+
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+               if (set & TIOCM_RTS) {
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         CyDTR);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         CyRTS);
+                       }
+                       CY_UNLOCK(info, flags);
+               }
+               if (clear & TIOCM_RTS) {
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         ~CyDTR);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         ~CyRTS);
+                       }
+                       CY_UNLOCK(info, flags);
+               }
+               if (set & TIOCM_DTR) {
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         CyRTS);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         CyDTR);
+                       }
 #ifdef CY_DEBUG_DTR
-               printk("cyc:set_modem_info raising DTR\n");
-               printk("     status: 0x%x, 0x%x\n",
-                   cy_readb(base_addr+(CyMSVR1<<index)), 
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                       printk("cyc:set_modem_info raising DTR\n");
+                       printk("     status: 0x%x, 0x%x\n",
+                               cy_readb(base_addr + (CyMSVR1 << index)),
+                               cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-               CY_UNLOCK(info, flags);
-       }
-       if (clear & TIOCM_DTR) {
-               CY_LOCK(info, flags);
-               cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-                if (info->rtsdtr_inv) {
-                       cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-                } else {
-                       cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
-                }
+                       CY_UNLOCK(info, flags);
+               }
+               if (clear & TIOCM_DTR) {
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         ~CyRTS);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         ~CyDTR);
+                       }
 
 #ifdef CY_DEBUG_DTR
-               printk("cyc:set_modem_info dropping DTR\n");
-               printk("     status: 0x%x, 0x%x\n",
-                   cy_readb(base_addr+(CyMSVR1<<index)), 
-                    cy_readb(base_addr+(CyMSVR2<<index)));
+                       printk("cyc:set_modem_info dropping DTR\n");
+                       printk("     status: 0x%x, 0x%x\n",
+                               cy_readb(base_addr + (CyMSVR1 << index)),
+                               cy_readb(base_addr + (CyMSVR2 << index)));
 #endif
-               CY_UNLOCK(info, flags);
-       }
-    } else {
-       base_addr = cy_card[card].base_addr;
-
-       firm_id = cy_card[card].base_addr + ID_ADDRESS;
-        if (ISZLOADED(cy_card[card])) {
-           zfw_ctrl = cy_card[card].base_addr + (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
-           board_ctrl = &zfw_ctrl->board_ctrl;
-           ch_ctrl = zfw_ctrl->ch_ctrl;
-
-           if (set & TIOCM_RTS){
-                   CY_LOCK(info, flags);
-                   cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) | C_RS_RTS);
-                   CY_UNLOCK(info, flags);
-           }
-           if (clear & TIOCM_RTS) {
-                   CY_LOCK(info, flags);
-                   cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) & ~C_RS_RTS);
-                   CY_UNLOCK(info, flags);
-           }
-           if (set & TIOCM_DTR){
-                   CY_LOCK(info, flags);
-                   cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) | C_RS_DTR);
+                       CY_UNLOCK(info, flags);
+               }
+       } else {
+               base_addr = cy_card[card].base_addr;
+
+               firm_id = cy_card[card].base_addr + ID_ADDRESS;
+               if (ISZLOADED(cy_card[card])) {
+                       zfw_ctrl = cy_card[card].base_addr +
+                               (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                       board_ctrl = &zfw_ctrl->board_ctrl;
+                       ch_ctrl = zfw_ctrl->ch_ctrl;
+
+                       if (set & TIOCM_RTS) {
+                               CY_LOCK(info, flags);
+                               cy_writel(&ch_ctrl[channel].rs_control,
+                                         cy_readl(&ch_ctrl[channel].
+                                                  rs_control) | C_RS_RTS);
+                               CY_UNLOCK(info, flags);
+                       }
+                       if (clear & TIOCM_RTS) {
+                               CY_LOCK(info, flags);
+                               cy_writel(&ch_ctrl[channel].rs_control,
+                                         cy_readl(&ch_ctrl[channel].
+                                                  rs_control) & ~C_RS_RTS);
+                               CY_UNLOCK(info, flags);
+                       }
+                       if (set & TIOCM_DTR) {
+                               CY_LOCK(info, flags);
+                               cy_writel(&ch_ctrl[channel].rs_control,
+                                         cy_readl(&ch_ctrl[channel].
+                                                  rs_control) | C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                   printk("cyc:set_modem_info raising Z DTR\n");
+                               printk("cyc:set_modem_info raising Z DTR\n");
 #endif
-                   CY_UNLOCK(info, flags);
-           }
-           if (clear & TIOCM_DTR) {
-                   CY_LOCK(info, flags);
-                   cy_writel(&ch_ctrl[channel].rs_control,
-                       cy_readl(&ch_ctrl[channel].rs_control) & ~C_RS_DTR);
+                               CY_UNLOCK(info, flags);
+                       }
+                       if (clear & TIOCM_DTR) {
+                               CY_LOCK(info, flags);
+                               cy_writel(&ch_ctrl[channel].rs_control,
+                                         cy_readl(&ch_ctrl[channel].
+                                                  rs_control) & ~C_RS_DTR);
 #ifdef CY_DEBUG_DTR
-                   printk("cyc:set_modem_info clearing Z DTR\n");
+                               printk("cyc:set_modem_info clearing Z DTR\n");
 #endif
-                   CY_UNLOCK(info, flags);
-           }
-       }else{
-           return -ENODEV;
-       }
-       CY_LOCK(info, flags);
-        retval = cyz_issue_cmd(&cy_card[info->card],
-                                   channel, C_CM_IOCTLM,0L);
-       if (retval != 0){
-           printk("cyc:set_modem_info retval on ttyC%d was %x\n",
-                  info->line, retval);
+                               CY_UNLOCK(info, flags);
+                       }
+               } else {
+                       return -ENODEV;
+               }
+               CY_LOCK(info, flags);
+               retval = cyz_issue_cmd(&cy_card[info->card],
+                                       channel, C_CM_IOCTLM, 0L);
+               if (retval != 0) {
+                       printk("cyc:set_modem_info retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
+               CY_UNLOCK(info, flags);
        }
-       CY_UNLOCK(info, flags);
-    }
-    return 0;
-} /* cy_tiocmset */
+       return 0;
+}                              /* cy_tiocmset */
 
 /*
  * cy_break() --- routine which turns the break handling on or off
  */
-static void
-cy_break(struct tty_struct *tty, int break_state)
+static void cy_break(struct tty_struct *tty, int break_state)
 {
-    struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-    unsigned long flags;
-
-    if (serial_paranoia_check(info, tty->name, "cy_break"))
-       return;
-
-    CY_LOCK(info, flags);
-    if (!IS_CYC_Z(cy_card[info->card])) {
-        /* Let the transmit ISR take care of this (since it
-          requires stuffing characters into the output stream).
-        */
-       if (break_state == -1) {
-           if (!info->breakon) {
-               info->breakon = 1;
-               if (!info->xmit_cnt) {
-                   CY_UNLOCK(info, flags);
-                   start_xmit(info);
-                   CY_LOCK(info, flags);
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       unsigned long flags;
+
+       if (serial_paranoia_check(info, tty->name, "cy_break"))
+               return;
+
+       CY_LOCK(info, flags);
+       if (!IS_CYC_Z(cy_card[info->card])) {
+               /* Let the transmit ISR take care of this (since it
+                  requires stuffing characters into the output stream).
+                */
+               if (break_state == -1) {
+                       if (!info->breakon) {
+                               info->breakon = 1;
+                               if (!info->xmit_cnt) {
+                                       CY_UNLOCK(info, flags);
+                                       start_xmit(info);
+                                       CY_LOCK(info, flags);
+                               }
+                       }
+               } else {
+                       if (!info->breakoff) {
+                               info->breakoff = 1;
+                               if (!info->xmit_cnt) {
+                                       CY_UNLOCK(info, flags);
+                                       start_xmit(info);
+                                       CY_LOCK(info, flags);
+                               }
+                       }
                }
-           }
        } else {
-           if (!info->breakoff) {
-               info->breakoff = 1;
-               if (!info->xmit_cnt) {
-                   CY_UNLOCK(info, flags);
-                   start_xmit(info);
-                   CY_LOCK(info, flags);
+               int retval;
+
+               if (break_state == -1) {
+                       retval = cyz_issue_cmd(&cy_card[info->card],
+                               info->line - cy_card[info->card].first_line,
+                               C_CM_SET_BREAK, 0L);
+                       if (retval != 0) {
+                               printk("cyc:cy_break (set) retval on ttyC%d "
+                                       "was %x\n", info->line, retval);
+                       }
+               } else {
+                       retval = cyz_issue_cmd(&cy_card[info->card],
+                               info->line - cy_card[info->card].first_line,
+                               C_CM_CLR_BREAK, 0L);
+                       if (retval != 0) {
+                               printk("cyc:cy_break (clr) retval on ttyC%d "
+                                       "was %x\n", info->line, retval);
+                       }
                }
-           }
-       }
-    } else {
-       int retval;
-
-       if (break_state == -1) {
-           retval = cyz_issue_cmd(&cy_card[info->card],
-               (info->line) - (cy_card[info->card].first_line),
-               C_CM_SET_BREAK, 0L);
-           if (retval != 0) {
-               printk("cyc:cy_break (set) retval on ttyC%d was %x\n",
-                      info->line, retval);
-           }
-       } else {
-           retval = cyz_issue_cmd(&cy_card[info->card],
-               (info->line) - (cy_card[info->card].first_line),
-               C_CM_CLR_BREAK, 0L);
-           if (retval != 0) {
-               printk("cyc:cy_break (clr) retval on ttyC%d was %x\n",
-                      info->line, retval);
-           }
        }
-    }
-    CY_UNLOCK(info, flags);
-} /* cy_break */
+       CY_UNLOCK(info, flags);
+}                              /* cy_break */
 
 static int
-get_mon_info(struct cyclades_port * info, struct cyclades_monitor __user * mon)
+get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
 {
 
-    if(copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
-       return -EFAULT;
-    info->mon.int_count  = 0;
-    info->mon.char_count = 0;
-    info->mon.char_max   = 0;
-    info->mon.char_last  = 0;
-    return 0;
-}/* get_mon_info */
-
+       if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
+               return -EFAULT;
+       info->mon.int_count = 0;
+       info->mon.char_count = 0;
+       info->mon.char_max = 0;
+       info->mon.char_last = 0;
+       return 0;
+}                              /* get_mon_info */
 
-static int
-set_threshold(struct cyclades_port * info, unsigned long value)
+static int set_threshold(struct cyclades_port *info, unsigned long value)
 {
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long flags;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-       info->cor3 &= ~CyREC_FIFO;
-       info->cor3 |= value & CyREC_FIFO;
+       void __iomem *base_addr;
+       int card, channel, chip, index;
+       unsigned long flags;
 
-       CY_LOCK(info, flags);
-           cy_writeb(base_addr+(CyCOR3<<index), info->cor3);
-           cyy_issue_cmd(base_addr,CyCOR_CHANGE|CyCOR3ch,index);
-       CY_UNLOCK(info, flags);
-    } else {
-       // Nothing to do!
-    }
-    return 0;
-}/* set_threshold */
+       card = info->card;
+       channel = info->line - cy_card[card].first_line;
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
 
+               info->cor3 &= ~CyREC_FIFO;
+               info->cor3 |= value & CyREC_FIFO;
 
-static int
-get_threshold(struct cyclades_port * info, unsigned long __user *value)
-{
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long tmp;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-       tmp = cy_readb(base_addr+(CyCOR3<<index)) & CyREC_FIFO;
-       return put_user(tmp,value);
-    } else {
-       // Nothing to do!
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
+               cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
+               CY_UNLOCK(info, flags);
+       } else {
+               /* Nothing to do! */
+       }
        return 0;
-    }
-}/* get_threshold */
-
+}                              /* set_threshold */
 
 static int
-set_default_threshold(struct cyclades_port * info, unsigned long value)
+get_threshold(struct cyclades_port *info, unsigned long __user * value)
 {
-    info->default_threshold = value & 0x0f;
-    return 0;
-}/* set_default_threshold */
+       void __iomem *base_addr;
+       int card, channel, chip, index;
+       unsigned long tmp;
 
+       card = info->card;
+       channel = info->line - cy_card[card].first_line;
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+               tmp = cy_readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
+               return put_user(tmp, value);
+       } else {
+               /* Nothing to do! */
+               return 0;
+       }
+}                              /* get_threshold */
 
 static int
-get_default_threshold(struct cyclades_port * info, unsigned long __user *value)
+set_default_threshold(struct cyclades_port *info, unsigned long value)
 {
-    return put_user(info->default_threshold,value);
-}/* get_default_threshold */
-
+       info->default_threshold = value & 0x0f;
+       return 0;
+}                              /* set_default_threshold */
 
 static int
-set_timeout(struct cyclades_port * info, unsigned long value)
+get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
 {
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long flags;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
+       return put_user(info->default_threshold, value);
+}                              /* get_default_threshold */
 
-       CY_LOCK(info, flags);
-           cy_writeb(base_addr+(CyRTPR<<index), value & 0xff);
-       CY_UNLOCK(info, flags);
-    } else {
-       // Nothing to do!
-    }
-    return 0;
-}/* set_timeout */
+static int set_timeout(struct cyclades_port *info, unsigned long value)
+{
+       void __iomem *base_addr;
+       int card, channel, chip, index;
+       unsigned long flags;
 
+       card = info->card;
+       channel = info->line - cy_card[card].first_line;
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
 
-static int
-get_timeout(struct cyclades_port * info, unsigned long __user *value)
-{
-  void __iomem *base_addr;
-  int card,channel,chip,index;
-  unsigned long tmp;
-   
-    card = info->card;
-    channel = info->line - cy_card[card].first_line;
-    if (!IS_CYC_Z(cy_card[card])) {
-       chip = channel>>2;
-       channel &= 0x03;
-       index = cy_card[card].bus_index;
-       base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-       tmp = cy_readb(base_addr+(CyRTPR<<index));
-       return put_user(tmp,value);
-    } else {
-       // Nothing to do!
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
+               CY_UNLOCK(info, flags);
+       } else {
+               /* Nothing to do! */
+       }
        return 0;
-    }
-}/* get_timeout */
-
+}                              /* set_timeout */
 
-static int
-set_default_timeout(struct cyclades_port * info, unsigned long value)
+static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
 {
-    info->default_timeout = value & 0xff;
-    return 0;
-}/* set_default_timeout */
+       void __iomem *base_addr;
+       int card, channel, chip, index;
+       unsigned long tmp;
 
+       card = info->card;
+       channel = info->line - cy_card[card].first_line;
+       if (!IS_CYC_Z(cy_card[card])) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               index = cy_card[card].bus_index;
+               base_addr =
+                   cy_card[card].base_addr + (cy_chip_offset[chip] << index);
+
+               tmp = cy_readb(base_addr + (CyRTPR << index));
+               return put_user(tmp, value);
+       } else {
+               /* Nothing to do! */
+               return 0;
+       }
+}                              /* get_timeout */
+
+static int set_default_timeout(struct cyclades_port *info, unsigned long value)
+{
+       info->default_timeout = value & 0xff;
+       return 0;
+}                              /* set_default_timeout */
 
 static int
-get_default_timeout(struct cyclades_port * info, unsigned long __user *value)
+get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
 {
-    return put_user(info->default_timeout,value);
-}/* get_default_timeout */
+       return put_user(info->default_timeout, value);
+}                              /* get_default_timeout */
 
 /*
  * This routine allows the tty driver to implement device-
@@ -3915,184 +4016,193 @@ get_default_timeout(struct cyclades_port * info, unsigned long __user *value)
  * not recognized by the driver, it should return ENOIOCTLCMD.
  */
 static int
-cy_ioctl(struct tty_struct *tty, struct file * file,
-            unsigned int cmd, unsigned long arg)
+cy_ioctl(struct tty_struct *tty, struct file *file,
+        unsigned int cmd, unsigned long arg)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-  struct cyclades_icount cprev, cnow;          /* kernel counter temps */
-  struct serial_icounter_struct __user *p_cuser;       /* user space */
-  int ret_val = 0;
-  unsigned long flags;
-  void __user *argp = (void __user *)arg;
-
-    if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
-       return -ENODEV;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       struct cyclades_icount cprev, cnow;     /* kernel counter temps */
+       struct serial_icounter_struct __user *p_cuser;  /* user space */
+       int ret_val = 0;
+       unsigned long flags;
+       void __user *argp = (void __user *)arg;
+
+       if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
+               return -ENODEV;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
-        info->line, cmd, arg); /* */
+       printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg);      /* */
 #endif
 
-    switch (cmd) {
-        case CYGETMON:
-            ret_val = get_mon_info(info, argp);
-            break;
-        case CYGETTHRESH:
-            ret_val = get_threshold(info, argp);
-            break;
-        case CYSETTHRESH:
-            ret_val = set_threshold(info, arg);
-            break;
-        case CYGETDEFTHRESH:
-            ret_val = get_default_threshold(info, argp);
-            break;
-        case CYSETDEFTHRESH:
-            ret_val = set_default_threshold(info, arg);
-            break;
-        case CYGETTIMEOUT:
-            ret_val = get_timeout(info, argp);
-            break;
-        case CYSETTIMEOUT:
-            ret_val = set_timeout(info, arg);
-            break;
-        case CYGETDEFTIMEOUT:
-            ret_val = get_default_timeout(info, argp);
-            break;
-        case CYSETDEFTIMEOUT:
-            ret_val = set_default_timeout(info, arg);
-            break;
+       switch (cmd) {
+       case CYGETMON:
+               ret_val = get_mon_info(info, argp);
+               break;
+       case CYGETTHRESH:
+               ret_val = get_threshold(info, argp);
+               break;
+       case CYSETTHRESH:
+               ret_val = set_threshold(info, arg);
+               break;
+       case CYGETDEFTHRESH:
+               ret_val = get_default_threshold(info, argp);
+               break;
+       case CYSETDEFTHRESH:
+               ret_val = set_default_threshold(info, arg);
+               break;
+       case CYGETTIMEOUT:
+               ret_val = get_timeout(info, argp);
+               break;
+       case CYSETTIMEOUT:
+               ret_val = set_timeout(info, arg);
+               break;
+       case CYGETDEFTIMEOUT:
+               ret_val = get_default_timeout(info, argp);
+               break;
+       case CYSETDEFTIMEOUT:
+               ret_val = set_default_timeout(info, arg);
+               break;
        case CYSETRFLOW:
-           info->rflow = (int)arg;
-           ret_val = 0;
-           break;
+               info->rflow = (int)arg;
+               ret_val = 0;
+               break;
        case CYGETRFLOW:
-           ret_val = info->rflow;
-           break;
+               ret_val = info->rflow;
+               break;
        case CYSETRTSDTR_INV:
-           info->rtsdtr_inv = (int)arg;
-           ret_val = 0;
-           break;
+               info->rtsdtr_inv = (int)arg;
+               ret_val = 0;
+               break;
        case CYGETRTSDTR_INV:
-           ret_val = info->rtsdtr_inv;
-           break;
+               ret_val = info->rtsdtr_inv;
+               break;
        case CYGETCARDINFO:
-            if (copy_to_user(argp, &cy_card[info->card], 
-                       sizeof (struct cyclades_card))) {
-               ret_val = -EFAULT;
+               if (copy_to_user(argp, &cy_card[info->card],
+                                sizeof(struct cyclades_card))) {
+                       ret_val = -EFAULT;
+                       break;
+               }
+               ret_val = 0;
                break;
-           }
-           ret_val = 0;
-            break;
        case CYGETCD1400VER:
-           ret_val = info->chip_rev;
-           break;
+               ret_val = info->chip_rev;
+               break;
 #ifndef CONFIG_CYZ_INTR
        case CYZSETPOLLCYCLE:
-            cyz_polling_cycle = (arg * HZ) / 1000;
-           ret_val = 0;
-           break;
+               cyz_polling_cycle = (arg * HZ) / 1000;
+               ret_val = 0;
+               break;
        case CYZGETPOLLCYCLE:
-            ret_val = (cyz_polling_cycle * 1000) / HZ;
-           break;
-#endif /* CONFIG_CYZ_INTR */
+               ret_val = (cyz_polling_cycle * 1000) / HZ;
+               break;
+#endif                         /* CONFIG_CYZ_INTR */
        case CYSETWAIT:
-           info->closing_wait = (unsigned short)arg * HZ/100;
-           ret_val = 0;
-           break;
+               info->closing_wait = (unsigned short)arg *HZ / 100;
+               ret_val = 0;
+               break;
        case CYGETWAIT:
-           ret_val = info->closing_wait / (HZ/100);
-           break;
-        case TIOCGSERIAL:
-            ret_val = get_serial_info(info, argp);
-            break;
-        case TIOCSSERIAL:
-            ret_val = set_serial_info(info, argp);
-            break;
-       case TIOCSERGETLSR: /* Get line status register */
-           ret_val = get_lsr_info(info, argp);
-           break;
-       /*
-        * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change 
-        * - mask passed in arg for lines of interest
-        *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
-        * Caller should use TIOCGICOUNT to see which one it was
-        */
+               ret_val = info->closing_wait / (HZ / 100);
+               break;
+       case TIOCGSERIAL:
+               ret_val = get_serial_info(info, argp);
+               break;
+       case TIOCSSERIAL:
+               ret_val = set_serial_info(info, argp);
+               break;
+       case TIOCSERGETLSR:     /* Get line status register */
+               ret_val = get_lsr_info(info, argp);
+               break;
+               /*
+                * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
+                * - mask passed in arg for lines of interest
+                *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
+                * Caller should use TIOCGICOUNT to see which one it was
+                */
        case TIOCMIWAIT:
-           CY_LOCK(info, flags);
-           /* note the counters on entry */
-           cprev = info->icount;
-           CY_UNLOCK(info, flags);
-           while (1) {
-               interruptible_sleep_on(&info->delta_msr_wait);
-               /* see if a signal did it */
-               if (signal_pending(current)) {
-                   return -ERESTARTSYS;
-               }
-
                CY_LOCK(info, flags);
-               cnow = info->icount; /* atomic copy */
+               /* note the counters on entry */
+               cprev = info->icount;
                CY_UNLOCK(info, flags);
+               while (1) {
+                       interruptible_sleep_on(&info->delta_msr_wait);
+                       /* see if a signal did it */
+                       if (signal_pending(current)) {
+                               return -ERESTARTSYS;
+                       }
 
-               if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 
-                   cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
-                   return -EIO; /* no change => error */
-               }
-               if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 
-                    ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 
-                    ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) || 
-                    ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
-                   return 0;
-               }
-               cprev = cnow;
-           }
-           /* NOTREACHED */
+                       CY_LOCK(info, flags);
+                       cnow = info->icount;    /* atomic copy */
+                       CY_UNLOCK(info, flags);
 
-       /*
-        * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
-        * Return: write counters to the user passed counter struct
-        * NB: both 1->0 and 0->1 transitions are counted except for
-        *     RI where only 0->1 is counted.
-        */
+                       if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
+                           cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
+                               return -EIO;    /* no change => error */
+                       }
+                       if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+                           ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+                           ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
+                           ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
+                               return 0;
+                       }
+                       cprev = cnow;
+               }
+               /* NOTREACHED */
+
+               /*
+                * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
+                * Return: write counters to the user passed counter struct
+                * NB: both 1->0 and 0->1 transitions are counted except for
+                *     RI where only 0->1 is counted.
+                */
        case TIOCGICOUNT:
-           CY_LOCK(info, flags);
-           cnow = info->icount;
-           CY_UNLOCK(info, flags);
-           p_cuser = argp;
-           ret_val = put_user(cnow.cts, &p_cuser->cts);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.dsr, &p_cuser->dsr);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.rng, &p_cuser->rng);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.dcd, &p_cuser->dcd);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.rx, &p_cuser->rx);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.tx, &p_cuser->tx);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.frame, &p_cuser->frame);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.overrun, &p_cuser->overrun);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.parity, &p_cuser->parity);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.brk, &p_cuser->brk);
-           if (ret_val) return ret_val;
-           ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
-           if (ret_val) return ret_val;
-           ret_val = 0;
-           break;
-        default:
-            ret_val = -ENOIOCTLCMD;
-    }
+               CY_LOCK(info, flags);
+               cnow = info->icount;
+               CY_UNLOCK(info, flags);
+               p_cuser = argp;
+               ret_val = put_user(cnow.cts, &p_cuser->cts);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.dsr, &p_cuser->dsr);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.rng, &p_cuser->rng);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.dcd, &p_cuser->dcd);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.rx, &p_cuser->rx);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.tx, &p_cuser->tx);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.frame, &p_cuser->frame);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.overrun, &p_cuser->overrun);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.parity, &p_cuser->parity);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.brk, &p_cuser->brk);
+               if (ret_val)
+                       return ret_val;
+               ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
+               if (ret_val)
+                       return ret_val;
+               ret_val = 0;
+               break;
+       default:
+               ret_val = -ENOIOCTLCMD;
+       }
 
 #ifdef CY_DEBUG_OTHER
-    printk(" cyc:cy_ioctl done\n");
+       printk(" cyc:cy_ioctl done\n");
 #endif
 
-    return ret_val;
-} /* cy_ioctl */
-
+       return ret_val;
+}                              /* cy_ioctl */
 
 /*
  * This routine allows the tty driver to be notified when
@@ -4100,66 +4210,64 @@ cy_ioctl(struct tty_struct *tty, struct file * file,
  * well-designed tty driver should be prepared to accept the case
  * where old == NULL, and try to do something rational.
  */
-static void
-cy_set_termios(struct tty_struct *tty, struct ktermios * old_termios)
+static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_set_termios ttyC%d\n", info->line);
+       printk("cyc:cy_set_termios ttyC%d\n", info->line);
 #endif
 
-    if ((tty->termios->c_cflag == old_termios->c_cflag) &&
-       ((tty->termios->c_iflag & (IXON|IXANY)) == 
-        (old_termios->c_iflag & (IXON|IXANY))))
-        return;
-    set_line_char(info);
-
-    if ((old_termios->c_cflag & CRTSCTS) &&
-        !(tty->termios->c_cflag & CRTSCTS)) {
-            tty->hw_stopped = 0;
-            cy_start(tty);
-    }
+       if (tty->termios->c_cflag == old_termios->c_cflag &&
+                       (tty->termios->c_iflag & (IXON | IXANY)) ==
+                       (old_termios->c_iflag & (IXON | IXANY)))
+               return;
+       set_line_char(info);
+
+       if ((old_termios->c_cflag & CRTSCTS) &&
+                       !(tty->termios->c_cflag & CRTSCTS)) {
+               tty->hw_stopped = 0;
+               cy_start(tty);
+       }
 #if 0
-    /*
-     * No need to wake up processes in open wait, since they
-     * sample the CLOCAL flag once, and don't recheck it.
-     * XXX  It's not clear whether the current behavior is correct
-     * or not.  Hence, this may change.....
-     */
-    if (!(old_termios->c_cflag & CLOCAL) &&
-        (tty->termios->c_cflag & CLOCAL))
-            wake_up_interruptible(&info->open_wait);
+       /*
+        * No need to wake up processes in open wait, since they
+        * sample the CLOCAL flag once, and don't recheck it.
+        * XXX  It's not clear whether the current behavior is correct
+        * or not.  Hence, this may change.....
+        */
+       if (!(old_termios->c_cflag & CLOCAL) &&
+           (tty->termios->c_cflag & CLOCAL))
+               wake_up_interruptible(&info->open_wait);
 #endif
-
-    return;
-} /* cy_set_termios */
+}                              /* cy_set_termios */
 
 /* This function is used to send a high-priority XON/XOFF character to
    the device.
 */
-static void
-cy_send_xchar (struct tty_struct *tty, char ch)
+static void cy_send_xchar(struct tty_struct *tty, char ch)
 {
-       struct cyclades_port *info = (struct cyclades_port *) tty->driver_data;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
        int card, channel;
 
-       if (serial_paranoia_check (info, tty->name, "cy_send_xchar"))
+       if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
                return;
 
-       info->x_char = ch;
+       info->x_char = ch;
 
        if (ch)
-               cy_start (tty);
+               cy_start(tty);
 
        card = info->card;
        channel = info->line - cy_card[card].first_line;
 
-       if (IS_CYC_Z (cy_card[card])) {
-               if (ch == STOP_CHAR (tty))
-                       cyz_issue_cmd (&cy_card[card], channel, C_CM_SENDXOFF, 0L);
-               else if (ch == START_CHAR (tty))
-                       cyz_issue_cmd (&cy_card[card], channel, C_CM_SENDXON, 0L);
+       if (IS_CYC_Z(cy_card[card])) {
+               if (ch == STOP_CHAR(tty))
+                       cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXOFF,
+                                       0L);
+               else if (ch == START_CHAR(tty))
+                       cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXON,
+                                       0L);
        }
 }
 
@@ -4167,260 +4275,247 @@ cy_send_xchar (struct tty_struct *tty, char ch)
    that incoming characters should be throttled because the input
    buffers are close to full.
  */
-static void
-cy_throttle(struct tty_struct * tty)
+static void cy_throttle(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       unsigned long flags;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
-  char buf[64];
+       char buf[64];
 
-    printk("cyc:throttle %s: %d....ttyC%d\n", 
-          tty_name(tty, buf),
-           tty->ldisc.chars_in_buffer(tty), info->line);
+       printk("cyc:throttle %s: %d....ttyC%d\n", tty_name(tty, buf),
+                       tty->ldisc.chars_in_buffer(tty), info->line);
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_throttle")){
-            return;
-    }
-
-    card = info->card;
-
-    if (I_IXOFF(tty)) {
-        if (!IS_CYC_Z (cy_card[card]))
-            cy_send_xchar (tty, STOP_CHAR (tty));
-        else
-            info->throttle = 1;
-    }
-
-    if (tty->termios->c_cflag & CRTSCTS) {
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
-            chip = channel>>2;
-            channel &= 0x03;
-            index = cy_card[card].bus_index;
-            base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-            CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-            if (info->rtsdtr_inv) {
-                cy_writeb(base_addr+(CyMSVR2<<index), ~CyDTR);
-             } else {
-                cy_writeb(base_addr+(CyMSVR1<<index), ~CyRTS);
-            }
-           CY_UNLOCK(info, flags);
-       } else {
-           info->throttle = 1;
-        }
-    }
+       if (serial_paranoia_check(info, tty->name, "cy_throttle")) {
+               return;
+       }
 
-    return;
-} /* cy_throttle */
+       card = info->card;
+
+       if (I_IXOFF(tty)) {
+               if (!IS_CYC_Z(cy_card[card]))
+                       cy_send_xchar(tty, STOP_CHAR(tty));
+               else
+                       info->throttle = 1;
+       }
 
+       if (tty->termios->c_cflag & CRTSCTS) {
+               channel = info->line - cy_card[card].first_line;
+               if (!IS_CYC_Z(cy_card[card])) {
+                       chip = channel >> 2;
+                       channel &= 0x03;
+                       index = cy_card[card].bus_index;
+                       base_addr = cy_card[card].base_addr +
+                               (cy_chip_offset[chip] << index);
+
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         ~CyDTR);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         ~CyRTS);
+                       }
+                       CY_UNLOCK(info, flags);
+               } else {
+                       info->throttle = 1;
+               }
+       }
+}                              /* cy_throttle */
 
 /*
  * This routine notifies the tty driver that it should signal
  * that characters can now be sent to the tty without fear of
  * overrunning the input buffers of the line disciplines.
  */
-static void
-cy_unthrottle(struct tty_struct * tty)
+static void cy_unthrottle(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  unsigned long flags;
-  void __iomem *base_addr;
-  int card,chip,channel,index;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       unsigned long flags;
+       void __iomem *base_addr;
+       int card, chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
-  char buf[64];
-        
-    printk("cyc:unthrottle %s: %d....ttyC%d\n", 
-          tty_name(tty, buf),
-           tty->ldisc.chars_in_buffer(tty), info->line);
-#endif
+       char buf[64];
 
-    if (serial_paranoia_check(info, tty->name, "cy_unthrottle")){
-            return;
-    }
+       printk("cyc:unthrottle %s: %d....ttyC%d\n", tty_name(tty, buf),
+               tty->ldisc.chars_in_buffer(tty), info->line);
+#endif
 
-    if (I_IXOFF(tty)) {
-       if (info->x_char)
-           info->x_char = 0;
-       else
-           cy_send_xchar (tty, START_CHAR (tty));
-    }
-
-    if (tty->termios->c_cflag & CRTSCTS) {
-        card = info->card;
-        channel = info->line - cy_card[card].first_line;
-        if (!IS_CYC_Z(cy_card[card])) {
-           chip = channel>>2;
-           channel &= 0x03;
-           index = cy_card[card].bus_index;
-           base_addr = cy_card[card].base_addr + (cy_chip_offset[chip]<<index);
-
-           CY_LOCK(info, flags);
-           cy_writeb(base_addr+(CyCAR<<index), (u_char)channel);
-           if (info->rtsdtr_inv) {
-                   cy_writeb(base_addr+(CyMSVR2<<index), CyDTR);
-           } else {
-                   cy_writeb(base_addr+(CyMSVR1<<index), CyRTS);
-           }
-           CY_UNLOCK(info, flags);
-        } else {
-           info->throttle = 0;
+       if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
+               return;
        }
-    }
 
-    return;
-} /* cy_unthrottle */
+       if (I_IXOFF(tty)) {
+               if (info->x_char)
+                       info->x_char = 0;
+               else
+                       cy_send_xchar(tty, START_CHAR(tty));
+       }
 
+       if (tty->termios->c_cflag & CRTSCTS) {
+               card = info->card;
+               channel = info->line - cy_card[card].first_line;
+               if (!IS_CYC_Z(cy_card[card])) {
+                       chip = channel >> 2;
+                       channel &= 0x03;
+                       index = cy_card[card].bus_index;
+                       base_addr = cy_card[card].base_addr +
+                               (cy_chip_offset[chip] << index);
+
+                       CY_LOCK(info, flags);
+                       cy_writeb(base_addr + (CyCAR << index),
+                                 (u_char) channel);
+                       if (info->rtsdtr_inv) {
+                               cy_writeb(base_addr + (CyMSVR2 << index),
+                                         CyDTR);
+                       } else {
+                               cy_writeb(base_addr + (CyMSVR1 << index),
+                                         CyRTS);
+                       }
+                       CY_UNLOCK(info, flags);
+               } else {
+                       info->throttle = 0;
+               }
+       }
+}                              /* cy_unthrottle */
 
 /* cy_start and cy_stop provide software output flow control as a
    function of XON/XOFF, software CTS, and other such stuff.
 */
-static void
-cy_stop(struct tty_struct *tty)
+static void cy_stop(struct tty_struct *tty)
 {
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  void __iomem *base_addr;
-  int chip,channel,index;
-  unsigned long flags;
+       struct cyclades_card *cinfo;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       void __iomem *base_addr;
+       int chip, channel, index;
+       unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_stop ttyC%d\n", info->line); /* */
+       printk("cyc:cy_stop ttyC%d\n", info->line);     /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_stop"))
-        return;
-        
-    cinfo = &cy_card[info->card];
-    channel = info->line - cinfo->first_line;
-    if (!IS_CYC_Z(*cinfo)) {
-        index = cinfo->bus_index;
-        chip = channel>>2;
-        channel &= 0x03;
-        base_addr = cy_card[info->card].base_addr + (cy_chip_offset[chip]<<index);
-
-       CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index),
-              (u_char)(channel & 0x0003)); /* index channel */
-            cy_writeb(base_addr+(CySRER<<index), 
-               cy_readb(base_addr+(CySRER<<index)) & ~CyTxRdy);
-       CY_UNLOCK(info, flags);
-    } else {
-       // Nothing to do!
-    }
+       if (serial_paranoia_check(info, tty->name, "cy_stop"))
+               return;
 
-    return;
-} /* cy_stop */
+       cinfo = &cy_card[info->card];
+       channel = info->line - cinfo->first_line;
+       if (!IS_CYC_Z(*cinfo)) {
+               index = cinfo->bus_index;
+               chip = channel >> 2;
+               channel &= 0x03;
+               base_addr = cy_card[info->card].base_addr +
+                       (cy_chip_offset[chip] << index);
 
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyCAR << index),
+                       (u_char)(channel & 0x0003)); /* index channel */
+               cy_writeb(base_addr + (CySRER << index),
+                         cy_readb(base_addr + (CySRER << index)) & ~CyTxRdy);
+               CY_UNLOCK(info, flags);
+       } else {
+               /* Nothing to do! */
+       }
+}                              /* cy_stop */
 
-static void
-cy_start(struct tty_struct *tty)
+static void cy_start(struct tty_struct *tty)
 {
-  struct cyclades_card *cinfo;
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  void __iomem *base_addr;
-  int chip,channel,index;
-  unsigned long flags;
+       struct cyclades_card *cinfo;
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       void __iomem *base_addr;
+       int chip, channel, index;
+       unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_start ttyC%d\n", info->line); /* */
+       printk("cyc:cy_start ttyC%d\n", info->line);    /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_start"))
-        return;
-        
-    cinfo = &cy_card[info->card];
-    channel = info->line - cinfo->first_line;
-    index = cinfo->bus_index;
-    if (!IS_CYC_Z(*cinfo)) {
-        chip = channel>>2;
-        channel &= 0x03;
-        base_addr = cy_card[info->card].base_addr + (cy_chip_offset[chip]<<index);
-
-       CY_LOCK(info, flags);
-            cy_writeb(base_addr+(CyCAR<<index),
-              (u_char)(channel & 0x0003)); /* index channel */
-            cy_writeb(base_addr+(CySRER<<index), 
-               cy_readb(base_addr+(CySRER<<index)) | CyTxRdy);
-       CY_UNLOCK(info, flags);
-    } else {
-       // Nothing to do!
-    }
+       if (serial_paranoia_check(info, tty->name, "cy_start"))
+               return;
 
-    return;
-} /* cy_start */
+       cinfo = &cy_card[info->card];
+       channel = info->line - cinfo->first_line;
+       index = cinfo->bus_index;
+       if (!IS_CYC_Z(*cinfo)) {
+               chip = channel >> 2;
+               channel &= 0x03;
+               base_addr = cy_card[info->card].base_addr +
+                       (cy_chip_offset[chip] << index);
 
+               CY_LOCK(info, flags);
+               cy_writeb(base_addr + (CyCAR << index), (u_char) (channel & 0x0003));   /* index channel */
+               cy_writeb(base_addr + (CySRER << index),
+                         cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
+               CY_UNLOCK(info, flags);
+       } else {
+               /* Nothing to do! */
+       }
+}                              /* cy_start */
 
-static void
-cy_flush_buffer(struct tty_struct *tty)
+static void cy_flush_buffer(struct tty_struct *tty)
 {
-  struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
-  int card, channel, retval;
-  unsigned long flags;
-                                
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+       int card, channel, retval;
+       unsigned long flags;
+
 #ifdef CY_DEBUG_IO
-    printk("cyc:cy_flush_buffer ttyC%d\n", info->line); /* */
+       printk("cyc:cy_flush_buffer ttyC%d\n", info->line);     /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
-        return;
-
-    card = info->card;
-    channel = (info->line) - (cy_card[card].first_line);
+       if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
+               return;
 
-    CY_LOCK(info, flags);
-    info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-    CY_UNLOCK(info, flags);
+       card = info->card;
+       channel = (info->line) - (cy_card[card].first_line);
 
-    if (IS_CYC_Z(cy_card[card])) { /* If it is a Z card, flush the on-board 
-                                     buffers as well */
        CY_LOCK(info, flags);
-       retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
-       if (retval != 0) {
-           printk("cyc: flush_buffer retval on ttyC%d was %x\n",
-                  info->line, retval);
-       }
+       info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
        CY_UNLOCK(info, flags);
-    }
-    tty_wakeup(tty);
-    wake_up_interruptible(&tty->write_wait);
-} /* cy_flush_buffer */
 
+       if (IS_CYC_Z(cy_card[card])) {  /* If it is a Z card, flush the on-board
+                                          buffers as well */
+               CY_LOCK(info, flags);
+               retval =
+                   cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
+               if (retval != 0) {
+                       printk("cyc: flush_buffer retval on ttyC%d was %x\n",
+                               info->line, retval);
+               }
+               CY_UNLOCK(info, flags);
+       }
+       tty_wakeup(tty);
+}                              /* cy_flush_buffer */
 
 /*
  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
  */
-static void
-cy_hangup(struct tty_struct *tty)
+static void cy_hangup(struct tty_struct *tty)
 {
-  struct cyclades_port * info = (struct cyclades_port *)tty->driver_data;
-        
+       struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
+
 #ifdef CY_DEBUG_OTHER
-    printk("cyc:cy_hangup ttyC%d\n", info->line); /* */
+       printk("cyc:cy_hangup ttyC%d\n", info->line);   /* */
 #endif
 
-    if (serial_paranoia_check(info, tty->name, "cy_hangup"))
-        return;
+       if (serial_paranoia_check(info, tty->name, "cy_hangup"))
+               return;
 
-    cy_flush_buffer(tty);
-    shutdown(info);
-    info->event = 0;
-    info->count = 0;
+       cy_flush_buffer(tty);
+       shutdown(info);
+       info->event = 0;
+       info->count = 0;
 #ifdef CY_DEBUG_COUNT
-    printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
+       printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
 #endif
-    info->tty = NULL;
-    info->flags &= ~ASYNC_NORMAL_ACTIVE;
-    wake_up_interruptible(&info->open_wait);
-} /* cy_hangup */
-
+       info->tty = NULL;
+       info->flags &= ~ASYNC_NORMAL_ACTIVE;
+       wake_up_interruptible(&info->open_wait);
+}                              /* cy_hangup */
 
 /*
  * ---------------------------------------------------------------------
@@ -4433,82 +4528,84 @@ cy_hangup(struct tty_struct *tty)
 /* initialize chips on Cyclom-Y card -- return number of valid
    chips (which is number of ports/4) */
 static unsigned short __init
-cyy_init_card(void __iomem *true_base_addr,int index)
+cyy_init_card(void __iomem * true_base_addr, int index)
 {
-  unsigned int chip_number;
-  void __iomem *base_addr;
-
-    cy_writeb(true_base_addr+(Cy_HwReset<<index), 0); 
-                                               /* Cy_HwReset is 0x1400 */
-    cy_writeb(true_base_addr+(Cy_ClrIntr<<index), 0); 
-                                               /* Cy_ClrIntr is 0x1800 */
-    udelay(500L);
-
-    for(chip_number=0; chip_number<CyMAX_CHIPS_PER_CARD; chip_number++){
-        base_addr = true_base_addr + (cy_chip_offset[chip_number]<<index);
-        mdelay(1);
-        if(cy_readb(base_addr+(CyCCR<<index)) != 0x00){
-            /*************
-            printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
-               chip_number, (unsigned long)base_addr);
-            *************/
-            return chip_number;
-        }
-
-        cy_writeb(base_addr+(CyGFRCR<<index), 0);
-        udelay(10L);
-
-        /* The Cyclom-16Y does not decode address bit 9 and therefore
-           cannot distinguish between references to chip 0 and a non-
-           existent chip 4.  If the preceding clearing of the supposed
-           chip 4 GFRCR register appears at chip 0, there is no chip 4
-           and this must be a Cyclom-16Y, not a Cyclom-32Ye.
-        */
-        if (chip_number == 4
-        && cy_readb(true_base_addr
-           + (cy_chip_offset[0]<<index)
-           + (CyGFRCR<<index)) == 0){
-            return chip_number;
-        }
-
-        cy_writeb(base_addr+(CyCCR<<index), CyCHIP_RESET);
-        mdelay(1);
-
-        if(cy_readb(base_addr+(CyGFRCR<<index)) == 0x00){
-            /*
-            printk(" chip #%d at %#6lx is not responding ",
-               chip_number, (unsigned long)base_addr);
-            printk("(GFRCR stayed 0)\n",
-            */
-            return chip_number;
-        }
-        if((0xf0 & (cy_readb(base_addr+(CyGFRCR<<index)))) != 0x40){
-            /*
-            printk(" chip #%d at %#6lx is not valid (GFRCR == %#2x)\n",
-               chip_number, (unsigned long)base_addr,
-              base_addr[CyGFRCR<<index]);
-            */
-            return chip_number;
-        }
-        cy_writeb(base_addr+(CyGCR<<index), CyCH0_SERIAL);
-        if (cy_readb(base_addr+(CyGFRCR<<index)) >= CD1400_REV_J){
-           /* It is a CD1400 rev. J or later */
-           /* Impossible to reach 5ms with this chip. 
-              Changed to 2ms instead (f = 500 Hz). */
-           cy_writeb(base_addr+(CyPPR<<index), CyCLOCK_60_2MS);
-       } else {
-           /* f = 200 Hz */
-           cy_writeb(base_addr+(CyPPR<<index), CyCLOCK_25_5MS);
-       }
+       unsigned int chip_number;
+       void __iomem *base_addr;
+
+       cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
+       /* Cy_HwReset is 0x1400 */
+       cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
+       /* Cy_ClrIntr is 0x1800 */
+       udelay(500L);
+
+       for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD; chip_number++) {
+               base_addr =
+                   true_base_addr + (cy_chip_offset[chip_number] << index);
+               mdelay(1);
+               if (cy_readb(base_addr + (CyCCR << index)) != 0x00) {
+                       /*************
+                       printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
+                       chip_number, (unsigned long)base_addr);
+                       *************/
+                       return chip_number;
+               }
+
+               cy_writeb(base_addr + (CyGFRCR << index), 0);
+               udelay(10L);
+
+               /* The Cyclom-16Y does not decode address bit 9 and therefore
+                  cannot distinguish between references to chip 0 and a non-
+                  existent chip 4.  If the preceding clearing of the supposed
+                  chip 4 GFRCR register appears at chip 0, there is no chip 4
+                  and this must be a Cyclom-16Y, not a Cyclom-32Ye.
+                */
+               if (chip_number == 4 && cy_readb(true_base_addr +
+                               (cy_chip_offset[0] << index) +
+                               (CyGFRCR << index)) == 0) {
+                       return chip_number;
+               }
+
+               cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
+               mdelay(1);
+
+               if (cy_readb(base_addr + (CyGFRCR << index)) == 0x00) {
+                       /*
+                          printk(" chip #%d at %#6lx is not responding ",
+                          chip_number, (unsigned long)base_addr);
+                          printk("(GFRCR stayed 0)\n",
+                        */
+                       return chip_number;
+               }
+               if ((0xf0 & (cy_readb(base_addr + (CyGFRCR << index)))) !=
+                               0x40) {
+                       /*
+                       printk(" chip #%d at %#6lx is not valid (GFRCR == "
+                                       "%#2x)\n",
+                                       chip_number, (unsigned long)base_addr,
+                                       base_addr[CyGFRCR<<index]);
+                        */
+                       return chip_number;
+               }
+               cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
+               if (cy_readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
+                       /* It is a CD1400 rev. J or later */
+                       /* Impossible to reach 5ms with this chip.
+                          Changed to 2ms instead (f = 500 Hz). */
+                       cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
+               } else {
+                       /* f = 200 Hz */
+                       cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
+               }
 
-    /*
-        printk(" chip #%d at %#6lx is rev 0x%2x\n",
-               chip_number, (unsigned long)base_addr,
-              cy_readb(base_addr+(CyGFRCR<<index)));
-    */
-    }
-    return chip_number;
-} /* cyy_init_card */
+               /*
+                  printk(" chip #%d at %#6lx is rev 0x%2x\n",
+                  chip_number, (unsigned long)base_addr,
+                  cy_readb(base_addr+(CyGFRCR<<index)));
+                */
+       }
+       return chip_number;
+}                              /* cyy_init_card */
 
 /*
  * ---------------------------------------------------------------------
@@ -4516,126 +4613,124 @@ cyy_init_card(void __iomem *true_base_addr,int index)
  * sets global variables and return the number of ISA boards found.
  * ---------------------------------------------------------------------
  */
-static int __init
-cy_detect_isa(void)
+static int __init cy_detect_isa(void)
 {
 #ifdef CONFIG_ISA
-  unsigned short       cy_isa_irq,nboard;
-  void __iomem         *cy_isa_address;
-  unsigned short       i,j,cy_isa_nchan;
+       unsigned short cy_isa_irq, nboard;
+       void __iomem *cy_isa_address;
+       unsigned short i, j, cy_isa_nchan;
 #ifdef MODULE
-  int isparam = 0;
+       int isparam = 0;
 #endif
 
-        nboard = 0;
+       nboard = 0;
 
 #ifdef MODULE
        /* Check for module parameters */
-       for(i = 0 ; i < NR_CARDS; i++) {
-           if (maddr[i] || i) {
-               isparam = 1;
-               cy_isa_addresses[i] = maddr[i];
-           }
-           if (!maddr[i])
-               break;
+       for (i = 0; i < NR_CARDS; i++) {
+               if (maddr[i] || i) {
+                       isparam = 1;
+                       cy_isa_addresses[i] = maddr[i];
+               }
+               if (!maddr[i])
+                       break;
        }
 #endif
 
-        /* scan the address table probing for Cyclom-Y/ISA boards */
-        for (i = 0 ; i < NR_ISA_ADDRS ; i++) {
-               unsigned int isa_address = cy_isa_addresses[i];
-                if (isa_address  == 0x0000) {
-                        return(nboard);
-                }
+       /* scan the address table probing for Cyclom-Y/ISA boards */
+       for (i = 0; i < NR_ISA_ADDRS; i++) {
+               unsigned int isa_address = cy_isa_addresses[i];
+               if (isa_address == 0x0000) {
+                       return nboard;
+               }
 
-                /* probe for CD1400... */
+               /* probe for CD1400... */
                cy_isa_address = ioremap(isa_address, CyISA_Ywin);
-                cy_isa_nchan = CyPORTS_PER_CHIP * 
-                     cyy_init_card(cy_isa_address,0);
-                if (cy_isa_nchan == 0) {
-                        continue;
-                }
-
+               cy_isa_nchan = CyPORTS_PER_CHIP *
+                       cyy_init_card(cy_isa_address, 0);
+               if (cy_isa_nchan == 0) {
+                       continue;
+               }
 #ifdef MODULE
                if (isparam && irq[i])
-                   cy_isa_irq = irq[i];
+                       cy_isa_irq = irq[i];
                else
 #endif
-                /* find out the board's irq by probing */
-                cy_isa_irq = detect_isa_irq(cy_isa_address);
-                if (cy_isa_irq == 0) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but the IRQ could not be detected.\n");
-                        continue;
-                }
-
-                if((cy_next_channel+cy_isa_nchan) > NR_PORTS) {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but no more channels are available.\n");
-                        printk("Change NR_PORTS in cyclades.c and recompile kernel.\n");
-                        return(nboard);
-                }
-                /* fill the next cy_card structure available */
-                for (j = 0 ; j < NR_CARDS ; j++) {
-                        if (cy_card[j].base_addr == 0)  break;
-                }
-                if (j == NR_CARDS) {    /* no more cy_cards available */
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but no more cards can be used .\n");
-                        printk("Change NR_CARDS in cyclades.c and recompile kernel.\n");
-                        return(nboard);
-                }
-
-                /* allocate IRQ */
-                if(request_irq(cy_isa_irq, cyy_interrupt,
-                                  IRQF_DISABLED, "Cyclom-Y", &cy_card[j]))
-                {
-                        printk("Cyclom-Y/ISA found at 0x%lx ",
-                                (unsigned long) cy_isa_address);
-                        printk("but could not allocate IRQ#%d.\n",
-                                cy_isa_irq);
-                        return(nboard);
-                }
-
-                /* set cy_card */
-                cy_card[j].base_addr = cy_isa_address;
-                cy_card[j].ctl_addr = NULL;
-                cy_card[j].irq = (int) cy_isa_irq;
-                cy_card[j].bus_index = 0;
-                cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = cy_isa_nchan/4;
-                nboard++;
-                        
-                /* print message */
-                printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
-                    j+1, (unsigned long) cy_isa_address,
-                    (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
-                   cy_isa_irq);
-                printk("%d channels starting from port %d.\n",
-                        cy_isa_nchan, cy_next_channel);
-                cy_next_channel += cy_isa_nchan;
-        }
-        return(nboard);
+                       /* find out the board's irq by probing */
+                       cy_isa_irq = detect_isa_irq(cy_isa_address);
+               if (cy_isa_irq == 0) {
+                       printk("Cyclom-Y/ISA found at 0x%lx ",
+                               (unsigned long)cy_isa_address);
+                       printk("but the IRQ could not be detected.\n");
+                       continue;
+               }
+
+               if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
+                       printk("Cyclom-Y/ISA found at 0x%lx ",
+                               (unsigned long)cy_isa_address);
+                       printk("but no more channels are available.\n");
+                       printk("Change NR_PORTS in cyclades.c and recompile "
+                                       "kernel.\n");
+                       return nboard;
+               }
+               /* fill the next cy_card structure available */
+               for (j = 0; j < NR_CARDS; j++) {
+                       if (cy_card[j].base_addr == 0)
+                               break;
+               }
+               if (j == NR_CARDS) {    /* no more cy_cards available */
+                       printk("Cyclom-Y/ISA found at 0x%lx ",
+                               (unsigned long)cy_isa_address);
+                       printk("but no more cards can be used .\n");
+                       printk("Change NR_CARDS in cyclades.c and recompile "
+                                       "kernel.\n");
+                       return nboard;
+               }
+
+               /* allocate IRQ */
+               if (request_irq(cy_isa_irq, cyy_interrupt,
+                               IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
+                       printk("Cyclom-Y/ISA found at 0x%lx ",
+                               (unsigned long)cy_isa_address);
+                       printk("but could not allocate IRQ#%d.\n", cy_isa_irq);
+                       return nboard;
+               }
+
+               /* set cy_card */
+               cy_card[j].base_addr = cy_isa_address;
+               cy_card[j].ctl_addr = NULL;
+               cy_card[j].irq = (int)cy_isa_irq;
+               cy_card[j].bus_index = 0;
+               cy_card[j].first_line = cy_next_channel;
+               cy_card[j].num_chips = cy_isa_nchan / 4;
+               nboard++;
+
+               /* print message */
+               printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
+                       j + 1, (unsigned long)cy_isa_address,
+                       (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
+                       cy_isa_irq);
+               printk("%d channels starting from port %d.\n",
+                       cy_isa_nchan, cy_next_channel);
+               cy_next_channel += cy_isa_nchan;
+