drivers/tty/cyclades.c

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