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