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 <bentson@grieg.seaslug.org>.
  10  * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
  11  *
  12  * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
  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) && (info->port.flags & ASYNC_CTS_FLOW)) {
 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(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 (!tty->termios) /* XXX can this happen at all? */
2003                 return;
2004
2005         if (info->line == -1)
2006                 return;
2007
2008         cflag = tty->termios->c_cflag;
2009         iflag = tty->termios->c_iflag;
2010
2011         /*
2012          * Set up the tty->alt_speed kludge
2013          */
2014         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2015                 tty->alt_speed = 57600;
2016         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2017                 tty->alt_speed = 115200;
2018         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2019                 tty->alt_speed = 230400;
2020         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2021                 tty->alt_speed = 460800;
2022
2023         card = info->card;
2024         channel = info->line - card->first_line;
2025
2026         if (!cy_is_Z(card)) {
2027                 u32 cflags;
2028
2029                 /* baud rate */
2030                 baud = tty_get_baud_rate(tty);
2031                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2032                                 ASYNC_SPD_CUST) {
2033                         if (info->custom_divisor)
2034                                 baud_rate = info->baud / info->custom_divisor;
2035                         else
2036                                 baud_rate = info->baud;
2037                 } else if (baud > CD1400_MAX_SPEED) {
2038                         baud = CD1400_MAX_SPEED;
2039                 }
2040                 /* find the baud index */
2041                 for (i = 0; i < 20; i++) {
2042                         if (baud == baud_table[i])
2043                                 break;
2044                 }
2045                 if (i == 20)
2046                         i = 19; /* CD1400_MAX_SPEED */
2047
2048                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2049                                 ASYNC_SPD_CUST) {
2050                         cyy_baud_calc(info, baud_rate);
2051                 } else {
2052                         if (info->chip_rev >= CD1400_REV_J) {
2053                                 /* It is a CD1400 rev. J or later */
2054                                 info->tbpr = baud_bpr_60[i];    /* Tx BPR */
2055                                 info->tco = baud_co_60[i];      /* Tx CO */
2056                                 info->rbpr = baud_bpr_60[i];    /* Rx BPR */
2057                                 info->rco = baud_co_60[i];      /* Rx CO */
2058                         } else {
2059                                 info->tbpr = baud_bpr_25[i];    /* Tx BPR */
2060                                 info->tco = baud_co_25[i];      /* Tx CO */
2061                                 info->rbpr = baud_bpr_25[i];    /* Rx BPR */
2062                                 info->rco = baud_co_25[i];      /* Rx CO */
2063                         }
2064                 }
2065                 if (baud_table[i] == 134) {
2066                         /* get it right for 134.5 baud */
2067                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2068                                         2;
2069                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2070                                 ASYNC_SPD_CUST) {
2071                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2072                                         baud_rate) + 2;
2073                 } else if (baud_table[i]) {
2074                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2075                                         baud_table[i]) + 2;
2076                         /* this needs to be propagated into the card info */
2077                 } else {
2078                         info->timeout = 0;
2079                 }
2080                 /* By tradition (is it a standard?) a baud rate of zero
2081                    implies the line should be/has been closed.  A bit
2082                    later in this routine such a test is performed. */
2083
2084                 /* byte size and parity */
2085                 info->cor5 = 0;
2086                 info->cor4 = 0;
2087                 /* receive threshold */
2088                 info->cor3 = (info->default_threshold ?
2089                                 info->default_threshold : baud_cor3[i]);
2090                 info->cor2 = CyETC;
2091                 switch (cflag & CSIZE) {
2092                 case CS5:
2093                         info->cor1 = Cy_5_BITS;
2094                         break;
2095                 case CS6:
2096                         info->cor1 = Cy_6_BITS;
2097                         break;
2098                 case CS7:
2099                         info->cor1 = Cy_7_BITS;
2100                         break;
2101                 case CS8:
2102                         info->cor1 = Cy_8_BITS;
2103                         break;
2104                 }
2105                 if (cflag & CSTOPB)
2106                         info->cor1 |= Cy_2_STOP;
2107
2108                 if (cflag & PARENB) {
2109                         if (cflag & PARODD)
2110                                 info->cor1 |= CyPARITY_O;
2111                         else
2112                                 info->cor1 |= CyPARITY_E;
2113                 } else
2114                         info->cor1 |= CyPARITY_NONE;
2115
2116                 /* CTS flow control flag */
2117                 if (cflag & CRTSCTS) {
2118                         info->port.flags |= ASYNC_CTS_FLOW;
2119                         info->cor2 |= CyCtsAE;
2120                 } else {
2121                         info->port.flags &= ~ASYNC_CTS_FLOW;
2122                         info->cor2 &= ~CyCtsAE;
2123                 }
2124                 if (cflag & CLOCAL)
2125                         info->port.flags &= ~ASYNC_CHECK_CD;
2126                 else
2127                         info->port.flags |= ASYNC_CHECK_CD;
2128
2129          /***********************************************
2130             The hardware option, CyRtsAO, presents RTS when
2131             the chip has characters to send.  Since most modems
2132             use RTS as reverse (inbound) flow control, this
2133             option is not used.  If inbound flow control is
2134             necessary, DTR can be programmed to provide the
2135             appropriate signals for use with a non-standard
2136             cable.  Contact Marcio Saito for details.
2137          ***********************************************/
2138
2139                 channel &= 0x03;
2140
2141                 spin_lock_irqsave(&card->card_lock, flags);
2142                 cyy_writeb(info, CyCAR, channel);
2143
2144                 /* tx and rx baud rate */
2145
2146                 cyy_writeb(info, CyTCOR, info->tco);
2147                 cyy_writeb(info, CyTBPR, info->tbpr);
2148                 cyy_writeb(info, CyRCOR, info->rco);
2149                 cyy_writeb(info, CyRBPR, info->rbpr);
2150
2151                 /* set line characteristics  according configuration */
2152
2153                 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2154                 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2155                 cyy_writeb(info, CyCOR1, info->cor1);
2156                 cyy_writeb(info, CyCOR2, info->cor2);
2157                 cyy_writeb(info, CyCOR3, info->cor3);
2158                 cyy_writeb(info, CyCOR4, info->cor4);
2159                 cyy_writeb(info, CyCOR5, info->cor5);
2160
2161                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2162                                 CyCOR3ch);
2163
2164                 /* !!! Is this needed? */
2165                 cyy_writeb(info, CyCAR, channel);
2166                 cyy_writeb(info, CyRTPR,
2167                         (info->default_timeout ? info->default_timeout : 0x02));
2168                 /* 10ms rx timeout */
2169
2170                 cflags = CyCTS;
2171                 if (!C_CLOCAL(tty))
2172                         cflags |= CyDSR | CyRI | CyDCD;
2173                 /* without modem intr */
2174                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2175                 /* act on 1->0 modem transitions */
2176                 if ((cflag & CRTSCTS) && info->rflow)
2177                         cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2178                 else
2179                         cyy_writeb(info, CyMCOR1, cflags);
2180                 /* act on 0->1 modem transitions */
2181                 cyy_writeb(info, CyMCOR2, cflags);
2182
2183                 if (i == 0)     /* baud rate is zero, turn off line */
2184                         cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2185                 else
2186                         cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2187
2188                 clear_bit(TTY_IO_ERROR, &tty->flags);
2189                 spin_unlock_irqrestore(&card->card_lock, flags);
2190
2191         } else {
2192                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2193                 __u32 sw_flow;
2194                 int retval;
2195
2196                 if (!cyz_is_loaded(card))
2197                         return;
2198
2199                 /* baud rate */
2200                 baud = tty_get_baud_rate(tty);
2201                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2202                                 ASYNC_SPD_CUST) {
2203                         if (info->custom_divisor)
2204                                 baud_rate = info->baud / info->custom_divisor;
2205                         else
2206                                 baud_rate = info->baud;
2207                 } else if (baud > CYZ_MAX_SPEED) {
2208                         baud = CYZ_MAX_SPEED;
2209                 }
2210                 cy_writel(&ch_ctrl->comm_baud, baud);
2211
2212                 if (baud == 134) {
2213                         /* get it right for 134.5 baud */
2214                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2215                                         2;
2216                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2217                                 ASYNC_SPD_CUST) {
2218                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2219                                         baud_rate) + 2;
2220                 } else if (baud) {
2221                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2222                                         baud) + 2;
2223                         /* this needs to be propagated into the card info */
2224                 } else {
2225                         info->timeout = 0;
2226                 }
2227
2228                 /* byte size and parity */
2229                 switch (cflag & CSIZE) {
2230                 case CS5:
2231                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2232                         break;
2233                 case CS6:
2234                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2235                         break;
2236                 case CS7:
2237                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2238                         break;
2239                 case CS8:
2240                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2241                         break;
2242                 }
2243                 if (cflag & CSTOPB) {
2244                         cy_writel(&ch_ctrl->comm_data_l,
2245                                   readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2246                 } else {
2247                         cy_writel(&ch_ctrl->comm_data_l,
2248                                   readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2249                 }
2250                 if (cflag & PARENB) {
2251                         if (cflag & PARODD)
2252                                 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2253                         else
2254                                 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2255                 } else
2256                         cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2257
2258                 /* CTS flow control flag */
2259                 if (cflag & CRTSCTS) {
2260                         cy_writel(&ch_ctrl->hw_flow,
2261                                 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2262                 } else {
2263                         cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2264                                         ~(C_RS_CTS | C_RS_RTS));
2265                 }
2266                 /* As the HW flow control is done in firmware, the driver
2267                    doesn't need to care about it */
2268                 info->port.flags &= ~ASYNC_CTS_FLOW;
2269
2270                 /* XON/XOFF/XANY flow control flags */
2271                 sw_flow = 0;
2272                 if (iflag & IXON) {
2273                         sw_flow |= C_FL_OXX;
2274                         if (iflag & IXANY)
2275                                 sw_flow |= C_FL_OIXANY;
2276                 }
2277                 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2278
2279                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2280                 if (retval != 0) {
2281                         printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2282                                 "was %x\n", info->line, retval);
2283                 }
2284
2285                 /* CD sensitivity */
2286                 if (cflag & CLOCAL)
2287                         info->port.flags &= ~ASYNC_CHECK_CD;
2288                 else
2289                         info->port.flags |= ASYNC_CHECK_CD;
2290
2291                 if (baud == 0) {        /* baud rate is zero, turn off line */
2292                         cy_writel(&ch_ctrl->rs_control,
2293                                   readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2294 #ifdef CY_DEBUG_DTR
2295                         printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2296 #endif
2297                 } else {
2298                         cy_writel(&ch_ctrl->rs_control,
2299                                   readl(&ch_ctrl->rs_control) | C_RS_DTR);
2300 #ifdef CY_DEBUG_DTR
2301                         printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2302 #endif
2303                 }
2304
2305                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2306                 if (retval != 0) {
2307                         printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2308                                 "was %x\n", info->line, retval);
2309                 }
2310
2311                 clear_bit(TTY_IO_ERROR, &tty->flags);
2312         }
2313 }                               /* set_line_char */
2314
2315 static int cy_get_serial_info(struct cyclades_port *info,
2316                 struct serial_struct __user *retinfo)
2317 {
2318         struct cyclades_card *cinfo = info->card;
2319         struct serial_struct tmp = {
2320                 .type = info->type,
2321                 .line = info->line,
2322                 .port = (info->card - cy_card) * 0x100 + info->line -
2323                         cinfo->first_line,
2324                 .irq = cinfo->irq,
2325                 .flags = info->port.flags,
2326                 .close_delay = info->port.close_delay,
2327                 .closing_wait = info->port.closing_wait,
2328                 .baud_base = info->baud,
2329                 .custom_divisor = info->custom_divisor,
2330                 .hub6 = 0,              /*!!! */
2331         };
2332         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2333 }
2334
2335 static int
2336 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2337                 struct serial_struct __user *new_info)
2338 {
2339         struct serial_struct new_serial;
2340         int ret;
2341
2342         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2343                 return -EFAULT;
2344
2345         mutex_lock(&info->port.mutex);
2346         if (!capable(CAP_SYS_ADMIN)) {
2347                 if (new_serial.close_delay != info->port.close_delay ||
2348                                 new_serial.baud_base != info->baud ||
2349                                 (new_serial.flags & ASYNC_FLAGS &
2350                                         ~ASYNC_USR_MASK) !=
2351                                 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2352                 {
2353                         mutex_unlock(&info->port.mutex);
2354                         return -EPERM;
2355                 }
2356                 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2357                                 (new_serial.flags & ASYNC_USR_MASK);
2358                 info->baud = new_serial.baud_base;
2359                 info->custom_divisor = new_serial.custom_divisor;
2360                 goto check_and_exit;
2361         }
2362
2363         /*
2364          * OK, past this point, all the error checking has been done.
2365          * At this point, we start making changes.....
2366          */
2367
2368         info->baud = new_serial.baud_base;
2369         info->custom_divisor = new_serial.custom_divisor;
2370         info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2371                         (new_serial.flags & ASYNC_FLAGS);
2372         info->port.close_delay = new_serial.close_delay * HZ / 100;
2373         info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2374
2375 check_and_exit:
2376         if (info->port.flags & ASYNC_INITIALIZED) {
2377                 cy_set_line_char(info, tty);
2378                 ret = 0;
2379         } else {
2380                 ret = cy_startup(info, tty);
2381         }
2382         mutex_unlock(&info->port.mutex);
2383         return ret;
2384 }                               /* set_serial_info */
2385
2386 /*
2387  * get_lsr_info - get line status register info
2388  *
2389  * Purpose: Let user call ioctl() to get info when the UART physically
2390  *          is emptied.  On bus types like RS485, the transmitter must
2391  *          release the bus after transmitting. This must be done when
2392  *          the transmit shift register is empty, not be done when the
2393  *          transmit holding register is empty.  This functionality
2394  *          allows an RS485 driver to be written in user space.
2395  */
2396 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2397 {
2398         struct cyclades_card *card = info->card;
2399         unsigned int result;
2400         unsigned long flags;
2401         u8 status;
2402
2403         if (!cy_is_Z(card)) {
2404                 spin_lock_irqsave(&card->card_lock, flags);
2405                 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2406                 spin_unlock_irqrestore(&card->card_lock, flags);
2407                 result = (status ? 0 : TIOCSER_TEMT);
2408         } else {
2409                 /* Not supported yet */
2410                 return -EINVAL;
2411         }
2412         return put_user(result, value);
2413 }
2414
2415 static int cy_tiocmget(struct tty_struct *tty)
2416 {
2417         struct cyclades_port *info = tty->driver_data;
2418         struct cyclades_card *card;
2419         int result;
2420
2421         if (serial_paranoia_check(info, tty->name, __func__))
2422                 return -ENODEV;
2423
2424         card = info->card;
2425
2426         if (!cy_is_Z(card)) {
2427                 unsigned long flags;
2428                 int channel = info->line - card->first_line;
2429                 u8 status;
2430
2431                 spin_lock_irqsave(&card->card_lock, flags);
2432                 cyy_writeb(info, CyCAR, channel & 0x03);
2433                 status = cyy_readb(info, CyMSVR1);
2434                 status |= cyy_readb(info, CyMSVR2);
2435                 spin_unlock_irqrestore(&card->card_lock, flags);
2436
2437                 if (info->rtsdtr_inv) {
2438                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2439                                 ((status & CyDTR) ? TIOCM_RTS : 0);
2440                 } else {
2441                         result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2442                                 ((status & CyDTR) ? TIOCM_DTR : 0);
2443                 }
2444                 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2445                         ((status & CyRI) ? TIOCM_RNG : 0) |
2446                         ((status & CyDSR) ? TIOCM_DSR : 0) |
2447                         ((status & CyCTS) ? TIOCM_CTS : 0);
2448         } else {
2449                 u32 lstatus;
2450
2451                 if (!cyz_is_loaded(card)) {
2452                         result = -ENODEV;
2453                         goto end;
2454                 }
2455
2456                 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2457                 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2458                         ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2459                         ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2460                         ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2461                         ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2462                         ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2463         }
2464 end:
2465         return result;
2466 }                               /* cy_tiomget */
2467
2468 static int
2469 cy_tiocmset(struct tty_struct *tty,
2470                 unsigned int set, unsigned int clear)
2471 {
2472         struct cyclades_port *info = tty->driver_data;
2473         struct cyclades_card *card;
2474         unsigned long flags;
2475
2476         if (serial_paranoia_check(info, tty->name, __func__))
2477                 return -ENODEV;
2478
2479         card = info->card;
2480         if (!cy_is_Z(card)) {
2481                 spin_lock_irqsave(&card->card_lock, flags);
2482                 cyy_change_rts_dtr(info, set, clear);
2483                 spin_unlock_irqrestore(&card->card_lock, flags);
2484         } else {
2485                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2486                 int retval, channel = info->line - card->first_line;
2487                 u32 rs;
2488
2489                 if (!cyz_is_loaded(card))
2490                         return -ENODEV;
2491
2492                 spin_lock_irqsave(&card->card_lock, flags);
2493                 rs = readl(&ch_ctrl->rs_control);
2494                 if (set & TIOCM_RTS)
2495                         rs |= C_RS_RTS;
2496                 if (clear & TIOCM_RTS)
2497                         rs &= ~C_RS_RTS;
2498                 if (set & TIOCM_DTR) {
2499                         rs |= C_RS_DTR;
2500 #ifdef CY_DEBUG_DTR
2501                         printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2502 #endif
2503                 }
2504                 if (clear & TIOCM_DTR) {
2505                         rs &= ~C_RS_DTR;
2506 #ifdef CY_DEBUG_DTR
2507                         printk(KERN_DEBUG "cyc:set_modem_info clearing "
2508                                 "Z DTR\n");
2509 #endif
2510                 }
2511                 cy_writel(&ch_ctrl->rs_control, rs);
2512                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2513                 spin_unlock_irqrestore(&card->card_lock, flags);
2514                 if (retval != 0) {
2515                         printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2516                                 "was %x\n", info->line, retval);
2517                 }
2518         }
2519         return 0;
2520 }
2521
2522 /*
2523  * cy_break() --- routine which turns the break handling on or off
2524  */
2525 static int cy_break(struct tty_struct *tty, int break_state)
2526 {
2527         struct cyclades_port *info = tty->driver_data;
2528         struct cyclades_card *card;
2529         unsigned long flags;
2530         int retval = 0;
2531
2532         if (serial_paranoia_check(info, tty->name, "cy_break"))
2533                 return -EINVAL;
2534
2535         card = info->card;
2536
2537         spin_lock_irqsave(&card->card_lock, flags);
2538         if (!cy_is_Z(card)) {
2539                 /* Let the transmit ISR take care of this (since it
2540                    requires stuffing characters into the output stream).
2541                  */
2542                 if (break_state == -1) {
2543                         if (!info->breakon) {
2544                                 info->breakon = 1;
2545                                 if (!info->xmit_cnt) {
2546                                         spin_unlock_irqrestore(&card->card_lock, flags);
2547                                         start_xmit(info);
2548                                         spin_lock_irqsave(&card->card_lock, flags);
2549                                 }
2550                         }
2551                 } else {
2552                         if (!info->breakoff) {
2553                                 info->breakoff = 1;
2554                                 if (!info->xmit_cnt) {
2555                                         spin_unlock_irqrestore(&card->card_lock, flags);
2556                                         start_xmit(info);
2557                                         spin_lock_irqsave(&card->card_lock, flags);
2558                                 }
2559                         }
2560                 }
2561         } else {
2562                 if (break_state == -1) {
2563                         retval = cyz_issue_cmd(card,
2564                                 info->line - card->first_line,
2565                                 C_CM_SET_BREAK, 0L);
2566                         if (retval != 0) {
2567                                 printk(KERN_ERR "cyc:cy_break (set) retval on "
2568                                         "ttyC%d was %x\n", info->line, retval);
2569                         }
2570                 } else {
2571                         retval = cyz_issue_cmd(card,
2572                                 info->line - card->first_line,
2573                                 C_CM_CLR_BREAK, 0L);
2574                         if (retval != 0) {
2575                                 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2576                                         "on ttyC%d was %x\n", info->line,
2577                                         retval);
2578                         }
2579                 }
2580         }
2581         spin_unlock_irqrestore(&card->card_lock, flags);
2582         return retval;
2583 }                               /* cy_break */
2584
2585 static int set_threshold(struct cyclades_port *info, unsigned long value)
2586 {
2587         struct cyclades_card *card = info->card;
2588         unsigned long flags;
2589
2590         if (!cy_is_Z(card)) {
2591                 info->cor3 &= ~CyREC_FIFO;
2592                 info->cor3 |= value & CyREC_FIFO;
2593
2594                 spin_lock_irqsave(&card->card_lock, flags);
2595                 cyy_writeb(info, CyCOR3, info->cor3);
2596                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2597                 spin_unlock_irqrestore(&card->card_lock, flags);
2598         }
2599         return 0;
2600 }                               /* set_threshold */
2601
2602 static int get_threshold(struct cyclades_port *info,
2603                                                 unsigned long __user *value)
2604 {
2605         struct cyclades_card *card = info->card;
2606
2607         if (!cy_is_Z(card)) {
2608                 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2609                 return put_user(tmp, value);
2610         }
2611         return 0;
2612 }                               /* get_threshold */
2613
2614 static int set_timeout(struct cyclades_port *info, unsigned long value)
2615 {
2616         struct cyclades_card *card = info->card;
2617         unsigned long flags;
2618
2619         if (!cy_is_Z(card)) {
2620                 spin_lock_irqsave(&card->card_lock, flags);
2621                 cyy_writeb(info, CyRTPR, value & 0xff);
2622                 spin_unlock_irqrestore(&card->card_lock, flags);
2623         }
2624         return 0;
2625 }                               /* set_timeout */
2626
2627 static int get_timeout(struct cyclades_port *info,
2628                                                 unsigned long __user *value)
2629 {
2630         struct cyclades_card *card = info->card;
2631
2632         if (!cy_is_Z(card)) {
2633                 u8 tmp = cyy_readb(info, CyRTPR);
2634                 return put_user(tmp, value);
2635         }
2636         return 0;
2637 }                               /* get_timeout */
2638
2639 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2640                 struct cyclades_icount *cprev)
2641 {
2642         struct cyclades_icount cnow;
2643         unsigned long flags;
2644         int ret;
2645
2646         spin_lock_irqsave(&info->card->card_lock, flags);
2647         cnow = info->icount;    /* atomic copy */
2648         spin_unlock_irqrestore(&info->card->card_lock, flags);
2649
2650         ret =   ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2651                 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2652                 ((arg & TIOCM_CD)  && (cnow.dcd != cprev->dcd)) ||
2653                 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2654
2655         *cprev = cnow;
2656
2657         return ret;
2658 }
2659
2660 /*
2661  * This routine allows the tty driver to implement device-
2662  * specific ioctl's.  If the ioctl number passed in cmd is
2663  * not recognized by the driver, it should return ENOIOCTLCMD.
2664  */
2665 static int
2666 cy_ioctl(struct tty_struct *tty,
2667          unsigned int cmd, unsigned long arg)
2668 {
2669         struct cyclades_port *info = tty->driver_data;
2670         struct cyclades_icount cnow;    /* kernel counter temps */
2671         int ret_val = 0;
2672         unsigned long flags;
2673         void __user *argp = (void __user *)arg;
2674
2675         if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2676                 return -ENODEV;
2677
2678 #ifdef CY_DEBUG_OTHER
2679         printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2680                 info->line, cmd, arg);
2681 #endif
2682
2683         switch (cmd) {
2684         case CYGETMON:
2685                 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2686                         ret_val = -EFAULT;
2687                         break;
2688                 }
2689                 memset(&info->mon, 0, sizeof(info->mon));
2690                 break;
2691         case CYGETTHRESH:
2692                 ret_val = get_threshold(info, argp);
2693                 break;
2694         case CYSETTHRESH:
2695                 ret_val = set_threshold(info, arg);
2696                 break;
2697         case CYGETDEFTHRESH:
2698                 ret_val = put_user(info->default_threshold,
2699                                 (unsigned long __user *)argp);
2700                 break;
2701         case CYSETDEFTHRESH:
2702                 info->default_threshold = arg & 0x0f;
2703                 break;
2704         case CYGETTIMEOUT:
2705                 ret_val = get_timeout(info, argp);
2706                 break;
2707         case CYSETTIMEOUT:
2708                 ret_val = set_timeout(info, arg);
2709                 break;
2710         case CYGETDEFTIMEOUT:
2711                 ret_val = put_user(info->default_timeout,
2712                                 (unsigned long __user *)argp);
2713                 break;
2714         case CYSETDEFTIMEOUT:
2715                 info->default_timeout = arg & 0xff;
2716                 break;
2717         case CYSETRFLOW:
2718                 info->rflow = (int)arg;
2719                 break;
2720         case CYGETRFLOW:
2721                 ret_val = info->rflow;
2722                 break;
2723         case CYSETRTSDTR_INV:
2724                 info->rtsdtr_inv = (int)arg;
2725                 break;
2726         case CYGETRTSDTR_INV:
2727                 ret_val = info->rtsdtr_inv;
2728                 break;
2729         case CYGETCD1400VER:
2730                 ret_val = info->chip_rev;
2731                 break;
2732 #ifndef CONFIG_CYZ_INTR
2733         case CYZSETPOLLCYCLE:
2734                 cyz_polling_cycle = (arg * HZ) / 1000;
2735                 break;
2736         case CYZGETPOLLCYCLE:
2737                 ret_val = (cyz_polling_cycle * 1000) / HZ;
2738                 break;
2739 #endif                          /* CONFIG_CYZ_INTR */
2740         case CYSETWAIT:
2741                 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2742                 break;
2743         case CYGETWAIT:
2744                 ret_val = info->port.closing_wait / (HZ / 100);
2745                 break;
2746         case TIOCGSERIAL:
2747                 ret_val = cy_get_serial_info(info, argp);
2748                 break;
2749         case TIOCSSERIAL:
2750                 ret_val = cy_set_serial_info(info, tty, argp);
2751                 break;
2752         case TIOCSERGETLSR:     /* Get line status register */
2753                 ret_val = get_lsr_info(info, argp);
2754                 break;
2755                 /*
2756                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2757                  * - mask passed in arg for lines of interest
2758                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2759                  * Caller should use TIOCGICOUNT to see which one it was
2760                  */
2761         case TIOCMIWAIT:
2762                 spin_lock_irqsave(&info->card->card_lock, flags);
2763                 /* note the counters on entry */
2764                 cnow = info->icount;
2765                 spin_unlock_irqrestore(&info->card->card_lock, flags);
2766                 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2767                                 cy_cflags_changed(info, arg, &cnow));
2768                 break;
2769
2770                 /*
2771                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2772                  * Return: write counters to the user passed counter struct
2773                  * NB: both 1->0 and 0->1 transitions are counted except for
2774                  *     RI where only 0->1 is counted.
2775                  */
2776         default:
2777                 ret_val = -ENOIOCTLCMD;
2778         }
2779
2780 #ifdef CY_DEBUG_OTHER
2781         printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2782 #endif
2783         return ret_val;
2784 }                               /* cy_ioctl */
2785
2786 static int cy_get_icount(struct tty_struct *tty,
2787                                 struct serial_icounter_struct *sic)
2788 {
2789         struct cyclades_port *info = tty->driver_data;
2790         struct cyclades_icount cnow;    /* Used to snapshot */
2791         unsigned long flags;
2792
2793         spin_lock_irqsave(&info->card->card_lock, flags);
2794         cnow = info->icount;
2795         spin_unlock_irqrestore(&info->card->card_lock, flags);
2796
2797         sic->cts = cnow.cts;
2798         sic->dsr = cnow.dsr;
2799         sic->rng = cnow.rng;
2800         sic->dcd = cnow.dcd;
2801         sic->rx = cnow.rx;
2802         sic->tx = cnow.tx;
2803         sic->frame = cnow.frame;
2804         sic->overrun = cnow.overrun;
2805         sic->parity = cnow.parity;
2806         sic->brk = cnow.brk;
2807         sic->buf_overrun = cnow.buf_overrun;
2808         return 0;
2809 }
2810
2811 /*
2812  * This routine allows the tty driver to be notified when
2813  * device's termios settings have changed.  Note that a
2814  * well-designed tty driver should be prepared to accept the case
2815  * where old == NULL, and try to do something rational.
2816  */
2817 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2818 {
2819         struct cyclades_port *info = tty->driver_data;
2820
2821 #ifdef CY_DEBUG_OTHER
2822         printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2823 #endif
2824
2825         cy_set_line_char(info, tty);
2826
2827         if ((old_termios->c_cflag & CRTSCTS) &&
2828                         !(tty->termios->c_cflag & CRTSCTS)) {
2829                 tty->hw_stopped = 0;
2830                 cy_start(tty);
2831         }
2832 #if 0
2833         /*
2834          * No need to wake up processes in open wait, since they
2835          * sample the CLOCAL flag once, and don't recheck it.
2836          * XXX  It's not clear whether the current behavior is correct
2837          * or not.  Hence, this may change.....
2838          */
2839         if (!(old_termios->c_cflag & CLOCAL) &&
2840             (tty->termios->c_cflag & CLOCAL))
2841                 wake_up_interruptible(&info->port.open_wait);
2842 #endif
2843 }                               /* cy_set_termios */
2844
2845 /* This function is used to send a high-priority XON/XOFF character to
2846    the device.
2847 */
2848 static void cy_send_xchar(struct tty_struct *tty, char ch)
2849 {
2850         struct cyclades_port *info = tty->driver_data;
2851         struct cyclades_card *card;
2852         int channel;
2853
2854         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2855                 return;
2856
2857         info->x_char = ch;
2858
2859         if (ch)
2860                 cy_start(tty);
2861
2862         card = info->card;
2863         channel = info->line - card->first_line;
2864
2865         if (cy_is_Z(card)) {
2866                 if (ch == STOP_CHAR(tty))
2867                         cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2868                 else if (ch == START_CHAR(tty))
2869                         cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2870         }
2871 }
2872
2873 /* This routine is called by the upper-layer tty layer to signal
2874    that incoming characters should be throttled because the input
2875    buffers are close to full.
2876  */
2877 static void cy_throttle(struct tty_struct *tty)
2878 {
2879         struct cyclades_port *info = tty->driver_data;
2880         struct cyclades_card *card;
2881         unsigned long flags;
2882
2883 #ifdef CY_DEBUG_THROTTLE
2884         char buf[64];
2885
2886         printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2887                         tty->ldisc.chars_in_buffer(tty), info->line);
2888 #endif
2889
2890         if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2891                 return;
2892
2893         card = info->card;
2894
2895         if (I_IXOFF(tty)) {
2896                 if (!cy_is_Z(card))
2897                         cy_send_xchar(tty, STOP_CHAR(tty));
2898                 else
2899                         info->throttle = 1;
2900         }
2901
2902         if (tty->termios->c_cflag & CRTSCTS) {
2903                 if (!cy_is_Z(card)) {
2904                         spin_lock_irqsave(&card->card_lock, flags);
2905                         cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2906                         spin_unlock_irqrestore(&card->card_lock, flags);
2907                 } else {
2908                         info->throttle = 1;
2909                 }
2910         }
2911 }                               /* cy_throttle */
2912
2913 /*
2914  * This routine notifies the tty driver that it should signal
2915  * that characters can now be sent to the tty without fear of
2916  * overrunning the input buffers of the line disciplines.
2917  */
2918 static void cy_unthrottle(struct tty_struct *tty)
2919 {
2920         struct cyclades_port *info = tty->driver_data;
2921         struct cyclades_card *card;
2922         unsigned long flags;
2923
2924 #ifdef CY_DEBUG_THROTTLE
2925         char buf[64];
2926
2927         printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2928                 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2929 #endif
2930
2931         if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2932                 return;
2933
2934         if (I_IXOFF(tty)) {
2935                 if (info->x_char)
2936                         info->x_char = 0;
2937                 else
2938                         cy_send_xchar(tty, START_CHAR(tty));
2939         }
2940
2941         if (tty->termios->c_cflag & CRTSCTS) {
2942                 card = info->card;
2943                 if (!cy_is_Z(card)) {
2944                         spin_lock_irqsave(&card->card_lock, flags);
2945                         cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2946                         spin_unlock_irqrestore(&card->card_lock, flags);
2947                 } else {
2948                         info->throttle = 0;
2949                 }
2950         }
2951 }                               /* cy_unthrottle */
2952
2953 /* cy_start and cy_stop provide software output flow control as a
2954    function of XON/XOFF, software CTS, and other such stuff.
2955 */
2956 static void cy_stop(struct tty_struct *tty)
2957 {
2958         struct cyclades_card *cinfo;
2959         struct cyclades_port *info = tty->driver_data;
2960         int channel;
2961         unsigned long flags;
2962
2963 #ifdef CY_DEBUG_OTHER
2964         printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2965 #endif
2966
2967         if (serial_paranoia_check(info, tty->name, "cy_stop"))
2968                 return;
2969
2970         cinfo = info->card;
2971         channel = info->line - cinfo->first_line;
2972         if (!cy_is_Z(cinfo)) {
2973                 spin_lock_irqsave(&cinfo->card_lock, flags);
2974                 cyy_writeb(info, CyCAR, channel & 0x03);
2975                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2976                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2977         }
2978 }                               /* cy_stop */
2979
2980 static void cy_start(struct tty_struct *tty)
2981 {
2982         struct cyclades_card *cinfo;
2983         struct cyclades_port *info = tty->driver_data;
2984         int channel;
2985         unsigned long flags;
2986
2987 #ifdef CY_DEBUG_OTHER
2988         printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
2989 #endif
2990
2991         if (serial_paranoia_check(info, tty->name, "cy_start"))
2992                 return;
2993
2994         cinfo = info->card;
2995         channel = info->line - cinfo->first_line;
2996         if (!cy_is_Z(cinfo)) {
2997                 spin_lock_irqsave(&cinfo->card_lock, flags);
2998                 cyy_writeb(info, CyCAR, channel & 0x03);
2999                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
3000                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3001         }
3002 }                               /* cy_start */
3003
3004 /*
3005  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
3006  */
3007 static void cy_hangup(struct tty_struct *tty)
3008 {
3009         struct cyclades_port *info = tty->driver_data;
3010
3011 #ifdef CY_DEBUG_OTHER
3012         printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
3013 #endif
3014
3015         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3016                 return;
3017
3018         cy_flush_buffer(tty);
3019         cy_shutdown(info, tty);
3020         tty_port_hangup(&info->port);
3021 }                               /* cy_hangup */
3022
3023 static int cyy_carrier_raised(struct tty_port *port)
3024 {
3025         struct cyclades_port *info = container_of(port, struct cyclades_port,
3026                         port);
3027         struct cyclades_card *cinfo = info->card;
3028         unsigned long flags;
3029         int channel = info->line - cinfo->first_line;
3030         u32 cd;
3031
3032         spin_lock_irqsave(&cinfo->card_lock, flags);
3033         cyy_writeb(info, CyCAR, channel & 0x03);
3034         cd = cyy_readb(info, CyMSVR1) & CyDCD;
3035         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3036
3037         return cd;
3038 }
3039
3040 static void cyy_dtr_rts(struct tty_port *port, int raise)
3041 {
3042         struct cyclades_port *info = container_of(port, struct cyclades_port,
3043                         port);
3044         struct cyclades_card *cinfo = info->card;
3045         unsigned long flags;
3046
3047         spin_lock_irqsave(&cinfo->card_lock, flags);
3048         cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3049                         raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3050         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3051 }
3052
3053 static int cyz_carrier_raised(struct tty_port *port)
3054 {
3055         struct cyclades_port *info = container_of(port, struct cyclades_port,
3056                         port);
3057
3058         return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3059 }
3060
3061 static void cyz_dtr_rts(struct tty_port *port, int raise)
3062 {
3063         struct cyclades_port *info = container_of(port, struct cyclades_port,
3064                         port);
3065         struct cyclades_card *cinfo = info->card;
3066         struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3067         int ret, channel = info->line - cinfo->first_line;
3068         u32 rs;
3069
3070         rs = readl(&ch_ctrl->rs_control);
3071         if (raise)
3072                 rs |= C_RS_RTS | C_RS_DTR;
3073         else
3074                 rs &= ~(C_RS_RTS | C_RS_DTR);
3075         cy_writel(&ch_ctrl->rs_control, rs);
3076         ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3077         if (ret != 0)
3078                 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3079                                 __func__, info->line, ret);
3080 #ifdef CY_DEBUG_DTR
3081         printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3082 #endif
3083 }
3084
3085 static const struct tty_port_operations cyy_port_ops = {
3086         .carrier_raised = cyy_carrier_raised,
3087         .dtr_rts = cyy_dtr_rts,
3088         .shutdown = cy_do_close,
3089 };
3090
3091 static const struct tty_port_operations cyz_port_ops = {
3092         .carrier_raised = cyz_carrier_raised,
3093         .dtr_rts = cyz_dtr_rts,
3094         .shutdown = cy_do_close,
3095 };
3096
3097 /*
3098  * ---------------------------------------------------------------------
3099  * cy_init() and friends
3100  *
3101  * cy_init() is called at boot-time to initialize the serial driver.
3102  * ---------------------------------------------------------------------
3103  */
3104
3105 static int __devinit cy_init_card(struct cyclades_card *cinfo)
3106 {
3107         struct cyclades_port *info;
3108         unsigned int channel, port;
3109
3110         spin_lock_init(&cinfo->card_lock);
3111         cinfo->intr_enabled = 0;
3112
3113         cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3114                         GFP_KERNEL);
3115         if (cinfo->ports == NULL) {
3116                 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3117                 return -ENOMEM;
3118         }
3119
3120         for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3121                         channel++, port++) {
3122                 info = &cinfo->ports[channel];
3123                 tty_port_init(&info->port);
3124                 info->magic = CYCLADES_MAGIC;
3125                 info->card = cinfo;
3126                 info->line = port;
3127
3128                 info->port.closing_wait = CLOSING_WAIT_DELAY;
3129                 info->port.close_delay = 5 * HZ / 10;
3130                 info->port.flags = STD_COM_FLAGS;
3131                 init_completion(&info->shutdown_wait);
3132
3133                 if (cy_is_Z(cinfo)) {
3134                         struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3135                         struct ZFW_CTRL *zfw_ctrl;
3136
3137                         info->port.ops = &cyz_port_ops;
3138                         info->type = PORT_STARTECH;
3139
3140                         zfw_ctrl = cinfo->base_addr +
3141                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3142                         info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3143                         info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3144
3145                         if (cinfo->hw_ver == ZO_V1)
3146                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3147                         else
3148                                 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3149 #ifdef CONFIG_CYZ_INTR
3150                         setup_timer(&cyz_rx_full_timer[port],
3151                                 cyz_rx_restart, (unsigned long)info);
3152 #endif
3153                 } else {
3154                         unsigned short chip_number;
3155                         int index = cinfo->bus_index;
3156
3157                         info->port.ops = &cyy_port_ops;
3158                         info->type = PORT_CIRRUS;
3159                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3160                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3161                         info->cor2 = CyETC;
3162                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
3163
3164                         chip_number = channel / CyPORTS_PER_CHIP;
3165                         info->u.cyy.base_addr = cinfo->base_addr +
3166                                 (cy_chip_offset[chip_number] << index);
3167                         info->chip_rev = cyy_readb(info, CyGFRCR);
3168
3169                         if (info->chip_rev >= CD1400_REV_J) {
3170                                 /* It is a CD1400 rev. J or later */
3171                                 info->tbpr = baud_bpr_60[13];   /* Tx BPR */
3172                                 info->tco = baud_co_60[13];     /* Tx CO */
3173                                 info->rbpr = baud_bpr_60[13];   /* Rx BPR */
3174                                 info->rco = baud_co_60[13];     /* Rx CO */
3175                                 info->rtsdtr_inv = 1;
3176                         } else {
3177                                 info->tbpr = baud_bpr_25[13];   /* Tx BPR */
3178                                 info->tco = baud_co_25[13];     /* Tx CO */
3179                                 info->rbpr = baud_bpr_25[13];   /* Rx BPR */
3180                                 info->rco = baud_co_25[13];     /* Rx CO */
3181                                 info->rtsdtr_inv = 0;
3182                         }
3183                         info->read_status_mask = CyTIMEOUT | CySPECHAR |
3184                                 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3185                 }
3186
3187         }
3188
3189 #ifndef CONFIG_CYZ_INTR
3190         if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3191                 mod_timer(&cyz_timerlist, jiffies + 1);
3192 #ifdef CY_PCI_DEBUG
3193                 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3194 #endif
3195         }
3196 #endif
3197         return 0;
3198 }
3199
3200 /* initialize chips on Cyclom-Y card -- return number of valid
3201    chips (which is number of ports/4) */
3202 static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
3203                 int index)
3204 {
3205         unsigned int chip_number;
3206         void __iomem *base_addr;
3207
3208         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3209         /* Cy_HwReset is 0x1400 */
3210         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3211         /* Cy_ClrIntr is 0x1800 */
3212         udelay(500L);
3213
3214         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3215                                                         chip_number++) {
3216                 base_addr =
3217                     true_base_addr + (cy_chip_offset[chip_number] << index);
3218                 mdelay(1);
3219                 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3220                         /*************
3221                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3222                         chip_number, (unsigned long)base_addr);
3223                         *************/
3224                         return chip_number;
3225                 }
3226
3227                 cy_writeb(base_addr + (CyGFRCR << index), 0);
3228                 udelay(10L);
3229
3230                 /* The Cyclom-16Y does not decode address bit 9 and therefore
3231                    cannot distinguish between references to chip 0 and a non-
3232                    existent chip 4.  If the preceding clearing of the supposed
3233                    chip 4 GFRCR register appears at chip 0, there is no chip 4
3234                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3235                  */
3236                 if (chip_number == 4 && readb(true_base_addr +
3237                                 (cy_chip_offset[0] << index) +
3238                                 (CyGFRCR << index)) == 0) {
3239                         return chip_number;
3240                 }
3241
3242                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3243                 mdelay(1);
3244
3245                 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3246                         /*
3247                            printk(" chip #%d at %#6lx is not responding ",
3248                            chip_number, (unsigned long)base_addr);
3249                            printk("(GFRCR stayed 0)\n",
3250                          */
3251                         return chip_number;
3252                 }
3253                 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3254                                 0x40) {
3255                         /*
3256                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
3257                                         "%#2x)\n",
3258                                         chip_number, (unsigned long)base_addr,
3259                                         base_addr[CyGFRCR<<index]);
3260                          */
3261                         return chip_number;
3262                 }
3263                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3264                 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3265                         /* It is a CD1400 rev. J or later */
3266                         /* Impossible to reach 5ms with this chip.
3267                            Changed to 2ms instead (f = 500 Hz). */
3268                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3269                 } else {
3270                         /* f = 200 Hz */
3271                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3272                 }
3273
3274                 /*
3275                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
3276                    chip_number, (unsigned long)base_addr,
3277                    readb(base_addr+(CyGFRCR<<index)));
3278                  */
3279         }
3280         return chip_number;
3281 }                               /* cyy_init_card */
3282
3283 /*
3284  * ---------------------------------------------------------------------
3285  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3286  * sets global variables and return the number of ISA boards found.
3287  * ---------------------------------------------------------------------
3288  */
3289 static int __init cy_detect_isa(void)
3290 {
3291 #ifdef CONFIG_ISA
3292         unsigned short cy_isa_irq, nboard;
3293         void __iomem *cy_isa_address;
3294         unsigned short i, j, cy_isa_nchan;
3295         int isparam = 0;
3296
3297         nboard = 0;
3298
3299         /* Check for module parameters */
3300         for (i = 0; i < NR_CARDS; i++) {
3301                 if (maddr[i] || i) {
3302                         isparam = 1;
3303                         cy_isa_addresses[i] = maddr[i];
3304                 }
3305                 if (!maddr[i])
3306                         break;
3307         }
3308
3309         /* scan the address table probing for Cyclom-Y/ISA boards */
3310         for (i = 0; i < NR_ISA_ADDRS; i++) {
3311                 unsigned int isa_address = cy_isa_addresses[i];
3312                 if (isa_address == 0x0000)
3313                         return nboard;
3314
3315                 /* probe for CD1400... */
3316                 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3317                 if (cy_isa_address == NULL) {
3318                         printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3319                                         "address\n");
3320                         continue;
3321                 }
3322                 cy_isa_nchan = CyPORTS_PER_CHIP *
3323                         cyy_init_card(cy_isa_address, 0);
3324                 if (cy_isa_nchan == 0) {
3325                         iounmap(cy_isa_address);
3326                         continue;
3327                 }
3328
3329                 if (isparam && i < NR_CARDS && irq[i])
3330                         cy_isa_irq = irq[i];
3331                 else
3332                         /* find out the board's irq by probing */
3333                         cy_isa_irq = detect_isa_irq(cy_isa_address);
3334                 if (cy_isa_irq == 0) {
3335                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3336                                 "IRQ could not be detected.\n",
3337                                 (unsigned long)cy_isa_address);
3338                         iounmap(cy_isa_address);
3339                         continue;
3340                 }
3341
3342                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3343                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3344                                 "more channels are available. Change NR_PORTS "
3345                                 "in cyclades.c and recompile kernel.\n",
3346                                 (unsigned long)cy_isa_address);
3347                         iounmap(cy_isa_address);
3348                         return nboard;
3349                 }
3350                 /* fill the next cy_card structure available */
3351                 for (j = 0; j < NR_CARDS; j++) {
3352                         if (cy_card[j].base_addr == NULL)
3353                                 break;
3354                 }
3355                 if (j == NR_CARDS) {    /* no more cy_cards available */
3356                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3357                                 "more cards can be used. Change NR_CARDS in "
3358                                 "cyclades.c and recompile kernel.\n",
3359                                 (unsigned long)cy_isa_address);
3360                         iounmap(cy_isa_address);
3361                         return nboard;
3362                 }
3363
3364                 /* allocate IRQ */
3365                 if (request_irq(cy_isa_irq, cyy_interrupt,
3366                                 0, "Cyclom-Y", &cy_card[j])) {
3367                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3368                                 "could not allocate IRQ#%d.\n",
3369                                 (unsigned long)cy_isa_address, cy_isa_irq);
3370                         iounmap(cy_isa_address);
3371                         return nboard;
3372                 }
3373
3374                 /* set cy_card */
3375                 cy_card[j].base_addr = cy_isa_address;
3376                 cy_card[j].ctl_addr.p9050 = NULL;
3377                 cy_card[j].irq = (int)cy_isa_irq;
3378                 cy_card[j].bus_index = 0;
3379                 cy_card[j].first_line = cy_next_channel;
3380                 cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3381                 cy_card[j].nports = cy_isa_nchan;
3382                 if (cy_init_card(&cy_card[j])) {
3383                         cy_card[j].base_addr = NULL;
3384                         free_irq(cy_isa_irq, &cy_card[j]);
3385                         iounmap(cy_isa_address);
3386                         continue;
3387                 }
3388                 nboard++;
3389
3390                 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3391                         "%d channels starting from port %d\n",
3392                         j + 1, (unsigned long)cy_isa_address,
3393                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3394                         cy_isa_irq, cy_isa_nchan, cy_next_channel);
3395
3396                 for (j = cy_next_channel;
3397                                 j < cy_next_channel + cy_isa_nchan; j++)
3398                         tty_register_device(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         void __iomem *addr0 = NULL, *addr2 = NULL;
3699         char *card_name = NULL;
3700         u32 uninitialized_var(mailbox);
3701         unsigned int device_id, nchan = 0, card_no, i;
3702         unsigned char plx_ver;
3703         int retval, irq;
3704
3705         retval = pci_enable_device(pdev);
3706         if (retval) {
3707                 dev_err(&pdev->dev, "cannot enable device\n");
3708                 goto err;
3709         }
3710
3711         /* read PCI configuration area */
3712         irq = pdev->irq;
3713         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3714
3715 #if defined(__alpha__)
3716         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
3717                 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3718                         "addresses on Alpha systems.\n");
3719                 retval = -EIO;
3720                 goto err_dis;
3721         }
3722 #endif
3723         if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3724                 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3725                         "addresses\n");
3726                 retval = -EIO;
3727                 goto err_dis;
3728         }
3729
3730         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3731                 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3732                                 "it...\n");
3733                 pdev->resource[2].flags &= ~IORESOURCE_IO;
3734         }
3735
3736         retval = pci_request_regions(pdev, "cyclades");
3737         if (retval) {
3738                 dev_err(&pdev->dev, "failed to reserve resources\n");
3739                 goto err_dis;
3740         }
3741
3742         retval = -EIO;
3743         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3744                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3745                 card_name = "Cyclom-Y";
3746
3747                 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3748                                 CyPCI_Yctl);
3749                 if (addr0 == NULL) {
3750                         dev_err(&pdev->dev, "can't remap ctl region\n");
3751                         goto err_reg;
3752                 }
3753                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3754                                 CyPCI_Ywin);
3755                 if (addr2 == NULL) {
3756                         dev_err(&pdev->dev, "can't remap base region\n");
3757                         goto err_unmap;
3758                 }
3759
3760                 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3761                 if (nchan == 0) {
3762                         dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3763                                         "Serial-Modules\n");
3764                         goto err_unmap;
3765                 }
3766         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3767                 struct RUNTIME_9060 __iomem *ctl_addr;
3768
3769                 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3770                                 CyPCI_Zctl);
3771                 if (addr0 == NULL) {
3772                         dev_err(&pdev->dev, "can't remap ctl region\n");
3773                         goto err_reg;
3774                 }
3775
3776                 /* Disable interrupts on the PLX before resetting it */
3777                 cy_writew(&ctl_addr->intr_ctrl_stat,
3778                                 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3779
3780                 plx_init(pdev, irq, addr0);
3781
3782                 mailbox = readl(&ctl_addr->mail_box_0);
3783
3784                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3785                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3786                 if (addr2 == NULL) {
3787                         dev_err(&pdev->dev, "can't remap base region\n");
3788                         goto err_unmap;
3789                 }
3790
3791                 if (mailbox == ZE_V1) {
3792                         card_name = "Cyclades-Ze";
3793                 } else {
3794                         card_name = "Cyclades-8Zo";
3795 #ifdef CY_PCI_DEBUG
3796                         if (mailbox == ZO_V1) {
3797                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3798                                 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3799                                         "id %lx, ver %lx\n", (ulong)(0xff &
3800                                         readl(&((struct CUSTOM_REG *)addr2)->
3801                                                 fpga_id)), (ulong)(0xff &
3802                                         readl(&((struct CUSTOM_REG *)addr2)->
3803                                                 fpga_version)));
3804                                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3805                         } else {
3806                                 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3807                                         "Cyclades-Z board.  FPGA not loaded\n");
3808                         }
3809 #endif
3810                         /* The following clears the firmware id word.  This
3811                            ensures that the driver will not attempt to talk to
3812                            the board until it has been properly initialized.
3813                          */
3814                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3815                                 cy_writel(addr2 + ID_ADDRESS, 0L);
3816                 }
3817
3818                 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3819                 if (retval <= 0)
3820                         goto err_unmap;
3821                 nchan = retval;
3822         }
3823
3824         if ((cy_next_channel + nchan) > NR_PORTS) {
3825                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3826                         "channels are available. Change NR_PORTS in "
3827                         "cyclades.c and recompile kernel.\n");
3828                 goto err_unmap;
3829         }
3830         /* fill the next cy_card structure available */
3831         for (card_no = 0; card_no < NR_CARDS; card_no++) {
3832                 if (cy_card[card_no].base_addr == NULL)
3833                         break;
3834         }
3835         if (card_no == NR_CARDS) {      /* no more cy_cards available */
3836                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3837                         "more cards can be used. Change NR_CARDS in "
3838                         "cyclades.c and recompile kernel.\n");
3839                 goto err_unmap;
3840         }
3841
3842         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3843                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3844                 /* allocate IRQ */
3845                 retval = request_irq(irq, cyy_interrupt,
3846                                 IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
3847                 if (retval) {
3848                         dev_err(&pdev->dev, "could not allocate IRQ\n");
3849                         goto err_unmap;
3850                 }
3851                 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
3852         } else {
3853                 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3854                 struct ZFW_CTRL __iomem *zfw_ctrl;
3855
3856                 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3857
3858                 cy_card[card_no].hw_ver = mailbox;
3859                 cy_card[card_no].num_chips = (unsigned int)-1;
3860                 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
3861 #ifdef CONFIG_CYZ_INTR
3862                 /* allocate IRQ only if board has an IRQ */
3863                 if (irq != 0 && irq != 255) {
3864                         retval = request_irq(irq, cyz_interrupt,
3865                                         IRQF_SHARED, "Cyclades-Z",
3866                                         &cy_card[card_no]);
3867                         if (retval) {
3868                                 dev_err(&pdev->dev, "could not allocate IRQ\n");
3869                                 goto err_unmap;
3870                         }
3871                 }
3872 #endif                          /* CONFIG_CYZ_INTR */
3873         }
3874
3875         /* set cy_card */
3876         cy_card[card_no].base_addr = addr2;
3877         cy_card[card_no].ctl_addr.p9050 = addr0;
3878         cy_card[card_no].irq = irq;
3879         cy_card[card_no].bus_index = 1;
3880         cy_card[card_no].first_line = cy_next_channel;
3881         cy_card[card_no].nports = nchan;
3882         retval = cy_init_card(&cy_card[card_no]);
3883         if (retval)
3884                 goto err_null;
3885
3886         pci_set_drvdata(pdev, &cy_card[card_no]);
3887
3888         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3889                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3890                 /* enable interrupts in the PCI interface */
3891                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3892                 switch (plx_ver) {
3893                 case PLX_9050:
3894                         cy_writeb(addr0 + 0x4c, 0x43);
3895                         break;
3896
3897                 case PLX_9060:
3898                 case PLX_9080:
3899                 default:        /* Old boards, use PLX_9060 */
3900                 {
3901                         struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3902                         plx_init(pdev, irq, ctl_addr);
3903                         cy_writew(&ctl_addr->intr_ctrl_stat,
3904                                 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3905                         break;
3906                 }
3907                 }
3908         }
3909
3910         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3911                 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3912         for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
3913                 tty_register_device(cy_serial_driver, i, &pdev->dev);
3914         cy_next_channel += nchan;
3915
3916         return 0;
3917 err_null:
3918         cy_card[card_no].base_addr = NULL;
3919         free_irq(irq, &cy_card[card_no]);
3920 err_unmap:
3921         iounmap(addr0);
3922         if (addr2)
3923                 iounmap(addr2);
3924 err_reg:
3925         pci_release_regions(pdev);
3926 err_dis:
3927         pci_disable_device(pdev);
3928 err:
3929         return retval;
3930 }
3931
3932 static void __devexit cy_pci_remove(struct pci_dev *pdev)
3933 {
3934         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3935         unsigned int i;
3936
3937         /* non-Z with old PLX */
3938         if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3939                         PLX_9050)
3940                 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3941         else
3942 #ifndef CONFIG_CYZ_INTR
3943                 if (!cy_is_Z(cinfo))
3944 #endif
3945                 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3946                         readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3947                         ~0x0900);
3948
3949         iounmap(cinfo->base_addr);
3950         if (cinfo->ctl_addr.p9050)
3951                 iounmap(cinfo->ctl_addr.p9050);
3952         if (cinfo->irq
3953 #ifndef CONFIG_CYZ_INTR
3954                 && !cy_is_Z(cinfo)
3955 #endif /* CONFIG_CYZ_INTR */
3956                 )
3957                 free_irq(cinfo->irq, cinfo);
3958         pci_release_regions(pdev);
3959
3960         cinfo->base_addr = NULL;
3961         for (i = cinfo->first_line; i < cinfo->first_line +
3962                         cinfo->nports; i++)
3963                 tty_unregister_device(cy_serial_driver, i);
3964         cinfo->nports = 0;
3965         kfree(cinfo->ports);
3966 }
3967
3968 static struct pci_driver cy_pci_driver = {
3969         .name = "cyclades",
3970         .id_table = cy_pci_dev_id,
3971         .probe = cy_pci_probe,
3972         .remove = __devexit_p(cy_pci_remove)
3973 };
3974 #endif
3975
3976 static int cyclades_proc_show(struct seq_file *m, void *v)
3977 {
3978         struct cyclades_port *info;
3979         unsigned int i, j;
3980         __u32 cur_jifs = jiffies;
3981
3982         seq_puts(m, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
3983                         "IdleIn  Overruns  Ldisc\n");
3984
3985         /* Output one line for each known port */
3986         for (i = 0; i < NR_CARDS; i++)
3987                 for (j = 0; j < cy_card[i].nports; j++) {
3988                         info = &cy_card[i].ports[j];
3989
3990                         if (info->port.count) {
3991                                 /* XXX is the ldisc num worth this? */
3992                                 struct tty_struct *tty;
3993                                 struct tty_ldisc *ld;
3994                                 int num = 0;
3995                                 tty = tty_port_tty_get(&info->port);
3996                                 if (tty) {
3997                                         ld = tty_ldisc_ref(tty);
3998                                         if (ld) {
3999                                                 num = ld->ops->num;
4000                                                 tty_ldisc_deref(ld);
4001                                         }
4002                                         tty_kref_put(tty);
4003                                 }
4004                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4005                                         "%10lu %8lu %9lu %6d\n", info->line,
4006                                         (cur_jifs - info->idle_stats.in_use) /
4007                                         HZ, info->idle_stats.xmit_bytes,
4008                                         (cur_jifs - info->idle_stats.xmit_idle)/
4009                                         HZ, info->idle_stats.recv_bytes,
4010                                         (cur_jifs - info->idle_stats.recv_idle)/
4011                                         HZ, info->idle_stats.overruns,
4012                                         num);
4013                         } else
4014                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4015                                         "%10lu %8lu %9lu %6ld\n",
4016                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4017                 }
4018         return 0;
4019 }
4020
4021 static int cyclades_proc_open(struct inode *inode, struct file *file)
4022 {
4023         return single_open(file, cyclades_proc_show, NULL);
4024 }
4025
4026 static const struct file_operations cyclades_proc_fops = {
4027         .owner          = THIS_MODULE,
4028         .open           = cyclades_proc_open,
4029         .read           = seq_read,
4030         .llseek         = seq_lseek,
4031         .release        = single_release,
4032 };
4033
4034 /* The serial driver boot-time initialization code!
4035     Hardware I/O ports are mapped to character special devices on a
4036     first found, first allocated manner.  That is, this code searches
4037     for Cyclom cards in the system.  As each is found, it is probed
4038     to discover how many chips (and thus how many ports) are present.
4039     These ports are mapped to the tty ports 32 and upward in monotonic
4040     fashion.  If an 8-port card is replaced with a 16-port card, the
4041     port mapping on a following card will shift.
4042
4043     This approach is different from what is used in the other serial
4044     device driver because the Cyclom is more properly a multiplexer,
4045     not just an aggregation of serial ports on one card.
4046
4047     If there are more cards with more ports than have been
4048     statically allocated above, a warning is printed and the
4049     extra ports are ignored.
4050  */
4051
4052 static const struct tty_operations cy_ops = {
4053         .open = cy_open,
4054         .close = cy_close,
4055         .write = cy_write,
4056         .put_char = cy_put_char,
4057         .flush_chars = cy_flush_chars,
4058         .write_room = cy_write_room,
4059         .chars_in_buffer = cy_chars_in_buffer,
4060         .flush_buffer = cy_flush_buffer,
4061         .ioctl = cy_ioctl,
4062         .throttle = cy_throttle,
4063         .unthrottle = cy_unthrottle,
4064         .set_termios = cy_set_termios,
4065         .stop = cy_stop,
4066         .start = cy_start,
4067         .hangup = cy_hangup,
4068         .break_ctl = cy_break,
4069         .wait_until_sent = cy_wait_until_sent,
4070         .tiocmget = cy_tiocmget,
4071         .tiocmset = cy_tiocmset,
4072         .get_icount = cy_get_icount,
4073         .proc_fops = &cyclades_proc_fops,
4074 };
4075
4076 static int __init cy_init(void)
4077 {
4078         unsigned int nboards;
4079         int retval = -ENOMEM;
4080
4081         cy_serial_driver = alloc_tty_driver(NR_PORTS);
4082         if (!cy_serial_driver)
4083                 goto err;
4084
4085         printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4086
4087         /* Initialize the tty_driver structure */
4088
4089         cy_serial_driver->driver_name = "cyclades";
4090         cy_serial_driver->name = "ttyC";
4091         cy_serial_driver->major = CYCLADES_MAJOR;
4092         cy_serial_driver->minor_start = 0;
4093         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4094         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4095         cy_serial_driver->init_termios = tty_std_termios;
4096         cy_serial_driver->init_termios.c_cflag =
4097             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4098         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4099         tty_set_operations(cy_serial_driver, &cy_ops);
4100
4101         retval = tty_register_driver(cy_serial_driver);
4102         if (retval) {
4103                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4104                 goto err_frtty;
4105         }
4106
4107         /* the code below is responsible to find the boards. Each different
4108            type of board has its own detection routine. If a board is found,
4109            the next cy_card structure available is set by the detection
4110            routine. These functions are responsible for checking the
4111            availability of cy_card and cy_port data structures and updating
4112            the cy_next_channel. */
4113
4114         /* look for isa boards */
4115         nboards = cy_detect_isa();
4116
4117 #ifdef CONFIG_PCI
4118         /* look for pci boards */
4119         retval = pci_register_driver(&cy_pci_driver);
4120         if (retval && !nboards) {
4121                 tty_unregister_driver(cy_serial_driver);
4122                 goto err_frtty;
4123         }
4124 #endif
4125
4126         return 0;
4127 err_frtty:
4128         put_tty_driver(cy_serial_driver);
4129 err:
4130         return retval;
4131 }                               /* cy_init */
4132
4133 static void __exit cy_cleanup_module(void)
4134 {
4135         struct cyclades_card *card;
4136         unsigned int i, e1;
4137
4138 #ifndef CONFIG_CYZ_INTR
4139         del_timer_sync(&cyz_timerlist);
4140 #endif /* CONFIG_CYZ_INTR */
4141
4142         e1 = tty_unregister_driver(cy_serial_driver);
4143         if (e1)
4144                 printk(KERN_ERR "failed to unregister Cyclades serial "
4145                                 "driver(%d)\n", e1);
4146
4147 #ifdef CONFIG_PCI
4148         pci_unregister_driver(&cy_pci_driver);
4149 #endif
4150
4151         for (i = 0; i < NR_CARDS; i++) {
4152                 card = &cy_card[i];
4153                 if (card->base_addr) {
4154                         /* clear interrupt */
4155                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4156                         iounmap(card->base_addr);
4157                         if (card->ctl_addr.p9050)
4158                                 iounmap(card->ctl_addr.p9050);
4159                         if (card->irq
4160 #ifndef CONFIG_CYZ_INTR
4161                                 && !cy_is_Z(card)
4162 #endif /* CONFIG_CYZ_INTR */
4163                                 )
4164                                 free_irq(card->irq, card);
4165                         for (e1 = card->first_line; e1 < card->first_line +
4166                                         card->nports; e1++)
4167                                 tty_unregister_device(cy_serial_driver, e1);
4168                         kfree(card->ports);
4169                 }
4170         }
4171
4172         put_tty_driver(cy_serial_driver);
4173 } /* cy_cleanup_module */
4174
4175 module_init(cy_init);
4176 module_exit(cy_cleanup_module);
4177
4178 MODULE_LICENSE("GPL");
4179 MODULE_VERSION(CY_VERSION);
4180 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4181 MODULE_FIRMWARE("cyzfirm.bin");