drivers/char/cyclades.c

   1 #undef  BLOCKMOVE
   2 #define Z_WAKE
   3 #undef  Z_EXT_CHARS_IN_BUFFER
   4
   5 /*
   6  *  linux/drivers/char/cyclades.c
   7  *
   8  * This file contains the driver for the Cyclades async multiport
   9  * serial boards.
  10  *
  11  * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
  12  * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
  13  *
  14  * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
  15  *
  16  * Much of the design and some of the code came from serial.c
  17  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
  18  * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
  19  * and then fixed as suggested by Michael K. Johnson 12/12/92.
  20  * Converted to pci probing and cleaned up by Jiri Slaby.
  21  *
  22  */
  23
  24 #define CY_VERSION      "2.6"
  25
  26 /* If you need to install more boards than NR_CARDS, change the constant
  27    in the definition below. No other change is necessary to support up to
  28    eight boards. Beyond that you'll have to extend cy_isa_addresses. */
  29
  30 #define NR_CARDS        4
  31
  32 /*
  33    If the total number of ports is larger than NR_PORTS, change this
  34    constant in the definition below. No other change is necessary to
  35    support more boards/ports. */
  36
  37 #define NR_PORTS        256
  38
  39 #define ZO_V1   0
  40 #define ZO_V2   1
  41 #define ZE_V1   2
  42
  43 #define SERIAL_PARANOIA_CHECK
  44 #undef  CY_DEBUG_OPEN
  45 #undef  CY_DEBUG_THROTTLE
  46 #undef  CY_DEBUG_OTHER
  47 #undef  CY_DEBUG_IO
  48 #undef  CY_DEBUG_COUNT
  49 #undef  CY_DEBUG_DTR
  50 #undef  CY_DEBUG_WAIT_UNTIL_SENT
  51 #undef  CY_DEBUG_INTERRUPTS
  52 #undef  CY_16Y_HACK
  53 #undef  CY_ENABLE_MONITORING
  54 #undef  CY_PCI_DEBUG
  55
  56 /*
  57  * Include section
  58  */
  59 #include <linux/module.h>
  60 #include <linux/errno.h>
  61 #include <linux/signal.h>
  62 #include <linux/sched.h>
  63 #include <linux/timer.h>
  64 #include <linux/interrupt.h>
  65 #include <linux/tty.h>
  66 #include <linux/tty_flip.h>
  67 #include <linux/serial.h>
  68 #include <linux/major.h>
  69 #include <linux/string.h>
  70 #include <linux/fcntl.h>
  71 #include <linux/ptrace.h>
  72 #include <linux/cyclades.h>
  73 #include <linux/mm.h>
  74 #include <linux/ioport.h>
  75 #include <linux/init.h>
  76 #include <linux/delay.h>
  77 #include <linux/spinlock.h>
  78 #include <linux/bitops.h>
  79 #include <linux/firmware.h>
  80 #include <linux/device.h>
  81 #include <linux/slab.h>
  82
  83 #include <linux/io.h>
  84 #include <linux/uaccess.h>
  85
  86 #include <linux/kernel.h>
  87 #include <linux/pci.h>
  88
  89 #include <linux/stat.h>
  90 #include <linux/proc_fs.h>
  91 #include <linux/seq_file.h>
  92
  93 static void cy_send_xchar(struct tty_struct *tty, char ch);
  94
  95 #ifndef SERIAL_XMIT_SIZE
  96 #define SERIAL_XMIT_SIZE        (min(PAGE_SIZE, 4096))
  97 #endif
  98
  99 #define STD_COM_FLAGS (0)
 100
 101 /* firmware stuff */
 102 #define ZL_MAX_BLOCKS   16
 103 #define DRIVER_VERSION  0x02010203
 104 #define RAM_SIZE 0x80000
 105
 106 enum zblock_type {
 107         ZBLOCK_PRG = 0,
 108         ZBLOCK_FPGA = 1
 109 };
 110
 111 struct zfile_header {
 112         char name[64];
 113         char date[32];
 114         char aux[32];
 115         u32 n_config;
 116         u32 config_offset;
 117         u32 n_blocks;
 118         u32 block_offset;
 119         u32 reserved[9];
 120 } __attribute__ ((packed));
 121
 122 struct zfile_config {
 123         char name[64];
 124         u32 mailbox;
 125         u32 function;
 126         u32 n_blocks;
 127         u32 block_list[ZL_MAX_BLOCKS];
 128 } __attribute__ ((packed));
 129
 130 struct zfile_block {
 131         u32 type;
 132         u32 file_offset;
 133         u32 ram_offset;
 134         u32 size;
 135 } __attribute__ ((packed));
 136
 137 static struct tty_driver *cy_serial_driver;
 138
 139 #ifdef CONFIG_ISA
 140 /* This is the address lookup table. The driver will probe for
 141    Cyclom-Y/ISA boards at all addresses in here. If you want the
 142    driver to probe addresses at a different address, add it to
 143    this table.  If the driver is probing some other board and
 144    causing problems, remove the offending address from this table.
 145 */
 146
 147 static unsigned int cy_isa_addresses[] = {
 148         0xD0000,
 149         0xD2000,
 150         0xD4000,
 151         0xD6000,
 152         0xD8000,
 153         0xDA000,
 154         0xDC000,
 155         0xDE000,
 156         0, 0, 0, 0, 0, 0, 0, 0
 157 };
 158
 159 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 160
 161 static long maddr[NR_CARDS];
 162 static int irq[NR_CARDS];
 163
 164 module_param_array(maddr, long, NULL, 0);
 165 module_param_array(irq, int, NULL, 0);
 166
 167 #endif                          /* CONFIG_ISA */
 168
 169 /* This is the per-card data structure containing address, irq, number of
 170    channels, etc. This driver supports a maximum of NR_CARDS cards.
 171 */
 172 static struct cyclades_card cy_card[NR_CARDS];
 173
 174 static int cy_next_channel;     /* next minor available */
 175
 176 /*
 177  * This is used to look up the divisor speeds and the timeouts
 178  * We're normally limited to 15 distinct baud rates.  The extra
 179  * are accessed via settings in info->port.flags.
 180  *      0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
 181  *     10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 182  *                                               HI            VHI
 183  *     20
 184  */
 185 static const int baud_table[] = {
 186         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
 187         1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
 188         230400, 0
 189 };
 190
 191 static const char baud_co_25[] = {      /* 25 MHz clock option table */
 192         /* value =>    00    01   02    03    04 */
 193         /* divide by    8    32   128   512  2048 */
 194         0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
 195         0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 196 };
 197
 198 static const char baud_bpr_25[] = {     /* 25 MHz baud rate period table */
 199         0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
 200         0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
 201 };
 202
 203 static const char baud_co_60[] = {      /* 60 MHz clock option table (CD1400 J) */
 204         /* value =>    00    01   02    03    04 */
 205         /* divide by    8    32   128   512  2048 */
 206         0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
 207         0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 208         0x00
 209 };
 210
 211 static const char baud_bpr_60[] = {     /* 60 MHz baud rate period table (CD1400 J) */
 212         0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
 213         0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
 214         0x21
 215 };
 216
 217 static const char baud_cor3[] = {       /* receive threshold */
 218         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 219         0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
 220         0x07
 221 };
 222
 223 /*
 224  * The Cyclades driver implements HW flow control as any serial driver.
 225  * The cyclades_port structure member rflow and the vector rflow_thr
 226  * allows us to take advantage of a special feature in the CD1400 to avoid
 227  * data loss even when the system interrupt latency is too high. These flags
 228  * are to be used only with very special applications. Setting these flags
 229  * requires the use of a special cable (DTR and RTS reversed). In the new
 230  * CD1400-based boards (rev. 6.00 or later), there is no need for special
 231  * cables.
 232  */
 233
 234 static const char rflow_thr[] = {       /* rflow threshold */
 235         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 236         0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 237         0x0a
 238 };
 239
 240 /*  The Cyclom-Ye has placed the sequential chips in non-sequential
 241  *  address order.  This look-up table overcomes that problem.
 242  */
 243 static const unsigned int cy_chip_offset[] = { 0x0000,
 244         0x0400,
 245         0x0800,
 246         0x0C00,
 247         0x0200,
 248         0x0600,
 249         0x0A00,
 250         0x0E00
 251 };
 252
 253 /* PCI related definitions */
 254
 255 #ifdef CONFIG_PCI
 256 static const struct pci_device_id cy_pci_dev_id[] = {
 257         /* PCI < 1Mb */
 258         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
 259         /* PCI > 1Mb */
 260         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },
 261         /* 4Y PCI < 1Mb */
 262         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },
 263         /* 4Y PCI > 1Mb */
 264         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },
 265         /* 8Y PCI < 1Mb */
 266         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },
 267         /* 8Y PCI > 1Mb */
 268         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },
 269         /* Z PCI < 1Mb */
 270         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },
 271         /* Z PCI > 1Mb */
 272         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },
 273         { }                     /* end of table */
 274 };
 275 MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
 276 #endif
 277
 278 static void cy_start(struct tty_struct *);
 279 static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
 280 static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
 281 #ifdef CONFIG_ISA
 282 static unsigned detect_isa_irq(void __iomem *);
 283 #endif                          /* CONFIG_ISA */
 284
 285 #ifndef CONFIG_CYZ_INTR
 286 static void cyz_poll(unsigned long);
 287
 288 /* The Cyclades-Z polling cycle is defined by this variable */
 289 static long cyz_polling_cycle = CZ_DEF_POLL;
 290
 291 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
 292
 293 #else                           /* CONFIG_CYZ_INTR */
 294 static void cyz_rx_restart(unsigned long);
 295 static struct timer_list cyz_rx_full_timer[NR_PORTS];
 296 #endif                          /* CONFIG_CYZ_INTR */
 297
 298 static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
 299 {
 300         struct cyclades_card *card = port->card;
 301
 302         cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
 303 }
 304
 305 static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
 306 {
 307         struct cyclades_card *card = port->card;
 308
 309         return readb(port->u.cyy.base_addr + (reg << card->bus_index));
 310 }
 311
 312 static inline bool cy_is_Z(struct cyclades_card *card)
 313 {
 314         return card->num_chips == (unsigned int)-1;
 315 }
 316
 317 static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
 318 {
 319         return readl(&ctl_addr->init_ctrl) & (1 << 17);
 320 }
 321
 322 static inline bool cyz_fpga_loaded(struct cyclades_card *card)
 323 {
 324         return __cyz_fpga_loaded(card->ctl_addr.p9060);
 325 }
 326
 327 static inline bool cyz_is_loaded(struct cyclades_card *card)
 328 {
 329         struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
 330
 331         return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
 332                         readl(&fw_id->signature) == ZFIRM_ID;
 333 }
 334
 335 static inline int serial_paranoia_check(struct cyclades_port *info,
 336                 const char *name, const char *routine)
 337 {
 338 #ifdef SERIAL_PARANOIA_CHECK
 339         if (!info) {
 340                 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
 341                                 "in %s\n", name, routine);
 342                 return 1;
 343         }
 344
 345         if (info->magic != CYCLADES_MAGIC) {
 346                 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
 347                                 "struct (%s) in %s\n", name, routine);
 348                 return 1;
 349         }
 350 #endif
 351         return 0;
 352 }
 353
 354 /***********************************************************/
 355 /********* Start of block of Cyclom-Y specific code ********/
 356
 357 /* This routine waits up to 1000 micro-seconds for the previous
 358    command to the Cirrus chip to complete and then issues the
 359    new command.  An error is returned if the previous command
 360    didn't finish within the time limit.
 361
 362    This function is only called from inside spinlock-protected code.
 363  */
 364 static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
 365 {
 366         void __iomem *ccr = base_addr + (CyCCR << index);
 367         unsigned int i;
 368
 369         /* Check to see that the previous command has completed */
 370         for (i = 0; i < 100; i++) {
 371                 if (readb(ccr) == 0)
 372                         break;
 373                 udelay(10L);
 374         }
 375         /* if the CCR never cleared, the previous command
 376            didn't finish within the "reasonable time" */
 377         if (i == 100)
 378                 return -1;
 379
 380         /* Issue the new command */
 381         cy_writeb(ccr, cmd);
 382
 383         return 0;
 384 }
 385
 386 static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
 387 {
 388         return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
 389                         port->card->bus_index);
 390 }
 391
 392 #ifdef CONFIG_ISA
 393 /* ISA interrupt detection code */
 394 static unsigned detect_isa_irq(void __iomem *address)
 395 {
 396         int irq;
 397         unsigned long irqs, flags;
 398         int save_xir, save_car;
 399         int index = 0;          /* IRQ probing is only for ISA */
 400
 401         /* forget possible initially masked and pending IRQ */
 402         irq = probe_irq_off(probe_irq_on());
 403
 404         /* Clear interrupts on the board first */
 405         cy_writeb(address + (Cy_ClrIntr << index), 0);
 406         /* Cy_ClrIntr is 0x1800 */
 407
 408         irqs = probe_irq_on();
 409         /* Wait ... */
 410         msleep(5);
 411
 412         /* Enable the Tx interrupts on the CD1400 */
 413         local_irq_save(flags);
 414         cy_writeb(address + (CyCAR << index), 0);
 415         __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
 416
 417         cy_writeb(address + (CyCAR << index), 0);
 418         cy_writeb(address + (CySRER << index),
 419                   readb(address + (CySRER << index)) | CyTxRdy);
 420         local_irq_restore(flags);
 421
 422         /* Wait ... */
 423         msleep(5);
 424
 425         /* Check which interrupt is in use */
 426         irq = probe_irq_off(irqs);
 427
 428         /* Clean up */
 429         save_xir = (u_char) readb(address + (CyTIR << index));
 430         save_car = readb(address + (CyCAR << index));
 431         cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
 432         cy_writeb(address + (CySRER << index),
 433                   readb(address + (CySRER << index)) & ~CyTxRdy);
 434         cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
 435         cy_writeb(address + (CyCAR << index), (save_car));
 436         cy_writeb(address + (Cy_ClrIntr << index), 0);
 437         /* Cy_ClrIntr is 0x1800 */
 438
 439         return (irq > 0) ? irq : 0;
 440 }
 441 #endif                          /* CONFIG_ISA */
 442
 443 static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
 444                 void __iomem *base_addr)
 445 {
 446         struct cyclades_port *info;
 447         struct tty_struct *tty;
 448         int len, index = cinfo->bus_index;
 449         u8 ivr, save_xir, channel, save_car, data, char_count;
 450
 451 #ifdef CY_DEBUG_INTERRUPTS
 452         printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
 453 #endif
 454         /* determine the channel & change to that context */
 455         save_xir = readb(base_addr + (CyRIR << index));
 456         channel = save_xir & CyIRChannel;
 457         info = &cinfo->ports[channel + chip * 4];
 458         save_car = cyy_readb(info, CyCAR);
 459         cyy_writeb(info, CyCAR, save_xir);
 460         ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
 461
 462         tty = tty_port_tty_get(&info->port);
 463         /* if there is nowhere to put the data, discard it */
 464         if (tty == NULL) {
 465                 if (ivr == CyIVRRxEx) { /* exception */
 466                         data = cyy_readb(info, CyRDSR);
 467                 } else {        /* normal character reception */
 468                         char_count = cyy_readb(info, CyRDCR);
 469                         while (char_count--)
 470                                 data = cyy_readb(info, CyRDSR);
 471                 }
 472                 goto end;
 473         }
 474         /* there is an open port for this data */
 475         if (ivr == CyIVRRxEx) { /* exception */
 476                 data = cyy_readb(info, CyRDSR);
 477
 478                 /* For statistics only */
 479                 if (data & CyBREAK)
 480                         info->icount.brk++;
 481                 else if (data & CyFRAME)
 482                         info->icount.frame++;
 483                 else if (data & CyPARITY)
 484                         info->icount.parity++;
 485                 else if (data & CyOVERRUN)
 486                         info->icount.overrun++;
 487
 488                 if (data & info->ignore_status_mask) {
 489                         info->icount.rx++;
 490                         tty_kref_put(tty);
 491                         return;
 492                 }
 493                 if (tty_buffer_request_room(tty, 1)) {
 494                         if (data & info->read_status_mask) {
 495                                 if (data & CyBREAK) {
 496                                         tty_insert_flip_char(tty,
 497                                                 cyy_readb(info, CyRDSR),
 498                                                 TTY_BREAK);
 499                                         info->icount.rx++;
 500                                         if (info->port.flags & ASYNC_SAK)
 501                                                 do_SAK(tty);
 502                                 } else if (data & CyFRAME) {
 503                                         tty_insert_flip_char(tty,
 504                                                 cyy_readb(info, CyRDSR),
 505                                                 TTY_FRAME);
 506                                         info->icount.rx++;
 507                                         info->idle_stats.frame_errs++;
 508                                 } else if (data & CyPARITY) {
 509                                         /* Pieces of seven... */
 510                                         tty_insert_flip_char(tty,
 511                                                 cyy_readb(info, CyRDSR),
 512                                                 TTY_PARITY);
 513                                         info->icount.rx++;
 514                                         info->idle_stats.parity_errs++;
 515                                 } else if (data & CyOVERRUN) {
 516                                         tty_insert_flip_char(tty, 0,
 517                                                         TTY_OVERRUN);
 518                                         info->icount.rx++;
 519                                         /* If the flip buffer itself is
 520                                            overflowing, we still lose
 521                                            the next incoming character.
 522                                          */
 523                                         tty_insert_flip_char(tty,
 524                                                 cyy_readb(info, CyRDSR),
 525                                                 TTY_FRAME);
 526                                         info->icount.rx++;
 527                                         info->idle_stats.overruns++;
 528                                 /* These two conditions may imply */
 529                                 /* a normal read should be done. */
 530                                 /* } else if(data & CyTIMEOUT) { */
 531                                 /* } else if(data & CySPECHAR) { */
 532                                 } else {
 533                                         tty_insert_flip_char(tty, 0,
 534                                                         TTY_NORMAL);
 535                                         info->icount.rx++;
 536                                 }
 537                         } else {
 538                                 tty_insert_flip_char(tty, 0, TTY_NORMAL);
 539                                 info->icount.rx++;
 540                         }
 541                 } else {
 542                         /* there was a software buffer overrun and nothing
 543                          * could be done about it!!! */
 544                         info->icount.buf_overrun++;
 545                         info->idle_stats.overruns++;
 546                 }
 547         } else {        /* normal character reception */
 548                 /* load # chars available from the chip */
 549                 char_count = cyy_readb(info, CyRDCR);
 550
 551 #ifdef CY_ENABLE_MONITORING
 552                 ++info->mon.int_count;
 553                 info->mon.char_count += char_count;
 554                 if (char_count > info->mon.char_max)
 555                         info->mon.char_max = char_count;
 556                 info->mon.char_last = char_count;
 557 #endif
 558                 len = tty_buffer_request_room(tty, char_count);
 559                 while (len--) {
 560                         data = cyy_readb(info, CyRDSR);
 561                         tty_insert_flip_char(tty, data, TTY_NORMAL);
 562                         info->idle_stats.recv_bytes++;
 563                         info->icount.rx++;
 564 #ifdef CY_16Y_HACK
 565                         udelay(10L);
 566 #endif
 567                 }
 568                 info->idle_stats.recv_idle = jiffies;
 569         }
 570         tty_schedule_flip(tty);
 571         tty_kref_put(tty);
 572 end:
 573         /* end of service */
 574         cyy_writeb(info, CyRIR, save_xir & 0x3f);
 575         cyy_writeb(info, CyCAR, save_car);
 576 }
 577
 578 static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
 579                 void __iomem *base_addr)
 580 {
 581         struct cyclades_port *info;
 582         struct tty_struct *tty;
 583         int char_count, index = cinfo->bus_index;
 584         u8 save_xir, channel, save_car, outch;
 585
 586         /* Since we only get here when the transmit buffer
 587            is empty, we know we can always stuff a dozen
 588            characters. */
 589 #ifdef CY_DEBUG_INTERRUPTS
 590         printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
 591 #endif
 592
 593         /* determine the channel & change to that context */
 594         save_xir = readb(base_addr + (CyTIR << index));
 595         channel = save_xir & CyIRChannel;
 596         save_car = readb(base_addr + (CyCAR << index));
 597         cy_writeb(base_addr + (CyCAR << index), save_xir);
 598
 599         info = &cinfo->ports[channel + chip * 4];
 600         tty = tty_port_tty_get(&info->port);
 601         if (tty == NULL) {
 602                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
 603                 goto end;
 604         }
 605
 606         /* load the on-chip space for outbound data */
 607         char_count = info->xmit_fifo_size;
 608
 609         if (info->x_char) {     /* send special char */
 610                 outch = info->x_char;
 611                 cyy_writeb(info, CyTDR, outch);
 612                 char_count--;
 613                 info->icount.tx++;
 614                 info->x_char = 0;
 615         }
 616
 617         if (info->breakon || info->breakoff) {
 618                 if (info->breakon) {
 619                         cyy_writeb(info, CyTDR, 0);
 620                         cyy_writeb(info, CyTDR, 0x81);
 621                         info->breakon = 0;
 622                         char_count -= 2;
 623                 }
 624                 if (info->breakoff) {
 625                         cyy_writeb(info, CyTDR, 0);
 626                         cyy_writeb(info, CyTDR, 0x83);
 627                         info->breakoff = 0;
 628                         char_count -= 2;
 629                 }
 630         }
 631
 632         while (char_count-- > 0) {
 633                 if (!info->xmit_cnt) {
 634                         if (cyy_readb(info, CySRER) & CyTxMpty) {
 635                                 cyy_writeb(info, CySRER,
 636                                         cyy_readb(info, CySRER) & ~CyTxMpty);
 637                         } else {
 638                                 cyy_writeb(info, CySRER, CyTxMpty |
 639                                         (cyy_readb(info, CySRER) & ~CyTxRdy));
 640                         }
 641                         goto done;
 642                 }
 643                 if (info->port.xmit_buf == NULL) {
 644                         cyy_writeb(info, CySRER,
 645                                 cyy_readb(info, CySRER) & ~CyTxRdy);
 646                         goto done;
 647                 }
 648                 if (tty->stopped || tty->hw_stopped) {
 649                         cyy_writeb(info, CySRER,
 650                                 cyy_readb(info, CySRER) & ~CyTxRdy);
 651                         goto done;
 652                 }
 653                 /* Because the Embedded Transmit Commands have been enabled,
 654                  * we must check to see if the escape character, NULL, is being
 655                  * sent. If it is, we must ensure that there is room for it to
 656                  * be doubled in the output stream.  Therefore we no longer
 657                  * advance the pointer when the character is fetched, but
 658                  * rather wait until after the check for a NULL output
 659                  * character. This is necessary because there may not be room
 660                  * for the two chars needed to send a NULL.)
 661                  */
 662                 outch = info->port.xmit_buf[info->xmit_tail];
 663                 if (outch) {
 664                         info->xmit_cnt--;
 665                         info->xmit_tail = (info->xmit_tail + 1) &
 666                                         (SERIAL_XMIT_SIZE - 1);
 667                         cyy_writeb(info, CyTDR, outch);
 668                         info->icount.tx++;
 669                 } else {
 670                         if (char_count > 1) {
 671                                 info->xmit_cnt--;
 672                                 info->xmit_tail = (info->xmit_tail + 1) &
 673                                         (SERIAL_XMIT_SIZE - 1);
 674                                 cyy_writeb(info, CyTDR, outch);
 675                                 cyy_writeb(info, CyTDR, 0);
 676                                 info->icount.tx++;
 677                                 char_count--;
 678                         }
 679                 }
 680         }
 681
 682 done:
 683         tty_wakeup(tty);
 684         tty_kref_put(tty);
 685 end:
 686         /* end of service */
 687         cyy_writeb(info, CyTIR, save_xir & 0x3f);
 688         cyy_writeb(info, CyCAR, save_car);
 689 }
 690
 691 static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
 692                 void __iomem *base_addr)
 693 {
 694         struct cyclades_port *info;
 695         struct tty_struct *tty;
 696         int index = cinfo->bus_index;
 697         u8 save_xir, channel, save_car, mdm_change, mdm_status;
 698
 699         /* determine the channel & change to that context */
 700         save_xir = readb(base_addr + (CyMIR << index));
 701         channel = save_xir & CyIRChannel;
 702         info = &cinfo->ports[channel + chip * 4];
 703         save_car = cyy_readb(info, CyCAR);
 704         cyy_writeb(info, CyCAR, save_xir);
 705
 706         mdm_change = cyy_readb(info, CyMISR);
 707         mdm_status = cyy_readb(info, CyMSVR1);
 708
 709         tty = tty_port_tty_get(&info->port);
 710         if (!tty)
 711                 goto end;
 712
 713         if (mdm_change & CyANY_DELTA) {
 714                 /* For statistics only */
 715                 if (mdm_change & CyDCD)
 716                         info->icount.dcd++;
 717                 if (mdm_change & CyCTS)
 718                         info->icount.cts++;
 719                 if (mdm_change & CyDSR)
 720                         info->icount.dsr++;
 721                 if (mdm_change & CyRI)
 722                         info->icount.rng++;
 723
 724                 wake_up_interruptible(&info->port.delta_msr_wait);
 725         }
 726
 727         if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
 728                 if (mdm_status & CyDCD)
 729                         wake_up_interruptible(&info->port.open_wait);
 730                 else
 731                         tty_hangup(tty);
 732         }
 733         if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
 734                 if (tty->hw_stopped) {
 735                         if (mdm_status & CyCTS) {
 736                                 /* cy_start isn't used
 737                                    because... !!! */
 738                                 tty->hw_stopped = 0;
 739                                 cyy_writeb(info, CySRER,
 740                                         cyy_readb(info, CySRER) | CyTxRdy);
 741                                 tty_wakeup(tty);
 742                         }
 743                 } else {
 744                         if (!(mdm_status & CyCTS)) {
 745                                 /* cy_stop isn't used
 746                                    because ... !!! */
 747                                 tty->hw_stopped = 1;
 748                                 cyy_writeb(info, CySRER,
 749                                         cyy_readb(info, CySRER) & ~CyTxRdy);
 750                         }
 751                 }
 752         }
 753 /*      if (mdm_change & CyDSR) {
 754         }
 755         if (mdm_change & CyRI) {
 756         }*/
 757         tty_kref_put(tty);
 758 end:
 759         /* end of service */
 760         cyy_writeb(info, CyMIR, save_xir & 0x3f);
 761         cyy_writeb(info, CyCAR, save_car);
 762 }
 763
 764 /* The real interrupt service routine is called
 765    whenever the card wants its hand held--chars
 766    received, out buffer empty, modem change, etc.
 767  */
 768 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
 769 {
 770         int status;
 771         struct cyclades_card *cinfo = dev_id;
 772         void __iomem *base_addr, *card_base_addr;
 773         unsigned int chip, too_many, had_work;
 774         int index;
 775
 776         if (unlikely(cinfo == NULL)) {
 777 #ifdef CY_DEBUG_INTERRUPTS
 778                 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
 779                                 irq);
 780 #endif
 781                 return IRQ_NONE;        /* spurious interrupt */
 782         }
 783
 784         card_base_addr = cinfo->base_addr;
 785         index = cinfo->bus_index;
 786
 787         /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
 788         if (unlikely(card_base_addr == NULL))
 789                 return IRQ_HANDLED;
 790
 791         /* This loop checks all chips in the card.  Make a note whenever
 792            _any_ chip had some work to do, as this is considered an
 793            indication that there will be more to do.  Only when no chip
 794            has any work does this outermost loop exit.
 795          */
 796         do {
 797                 had_work = 0;
 798                 for (chip = 0; chip < cinfo->num_chips; chip++) {
 799                         base_addr = cinfo->base_addr +
 800                                         (cy_chip_offset[chip] << index);
 801                         too_many = 0;
 802                         while ((status = readb(base_addr +
 803                                                 (CySVRR << index))) != 0x00) {
 804                                 had_work++;
 805                         /* The purpose of the following test is to ensure that
 806                            no chip can monopolize the driver.  This forces the
 807                            chips to be checked in a round-robin fashion (after
 808                            draining each of a bunch (1000) of characters).
 809                          */
 810                                 if (1000 < too_many++)
 811                                         break;
 812                                 spin_lock(&cinfo->card_lock);
 813                                 if (status & CySRReceive) /* rx intr */
 814                                         cyy_chip_rx(cinfo, chip, base_addr);
 815                                 if (status & CySRTransmit) /* tx intr */
 816                                         cyy_chip_tx(cinfo, chip, base_addr);
 817                                 if (status & CySRModem) /* modem intr */
 818                                         cyy_chip_modem(cinfo, chip, base_addr);
 819                                 spin_unlock(&cinfo->card_lock);
 820                         }
 821                 }
 822         } while (had_work);
 823
 824         /* clear interrupts */
 825         spin_lock(&cinfo->card_lock);
 826         cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
 827         /* Cy_ClrIntr is 0x1800 */
 828         spin_unlock(&cinfo->card_lock);
 829         return IRQ_HANDLED;
 830 }                               /* cyy_interrupt */
 831
 832 static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
 833                 unsigned int clear)
 834 {
 835         struct cyclades_card *card = info->card;
 836         int channel = info->line - card->first_line;
 837         u32 rts, dtr, msvrr, msvrd;
 838
 839         channel &= 0x03;
 840
 841         if (info->rtsdtr_inv) {
 842                 msvrr = CyMSVR2;
 843                 msvrd = CyMSVR1;
 844                 rts = CyDTR;
 845                 dtr = CyRTS;
 846         } else {
 847                 msvrr = CyMSVR1;
 848                 msvrd = CyMSVR2;
 849                 rts = CyRTS;
 850                 dtr = CyDTR;
 851         }
 852         if (set & TIOCM_RTS) {
 853                 cyy_writeb(info, CyCAR, channel);
 854                 cyy_writeb(info, msvrr, rts);
 855         }
 856         if (clear & TIOCM_RTS) {
 857                 cyy_writeb(info, CyCAR, channel);
 858                 cyy_writeb(info, msvrr, ~rts);
 859         }
 860         if (set & TIOCM_DTR) {
 861                 cyy_writeb(info, CyCAR, channel);
 862                 cyy_writeb(info, msvrd, dtr);
 863 #ifdef CY_DEBUG_DTR
 864                 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
 865                 printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
 866                         cyy_readb(info, CyMSVR1),
 867                         cyy_readb(info, CyMSVR2));
 868 #endif
 869         }
 870         if (clear & TIOCM_DTR) {
 871                 cyy_writeb(info, CyCAR, channel);
 872                 cyy_writeb(info, msvrd, ~dtr);
 873 #ifdef CY_DEBUG_DTR
 874                 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
 875                 printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
 876                         cyy_readb(info, CyMSVR1),
 877                         cyy_readb(info, CyMSVR2));
 878 #endif
 879         }
 880 }
 881
 882 /***********************************************************/
 883 /********* End of block of Cyclom-Y specific code **********/
 884 /******** Start of block of Cyclades-Z specific code *******/
 885 /***********************************************************/
 886
 887 static int
 888 cyz_fetch_msg(struct cyclades_card *cinfo,
 889                 __u32 *channel, __u8 *cmd, __u32 *param)
 890 {
 891         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
 892         unsigned long loc_doorbell;
 893
 894         loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
 895         if (loc_doorbell) {
 896                 *cmd = (char)(0xff & loc_doorbell);
 897                 *channel = readl(&board_ctrl->fwcmd_channel);
 898                 *param = (__u32) readl(&board_ctrl->fwcmd_param);
 899                 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
 900                 return 1;
 901         }
 902         return 0;
 903 }                               /* cyz_fetch_msg */
 904
 905 static int
 906 cyz_issue_cmd(struct cyclades_card *cinfo,
 907                 __u32 channel, __u8 cmd, __u32 param)
 908 {
 909         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
 910         __u32 __iomem *pci_doorbell;
 911         unsigned int index;
 912
 913         if (!cyz_is_loaded(cinfo))
 914                 return -1;
 915
 916         index = 0;
 917         pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
 918         while ((readl(pci_doorbell) & 0xff) != 0) {
 919                 if (index++ == 1000)
 920                         return (int)(readl(pci_doorbell) & 0xff);
 921                 udelay(50L);
 922         }
 923         cy_writel(&board_ctrl->hcmd_channel, channel);
 924         cy_writel(&board_ctrl->hcmd_param, param);
 925         cy_writel(pci_doorbell, (long)cmd);
 926
 927         return 0;
 928 }                               /* cyz_issue_cmd */
 929
 930 static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
 931 {
 932         struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
 933         struct cyclades_card *cinfo = info->card;
 934         unsigned int char_count;
 935         int len;
 936 #ifdef BLOCKMOVE
 937         unsigned char *buf;
 938 #else
 939         char data;
 940 #endif
 941         __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
 942
 943         rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
 944         rx_put = readl(&buf_ctrl->rx_put);
 945         rx_bufsize = readl(&buf_ctrl->rx_bufsize);
 946         rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
 947         if (rx_put >= rx_get)
 948                 char_count = rx_put - rx_get;
 949         else
 950                 char_count = rx_put - rx_get + rx_bufsize;
 951
 952         if (char_count) {
 953 #ifdef CY_ENABLE_MONITORING
 954                 info->mon.int_count++;
 955                 info->mon.char_count += char_count;
 956                 if (char_count > info->mon.char_max)
 957                         info->mon.char_max = char_count;
 958                 info->mon.char_last = char_count;
 959 #endif
 960                 if (tty == NULL) {
 961                         /* flush received characters */
 962                         new_rx_get = (new_rx_get + char_count) &
 963                                         (rx_bufsize - 1);
 964                         info->rflush_count++;
 965                 } else {
 966 #ifdef BLOCKMOVE
 967                 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
 968                    for performance, but because of buffer boundaries, there
 969                    may be several steps to the operation */
 970                         while (1) {
 971                                 len = tty_prepare_flip_string(tty, &buf,
 972                                                 char_count);
 973                                 if (!len)
 974                                         break;
 975
 976                                 len = min_t(unsigned int, min(len, char_count),
 977                                                 rx_bufsize - new_rx_get);
 978
 979                                 memcpy_fromio(buf, cinfo->base_addr +
 980                                                 rx_bufaddr + new_rx_get, len);
 981
 982                                 new_rx_get = (new_rx_get + len) &
 983                                                 (rx_bufsize - 1);
 984                                 char_count -= len;
 985                                 info->icount.rx += len;
 986                                 info->idle_stats.recv_bytes += len;
 987                         }
 988 #else
 989                         len = tty_buffer_request_room(tty, char_count);
 990                         while (len--) {
 991                                 data = readb(cinfo->base_addr + rx_bufaddr +
 992                                                 new_rx_get);
 993                                 new_rx_get = (new_rx_get + 1) &
 994                                                         (rx_bufsize - 1);
 995                                 tty_insert_flip_char(tty, data, TTY_NORMAL);
 996                                 info->idle_stats.recv_bytes++;
 997                                 info->icount.rx++;
 998                         }
 999 #endif
1000 #ifdef CONFIG_CYZ_INTR
1001                 /* Recalculate the number of chars in the RX buffer and issue
1002                    a cmd in case it's higher than the RX high water mark */
1003                         rx_put = readl(&buf_ctrl->rx_put);
1004                         if (rx_put >= rx_get)
1005                                 char_count = rx_put - rx_get;
1006                         else
1007                                 char_count = rx_put - rx_get + rx_bufsize;
1008                         if (char_count >= readl(&buf_ctrl->rx_threshold) &&
1009                                         !timer_pending(&cyz_rx_full_timer[
1010                                                         info->line]))
1011                                 mod_timer(&cyz_rx_full_timer[info->line],
1012                                                 jiffies + 1);
1013 #endif
1014                         info->idle_stats.recv_idle = jiffies;
1015                         tty_schedule_flip(tty);
1016                 }
1017                 /* Update rx_get */
1018                 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1019         }
1020 }
1021
1022 static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
1023 {
1024         struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1025         struct cyclades_card *cinfo = info->card;
1026         u8 data;
1027         unsigned int char_count;
1028 #ifdef BLOCKMOVE
1029         int small_count;
1030 #endif
1031         __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1032
1033         if (info->xmit_cnt <= 0)        /* Nothing to transmit */
1034                 return;
1035
1036         tx_get = readl(&buf_ctrl->tx_get);
1037         tx_put = readl(&buf_ctrl->tx_put);
1038         tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1039         tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1040         if (tx_put >= tx_get)
1041                 char_count = tx_get - tx_put - 1 + tx_bufsize;
1042         else
1043                 char_count = tx_get - tx_put - 1;
1044
1045         if (char_count) {
1046
1047                 if (tty == NULL)
1048                         goto ztxdone;
1049
1050                 if (info->x_char) {     /* send special char */
1051                         data = info->x_char;
1052
1053                         cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1054                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
1055                         info->x_char = 0;
1056                         char_count--;
1057                         info->icount.tx++;
1058                 }
1059 #ifdef BLOCKMOVE
1060                 while (0 < (small_count = min_t(unsigned int,
1061                                 tx_bufsize - tx_put, min_t(unsigned int,
1062                                         (SERIAL_XMIT_SIZE - info->xmit_tail),
1063                                         min_t(unsigned int, info->xmit_cnt,
1064                                                 char_count))))) {
1065
1066                         memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1067                                         tx_put),
1068                                         &info->port.xmit_buf[info->xmit_tail],
1069                                         small_count);
1070
1071                         tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1072                         char_count -= small_count;
1073                         info->icount.tx += small_count;
1074                         info->xmit_cnt -= small_count;
1075                         info->xmit_tail = (info->xmit_tail + small_count) &
1076                                         (SERIAL_XMIT_SIZE - 1);
1077                 }
1078 #else
1079                 while (info->xmit_cnt && char_count) {
1080                         data = info->port.xmit_buf[info->xmit_tail];
1081                         info->xmit_cnt--;
1082                         info->xmit_tail = (info->xmit_tail + 1) &
1083                                         (SERIAL_XMIT_SIZE - 1);
1084
1085                         cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1086                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
1087                         char_count--;
1088                         info->icount.tx++;
1089                 }
1090 #endif
1091                 tty_wakeup(tty);
1092 ztxdone:
1093                 /* Update tx_put */
1094                 cy_writel(&buf_ctrl->tx_put, tx_put);
1095         }
1096 }
1097
1098 static void cyz_handle_cmd(struct cyclades_card *cinfo)
1099 {
1100         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1101         struct tty_struct *tty;
1102         struct cyclades_port *info;
1103         __u32 channel, param, fw_ver;
1104         __u8 cmd;
1105         int special_count;
1106         int delta_count;
1107
1108         fw_ver = readl(&board_ctrl->fw_version);
1109
1110         while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1111                 special_count = 0;
1112                 delta_count = 0;
1113                 info = &cinfo->ports[channel];
1114                 tty = tty_port_tty_get(&info->port);
1115                 if (tty == NULL)
1116                         continue;
1117
1118                 switch (cmd) {
1119                 case C_CM_PR_ERROR:
1120                         tty_insert_flip_char(tty, 0, TTY_PARITY);
1121                         info->icount.rx++;
1122                         special_count++;
1123                         break;
1124                 case C_CM_FR_ERROR:
1125                         tty_insert_flip_char(tty, 0, TTY_FRAME);
1126                         info->icount.rx++;
1127                         special_count++;
1128                         break;
1129                 case C_CM_RXBRK:
1130                         tty_insert_flip_char(tty, 0, TTY_BREAK);
1131                         info->icount.rx++;
1132                         special_count++;
1133                         break;
1134                 case C_CM_MDCD:
1135                         info->icount.dcd++;
1136                         delta_count++;
1137                         if (info->port.flags & ASYNC_CHECK_CD) {
1138                                 u32 dcd = fw_ver > 241 ? param :
1139                                         readl(&info->u.cyz.ch_ctrl->rs_status);
1140                                 if (dcd & C_RS_DCD)
1141                                         wake_up_interruptible(&info->port.open_wait);
1142                                 else
1143                                         tty_hangup(tty);
1144                         }
1145                         break;
1146                 case C_CM_MCTS:
1147                         info->icount.cts++;
1148                         delta_count++;
1149                         break;
1150                 case C_CM_MRI:
1151                         info->icount.rng++;
1152                         delta_count++;
1153                         break;
1154                 case C_CM_MDSR:
1155                         info->icount.dsr++;
1156                         delta_count++;
1157                         break;
1158 #ifdef Z_WAKE
1159                 case C_CM_IOCTLW:
1160                         complete(&info->shutdown_wait);
1161                         break;
1162 #endif
1163 #ifdef CONFIG_CYZ_INTR
1164                 case C_CM_RXHIWM:
1165                 case C_CM_RXNNDT:
1166                 case C_CM_INTBACK2:
1167                         /* Reception Interrupt */
1168 #ifdef CY_DEBUG_INTERRUPTS
1169                         printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1170                                         "port %ld\n", info->card, channel);
1171 #endif
1172                         cyz_handle_rx(info, tty);
1173                         break;
1174                 case C_CM_TXBEMPTY:
1175                 case C_CM_TXLOWWM:
1176                 case C_CM_INTBACK:
1177                         /* Transmission Interrupt */
1178 #ifdef CY_DEBUG_INTERRUPTS
1179                         printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1180                                         "port %ld\n", info->card, channel);
1181 #endif
1182                         cyz_handle_tx(info, tty);
1183                         break;
1184 #endif                          /* CONFIG_CYZ_INTR */
1185                 case C_CM_FATAL:
1186                         /* should do something with this !!! */
1187                         break;
1188                 default:
1189                         break;
1190                 }
1191                 if (delta_count)
1192                         wake_up_interruptible(&info->port.delta_msr_wait);
1193                 if (special_count)
1194                         tty_schedule_flip(tty);
1195                 tty_kref_put(tty);
1196         }
1197 }
1198
1199 #ifdef CONFIG_CYZ_INTR
1200 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1201 {
1202         struct cyclades_card *cinfo = dev_id;
1203
1204         if (unlikely(!cyz_is_loaded(cinfo))) {
1205 #ifdef CY_DEBUG_INTERRUPTS
1206                 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1207                                 "(IRQ%d).\n", irq);
1208 #endif
1209                 return IRQ_NONE;
1210         }
1211
1212         /* Handle the interrupts */
1213         cyz_handle_cmd(cinfo);
1214
1215         return IRQ_HANDLED;
1216 }                               /* cyz_interrupt */
1217
1218 static void cyz_rx_restart(unsigned long arg)
1219 {
1220         struct cyclades_port *info = (struct cyclades_port *)arg;
1221         struct cyclades_card *card = info->card;
1222         int retval;
1223         __u32 channel = info->line - card->first_line;
1224         unsigned long flags;
1225
1226         spin_lock_irqsave(&card->card_lock, flags);
1227         retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1228         if (retval != 0) {
1229                 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1230                         info->line, retval);
1231         }
1232         spin_unlock_irqrestore(&card->card_lock, flags);
1233 }
1234
1235 #else                           /* CONFIG_CYZ_INTR */
1236
1237 static void cyz_poll(unsigned long arg)
1238 {
1239         struct cyclades_card *cinfo;
1240         struct cyclades_port *info;
1241         unsigned long expires = jiffies + HZ;
1242         unsigned int port, card;
1243
1244         for (card = 0; card < NR_CARDS; card++) {
1245                 cinfo = &cy_card[card];
1246
1247                 if (!cy_is_Z(cinfo))
1248                         continue;
1249                 if (!cyz_is_loaded(cinfo))
1250                         continue;
1251
1252         /* Skip first polling cycle to avoid racing conditions with the FW */
1253                 if (!cinfo->intr_enabled) {
1254                         cinfo->intr_enabled = 1;
1255                         continue;
1256                 }
1257
1258                 cyz_handle_cmd(cinfo);
1259
1260                 for (port = 0; port < cinfo->nports; port++) {
1261                         struct tty_struct *tty;
1262
1263                         info = &cinfo->ports[port];
1264                         tty = tty_port_tty_get(&info->port);
1265                         /* OK to pass NULL to the handle functions below.
1266                            They need to drop the data in that case. */
1267
1268                         if (!info->throttle)
1269                                 cyz_handle_rx(info, tty);
1270                         cyz_handle_tx(info, tty);
1271                         tty_kref_put(tty);
1272                 }
1273                 /* poll every 'cyz_polling_cycle' period */
1274                 expires = jiffies + cyz_polling_cycle;
1275         }
1276         mod_timer(&cyz_timerlist, expires);
1277 }                               /* cyz_poll */
1278
1279 #endif                          /* CONFIG_CYZ_INTR */
1280
1281 /********** End of block of Cyclades-Z specific code *********/
1282 /***********************************************************/
1283
1284 /* This is called whenever a port becomes active;
1285    interrupts are enabled and DTR & RTS are turned on.
1286  */
1287 static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1288 {
1289         struct cyclades_card *card;
1290         unsigned long flags;
1291         int retval = 0;
1292         int channel;
1293         unsigned long page;
1294
1295         card = info->card;
1296         channel = info->line - card->first_line;
1297
1298         page = get_zeroed_page(GFP_KERNEL);
1299         if (!page)
1300                 return -ENOMEM;
1301
1302         spin_lock_irqsave(&card->card_lock, flags);
1303
1304         if (info->port.flags & ASYNC_INITIALIZED)
1305                 goto errout;
1306
1307         if (!info->type) {
1308                 set_bit(TTY_IO_ERROR, &tty->flags);
1309                 goto errout;
1310         }
1311
1312         if (info->port.xmit_buf)
1313                 free_page(page);
1314         else
1315                 info->port.xmit_buf = (unsigned char *)page;
1316
1317         spin_unlock_irqrestore(&card->card_lock, flags);
1318
1319         cy_set_line_char(info, tty);
1320
1321         if (!cy_is_Z(card)) {
1322                 channel &= 0x03;
1323
1324                 spin_lock_irqsave(&card->card_lock, flags);
1325
1326                 cyy_writeb(info, CyCAR, channel);
1327
1328                 cyy_writeb(info, CyRTPR,
1329                         (info->default_timeout ? info->default_timeout : 0x02));
1330                 /* 10ms rx timeout */
1331
1332                 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1333
1334                 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1335
1336                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1337         } else {
1338                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1339
1340                 if (!cyz_is_loaded(card))
1341                         return -ENODEV;
1342
1343 #ifdef CY_DEBUG_OPEN
1344                 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1345                         "base_addr %p\n", card, channel, card->base_addr);
1346 #endif
1347                 spin_lock_irqsave(&card->card_lock, flags);
1348
1349                 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1350 #ifdef Z_WAKE
1351 #ifdef CONFIG_CYZ_INTR
1352                 cy_writel(&ch_ctrl->intr_enable,
1353                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1354                           C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1355 #else
1356                 cy_writel(&ch_ctrl->intr_enable,
1357                           C_IN_IOCTLW | C_IN_MDCD);
1358 #endif                          /* CONFIG_CYZ_INTR */
1359 #else
1360 #ifdef CONFIG_CYZ_INTR
1361                 cy_writel(&ch_ctrl->intr_enable,
1362                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1363                           C_IN_RXNNDT | C_IN_MDCD);
1364 #else
1365                 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1366 #endif                          /* CONFIG_CYZ_INTR */
1367 #endif                          /* Z_WAKE */
1368
1369                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1370                 if (retval != 0) {
1371                         printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1372                                 "%x\n", info->line, retval);
1373                 }
1374
1375                 /* Flush RX buffers before raising DTR and RTS */
1376                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1377                 if (retval != 0) {
1378                         printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1379                                 "%x\n", info->line, retval);
1380                 }
1381
1382                 /* set timeout !!! */
1383                 /* set RTS and DTR !!! */
1384                 tty_port_raise_dtr_rts(&info->port);
1385
1386                 /* enable send, recv, modem !!! */
1387         }
1388
1389         info->port.flags |= ASYNC_INITIALIZED;
1390
1391         clear_bit(TTY_IO_ERROR, &tty->flags);
1392         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1393         info->breakon = info->breakoff = 0;
1394         memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1395         info->idle_stats.in_use =
1396         info->idle_stats.recv_idle =
1397         info->idle_stats.xmit_idle = jiffies;
1398
1399         spin_unlock_irqrestore(&card->card_lock, flags);
1400
1401 #ifdef CY_DEBUG_OPEN
1402         printk(KERN_DEBUG "cyc startup done\n");
1403 #endif
1404         return 0;
1405
1406 errout:
1407         spin_unlock_irqrestore(&card->card_lock, flags);
1408         free_page(page);
1409         return retval;
1410 }                               /* startup */
1411
1412 static void start_xmit(struct cyclades_port *info)
1413 {
1414         struct cyclades_card *card = info->card;
1415         unsigned long flags;
1416         int channel = info->line - card->first_line;
1417
1418         if (!cy_is_Z(card)) {
1419                 spin_lock_irqsave(&card->card_lock, flags);
1420                 cyy_writeb(info, CyCAR, channel & 0x03);
1421                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1422                 spin_unlock_irqrestore(&card->card_lock, flags);
1423         } else {
1424 #ifdef CONFIG_CYZ_INTR
1425                 int retval;
1426
1427                 spin_lock_irqsave(&card->card_lock, flags);
1428                 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1429                 if (retval != 0) {
1430                         printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1431                                 "%x\n", info->line, retval);
1432                 }
1433                 spin_unlock_irqrestore(&card->card_lock, flags);
1434 #else                           /* CONFIG_CYZ_INTR */
1435                 /* Don't have to do anything at this time */
1436 #endif                          /* CONFIG_CYZ_INTR */
1437         }
1438 }                               /* start_xmit */
1439
1440 /*
1441  * This routine shuts down a serial port; interrupts are disabled,
1442  * and DTR is dropped if the hangup on close termio flag is on.
1443  */
1444 static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1445 {
1446         struct cyclades_card *card;
1447         unsigned long flags;
1448         int channel;
1449
1450         if (!(info->port.flags & ASYNC_INITIALIZED))
1451                 return;
1452
1453         card = info->card;
1454         channel = info->line - card->first_line;
1455         if (!cy_is_Z(card)) {
1456                 spin_lock_irqsave(&card->card_lock, flags);
1457
1458                 /* Clear delta_msr_wait queue to avoid mem leaks. */
1459                 wake_up_interruptible(&info->port.delta_msr_wait);
1460
1461                 if (info->port.xmit_buf) {
1462                         unsigned char *temp;
1463                         temp = info->port.xmit_buf;
1464                         info->port.xmit_buf = NULL;
1465                         free_page((unsigned long)temp);
1466                 }
1467                 if (tty->termios->c_cflag & HUPCL)
1468                         cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1469
1470                 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1471                 /* it may be appropriate to clear _XMIT at
1472                    some later date (after testing)!!! */
1473
1474                 set_bit(TTY_IO_ERROR, &tty->flags);
1475                 info->port.flags &= ~ASYNC_INITIALIZED;
1476                 spin_unlock_irqrestore(&card->card_lock, flags);
1477         } else {
1478 #ifdef CY_DEBUG_OPEN
1479                 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1480                         "base_addr %p\n", card, channel, card->base_addr);
1481 #endif
1482
1483                 if (!cyz_is_loaded(card))
1484                         return;
1485
1486                 spin_lock_irqsave(&card->card_lock, flags);
1487
1488                 if (info->port.xmit_buf) {
1489                         unsigned char *temp;
1490                         temp = info->port.xmit_buf;
1491                         info->port.xmit_buf = NULL;
1492                         free_page((unsigned long)temp);
1493                 }
1494
1495                 if (tty->termios->c_cflag & HUPCL)
1496                         tty_port_lower_dtr_rts(&info->port);
1497
1498                 set_bit(TTY_IO_ERROR, &tty->flags);
1499                 info->port.flags &= ~ASYNC_INITIALIZED;
1500
1501                 spin_unlock_irqrestore(&card->card_lock, flags);
1502         }
1503
1504 #ifdef CY_DEBUG_OPEN
1505         printk(KERN_DEBUG "cyc shutdown done\n");
1506 #endif
1507 }                               /* shutdown */
1508
1509 /*
1510  * ------------------------------------------------------------
1511  * cy_open() and friends
1512  * ------------------------------------------------------------
1513  */
1514
1515 /*
1516  * This routine is called whenever a serial port is opened.  It
1517  * performs the serial-specific initialization for the tty structure.
1518  */
1519 static int cy_open(struct tty_struct *tty, struct file *filp)
1520 {
1521         struct cyclades_port *info;
1522         unsigned int i, line;
1523         int retval;
1524
1525         line = tty->index;
1526         if (tty->index < 0 || NR_PORTS <= line)
1527                 return -ENODEV;
1528
1529         for (i = 0; i < NR_CARDS; i++)
1530                 if (line < cy_card[i].first_line + cy_card[i].nports &&
1531                                 line >= cy_card[i].first_line)
1532                         break;
1533         if (i >= NR_CARDS)
1534                 return -ENODEV;
1535         info = &cy_card[i].ports[line - cy_card[i].first_line];
1536         if (info->line < 0)
1537                 return -ENODEV;
1538
1539         /* If the card's firmware hasn't been loaded,
1540            treat it as absent from the system.  This
1541            will make the user pay attention.
1542          */
1543         if (cy_is_Z(info->card)) {
1544                 struct cyclades_card *cinfo = info->card;
1545                 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1546
1547                 if (!cyz_is_loaded(cinfo)) {
1548                         if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1549                                         readl(&firm_id->signature) ==
1550                                         ZFIRM_HLT) {
1551                                 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1552                                         "need an external power supply for "
1553                                         "this number of ports.\nFirmware "
1554                                         "halted.\n");
1555                         } else {
1556                                 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1557                                         "yet loaded\n");
1558                         }
1559                         return -ENODEV;
1560                 }
1561 #ifdef CONFIG_CYZ_INTR
1562                 else {
1563                 /* In case this Z board is operating in interrupt mode, its
1564                    interrupts should be enabled as soon as the first open
1565                    happens to one of its ports. */
1566                         if (!cinfo->intr_enabled) {
1567                                 u16 intr;
1568
1569                                 /* Enable interrupts on the PLX chip */
1570                                 intr = readw(&cinfo->ctl_addr.p9060->
1571                                                 intr_ctrl_stat) | 0x0900;
1572                                 cy_writew(&cinfo->ctl_addr.p9060->
1573                                                 intr_ctrl_stat, intr);
1574                                 /* Enable interrupts on the FW */
1575                                 retval = cyz_issue_cmd(cinfo, 0,
1576                                                 C_CM_IRQ_ENBL, 0L);
1577                                 if (retval != 0) {
1578                                         printk(KERN_ERR "cyc:IRQ enable retval "
1579                                                 "was %x\n", retval);
1580                                 }
1581                                 cinfo->intr_enabled = 1;
1582                         }
1583                 }
1584 #endif                          /* CONFIG_CYZ_INTR */
1585                 /* Make sure this Z port really exists in hardware */
1586                 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1587                         return -ENODEV;
1588         }
1589 #ifdef CY_DEBUG_OTHER
1590         printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1591 #endif
1592         tty->driver_data = info;
1593         if (serial_paranoia_check(info, tty->name, "cy_open"))
1594                 return -ENODEV;
1595
1596 #ifdef CY_DEBUG_OPEN
1597         printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1598                         info->port.count);
1599 #endif
1600         info->port.count++;
1601 #ifdef CY_DEBUG_COUNT
1602         printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1603                 current->pid, info->port.count);
1604 #endif
1605
1606         /*
1607          * If the port is the middle of closing, bail out now
1608          */
1609         if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1610                 wait_event_interruptible_tty(info->port.close_wait,
1611                                 !(info->port.flags & ASYNC_CLOSING));
1612                 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1613         }
1614
1615         /*
1616          * Start up serial port
1617          */
1618         retval = cy_startup(info, tty);
1619         if (retval)
1620                 return retval;
1621
1622         retval = tty_port_block_til_ready(&info->port, tty, filp);
1623         if (retval) {
1624 #ifdef CY_DEBUG_OPEN
1625                 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1626                         "with %d\n", retval);
1627 #endif
1628                 return retval;
1629         }
1630
1631         info->throttle = 0;
1632         tty_port_tty_set(&info->port, tty);
1633
1634 #ifdef CY_DEBUG_OPEN
1635         printk(KERN_DEBUG "cyc:cy_open done\n");
1636 #endif
1637         return 0;
1638 }                               /* cy_open */
1639
1640 /*
1641  * cy_wait_until_sent() --- wait until the transmitter is empty
1642  */
1643 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1644 {
1645         struct cyclades_card *card;
1646         struct cyclades_port *info = tty->driver_data;
1647         unsigned long orig_jiffies;
1648         int char_time;
1649
1650         if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1651                 return;
1652
1653         if (info->xmit_fifo_size == 0)
1654                 return;         /* Just in case.... */
1655
1656         orig_jiffies = jiffies;
1657         /*
1658          * Set the check interval to be 1/5 of the estimated time to
1659          * send a single character, and make it at least 1.  The check
1660          * interval should also be less than the timeout.
1661          *
1662          * Note: we have to use pretty tight timings here to satisfy
1663          * the NIST-PCTS.
1664          */
1665         char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1666         char_time = char_time / 5;
1667         if (char_time <= 0)
1668                 char_time = 1;
1669         if (timeout < 0)
1670                 timeout = 0;
1671         if (timeout)
1672                 char_time = min(char_time, timeout);
1673         /*
1674          * If the transmitter hasn't cleared in twice the approximate
1675          * amount of time to send the entire FIFO, it probably won't
1676          * ever clear.  This assumes the UART isn't doing flow
1677          * control, which is currently the case.  Hence, if it ever
1678          * takes longer than info->timeout, this is probably due to a
1679          * UART bug of some kind.  So, we clamp the timeout parameter at
1680          * 2*info->timeout.
1681          */
1682         if (!timeout || timeout > 2 * info->timeout)
1683                 timeout = 2 * info->timeout;
1684 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1685         printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
1686                 timeout, char_time, jiffies);
1687 #endif
1688         card = info->card;
1689         if (!cy_is_Z(card)) {
1690                 while (cyy_readb(info, CySRER) & CyTxRdy) {
1691 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1692                         printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
1693 #endif
1694                         if (msleep_interruptible(jiffies_to_msecs(char_time)))
1695                                 break;
1696                         if (timeout && time_after(jiffies, orig_jiffies +
1697                                         timeout))
1698                                 break;
1699                 }
1700         }
1701         /* Run one more char cycle */
1702         msleep_interruptible(jiffies_to_msecs(char_time * 5));
1703 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1704         printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
1705 #endif
1706 }
1707
1708 static void cy_flush_buffer(struct tty_struct *tty)
1709 {
1710         struct cyclades_port *info = tty->driver_data;
1711         struct cyclades_card *card;
1712         int channel, retval;
1713         unsigned long flags;
1714
1715 #ifdef CY_DEBUG_IO
1716         printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1717 #endif
1718
1719         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1720                 return;
1721
1722         card = info->card;
1723         channel = info->line - card->first_line;
1724
1725         spin_lock_irqsave(&card->card_lock, flags);
1726         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1727         spin_unlock_irqrestore(&card->card_lock, flags);
1728
1729         if (cy_is_Z(card)) {    /* If it is a Z card, flush the on-board
1730                                            buffers as well */
1731                 spin_lock_irqsave(&card->card_lock, flags);
1732                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1733                 if (retval != 0) {
1734                         printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1735                                 "was %x\n", info->line, retval);
1736                 }
1737                 spin_unlock_irqrestore(&card->card_lock, flags);
1738         }
1739         tty_wakeup(tty);
1740 }                               /* cy_flush_buffer */
1741
1742
1743 static void cy_do_close(struct tty_port *port)
1744 {
1745         struct cyclades_port *info = container_of(port, struct cyclades_port,
1746                                                                 port);
1747         struct cyclades_card *card;
1748         unsigned long flags;
1749         int channel;
1750
1751         card = info->card;
1752         channel = info->line - card->first_line;
1753         spin_lock_irqsave(&card->card_lock, flags);
1754
1755         if (!cy_is_Z(card)) {
1756                 /* Stop accepting input */
1757                 cyy_writeb(info, CyCAR, channel & 0x03);
1758                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1759                 if (info->port.flags & ASYNC_INITIALIZED) {
1760                         /* Waiting for on-board buffers to be empty before
1761                            closing the port */
1762                         spin_unlock_irqrestore(&card->card_lock, flags);
1763                         cy_wait_until_sent(port->tty, info->timeout);
1764                         spin_lock_irqsave(&card->card_lock, flags);
1765                 }
1766         } else {
1767 #ifdef Z_WAKE
1768                 /* Waiting for on-board buffers to be empty before closing
1769                    the port */
1770                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1771                 int retval;
1772
1773                 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1774                         retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1775                         if (retval != 0) {
1776                                 printk(KERN_DEBUG "cyc:cy_close retval on "
1777                                         "ttyC%d was %x\n", info->line, retval);
1778                         }
1779                         spin_unlock_irqrestore(&card->card_lock, flags);
1780                         wait_for_completion_interruptible(&info->shutdown_wait);
1781                         spin_lock_irqsave(&card->card_lock, flags);
1782                 }
1783 #endif
1784         }
1785         spin_unlock_irqrestore(&card->card_lock, flags);
1786         cy_shutdown(info, port->tty);
1787 }
1788
1789 /*
1790  * This routine is called when a particular tty device is closed.
1791  */
1792 static void cy_close(struct tty_struct *tty, struct file *filp)
1793 {
1794         struct cyclades_port *info = tty->driver_data;
1795         if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1796                 return;
1797         tty_port_close(&info->port, tty, filp);
1798 }                               /* cy_close */
1799
1800 /* This routine gets called when tty_write has put something into
1801  * the write_queue.  The characters may come from user space or
1802  * kernel space.
1803  *
1804  * This routine will return the number of characters actually
1805  * accepted for writing.
1806  *
1807  * If the port is not already transmitting stuff, start it off by
1808  * enabling interrupts.  The interrupt service routine will then
1809  * ensure that the characters are sent.
1810  * If the port is already active, there is no need to kick it.
1811  *
1812  */
1813 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1814 {
1815         struct cyclades_port *info = tty->driver_data;
1816         unsigned long flags;
1817         int c, ret = 0;
1818
1819 #ifdef CY_DEBUG_IO
1820         printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1821 #endif
1822
1823         if (serial_paranoia_check(info, tty->name, "cy_write"))
1824                 return 0;
1825
1826         if (!info->port.xmit_buf)
1827                 return 0;
1828
1829         spin_lock_irqsave(&info->card->card_lock, flags);
1830         while (1) {
1831                 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1832                 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1833
1834                 if (c <= 0)
1835                         break;
1836
1837                 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1838                 info->xmit_head = (info->xmit_head + c) &
1839                         (SERIAL_XMIT_SIZE - 1);
1840                 info->xmit_cnt += c;
1841                 buf += c;
1842                 count -= c;
1843                 ret += c;
1844         }
1845         spin_unlock_irqrestore(&info->card->card_lock, flags);
1846
1847         info->idle_stats.xmit_bytes += ret;
1848         info->idle_stats.xmit_idle = jiffies;
1849
1850         if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1851                 start_xmit(info);
1852
1853         return ret;
1854 }                               /* cy_write */
1855
1856 /*
1857  * This routine is called by the kernel to write a single
1858  * character to the tty device.  If the kernel uses this routine,
1859  * it must call the flush_chars() routine (if defined) when it is
1860  * done stuffing characters into the driver.  If there is no room
1861  * in the queue, the character is ignored.
1862  */
1863 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1864 {
1865         struct cyclades_port *info = tty->driver_data;
1866         unsigned long flags;
1867
1868 #ifdef CY_DEBUG_IO
1869         printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1870 #endif
1871
1872         if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1873                 return 0;
1874
1875         if (!info->port.xmit_buf)
1876                 return 0;
1877
1878         spin_lock_irqsave(&info->card->card_lock, flags);
1879         if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1880                 spin_unlock_irqrestore(&info->card->card_lock, flags);
1881                 return 0;
1882         }
1883
1884         info->port.xmit_buf[info->xmit_head++] = ch;
1885         info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1886         info->xmit_cnt++;
1887         info->idle_stats.xmit_bytes++;
1888         info->idle_stats.xmit_idle = jiffies;
1889         spin_unlock_irqrestore(&info->card->card_lock, flags);
1890         return 1;
1891 }                               /* cy_put_char */
1892
1893 /*
1894  * This routine is called by the kernel after it has written a
1895  * series of characters to the tty device using put_char().
1896  */
1897 static void cy_flush_chars(struct tty_struct *tty)
1898 {
1899         struct cyclades_port *info = tty->driver_data;
1900
1901 #ifdef CY_DEBUG_IO
1902         printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1903 #endif
1904
1905         if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1906                 return;
1907
1908         if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1909                         !info->port.xmit_buf)
1910                 return;
1911
1912         start_xmit(info);
1913 }                               /* cy_flush_chars */
1914
1915 /*
1916  * This routine returns the numbers of characters the tty driver
1917  * will accept for queuing to be written.  This number is subject
1918  * to change as output buffers get emptied, or if the output flow
1919  * control is activated.
1920  */
1921 static int cy_write_room(struct tty_struct *tty)
1922 {
1923         struct cyclades_port *info = tty->driver_data;
1924         int ret;
1925
1926 #ifdef CY_DEBUG_IO
1927         printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1928 #endif
1929
1930         if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1931                 return 0;
1932         ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1933         if (ret < 0)
1934                 ret = 0;
1935         return ret;
1936 }                               /* cy_write_room */
1937
1938 static int cy_chars_in_buffer(struct tty_struct *tty)
1939 {
1940         struct cyclades_port *info = tty->driver_data;
1941
1942         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1943                 return 0;
1944
1945 #ifdef Z_EXT_CHARS_IN_BUFFER
1946         if (!cy_is_Z(info->card)) {
1947 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
1948 #ifdef CY_DEBUG_IO
1949                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1950                         info->line, info->xmit_cnt);
1951 #endif
1952                 return info->xmit_cnt;
1953 #ifdef Z_EXT_CHARS_IN_BUFFER
1954         } else {
1955                 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1956                 int char_count;
1957                 __u32 tx_put, tx_get, tx_bufsize;
1958
1959                 tx_get = readl(&buf_ctrl->tx_get);
1960                 tx_put = readl(&buf_ctrl->tx_put);
1961                 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1962                 if (tx_put >= tx_get)
1963                         char_count = tx_put - tx_get;
1964                 else
1965                         char_count = tx_put - tx_get + tx_bufsize;
1966 #ifdef CY_DEBUG_IO
1967                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1968                         info->line, info->xmit_cnt + char_count);
1969 #endif
1970                 return info->xmit_cnt + char_count;
1971         }
1972 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
1973 }                               /* cy_chars_in_buffer */
1974
1975 /*
1976  * ------------------------------------------------------------
1977  * cy_ioctl() and friends
1978  * ------------------------------------------------------------
1979  */
1980
1981 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1982 {
1983         int co, co_val, bpr;
1984         __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
1985                         25000000);
1986
1987         if (baud == 0) {
1988                 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1989                 return;
1990         }
1991
1992         /* determine which prescaler to use */
1993         for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1994                 if (cy_clock / co_val / baud > 63)
1995                         break;
1996         }
1997
1998         bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1999         if (bpr > 255)
2000                 bpr = 255;
2001
2002         info->tbpr = info->rbpr = bpr;
2003         info->tco = info->rco = co;
2004 }
2005
2006 /*
2007  * This routine finds or computes the various line characteristics.
2008  * It used to be called config_setup
2009  */
2010 static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
2011 {
2012         struct cyclades_card *card;
2013         unsigned long flags;
2014         int channel;
2015         unsigned cflag, iflag;
2016         int baud, baud_rate = 0;
2017         int i;
2018
2019         if (!tty->termios) /* XXX can this happen at all? */
2020                 return;
2021
2022         if (info->line == -1)
2023                 return;
2024
2025         cflag = tty->termios->c_cflag;
2026         iflag = tty->termios->c_iflag;
2027
2028         /*
2029          * Set up the tty->alt_speed kludge
2030          */
2031         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2032                 tty->alt_speed = 57600;
2033         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2034                 tty->alt_speed = 115200;
2035         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2036                 tty->alt_speed = 230400;
2037         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2038                 tty->alt_speed = 460800;
2039
2040         card = info->card;
2041         channel = info->line - card->first_line;
2042
2043         if (!cy_is_Z(card)) {
2044                 u32 cflags;
2045
2046                 /* baud rate */
2047                 baud = tty_get_baud_rate(tty);
2048                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2049                                 ASYNC_SPD_CUST) {
2050                         if (info->custom_divisor)
2051                                 baud_rate = info->baud / info->custom_divisor;
2052                         else
2053                                 baud_rate = info->baud;
2054                 } else if (baud > CD1400_MAX_SPEED) {
2055                         baud = CD1400_MAX_SPEED;
2056                 }
2057                 /* find the baud index */
2058                 for (i = 0; i < 20; i++) {
2059                         if (baud == baud_table[i])
2060                                 break;
2061                 }
2062                 if (i == 20)
2063                         i = 19; /* CD1400_MAX_SPEED */
2064
2065                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2066                                 ASYNC_SPD_CUST) {
2067                         cyy_baud_calc(info, baud_rate);
2068                 } else {
2069                         if (info->chip_rev >= CD1400_REV_J) {
2070                                 /* It is a CD1400 rev. J or later */
2071                                 info->tbpr = baud_bpr_60[i];    /* Tx BPR */
2072                                 info->tco = baud_co_60[i];      /* Tx CO */
2073                                 info->rbpr = baud_bpr_60[i];    /* Rx BPR */
2074                                 info->rco = baud_co_60[i];      /* Rx CO */
2075                         } else {
2076                                 info->tbpr = baud_bpr_25[i];    /* Tx BPR */
2077                                 info->tco = baud_co_25[i];      /* Tx CO */
2078                                 info->rbpr = baud_bpr_25[i];    /* Rx BPR */
2079                                 info->rco = baud_co_25[i];      /* Rx CO */
2080                         }
2081                 }
2082                 if (baud_table[i] == 134) {
2083                         /* get it right for 134.5 baud */
2084                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2085                                         2;
2086                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2087                                 ASYNC_SPD_CUST) {
2088                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2089                                         baud_rate) + 2;
2090                 } else if (baud_table[i]) {
2091                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2092                                         baud_table[i]) + 2;
2093                         /* this needs to be propagated into the card info */
2094                 } else {
2095                         info->timeout = 0;
2096                 }
2097                 /* By tradition (is it a standard?) a baud rate of zero
2098                    implies the line should be/has been closed.  A bit
2099                    later in this routine such a test is performed. */
2100
2101                 /* byte size and parity */
2102                 info->cor5 = 0;
2103                 info->cor4 = 0;
2104                 /* receive threshold */
2105                 info->cor3 = (info->default_threshold ?
2106                                 info->default_threshold : baud_cor3[i]);
2107                 info->cor2 = CyETC;
2108                 switch (cflag & CSIZE) {
2109                 case CS5:
2110                         info->cor1 = Cy_5_BITS;
2111                         break;
2112                 case CS6:
2113                         info->cor1 = Cy_6_BITS;
2114                         break;
2115                 case CS7:
2116                         info->cor1 = Cy_7_BITS;
2117                         break;
2118                 case CS8:
2119                         info->cor1 = Cy_8_BITS;
2120                         break;
2121                 }
2122                 if (cflag & CSTOPB)
2123                         info->cor1 |= Cy_2_STOP;
2124
2125                 if (cflag & PARENB) {
2126                         if (cflag & PARODD)
2127                                 info->cor1 |= CyPARITY_O;
2128                         else
2129                                 info->cor1 |= CyPARITY_E;
2130                 } else
2131                         info->cor1 |= CyPARITY_NONE;
2132
2133                 /* CTS flow control flag */
2134                 if (cflag & CRTSCTS) {
2135                         info->port.flags |= ASYNC_CTS_FLOW;
2136                         info->cor2 |= CyCtsAE;
2137                 } else {
2138                         info->port.flags &= ~ASYNC_CTS_FLOW;
2139                         info->cor2 &= ~CyCtsAE;
2140                 }
2141                 if (cflag & CLOCAL)
2142                         info->port.flags &= ~ASYNC_CHECK_CD;
2143                 else
2144                         info->port.flags |= ASYNC_CHECK_CD;
2145
2146          /***********************************************
2147             The hardware option, CyRtsAO, presents RTS when
2148             the chip has characters to send.  Since most modems
2149             use RTS as reverse (inbound) flow control, this
2150             option is not used.  If inbound flow control is
2151             necessary, DTR can be programmed to provide the
2152             appropriate signals for use with a non-standard
2153             cable.  Contact Marcio Saito for details.
2154          ***********************************************/
2155
2156                 channel &= 0x03;
2157
2158                 spin_lock_irqsave(&card->card_lock, flags);
2159                 cyy_writeb(info, CyCAR, channel);
2160
2161                 /* tx and rx baud rate */
2162
2163                 cyy_writeb(info, CyTCOR, info->tco);
2164                 cyy_writeb(info, CyTBPR, info->tbpr);
2165                 cyy_writeb(info, CyRCOR, info->rco);
2166                 cyy_writeb(info, CyRBPR, info->rbpr);
2167
2168                 /* set line characteristics  according configuration */
2169
2170                 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2171                 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2172                 cyy_writeb(info, CyCOR1, info->cor1);
2173                 cyy_writeb(info, CyCOR2, info->cor2);
2174                 cyy_writeb(info, CyCOR3, info->cor3);
2175                 cyy_writeb(info, CyCOR4, info->cor4);
2176                 cyy_writeb(info, CyCOR5, info->cor5);
2177
2178                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2179                                 CyCOR3ch);
2180
2181                 /* !!! Is this needed? */
2182                 cyy_writeb(info, CyCAR, channel);
2183                 cyy_writeb(info, CyRTPR,
2184                         (info->default_timeout ? info->default_timeout : 0x02));
2185                 /* 10ms rx timeout */
2186
2187                 cflags = CyCTS;
2188                 if (!C_CLOCAL(tty))
2189                         cflags |= CyDSR | CyRI | CyDCD;
2190                 /* without modem intr */
2191                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2192                 /* act on 1->0 modem transitions */
2193                 if ((cflag & CRTSCTS) && info->rflow)
2194                         cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2195                 else
2196                         cyy_writeb(info, CyMCOR1, cflags);
2197                 /* act on 0->1 modem transitions */
2198                 cyy_writeb(info, CyMCOR2, cflags);
2199
2200                 if (i == 0)     /* baud rate is zero, turn off line */
2201                         cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2202                 else
2203                         cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2204
2205                 clear_bit(TTY_IO_ERROR, &tty->flags);
2206                 spin_unlock_irqrestore(&card->card_lock, flags);
2207
2208         } else {
2209                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2210                 __u32 sw_flow;
2211                 int retval;
2212
2213                 if (!cyz_is_loaded(card))
2214                         return;
2215
2216                 /* baud rate */
2217                 baud = tty_get_baud_rate(tty);
2218                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2219                                 ASYNC_SPD_CUST) {
2220                         if (info->custom_divisor)
2221                                 baud_rate = info->baud / info->custom_divisor;
2222                         else
2223                                 baud_rate = info->baud;
2224                 } else if (baud > CYZ_MAX_SPEED) {
2225                         baud = CYZ_MAX_SPEED;
2226                 }
2227                 cy_writel(&ch_ctrl->comm_baud, baud);
2228
2229                 if (baud == 134) {
2230                         /* get it right for 134.5 baud */
2231                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2232                                         2;
2233                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2234                                 ASYNC_SPD_CUST) {
2235                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2236                                         baud_rate) + 2;
2237                 } else if (baud) {
2238                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2239                                         baud) + 2;
2240                         /* this needs to be propagated into the card info */
2241                 } else {
2242                         info->timeout = 0;
2243                 }
2244
2245                 /* byte size and parity */
2246                 switch (cflag & CSIZE) {
2247                 case CS5:
2248                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2249                         break;
2250                 case CS6:
2251                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2252                         break;
2253                 case CS7:
2254                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2255                         break;
2256                 case CS8:
2257                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2258                         break;
2259                 }
2260                 if (cflag & CSTOPB) {
2261                         cy_writel(&ch_ctrl->comm_data_l,
2262                                   readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2263                 } else {
2264                         cy_writel(&ch_ctrl->comm_data_l,
2265                                   readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2266                 }
2267                 if (cflag & PARENB) {
2268                         if (cflag & PARODD)
2269                                 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2270                         else
2271                                 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2272                 } else
2273                         cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2274
2275                 /* CTS flow control flag */
2276                 if (cflag & CRTSCTS) {
2277                         cy_writel(&ch_ctrl->hw_flow,
2278                                 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2279                 } else {
2280                         cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2281                                         ~(C_RS_CTS | C_RS_RTS));
2282                 }
2283                 /* As the HW flow control is done in firmware, the driver
2284                    doesn't need to care about it */
2285                 info->port.flags &= ~ASYNC_CTS_FLOW;
2286
2287                 /* XON/XOFF/XANY flow control flags */
2288                 sw_flow = 0;
2289                 if (iflag & IXON) {
2290                         sw_flow |= C_FL_OXX;
2291                         if (iflag & IXANY)
2292                                 sw_flow |= C_FL_OIXANY;
2293                 }
2294                 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2295
2296                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2297                 if (retval != 0) {
2298                         printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2299                                 "was %x\n", info->line, retval);
2300                 }
2301
2302                 /* CD sensitivity */
2303                 if (cflag & CLOCAL)
2304                         info->port.flags &= ~ASYNC_CHECK_CD;
2305                 else
2306                         info->port.flags |= ASYNC_CHECK_CD;
2307
2308                 if (baud == 0) {        /* baud rate is zero, turn off line */
2309                         cy_writel(&ch_ctrl->rs_control,
2310                                   readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2311 #ifdef CY_DEBUG_DTR
2312                         printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2313 #endif
2314                 } else {
2315                         cy_writel(&ch_ctrl->rs_control,
2316                                   readl(&ch_ctrl->rs_control) | C_RS_DTR);
2317 #ifdef CY_DEBUG_DTR
2318                         printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2319 #endif
2320                 }
2321
2322                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2323                 if (retval != 0) {
2324                         printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2325                                 "was %x\n", info->line, retval);
2326                 }
2327
2328                 clear_bit(TTY_IO_ERROR, &tty->flags);
2329         }
2330 }                               /* set_line_char */
2331
2332 static int cy_get_serial_info(struct cyclades_port *info,
2333                 struct serial_struct __user *retinfo)
2334 {
2335         struct cyclades_card *cinfo = info->card;
2336         struct serial_struct tmp = {
2337                 .type = info->type,
2338                 .line = info->line,
2339                 .port = (info->card - cy_card) * 0x100 + info->line -
2340                         cinfo->first_line,
2341                 .irq = cinfo->irq,
2342                 .flags = info->port.flags,
2343                 .close_delay = info->port.close_delay,
2344                 .closing_wait = info->port.closing_wait,
2345                 .baud_base = info->baud,
2346                 .custom_divisor = info->custom_divisor,
2347                 .hub6 = 0,              /*!!! */
2348         };
2349         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2350 }
2351
2352 static int
2353 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2354                 struct serial_struct __user *new_info)
2355 {
2356         struct serial_struct new_serial;
2357         int ret;
2358
2359         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2360                 return -EFAULT;
2361
2362         mutex_lock(&info->port.mutex);
2363         if (!capable(CAP_SYS_ADMIN)) {
2364                 if (new_serial.close_delay != info->port.close_delay ||
2365                                 new_serial.baud_base != info->baud ||
2366                                 (new_serial.flags & ASYNC_FLAGS &
2367                                         ~ASYNC_USR_MASK) !=
2368                                 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2369                 {
2370                         mutex_unlock(&info->port.mutex);
2371                         return -EPERM;
2372                 }
2373                 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2374                                 (new_serial.flags & ASYNC_USR_MASK);
2375                 info->baud = new_serial.baud_base;
2376                 info->custom_divisor = new_serial.custom_divisor;
2377                 goto check_and_exit;
2378         }
2379
2380         /*
2381          * OK, past this point, all the error checking has been done.
2382          * At this point, we start making changes.....
2383          */
2384
2385         info->baud = new_serial.baud_base;
2386         info->custom_divisor = new_serial.custom_divisor;
2387         info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2388                         (new_serial.flags & ASYNC_FLAGS);
2389         info->port.close_delay = new_serial.close_delay * HZ / 100;
2390         info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2391
2392 check_and_exit:
2393         if (info->port.flags & ASYNC_INITIALIZED) {
2394                 cy_set_line_char(info, tty);
2395                 ret = 0;
2396         } else {
2397                 ret = cy_startup(info, tty);
2398         }
2399         mutex_unlock(&info->port.mutex);
2400         return ret;
2401 }                               /* set_serial_info */
2402
2403 /*
2404  * get_lsr_info - get line status register info
2405  *
2406  * Purpose: Let user call ioctl() to get info when the UART physically
2407  *          is emptied.  On bus types like RS485, the transmitter must
2408  *          release the bus after transmitting. This must be done when
2409  *          the transmit shift register is empty, not be done when the
2410  *          transmit holding register is empty.  This functionality
2411  *          allows an RS485 driver to be written in user space.
2412  */
2413 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2414 {
2415         struct cyclades_card *card = info->card;
2416         unsigned int result;
2417         unsigned long flags;
2418         u8 status;
2419
2420         if (!cy_is_Z(card)) {
2421                 spin_lock_irqsave(&card->card_lock, flags);
2422                 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2423                 spin_unlock_irqrestore(&card->card_lock, flags);
2424                 result = (status ? 0 : TIOCSER_TEMT);
2425         } else {
2426                 /* Not supported yet */
2427                 return -EINVAL;
2428         }
2429         return put_user(result, (unsigned long __user *)value);
2430 }
2431
2432 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
2433 {
2434         struct cyclades_port *info = tty->driver_data;
2435         struct cyclades_card *card;
2436         int result;
2437
2438         if (serial_paranoia_check(info, tty->name, __func__))
2439                 return -ENODEV;
2440
2441         card = info->card;
2442
2443         if (!cy_is_Z(card)) {
2444                 unsigned long flags;
2445                 int channel = info->line - card->first_line;
2446                 u8 status;
2447
2448                 spin_lock_irqsave(&card->card_lock, flags);
2449                 cyy_writeb(info, CyCAR, channel & 0x03);
2450                 status = cyy_readb(info, CyMSVR1);
2451                 status |= cyy_readb(info, CyMSVR2);
2452                 spin_unlock_irqrestore(&card->card_lock, flags);
2453
2454                 if (info->rtsdtr_inv) {
2455                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2456                                 ((status & CyDTR) ? TIOCM_RTS : 0);
2457                 } else {
2458                         result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2459                                 ((status & CyDTR) ? TIOCM_DTR : 0);
2460                 }
2461                 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2462                         ((status & CyRI) ? TIOCM_RNG : 0) |
2463                         ((status & CyDSR) ? TIOCM_DSR : 0) |
2464                         ((status & CyCTS) ? TIOCM_CTS : 0);
2465         } else {
2466                 u32 lstatus;
2467
2468                 if (!cyz_is_loaded(card)) {
2469                         result = -ENODEV;
2470                         goto end;
2471                 }
2472
2473                 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2474                 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2475                         ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2476                         ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2477                         ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2478                         ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2479                         ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2480         }
2481 end:
2482         return result;
2483 }                               /* cy_tiomget */
2484
2485 static int
2486 cy_tiocmset(struct tty_struct *tty, struct file *file,
2487                 unsigned int set, unsigned int clear)
2488 {
2489         struct cyclades_port *info = tty->driver_data;
2490         struct cyclades_card *card;
2491         unsigned long flags;
2492
2493         if (serial_paranoia_check(info, tty->name, __func__))
2494                 return -ENODEV;
2495
2496         card = info->card;
2497         if (!cy_is_Z(card)) {
2498                 spin_lock_irqsave(&card->card_lock, flags);
2499                 cyy_change_rts_dtr(info, set, clear);
2500                 spin_unlock_irqrestore(&card->card_lock, flags);
2501         } else {
2502                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2503                 int retval, channel = info->line - card->first_line;
2504                 u32 rs;
2505
2506                 if (!cyz_is_loaded(card))
2507                         return -ENODEV;
2508
2509                 spin_lock_irqsave(&card->card_lock, flags);
2510                 rs = readl(&ch_ctrl->rs_control);
2511                 if (set & TIOCM_RTS)
2512                         rs |= C_RS_RTS;
2513                 if (clear & TIOCM_RTS)
2514                         rs &= ~C_RS_RTS;
2515                 if (set & TIOCM_DTR) {
2516                         rs |= C_RS_DTR;
2517 #ifdef CY_DEBUG_DTR
2518                         printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2519 #endif
2520                 }
2521                 if (clear & TIOCM_DTR) {
2522                         rs &= ~C_RS_DTR;
2523 #ifdef CY_DEBUG_DTR
2524                         printk(KERN_DEBUG "cyc:set_modem_info clearing "
2525                                 "Z DTR\n");
2526 #endif
2527                 }
2528                 cy_writel(&ch_ctrl->rs_control, rs);
2529                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2530                 spin_unlock_irqrestore(&card->card_lock, flags);
2531                 if (retval != 0) {
2532                         printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2533                                 "was %x\n", info->line, retval);
2534                 }
2535         }
2536         return 0;
2537 }
2538
2539 /*
2540  * cy_break() --- routine which turns the break handling on or off
2541  */
2542 static int cy_break(struct tty_struct *tty, int break_state)
2543 {
2544         struct cyclades_port *info = tty->driver_data;
2545         struct cyclades_card *card;
2546         unsigned long flags;
2547         int retval = 0;
2548
2549         if (serial_paranoia_check(info, tty->name, "cy_break"))
2550                 return -EINVAL;
2551
2552         card = info->card;
2553
2554         spin_lock_irqsave(&card->card_lock, flags);
2555         if (!cy_is_Z(card)) {
2556                 /* Let the transmit ISR take care of this (since it
2557                    requires stuffing characters into the output stream).
2558                  */
2559                 if (break_state == -1) {
2560                         if (!info->breakon) {
2561                                 info->breakon = 1;
2562                                 if (!info->xmit_cnt) {
2563                                         spin_unlock_irqrestore(&card->card_lock, flags);
2564                                         start_xmit(info);
2565                                         spin_lock_irqsave(&card->card_lock, flags);
2566                                 }
2567                         }
2568                 } else {
2569                         if (!info->breakoff) {
2570                                 info->breakoff = 1;
2571                                 if (!info->xmit_cnt) {
2572                                         spin_unlock_irqrestore(&card->card_lock, flags);
2573                                         start_xmit(info);
2574                                         spin_lock_irqsave(&card->card_lock, flags);
2575                                 }
2576                         }
2577                 }
2578         } else {
2579                 if (break_state == -1) {
2580                         retval = cyz_issue_cmd(card,
2581                                 info->line - card->first_line,
2582                                 C_CM_SET_BREAK, 0L);
2583                         if (retval != 0) {
2584                                 printk(KERN_ERR "cyc:cy_break (set) retval on "
2585                                         "ttyC%d was %x\n", info->line, retval);
2586                         }
2587                 } else {
2588                         retval = cyz_issue_cmd(card,
2589                                 info->line - card->first_line,
2590                                 C_CM_CLR_BREAK, 0L);
2591                         if (retval != 0) {
2592                                 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2593                                         "on ttyC%d was %x\n", info->line,
2594                                         retval);
2595                         }
2596                 }
2597         }
2598         spin_unlock_irqrestore(&card->card_lock, flags);
2599         return retval;
2600 }                               /* cy_break */
2601
2602 static int set_threshold(struct cyclades_port *info, unsigned long value)
2603 {
2604         struct cyclades_card *card = info->card;
2605         unsigned long flags;
2606
2607         if (!cy_is_Z(card)) {
2608                 info->cor3 &= ~CyREC_FIFO;
2609                 info->cor3 |= value & CyREC_FIFO;
2610
2611                 spin_lock_irqsave(&card->card_lock, flags);
2612                 cyy_writeb(info, CyCOR3, info->cor3);
2613                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2614                 spin_unlock_irqrestore(&card->card_lock, flags);
2615         }
2616         return 0;
2617 }                               /* set_threshold */
2618
2619 static int get_threshold(struct cyclades_port *info,
2620                                                 unsigned long __user *value)
2621 {
2622         struct cyclades_card *card = info->card;
2623
2624         if (!cy_is_Z(card)) {
2625                 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2626                 return put_user(tmp, value);
2627         }
2628         return 0;
2629 }                               /* get_threshold */
2630
2631 static int set_timeout(struct cyclades_port *info, unsigned long value)
2632 {
2633         struct cyclades_card *card = info->card;
2634         unsigned long flags;
2635
2636         if (!cy_is_Z(card)) {
2637                 spin_lock_irqsave(&card->card_lock, flags);
2638                 cyy_writeb(info, CyRTPR, value & 0xff);
2639                 spin_unlock_irqrestore(&card->card_lock, flags);
2640         }
2641         return 0;
2642 }                               /* set_timeout */
2643
2644 static int get_timeout(struct cyclades_port *info,
2645                                                 unsigned long __user *value)
2646 {
2647         struct cyclades_card *card = info->card;
2648
2649         if (!cy_is_Z(card)) {
2650                 u8 tmp = cyy_readb(info, CyRTPR);
2651                 return put_user(tmp, value);
2652         }
2653         return 0;
2654 }                               /* get_timeout */
2655
2656 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2657                 struct cyclades_icount *cprev)
2658 {
2659         struct cyclades_icount cnow;
2660         unsigned long flags;
2661         int ret;
2662
2663         spin_lock_irqsave(&info->card->card_lock, flags);
2664         cnow = info->icount;    /* atomic copy */
2665         spin_unlock_irqrestore(&info->card->card_lock, flags);
2666
2667         ret =   ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2668                 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2669                 ((arg & TIOCM_CD)  && (cnow.dcd != cprev->dcd)) ||
2670                 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2671
2672         *cprev = cnow;
2673
2674         return ret;
2675 }
2676
2677 /*
2678  * This routine allows the tty driver to implement device-
2679  * specific ioctl's.  If the ioctl number passed in cmd is
2680  * not recognized by the driver, it should return ENOIOCTLCMD.
2681  */
2682 static int
2683 cy_ioctl(struct tty_struct *tty, struct file *file,
2684          unsigned int cmd, unsigned long arg)
2685 {
2686         struct cyclades_port *info = tty->driver_data;
2687         struct cyclades_icount cnow;    /* kernel counter temps */
2688         int ret_val = 0;
2689         unsigned long flags;
2690         void __user *argp = (void __user *)arg;
2691
2692         if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2693                 return -ENODEV;
2694
2695 #ifdef CY_DEBUG_OTHER
2696         printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2697                 info->line, cmd, arg);
2698 #endif
2699
2700         switch (cmd) {
2701         case CYGETMON:
2702                 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2703                         ret_val = -EFAULT;
2704                         break;
2705                 }
2706                 memset(&info->mon, 0, sizeof(info->mon));
2707                 break;
2708         case CYGETTHRESH:
2709                 ret_val = get_threshold(info, argp);
2710                 break;
2711         case CYSETTHRESH:
2712                 ret_val = set_threshold(info, arg);
2713                 break;
2714         case CYGETDEFTHRESH:
2715                 ret_val = put_user(info->default_threshold,
2716                                 (unsigned long __user *)argp);
2717                 break;
2718         case CYSETDEFTHRESH:
2719                 info->default_threshold = arg & 0x0f;
2720                 break;
2721         case CYGETTIMEOUT:
2722                 ret_val = get_timeout(info, argp);
2723                 break;
2724         case CYSETTIMEOUT:
2725                 ret_val = set_timeout(info, arg);
2726                 break;
2727         case CYGETDEFTIMEOUT:
2728                 ret_val = put_user(info->default_timeout,
2729                                 (unsigned long __user *)argp);
2730                 break;
2731         case CYSETDEFTIMEOUT:
2732                 info->default_timeout = arg & 0xff;
2733                 break;
2734         case CYSETRFLOW:
2735                 info->rflow = (int)arg;
2736                 break;
2737         case CYGETRFLOW:
2738                 ret_val = info->rflow;
2739                 break;
2740         case CYSETRTSDTR_INV:
2741                 info->rtsdtr_inv = (int)arg;
2742                 break;
2743         case CYGETRTSDTR_INV:
2744                 ret_val = info->rtsdtr_inv;
2745                 break;
2746         case CYGETCD1400VER:
2747                 ret_val = info->chip_rev;
2748                 break;
2749 #ifndef CONFIG_CYZ_INTR
2750         case CYZSETPOLLCYCLE:
2751                 cyz_polling_cycle = (arg * HZ) / 1000;
2752                 break;
2753         case CYZGETPOLLCYCLE:
2754                 ret_val = (cyz_polling_cycle * 1000) / HZ;
2755                 break;
2756 #endif                          /* CONFIG_CYZ_INTR */
2757         case CYSETWAIT:
2758                 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2759                 break;
2760         case CYGETWAIT:
2761                 ret_val = info->port.closing_wait / (HZ / 100);
2762                 break;
2763         case TIOCGSERIAL:
2764                 ret_val = cy_get_serial_info(info, argp);
2765                 break;
2766         case TIOCSSERIAL:
2767                 ret_val = cy_set_serial_info(info, tty, argp);
2768                 break;
2769         case TIOCSERGETLSR:     /* Get line status register */
2770                 ret_val = get_lsr_info(info, argp);
2771                 break;
2772                 /*
2773                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2774                  * - mask passed in arg for lines of interest
2775                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2776                  * Caller should use TIOCGICOUNT to see which one it was
2777                  */
2778         case TIOCMIWAIT:
2779                 spin_lock_irqsave(&info->card->card_lock, flags);
2780                 /* note the counters on entry */
2781                 cnow = info->icount;
2782                 spin_unlock_irqrestore(&info->card->card_lock, flags);
2783                 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2784                                 cy_cflags_changed(info, arg, &cnow));
2785                 break;
2786
2787                 /*
2788                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2789                  * Return: write counters to the user passed counter struct
2790                  * NB: both 1->0 and 0->1 transitions are counted except for
2791                  *     RI where only 0->1 is counted.
2792                  */
2793         case TIOCGICOUNT: {
2794                 struct serial_icounter_struct sic = { };
2795
2796                 spin_lock_irqsave(&info->card->card_lock, flags);
2797                 cnow = info->icount;
2798                 spin_unlock_irqrestore(&info->card->card_lock, flags);
2799
2800                 sic.cts = cnow.cts;
2801                 sic.dsr = cnow.dsr;
2802                 sic.rng = cnow.rng;
2803                 sic.dcd = cnow.dcd;
2804                 sic.rx = cnow.rx;
2805                 sic.tx = cnow.tx;
2806                 sic.frame = cnow.frame;
2807                 sic.overrun = cnow.overrun;
2808                 sic.parity = cnow.parity;
2809                 sic.brk = cnow.brk;
2810                 sic.buf_overrun = cnow.buf_overrun;
2811
2812                 if (copy_to_user(argp, &sic, sizeof(sic)))
2813                         ret_val = -EFAULT;
2814                 break;
2815         }
2816         default:
2817                 ret_val = -ENOIOCTLCMD;
2818         }
2819
2820 #ifdef CY_DEBUG_OTHER
2821         printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2822 #endif
2823         return ret_val;
2824 }                               /* cy_ioctl */
2825
2826 /*
2827  * This routine allows the tty driver to be notified when
2828  * device's termios settings have changed.  Note that a
2829  * well-designed tty driver should be prepared to accept the case
2830  * where old == NULL, and try to do something rational.
2831  */
2832 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2833 {
2834         struct cyclades_port *info = tty->driver_data;
2835
2836 #ifdef CY_DEBUG_OTHER
2837         printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2838 #endif
2839
2840         cy_set_line_char(info, tty);
2841
2842         if ((old_termios->c_cflag & CRTSCTS) &&
2843                         !(tty->termios->c_cflag & CRTSCTS)) {
2844                 tty->hw_stopped = 0;
2845                 cy_start(tty);
2846         }
2847 #if 0
2848         /*
2849          * No need to wake up processes in open wait, since they
2850          * sample the CLOCAL flag once, and don't recheck it.
2851          * XXX  It's not clear whether the current behavior is correct
2852          * or not.  Hence, this may change.....
2853          */
2854         if (!(old_termios->c_cflag & CLOCAL) &&
2855             (tty->termios->c_cflag & CLOCAL))
2856                 wake_up_interruptible(&info->port.open_wait);
2857 #endif
2858 }                               /* cy_set_termios */
2859
2860 /* This function is used to send a high-priority XON/XOFF character to
2861    the device.
2862 */
2863 static void cy_send_xchar(struct tty_struct *tty, char ch)
2864 {
2865         struct cyclades_port *info = tty->driver_data;
2866         struct cyclades_card *card;
2867         int channel;
2868
2869         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2870                 return;
2871
2872         info->x_char = ch;
2873
2874         if (ch)
2875                 cy_start(tty);
2876
2877         card = info->card;
2878         channel = info->line - card->first_line;
2879
2880         if (cy_is_Z(card)) {
2881                 if (ch == STOP_CHAR(tty))
2882                         cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2883                 else if (ch == START_CHAR(tty))
2884                         cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2885         }
2886 }
2887
2888 /* This routine is called by the upper-layer tty layer to signal
2889    that incoming characters should be throttled because the input
2890    buffers are close to full.
2891  */
2892 static void cy_throttle(struct tty_struct *tty)
2893 {
2894         struct cyclades_port *info = tty->driver_data;
2895         struct cyclades_card *card;
2896         unsigned long flags;
2897
2898 #ifdef CY_DEBUG_THROTTLE
2899         char buf[64];
2900
2901         printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2902                         tty->ldisc.chars_in_buffer(tty), info->line);
2903 #endif
2904
2905         if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2906                 return;
2907
2908         card = info->card;
2909
2910         if (I_IXOFF(tty)) {
2911                 if (!cy_is_Z(card))
2912                         cy_send_xchar(tty, STOP_CHAR(tty));
2913                 else
2914                         info->throttle = 1;
2915         }
2916
2917         if (tty->termios->c_cflag & CRTSCTS) {
2918                 if (!cy_is_Z(card)) {
2919                         spin_lock_irqsave(&card->card_lock, flags);
2920                         cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2921                         spin_unlock_irqrestore(&card->card_lock, flags);
2922                 } else {
2923                         info->throttle = 1;
2924                 }
2925         }
2926 }                               /* cy_throttle */
2927
2928 /*
2929  * This routine notifies the tty driver that it should signal
2930  * that characters can now be sent to the tty without fear of
2931  * overrunning the input buffers of the line disciplines.
2932  */
2933 static void cy_unthrottle(struct tty_struct *tty)
2934 {
2935         struct cyclades_port *info = tty->driver_data;
2936         struct cyclades_card *card;
2937         unsigned long flags;
2938
2939 #ifdef CY_DEBUG_THROTTLE
2940         char buf[64];
2941
2942         printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2943                 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2944 #endif
2945
2946         if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2947                 return;
2948
2949         if (I_IXOFF(tty)) {
2950                 if (info->x_char)
2951                         info->x_char = 0;
2952                 else
2953                         cy_send_xchar(tty, START_CHAR(tty));
2954         }
2955
2956         if (tty->termios->c_cflag & CRTSCTS) {
2957                 card = info->card;
2958                 if (!cy_is_Z(card)) {
2959                         spin_lock_irqsave(&card->card_lock, flags);
2960                         cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2961                         spin_unlock_irqrestore(&card->card_lock, flags);
2962                 } else {
2963                         info->throttle = 0;
2964                 }
2965         }
2966 }                               /* cy_unthrottle */
2967
2968 /* cy_start and cy_stop provide software output flow control as a
2969    function of XON/XOFF, software CTS, and other such stuff.
2970 */
2971 static void cy_stop(struct tty_struct *tty)
2972 {
2973         struct cyclades_card *cinfo;
2974         struct cyclades_port *info = tty->driver_data;
2975         int channel;
2976         unsigned long flags;
2977
2978 #ifdef CY_DEBUG_OTHER
2979         printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2980 #endif
2981
2982         if (serial_paranoia_check(info, tty->name, "cy_stop"))
2983                 return;
2984
2985         cinfo = info->card;
2986         channel = info->line - cinfo->first_line;
2987         if (!cy_is_Z(cinfo)) {
2988                 spin_lock_irqsave(&cinfo->card_lock, flags);
2989                 cyy_writeb(info, CyCAR, channel & 0x03);
2990                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2991                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2992         }
2993 }                               /* cy_stop */
2994
2995 static void cy_start(struct tty_struct *tty)
2996 {
2997         struct cyclades_card *cinfo;
2998         struct cyclades_port *info = tty->driver_data;
2999         int channel;
3000         unsigned long flags;
3001
3002 #ifdef CY_DEBUG_OTHER
3003         printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
3004 #endif
3005
3006         if (serial_paranoia_check(info, tty->name, "cy_start"))
3007                 return;
3008
3009         cinfo = info->card;
3010         channel = info->line - cinfo->first_line;
3011         if (!cy_is_Z(cinfo)) {
3012                 spin_lock_irqsave(&cinfo->card_lock, flags);
3013                 cyy_writeb(info, CyCAR, channel & 0x03);
3014                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
3015                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3016         }
3017 }                               /* cy_start */
3018
3019 /*
3020  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
3021  */
3022 static void cy_hangup(struct tty_struct *tty)
3023 {
3024         struct cyclades_port *info = tty->driver_data;
3025
3026 #ifdef CY_DEBUG_OTHER
3027         printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
3028 #endif
3029
3030         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3031                 return;
3032
3033         cy_flush_buffer(tty);
3034         cy_shutdown(info, tty);
3035         tty_port_hangup(&info->port);
3036 }                               /* cy_hangup */
3037
3038 static int cyy_carrier_raised(struct tty_port *port)
3039 {
3040         struct cyclades_port *info = container_of(port, struct cyclades_port,
3041                         port);
3042         struct cyclades_card *cinfo = info->card;
3043         unsigned long flags;
3044         int channel = info->line - cinfo->first_line;
3045         u32 cd;
3046
3047         spin_lock_irqsave(&cinfo->card_lock, flags);
3048         cyy_writeb(info, CyCAR, channel & 0x03);
3049         cd = cyy_readb(info, CyMSVR1) & CyDCD;
3050         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3051
3052         return cd;
3053 }
3054
3055 static void cyy_dtr_rts(struct tty_port *port, int raise)
3056 {
3057         struct cyclades_port *info = container_of(port, struct cyclades_port,
3058                         port);
3059         struct cyclades_card *cinfo = info->card;
3060         unsigned long flags;
3061
3062         spin_lock_irqsave(&cinfo->card_lock, flags);
3063         cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3064                         raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3065         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3066 }
3067
3068 static int cyz_carrier_raised(struct tty_port *port)
3069 {
3070         struct cyclades_port *info = container_of(port, struct cyclades_port,
3071                         port);
3072
3073         return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3074 }
3075
3076 static void cyz_dtr_rts(struct tty_port *port, int raise)
3077 {
3078         struct cyclades_port *info = container_of(port, struct cyclades_port,
3079                         port);
3080         struct cyclades_card *cinfo = info->card;
3081         struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3082         int ret, channel = info->line - cinfo->first_line;
3083         u32 rs;
3084
3085         rs = readl(&ch_ctrl->rs_control);
3086         if (raise)
3087                 rs |= C_RS_RTS | C_RS_DTR;
3088         else
3089                 rs &= ~(C_RS_RTS | C_RS_DTR);
3090         cy_writel(&ch_ctrl->rs_control, rs);
3091         ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3092         if (ret != 0)
3093                 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3094                                 __func__, info->line, ret);
3095 #ifdef CY_DEBUG_DTR
3096         printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3097 #endif
3098 }
3099
3100 static const struct tty_port_operations cyy_port_ops = {
3101         .carrier_raised = cyy_carrier_raised,
3102         .dtr_rts = cyy_dtr_rts,
3103         .shutdown = cy_do_close,
3104 };
3105
3106 static const struct tty_port_operations cyz_port_ops = {
3107         .carrier_raised = cyz_carrier_raised,
3108         .dtr_rts = cyz_dtr_rts,
3109         .shutdown = cy_do_close,
3110 };
3111
3112 /*
3113  * ---------------------------------------------------------------------
3114  * cy_init() and friends
3115  *
3116  * cy_init() is called at boot-time to initialize the serial driver.
3117  * ---------------------------------------------------------------------
3118  */
3119
3120 static int __devinit cy_init_card(struct cyclades_card *cinfo)
3121 {
3122         struct cyclades_port *info;
3123         unsigned int channel, port;
3124
3125         spin_lock_init(&cinfo->card_lock);
3126         cinfo->intr_enabled = 0;
3127
3128         cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3129                         GFP_KERNEL);
3130         if (cinfo->ports == NULL) {
3131                 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3132                 return -ENOMEM;
3133         }
3134
3135         for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3136                         channel++, port++) {
3137                 info = &cinfo->ports[channel];
3138                 tty_port_init(&info->port);
3139                 info->magic = CYCLADES_MAGIC;
3140                 info->card = cinfo;
3141                 info->line = port;
3142
3143                 info->port.closing_wait = CLOSING_WAIT_DELAY;
3144                 info->port.close_delay = 5 * HZ / 10;
3145                 info->port.flags = STD_COM_FLAGS;
3146                 init_completion(&info->shutdown_wait);
3147
3148                 if (cy_is_Z(cinfo)) {
3149                         struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3150                         struct ZFW_CTRL *zfw_ctrl;
3151
3152                         info->port.ops = &cyz_port_ops;
3153                         info->type = PORT_STARTECH;
3154
3155                         zfw_ctrl = cinfo->base_addr +
3156                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3157                         info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3158                         info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3159
3160                         if (cinfo->hw_ver == ZO_V1)
3161                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3162                         else
3163                                 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3164 #ifdef CONFIG_CYZ_INTR
3165                         setup_timer(&cyz_rx_full_timer[port],
3166                                 cyz_rx_restart, (unsigned long)info);
3167 #endif
3168                 } else {
3169                         unsigned short chip_number;
3170                         int index = cinfo->bus_index;
3171
3172                         info->port.ops = &cyy_port_ops;
3173                         info->type = PORT_CIRRUS;
3174                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3175                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3176                         info->cor2 = CyETC;
3177                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
3178
3179                         chip_number = channel / CyPORTS_PER_CHIP;
3180                         info->u.cyy.base_addr = cinfo->base_addr +
3181                                 (cy_chip_offset[chip_number] << index);
3182                         info->chip_rev = cyy_readb(info, CyGFRCR);
3183
3184                         if (info->chip_rev >= CD1400_REV_J) {
3185                                 /* It is a CD1400 rev. J or later */
3186                                 info->tbpr = baud_bpr_60[13];   /* Tx BPR */
3187                                 info->tco = baud_co_60[13];     /* Tx CO */
3188                                 info->rbpr = baud_bpr_60[13];   /* Rx BPR */
3189                                 info->rco = baud_co_60[13];     /* Rx CO */
3190                                 info->rtsdtr_inv = 1;
3191                         } else {
3192                                 info->tbpr = baud_bpr_25[13];   /* Tx BPR */
3193                                 info->tco = baud_co_25[13];     /* Tx CO */
3194                                 info->rbpr = baud_bpr_25[13];   /* Rx BPR */
3195                                 info->rco = baud_co_25[13];     /* Rx CO */
3196                                 info->rtsdtr_inv = 0;
3197                         }
3198                         info->read_status_mask = CyTIMEOUT | CySPECHAR |
3199                                 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3200                 }
3201
3202         }
3203
3204 #ifndef CONFIG_CYZ_INTR
3205         if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3206                 mod_timer(&cyz_timerlist, jiffies + 1);
3207 #ifdef CY_PCI_DEBUG
3208                 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3209 #endif
3210         }
3211 #endif
3212         return 0;
3213 }
3214
3215 /* initialize chips on Cyclom-Y card -- return number of valid
3216    chips (which is number of ports/4) */
3217 static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
3218                 int index)
3219 {
3220         unsigned int chip_number;
3221         void __iomem *base_addr;
3222
3223         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3224         /* Cy_HwReset is 0x1400 */
3225         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3226         /* Cy_ClrIntr is 0x1800 */
3227         udelay(500L);
3228
3229         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3230                                                         chip_number++) {
3231                 base_addr =
3232                     true_base_addr + (cy_chip_offset[chip_number] << index);
3233                 mdelay(1);
3234                 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3235                         /*************
3236                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3237                         chip_number, (unsigned long)base_addr);
3238                         *************/
3239                         return chip_number;
3240                 }
3241
3242                 cy_writeb(base_addr + (CyGFRCR << index), 0);
3243                 udelay(10L);
3244
3245                 /* The Cyclom-16Y does not decode address bit 9 and therefore
3246                    cannot distinguish between references to chip 0 and a non-
3247                    existent chip 4.  If the preceding clearing of the supposed
3248                    chip 4 GFRCR register appears at chip 0, there is no chip 4
3249                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3250                  */
3251                 if (chip_number == 4 && readb(true_base_addr +
3252                                 (cy_chip_offset[0] << index) +
3253                                 (CyGFRCR << index)) == 0) {
3254                         return chip_number;
3255                 }
3256
3257                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3258                 mdelay(1);
3259
3260                 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3261                         /*
3262                            printk(" chip #%d at %#6lx is not responding ",
3263                            chip_number, (unsigned long)base_addr);
3264                            printk("(GFRCR stayed 0)\n",
3265                          */
3266                         return chip_number;
3267                 }
3268                 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3269                                 0x40) {
3270                         /*
3271                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
3272                                         "%#2x)\n",
3273                                         chip_number, (unsigned long)base_addr,
3274                                         base_addr[CyGFRCR<<index]);
3275                          */
3276                         return chip_number;
3277                 }
3278                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3279                 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3280                         /* It is a CD1400 rev. J or later */
3281                         /* Impossible to reach 5ms with this chip.
3282                            Changed to 2ms instead (f = 500 Hz). */
3283                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3284                 } else {
3285                         /* f = 200 Hz */
3286                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3287                 }
3288
3289                 /*
3290                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
3291                    chip_number, (unsigned long)base_addr,
3292                    readb(base_addr+(CyGFRCR<<index)));
3293                  */
3294         }
3295         return chip_number;
3296 }                               /* cyy_init_card */
3297
3298 /*
3299  * ---------------------------------------------------------------------
3300  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3301  * sets global variables and return the number of ISA boards found.
3302  * ---------------------------------------------------------------------
3303  */
3304 static int __init cy_detect_isa(void)
3305 {
3306 #ifdef CONFIG_ISA
3307         unsigned short cy_isa_irq, nboard;
3308         void __iomem *cy_isa_address;
3309         unsigned short i, j, cy_isa_nchan;
3310         int isparam = 0;
3311
3312         nboard = 0;
3313
3314         /* Check for module parameters */
3315         for (i = 0; i < NR_CARDS; i++) {
3316                 if (maddr[i] || i) {
3317                         isparam = 1;
3318                         cy_isa_addresses[i] = maddr[i];
3319                 }
3320                 if (!maddr[i])
3321                         break;
3322         }
3323
3324         /* scan the address table probing for Cyclom-Y/ISA boards */
3325         for (i = 0; i < NR_ISA_ADDRS; i++) {
3326                 unsigned int isa_address = cy_isa_addresses[i];
3327                 if (isa_address == 0x0000)
3328                         return nboard;
3329
3330                 /* probe for CD1400... */
3331                 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3332                 if (cy_isa_address == NULL) {
3333                         printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3334                                         "address\n");
3335                         continue;
3336                 }
3337                 cy_isa_nchan = CyPORTS_PER_CHIP *
3338                         cyy_init_card(cy_isa_address, 0);
3339                 if (cy_isa_nchan == 0) {
3340                         iounmap(cy_isa_address);
3341                         continue;
3342                 }
3343
3344                 if (isparam && i < NR_CARDS && irq[i])
3345                         cy_isa_irq = irq[i];
3346                 else
3347                         /* find out the board's irq by probing */
3348                         cy_isa_irq = detect_isa_irq(cy_isa_address);
3349                 if (cy_isa_irq == 0) {
3350                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3351                                 "IRQ could not be detected.\n",
3352                                 (unsigned long)cy_isa_address);
3353                         iounmap(cy_isa_address);
3354                         continue;
3355                 }
3356
3357                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3358                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3359                                 "more channels are available. Change NR_PORTS "
3360                                 "in cyclades.c and recompile kernel.\n",
3361                                 (unsigned long)cy_isa_address);
3362                         iounmap(cy_isa_address);
3363                         return nboard;
3364                 }
3365                 /* fill the next cy_card structure available */
3366                 for (j = 0; j < NR_CARDS; j++) {
3367                         if (cy_card[j].base_addr == NULL)
3368                                 break;
3369                 }
3370                 if (j == NR_CARDS) {    /* no more cy_cards available */
3371                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3372                                 "more cards can be used. Change NR_CARDS in "
3373                                 "cyclades.c and recompile kernel.\n",
3374                                 (unsigned long)cy_isa_address);
3375                         iounmap(cy_isa_address);
3376                         return nboard;
3377                 }
3378
3379                 /* allocate IRQ */
3380                 if (request_irq(cy_isa_irq, cyy_interrupt,
3381                                 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
3382                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3383                                 "could not allocate IRQ#%d.\n",
3384                                 (unsigned long)cy_isa_address, cy_isa_irq);
3385                         iounmap(cy_isa_address);
3386                         return nboard;
3387                 }
3388
3389                 /* set cy_card */
3390                 cy_card[j].base_addr = cy_isa_address;
3391                 cy_card[j].ctl_addr.p9050 = NULL;
3392                 cy_card[j].irq = (int)cy_isa_irq;
3393                 cy_card[j].bus_index = 0;
3394                 cy_card[j].first_line = cy_next_channel;
3395                 cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3396                 cy_card[j].nports = cy_isa_nchan;
3397                 if (cy_init_card(&cy_card[j])) {
3398                         cy_card[j].base_addr = NULL;
3399                         free_irq(cy_isa_irq, &cy_card[j]);
3400                         iounmap(cy_isa_address);
3401                         continue;
3402                 }
3403                 nboard++;
3404
3405                 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3406                         "%d channels starting from port %d\n",
3407                         j + 1, (unsigned long)cy_isa_address,
3408                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3409                         cy_isa_irq, cy_isa_nchan, cy_next_channel);
3410
3411                 for (j = cy_next_channel;
3412                                 j < cy_next_channel + cy_isa_nchan; j++)
3413                         tty_register_device(cy_serial_driver, j, NULL);
3414                 cy_next_channel += cy_isa_nchan;
3415         }
3416         return nboard;
3417 #else
3418         return 0;
3419 #endif                          /* CONFIG_ISA */
3420 }                               /* cy_detect_isa */
3421
3422 #ifdef CONFIG_PCI
3423 static inline int __devinit cyc_isfwstr(const char *str, unsigned int size)
3424 {
3425         unsigned int a;
3426
3427         for (a = 0; a < size && *str; a++, str++)
3428                 if (*str & 0x80)
3429                         return -EINVAL;
3430
3431         for (; a < size; a++, str++)
3432                 if (*str)
3433                         return -EINVAL;
3434
3435         return 0;
3436 }
3437
3438 static inline void __devinit cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3439                 unsigned int size)
3440 {
3441         for (; size > 0; size--) {
3442                 cy_writel(fpga, *data++);
3443                 udelay(10);
3444         }
3445 }
3446
3447 static void __devinit plx_init(struct pci_dev *pdev, int irq,
3448                 struct RUNTIME_9060 __iomem *addr)
3449 {
3450         /* Reset PLX */
3451         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3452         udelay(100L);
3453         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3454
3455         /* Reload Config. Registers from EEPROM */
3456         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3457         udelay(100L);
3458         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3459
3460         /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3461          * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3462          * registers. This will remain here until we find a permanent fix.
3463          */
3464         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3465 }
3466
3467 static int __devinit __cyz_load_fw(const struct firmware *fw,
3468                 const char *name, const u32 mailbox, void __iomem *base,
3469                 void __iomem *fpga)
3470 {
3471         const void *ptr = fw->data;
3472         const struct zfile_header *h = ptr;
3473         const struct zfile_config *c, *cs;
3474         const struct zfile_block *b, *bs;
3475         unsigned int a, tmp, len = fw->size;
3476 #define BAD_FW KERN_ERR "Bad firmware: "
3477         if (len < sizeof(*h)) {
3478                 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3479                 return -EINVAL;
3480         }
3481
3482         cs = ptr + h->config_offset;
3483         bs = ptr + h->block_offset;
3484
3485         if ((void *)(cs + h->n_config) > ptr + len ||
3486                         (void *)(bs + h->n_blocks) > ptr + len) {
3487                 printk(BAD_FW "too short");
3488                 return  -EINVAL;
3489         }
3490
3491         if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3492                         cyc_isfwstr(h->date, sizeof(h->date))) {
3493                 printk(BAD_FW "bad formatted header string\n");
3494                 return -EINVAL;
3495         }
3496
3497         if (strncmp(name, h->name, sizeof(h->name))) {
3498                 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3499                 return -EINVAL;
3500         }
3501
3502         tmp = 0;
3503         for (c = cs; c < cs + h->n_config; c++) {
3504                 for (a = 0; a < c->n_blocks; a++)
3505                         if (c->block_list[a] > h->n_blocks) {
3506                                 printk(BAD_FW "bad block ref number in cfgs\n");
3507                                 return -EINVAL;
3508                         }
3509                 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3510                         tmp++;
3511         }
3512         if (!tmp) {
3513                 printk(BAD_FW "nothing appropriate\n");
3514                 return -EINVAL;
3515         }
3516
3517         for (b = bs; b < bs + h->n_blocks; b++)
3518                 if (b->file_offset + b->size > len) {
3519                         printk(BAD_FW "bad block data offset\n");
3520                         return -EINVAL;
3521                 }
3522
3523         /* everything is OK, let's seek'n'load it */
3524         for (c = cs; c < cs + h->n_config; c++)
3525                 if (c->mailbox == mailbox && c->function == 0)
3526                         break;
3527
3528         for (a = 0; a < c->n_blocks; a++) {
3529                 b = &bs[c->block_list[a]];
3530                 if (b->type == ZBLOCK_FPGA) {
3531                         if (fpga != NULL)
3532                                 cyz_fpga_copy(fpga, ptr + b->file_offset,
3533                                                 b->size);
3534                 } else {
3535                         if (base != NULL)
3536                                 memcpy_toio(base + b->ram_offset,
3537                                                ptr + b->file_offset, b->size);
3538                 }
3539         }
3540 #undef BAD_FW
3541         return 0;
3542 }
3543
3544 static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3545                 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3546 {
3547         const struct firmware *fw;
3548         struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3549         struct CUSTOM_REG __iomem *cust = base_addr;
3550         struct ZFW_CTRL __iomem *pt_zfwctrl;
3551         void __iomem *tmp;
3552         u32 mailbox, status, nchan;
3553         unsigned int i;
3554         int retval;
3555
3556         retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3557         if (retval) {
3558                 dev_err(&pdev->dev, "can't get firmware\n");
3559                 goto err;
3560         }
3561
3562         /* Check whether the firmware is already loaded and running. If
3563            positive, skip this board */
3564         if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3565                 u32 cntval = readl(base_addr + 0x190);
3566
3567                 udelay(100);
3568                 if (cntval != readl(base_addr + 0x190)) {
3569                         /* FW counter is working, FW is running */
3570                         dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3571                                         "Skipping board.\n");
3572                         retval = 0;
3573                         goto err_rel;
3574                 }
3575         }
3576
3577         /* start boot */
3578         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3579                         ~0x00030800UL);
3580
3581         mailbox = readl(&ctl_addr->mail_box_0);
3582
3583         if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3584                 /* stops CPU and set window to beginning of RAM */
3585                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3586                 cy_writel(&cust->cpu_stop, 0);
3587                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3588                 udelay(100);
3589         }
3590
3591         plx_init(pdev, irq, ctl_addr);
3592
3593         if (mailbox != 0) {
3594                 /* load FPGA */
3595                 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3596                                 base_addr);
3597                 if (retval)
3598                         goto err_rel;
3599                 if (!__cyz_fpga_loaded(ctl_addr)) {
3600                         dev_err(&pdev->dev, "fw upload successful, but fw is "
3601                                         "not loaded\n");
3602                         goto err_rel;
3603                 }
3604         }
3605
3606         /* stops CPU and set window to beginning of RAM */
3607         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3608         cy_writel(&cust->cpu_stop, 0);
3609         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3610         udelay(100);
3611
3612         /* clear memory */
3613         for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3614                 cy_writeb(tmp, 255);
3615         if (mailbox != 0) {
3616                 /* set window to last 512K of RAM */
3617                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3618                 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3619                         cy_writeb(tmp, 255);
3620                 /* set window to beginning of RAM */
3621                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3622         }
3623
3624         retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3625         release_firmware(fw);
3626         if (retval)
3627                 goto err;
3628
3629         /* finish boot and start boards */
3630         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3631         cy_writel(&cust->cpu_start, 0);
3632         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3633         i = 0;
3634         while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3635                 msleep(100);
3636         if (status != ZFIRM_ID) {
3637                 if (status == ZFIRM_HLT) {
3638                         dev_err(&pdev->dev, "you need an external power supply "
3639                                 "for this number of ports. Firmware halted and "
3640                                 "board reset.\n");
3641                         retval = -EIO;
3642                         goto err;
3643                 }
3644                 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3645                                 "some more time\n", status);
3646                 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3647                                 i++ < 200)
3648                         msleep(100);
3649                 if (status != ZFIRM_ID) {
3650                         dev_err(&pdev->dev, "Board not started in 20 seconds! "
3651                                         "Giving up. (fid->signature = 0x%x)\n",
3652                                         status);
3653                         dev_info(&pdev->dev, "*** Warning ***: if you are "
3654                                 "upgrading the FW, please power cycle the "
3655                                 "system before loading the new FW to the "
3656                                 "Cyclades-Z.\n");
3657
3658                         if (__cyz_fpga_loaded(ctl_addr))
3659                                 plx_init(pdev, irq, ctl_addr);
3660
3661                         retval = -EIO;
3662                         goto err;
3663                 }
3664                 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3665                                 i / 10);
3666         }
3667         pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3668
3669         dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3670                         base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3671                         base_addr + readl(&fid->zfwctrl_addr));
3672
3673         nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3674         dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3675                 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3676
3677         if (nchan == 0) {
3678                 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3679                         "check the connection between the Z host card and the "
3680                         "serial expanders.\n");
3681
3682                 if (__cyz_fpga_loaded(ctl_addr))
3683                         plx_init(pdev, irq, ctl_addr);
3684
3685                 dev_info(&pdev->dev, "Null number of ports detected. Board "
3686                                 "reset.\n");
3687                 retval = 0;
3688                 goto err;
3689         }
3690
3691         cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3692         cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3693
3694         /*
3695            Early firmware failed to start looking for commands.
3696            This enables firmware interrupts for those commands.
3697          */
3698         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3699                         (1 << 17));
3700         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3701                         0x00030800UL);
3702
3703         return nchan;
3704 err_rel:
3705         release_firmware(fw);
3706 err:
3707         return retval;
3708 }
3709
3710 static int __devinit cy_pci_probe(struct pci_dev *pdev,
3711                 const struct pci_device_id *ent)
3712 {
3713         void __iomem *addr0 = NULL, *addr2 = NULL;
3714         char *card_name = NULL;
3715         u32 uninitialized_var(mailbox);
3716         unsigned int device_id, nchan = 0, card_no, i;
3717         unsigned char plx_ver;
3718         int retval, irq;
3719
3720         retval = pci_enable_device(pdev);
3721         if (retval) {
3722                 dev_err(&pdev->dev, "cannot enable device\n");
3723                 goto err;
3724         }
3725
3726         /* read PCI configuration area */
3727         irq = pdev->irq;
3728         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3729
3730 #if defined(__alpha__)
3731         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
3732                 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3733                         "addresses on Alpha systems.\n");
3734                 retval = -EIO;
3735                 goto err_dis;
3736         }
3737 #endif
3738         if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3739                 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3740                         "addresses\n");
3741                 retval = -EIO;
3742                 goto err_dis;
3743         }
3744
3745         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3746                 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3747                                 "it...\n");
3748                 pdev->resource[2].flags &= ~IORESOURCE_IO;
3749         }
3750
3751         retval = pci_request_regions(pdev, "cyclades");
3752         if (retval) {
3753                 dev_err(&pdev->dev, "failed to reserve resources\n");
3754                 goto err_dis;
3755         }
3756
3757         retval = -EIO;
3758         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3759                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3760                 card_name = "Cyclom-Y";
3761
3762                 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3763                                 CyPCI_Yctl);
3764                 if (addr0 == NULL) {
3765                         dev_err(&pdev->dev, "can't remap ctl region\n");
3766                         goto err_reg;
3767                 }
3768                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3769                                 CyPCI_Ywin);
3770                 if (addr2 == NULL) {
3771                         dev_err(&pdev->dev, "can't remap base region\n");
3772                         goto err_unmap;
3773                 }
3774
3775                 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3776                 if (nchan == 0) {
3777                         dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3778                                         "Serial-Modules\n");
3779                         goto err_unmap;
3780                 }
3781         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3782                 struct RUNTIME_9060 __iomem *ctl_addr;
3783
3784                 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3785                                 CyPCI_Zctl);
3786                 if (addr0 == NULL) {
3787                         dev_err(&pdev->dev, "can't remap ctl region\n");
3788                         goto err_reg;
3789                 }
3790
3791                 /* Disable interrupts on the PLX before resetting it */
3792                 cy_writew(&ctl_addr->intr_ctrl_stat,
3793                                 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3794
3795                 plx_init(pdev, irq, addr0);
3796
3797                 mailbox = readl(&ctl_addr->mail_box_0);
3798
3799                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3800                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3801                 if (addr2 == NULL) {
3802                         dev_err(&pdev->dev, "can't remap base region\n");
3803                         goto err_unmap;
3804                 }
3805
3806                 if (mailbox == ZE_V1) {
3807                         card_name = "Cyclades-Ze";
3808                 } else {
3809                         card_name = "Cyclades-8Zo";
3810 #ifdef CY_PCI_DEBUG
3811                         if (mailbox == ZO_V1) {
3812                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3813                                 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3814                                         "id %lx, ver %lx\n", (ulong)(0xff &
3815                                         readl(&((struct CUSTOM_REG *)addr2)->
3816                                                 fpga_id)), (ulong)(0xff &
3817                                         readl(&((struct CUSTOM_REG *)addr2)->
3818                                                 fpga_version)));
3819                                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3820                         } else {
3821                                 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3822                                         "Cyclades-Z board.  FPGA not loaded\n");
3823                         }
3824 #endif
3825                         /* The following clears the firmware id word.  This
3826                            ensures that the driver will not attempt to talk to
3827                            the board until it has been properly initialized.
3828                          */
3829                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3830                                 cy_writel(addr2 + ID_ADDRESS, 0L);
3831                 }
3832
3833                 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3834                 if (retval <= 0)
3835                         goto err_unmap;
3836                 nchan = retval;
3837         }
3838
3839         if ((cy_next_channel + nchan) > NR_PORTS) {
3840                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3841                         "channels are available. Change NR_PORTS in "
3842                         "cyclades.c and recompile kernel.\n");
3843                 goto err_unmap;
3844         }
3845         /* fill the next cy_card structure available */
3846         for (card_no = 0; card_no < NR_CARDS; card_no++) {
3847                 if (cy_card[card_no].base_addr == NULL)
3848                         break;
3849         }
3850         if (card_no == NR_CARDS) {      /* no more cy_cards available */
3851                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3852                         "more cards can be used. Change NR_CARDS in "
3853                         "cyclades.c and recompile kernel.\n");
3854                 goto err_unmap;
3855         }
3856
3857         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3858                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3859                 /* allocate IRQ */
3860                 retval = request_irq(irq, cyy_interrupt,
3861                                 IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
3862                 if (retval) {
3863                         dev_err(&pdev->dev, "could not allocate IRQ\n");
3864                         goto err_unmap;
3865                 }
3866                 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
3867         } else {
3868                 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3869                 struct ZFW_CTRL __iomem *zfw_ctrl;
3870
3871                 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3872
3873                 cy_card[card_no].hw_ver = mailbox;
3874                 cy_card[card_no].num_chips = (unsigned int)-1;
3875                 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
3876 #ifdef CONFIG_CYZ_INTR
3877                 /* allocate IRQ only if board has an IRQ */
3878                 if (irq != 0 && irq != 255) {
3879                         retval = request_irq(irq, cyz_interrupt,
3880                                         IRQF_SHARED, "Cyclades-Z",
3881                                         &cy_card[card_no]);
3882                         if (retval) {
3883                                 dev_err(&pdev->dev, "could not allocate IRQ\n");
3884                                 goto err_unmap;
3885                         }
3886                 }
3887 #endif                          /* CONFIG_CYZ_INTR */
3888         }
3889
3890         /* set cy_card */
3891         cy_card[card_no].base_addr = addr2;
3892         cy_card[card_no].ctl_addr.p9050 = addr0;
3893         cy_card[card_no].irq = irq;
3894         cy_card[card_no].bus_index = 1;
3895         cy_card[card_no].first_line = cy_next_channel;
3896         cy_card[card_no].nports = nchan;
3897         retval = cy_init_card(&cy_card[card_no]);
3898         if (retval)
3899                 goto err_null;
3900
3901         pci_set_drvdata(pdev, &cy_card[card_no]);
3902
3903         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3904                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3905                 /* enable interrupts in the PCI interface */
3906                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3907                 switch (plx_ver) {
3908                 case PLX_9050:
3909                         cy_writeb(addr0 + 0x4c, 0x43);
3910                         break;
3911
3912                 case PLX_9060:
3913                 case PLX_9080:
3914                 default:        /* Old boards, use PLX_9060 */
3915                 {
3916                         struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3917                         plx_init(pdev, irq, ctl_addr);
3918                         cy_writew(&ctl_addr->intr_ctrl_stat,
3919                                 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3920                         break;
3921                 }
3922                 }
3923         }
3924
3925         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3926                 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3927         for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
3928                 tty_register_device(cy_serial_driver, i, &pdev->dev);
3929         cy_next_channel += nchan;
3930
3931         return 0;
3932 err_null:
3933         cy_card[card_no].base_addr = NULL;
3934         free_irq(irq, &cy_card[card_no]);
3935 err_unmap:
3936         iounmap(addr0);
3937         if (addr2)
3938                 iounmap(addr2);
3939 err_reg:
3940         pci_release_regions(pdev);
3941 err_dis:
3942         pci_disable_device(pdev);
3943 err:
3944         return retval;
3945 }
3946
3947 static void __devexit cy_pci_remove(struct pci_dev *pdev)
3948 {
3949         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3950         unsigned int i;
3951
3952         /* non-Z with old PLX */
3953         if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3954                         PLX_9050)
3955                 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3956         else
3957 #ifndef CONFIG_CYZ_INTR
3958                 if (!cy_is_Z(cinfo))
3959 #endif
3960                 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3961                         readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3962                         ~0x0900);
3963
3964         iounmap(cinfo->base_addr);
3965         if (cinfo->ctl_addr.p9050)
3966                 iounmap(cinfo->ctl_addr.p9050);
3967         if (cinfo->irq
3968 #ifndef CONFIG_CYZ_INTR
3969                 && !cy_is_Z(cinfo)
3970 #endif /* CONFIG_CYZ_INTR */
3971                 )
3972                 free_irq(cinfo->irq, cinfo);
3973         pci_release_regions(pdev);
3974
3975         cinfo->base_addr = NULL;
3976         for (i = cinfo->first_line; i < cinfo->first_line +
3977                         cinfo->nports; i++)
3978                 tty_unregister_device(cy_serial_driver, i);
3979         cinfo->nports = 0;
3980         kfree(cinfo->ports);
3981 }
3982
3983 static struct pci_driver cy_pci_driver = {
3984         .name = "cyclades",
3985         .id_table = cy_pci_dev_id,
3986         .probe = cy_pci_probe,
3987         .remove = __devexit_p(cy_pci_remove)
3988 };
3989 #endif
3990
3991 static int cyclades_proc_show(struct seq_file *m, void *v)
3992 {
3993         struct cyclades_port *info;
3994         unsigned int i, j;
3995         __u32 cur_jifs = jiffies;
3996
3997         seq_puts(m, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
3998                         "IdleIn  Overruns  Ldisc\n");
3999
4000         /* Output one line for each known port */
4001         for (i = 0; i < NR_CARDS; i++)
4002                 for (j = 0; j < cy_card[i].nports; j++) {
4003                         info = &cy_card[i].ports[j];
4004
4005                         if (info->port.count) {
4006                                 /* XXX is the ldisc num worth this? */
4007                                 struct tty_struct *tty;
4008                                 struct tty_ldisc *ld;
4009                                 int num = 0;
4010                                 tty = tty_port_tty_get(&info->port);
4011                                 if (tty) {
4012                                         ld = tty_ldisc_ref(tty);
4013                                         if (ld) {
4014                                                 num = ld->ops->num;
4015                                                 tty_ldisc_deref(ld);
4016                                         }
4017                                         tty_kref_put(tty);
4018                                 }
4019                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4020                                         "%10lu %8lu %9lu %6d\n", info->line,
4021                                         (cur_jifs - info->idle_stats.in_use) /
4022                                         HZ, info->idle_stats.xmit_bytes,
4023                                         (cur_jifs - info->idle_stats.xmit_idle)/
4024                                         HZ, info->idle_stats.recv_bytes,
4025                                         (cur_jifs - info->idle_stats.recv_idle)/
4026                                         HZ, info->idle_stats.overruns,
4027                                         num);
4028                         } else
4029                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4030                                         "%10lu %8lu %9lu %6ld\n",
4031                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4032                 }
4033         return 0;
4034 }
4035
4036 static int cyclades_proc_open(struct inode *inode, struct file *file)
4037 {
4038         return single_open(file, cyclades_proc_show, NULL);
4039 }
4040
4041 static const struct file_operations cyclades_proc_fops = {
4042         .owner          = THIS_MODULE,
4043         .open           = cyclades_proc_open,
4044         .read           = seq_read,
4045         .llseek         = seq_lseek,
4046         .release        = single_release,
4047 };
4048
4049 /* The serial driver boot-time initialization code!
4050     Hardware I/O ports are mapped to character special devices on a
4051     first found, first allocated manner.  That is, this code searches
4052     for Cyclom cards in the system.  As each is found, it is probed
4053     to discover how many chips (and thus how many ports) are present.
4054     These ports are mapped to the tty ports 32 and upward in monotonic
4055     fashion.  If an 8-port card is replaced with a 16-port card, the
4056     port mapping on a following card will shift.
4057
4058     This approach is different from what is used in the other serial
4059     device driver because the Cyclom is more properly a multiplexer,
4060     not just an aggregation of serial ports on one card.
4061
4062     If there are more cards with more ports than have been
4063     statically allocated above, a warning is printed and the
4064     extra ports are ignored.
4065  */
4066
4067 static const struct tty_operations cy_ops = {
4068         .open = cy_open,
4069         .close = cy_close,
4070         .write = cy_write,
4071         .put_char = cy_put_char,
4072         .flush_chars = cy_flush_chars,
4073         .write_room = cy_write_room,
4074         .chars_in_buffer = cy_chars_in_buffer,
4075         .flush_buffer = cy_flush_buffer,
4076         .ioctl = cy_ioctl,
4077         .throttle = cy_throttle,
4078         .unthrottle = cy_unthrottle,
4079         .set_termios = cy_set_termios,
4080         .stop = cy_stop,
4081         .start = cy_start,
4082         .hangup = cy_hangup,
4083         .break_ctl = cy_break,
4084         .wait_until_sent = cy_wait_until_sent,
4085         .tiocmget = cy_tiocmget,
4086         .tiocmset = cy_tiocmset,
4087         .proc_fops = &cyclades_proc_fops,
4088 };
4089
4090 static int __init cy_init(void)
4091 {
4092         unsigned int nboards;
4093         int retval = -ENOMEM;
4094
4095         cy_serial_driver = alloc_tty_driver(NR_PORTS);
4096         if (!cy_serial_driver)
4097                 goto err;
4098
4099         printk(KERN_INFO "Cyclades driver " CY_VERSION " (built %s %s)\n",
4100                         __DATE__, __TIME__);
4101
4102         /* Initialize the tty_driver structure */
4103
4104         cy_serial_driver->owner = THIS_MODULE;
4105         cy_serial_driver->driver_name = "cyclades";
4106         cy_serial_driver->name = "ttyC";
4107         cy_serial_driver->major = CYCLADES_MAJOR;
4108         cy_serial_driver->minor_start = 0;
4109         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4110         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4111         cy_serial_driver->init_termios = tty_std_termios;
4112         cy_serial_driver->init_termios.c_cflag =
4113             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4114         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4115         tty_set_operations(cy_serial_driver, &cy_ops);
4116
4117         retval = tty_register_driver(cy_serial_driver);
4118         if (retval) {
4119                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4120                 goto err_frtty;
4121         }
4122
4123         /* the code below is responsible to find the boards. Each different
4124            type of board has its own detection routine. If a board is found,
4125            the next cy_card structure available is set by the detection
4126            routine. These functions are responsible for checking the
4127            availability of cy_card and cy_port data structures and updating
4128            the cy_next_channel. */
4129
4130         /* look for isa boards */
4131         nboards = cy_detect_isa();
4132
4133 #ifdef CONFIG_PCI
4134         /* look for pci boards */
4135         retval = pci_register_driver(&cy_pci_driver);
4136         if (retval && !nboards) {
4137                 tty_unregister_driver(cy_serial_driver);
4138                 goto err_frtty;
4139         }
4140 #endif
4141
4142         return 0;
4143 err_frtty:
4144         put_tty_driver(cy_serial_driver);
4145 err:
4146         return retval;
4147 }                               /* cy_init */
4148
4149 static void __exit cy_cleanup_module(void)
4150 {
4151         struct cyclades_card *card;
4152         unsigned int i, e1;
4153
4154 #ifndef CONFIG_CYZ_INTR
4155         del_timer_sync(&cyz_timerlist);
4156 #endif /* CONFIG_CYZ_INTR */
4157
4158         e1 = tty_unregister_driver(cy_serial_driver);
4159         if (e1)
4160                 printk(KERN_ERR "failed to unregister Cyclades serial "
4161                                 "driver(%d)\n", e1);
4162
4163 #ifdef CONFIG_PCI
4164         pci_unregister_driver(&cy_pci_driver);
4165 #endif
4166
4167         for (i = 0; i < NR_CARDS; i++) {
4168                 card = &cy_card[i];
4169                 if (card->base_addr) {
4170                         /* clear interrupt */
4171                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4172                         iounmap(card->base_addr);
4173                         if (card->ctl_addr.p9050)
4174                                 iounmap(card->ctl_addr.p9050);
4175                         if (card->irq
4176 #ifndef CONFIG_CYZ_INTR
4177                                 && !cy_is_Z(card)
4178 #endif /* CONFIG_CYZ_INTR */
4179                                 )
4180                                 free_irq(card->irq, card);
4181                         for (e1 = card->first_line; e1 < card->first_line +
4182                                         card->nports; e1++)
4183                                 tty_unregister_device(cy_serial_driver, e1);
4184                         kfree(card->ports);
4185                 }
4186         }
4187
4188         put_tty_driver(cy_serial_driver);
4189 } /* cy_cleanup_module */
4190
4191 module_init(cy_init);
4192 module_exit(cy_cleanup_module);
4193
4194 MODULE_LICENSE("GPL");
4195 MODULE_VERSION(CY_VERSION);
4196 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4197 MODULE_FIRMWARE("cyzfirm.bin");