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         struct tty_port *port;
 446         int len, index = cinfo->bus_index;
 447         u8 ivr, save_xir, channel, save_car, data, char_count;
 448
 449 #ifdef CY_DEBUG_INTERRUPTS
 450         printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
 451 #endif
 452         /* determine the channel & change to that context */
 453         save_xir = readb(base_addr + (CyRIR << index));
 454         channel = save_xir & CyIRChannel;
 455         info = &cinfo->ports[channel + chip * 4];
 456         port = &info->port;
 457         save_car = cyy_readb(info, CyCAR);
 458         cyy_writeb(info, CyCAR, save_xir);
 459         ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
 460
 461         tty = tty_port_tty_get(port);
 462         /* if there is nowhere to put the data, discard it */
 463         if (tty == NULL) {
 464                 if (ivr == CyIVRRxEx) { /* exception */
 465                         data = cyy_readb(info, CyRDSR);
 466                 } else {        /* normal character reception */
 467                         char_count = cyy_readb(info, CyRDCR);
 468                         while (char_count--)
 469                                 data = cyy_readb(info, CyRDSR);
 470                 }
 471                 goto end;
 472         }
 473         /* there is an open port for this data */
 474         if (ivr == CyIVRRxEx) { /* exception */
 475                 data = cyy_readb(info, CyRDSR);
 476
 477                 /* For statistics only */
 478                 if (data & CyBREAK)
 479                         info->icount.brk++;
 480                 else if (data & CyFRAME)
 481                         info->icount.frame++;
 482                 else if (data & CyPARITY)
 483                         info->icount.parity++;
 484                 else if (data & CyOVERRUN)
 485                         info->icount.overrun++;
 486
 487                 if (data & info->ignore_status_mask) {
 488                         info->icount.rx++;
 489                         tty_kref_put(tty);
 490                         return;
 491                 }
 492                 if (tty_buffer_request_room(port, 1)) {
 493                         if (data & info->read_status_mask) {
 494                                 if (data & CyBREAK) {
 495                                         tty_insert_flip_char(tty,
 496                                                 cyy_readb(info, CyRDSR),
 497                                                 TTY_BREAK);
 498                                         info->icount.rx++;
 499                                         if (port->flags & ASYNC_SAK)
 500                                                 do_SAK(tty);
 501                                 } else if (data & CyFRAME) {
 502                                         tty_insert_flip_char(tty,
 503                                                 cyy_readb(info, CyRDSR),
 504                                                 TTY_FRAME);
 505                                         info->icount.rx++;
 506                                         info->idle_stats.frame_errs++;
 507                                 } else if (data & CyPARITY) {
 508                                         /* Pieces of seven... */
 509                                         tty_insert_flip_char(tty,
 510                                                 cyy_readb(info, CyRDSR),
 511                                                 TTY_PARITY);
 512                                         info->icount.rx++;
 513                                         info->idle_stats.parity_errs++;
 514                                 } else if (data & CyOVERRUN) {
 515                                         tty_insert_flip_char(tty, 0,
 516                                                         TTY_OVERRUN);
 517                                         info->icount.rx++;
 518                                         /* If the flip buffer itself is
 519                                            overflowing, we still lose
 520                                            the next incoming character.
 521                                          */
 522                                         tty_insert_flip_char(tty,
 523                                                 cyy_readb(info, CyRDSR),
 524                                                 TTY_FRAME);
 525                                         info->icount.rx++;
 526                                         info->idle_stats.overruns++;
 527                                 /* These two conditions may imply */
 528                                 /* a normal read should be done. */
 529                                 /* } else if(data & CyTIMEOUT) { */
 530                                 /* } else if(data & CySPECHAR) { */
 531                                 } else {
 532                                         tty_insert_flip_char(tty, 0,
 533                                                         TTY_NORMAL);
 534                                         info->icount.rx++;
 535                                 }
 536                         } else {
 537                                 tty_insert_flip_char(tty, 0, TTY_NORMAL);
 538                                 info->icount.rx++;
 539                         }
 540                 } else {
 541                         /* there was a software buffer overrun and nothing
 542                          * could be done about it!!! */
 543                         info->icount.buf_overrun++;
 544                         info->idle_stats.overruns++;
 545                 }
 546         } else {        /* normal character reception */
 547                 /* load # chars available from the chip */
 548                 char_count = cyy_readb(info, CyRDCR);
 549
 550 #ifdef CY_ENABLE_MONITORING
 551                 ++info->mon.int_count;
 552                 info->mon.char_count += char_count;
 553                 if (char_count > info->mon.char_max)
 554                         info->mon.char_max = char_count;
 555                 info->mon.char_last = char_count;
 556 #endif
 557                 len = tty_buffer_request_room(port, char_count);
 558                 while (len--) {
 559                         data = cyy_readb(info, CyRDSR);
 560                         tty_insert_flip_char(tty, data, TTY_NORMAL);
 561                         info->idle_stats.recv_bytes++;
 562                         info->icount.rx++;
 563 #ifdef CY_16Y_HACK
 564                         udelay(10L);
 565 #endif
 566                 }
 567                 info->idle_stats.recv_idle = jiffies;
 568         }
 569         tty_schedule_flip(tty);
 570         tty_kref_put(tty);
 571 end:
 572         /* end of service */
 573         cyy_writeb(info, CyRIR, save_xir & 0x3f);
 574         cyy_writeb(info, CyCAR, save_car);
 575 }
 576
 577 static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
 578                 void __iomem *base_addr)
 579 {
 580         struct cyclades_port *info;
 581         struct tty_struct *tty;
 582         int char_count, index = cinfo->bus_index;
 583         u8 save_xir, channel, save_car, outch;
 584
 585         /* Since we only get here when the transmit buffer
 586            is empty, we know we can always stuff a dozen
 587            characters. */
 588 #ifdef CY_DEBUG_INTERRUPTS
 589         printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
 590 #endif
 591
 592         /* determine the channel & change to that context */
 593         save_xir = readb(base_addr + (CyTIR << index));
 594         channel = save_xir & CyIRChannel;
 595         save_car = readb(base_addr + (CyCAR << index));
 596         cy_writeb(base_addr + (CyCAR << index), save_xir);
 597
 598         info = &cinfo->ports[channel + chip * 4];
 599         tty = tty_port_tty_get(&info->port);
 600         if (tty == NULL) {
 601                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
 602                 goto end;
 603         }
 604
 605         /* load the on-chip space for outbound data */
 606         char_count = info->xmit_fifo_size;
 607
 608         if (info->x_char) {     /* send special char */
 609                 outch = info->x_char;
 610                 cyy_writeb(info, CyTDR, outch);
 611                 char_count--;
 612                 info->icount.tx++;
 613                 info->x_char = 0;
 614         }
 615
 616         if (info->breakon || info->breakoff) {
 617                 if (info->breakon) {
 618                         cyy_writeb(info, CyTDR, 0);
 619                         cyy_writeb(info, CyTDR, 0x81);
 620                         info->breakon = 0;
 621                         char_count -= 2;
 622                 }
 623                 if (info->breakoff) {
 624                         cyy_writeb(info, CyTDR, 0);
 625                         cyy_writeb(info, CyTDR, 0x83);
 626                         info->breakoff = 0;
 627                         char_count -= 2;
 628                 }
 629         }
 630
 631         while (char_count-- > 0) {
 632                 if (!info->xmit_cnt) {
 633                         if (cyy_readb(info, CySRER) & CyTxMpty) {
 634                                 cyy_writeb(info, CySRER,
 635                                         cyy_readb(info, CySRER) & ~CyTxMpty);
 636                         } else {
 637                                 cyy_writeb(info, CySRER, CyTxMpty |
 638                                         (cyy_readb(info, CySRER) & ~CyTxRdy));
 639                         }
 640                         goto done;
 641                 }
 642                 if (info->port.xmit_buf == NULL) {
 643                         cyy_writeb(info, CySRER,
 644                                 cyy_readb(info, CySRER) & ~CyTxRdy);
 645                         goto done;
 646                 }
 647                 if (tty->stopped || tty->hw_stopped) {
 648                         cyy_writeb(info, CySRER,
 649                                 cyy_readb(info, CySRER) & ~CyTxRdy);
 650                         goto done;
 651                 }
 652                 /* Because the Embedded Transmit Commands have been enabled,
 653                  * we must check to see if the escape character, NULL, is being
 654                  * sent. If it is, we must ensure that there is room for it to
 655                  * be doubled in the output stream.  Therefore we no longer
 656                  * advance the pointer when the character is fetched, but
 657                  * rather wait until after the check for a NULL output
 658                  * character. This is necessary because there may not be room
 659                  * for the two chars needed to send a NULL.)
 660                  */
 661                 outch = info->port.xmit_buf[info->xmit_tail];
 662                 if (outch) {
 663                         info->xmit_cnt--;
 664                         info->xmit_tail = (info->xmit_tail + 1) &
 665                                         (SERIAL_XMIT_SIZE - 1);
 666                         cyy_writeb(info, CyTDR, outch);
 667                         info->icount.tx++;
 668                 } else {
 669                         if (char_count > 1) {
 670                                 info->xmit_cnt--;
 671                                 info->xmit_tail = (info->xmit_tail + 1) &
 672                                         (SERIAL_XMIT_SIZE - 1);
 673                                 cyy_writeb(info, CyTDR, outch);
 674                                 cyy_writeb(info, CyTDR, 0);
 675                                 info->icount.tx++;
 676                                 char_count--;
 677                         }
 678                 }
 679         }
 680
 681 done:
 682         tty_wakeup(tty);
 683         tty_kref_put(tty);
 684 end:
 685         /* end of service */
 686         cyy_writeb(info, CyTIR, save_xir & 0x3f);
 687         cyy_writeb(info, CyCAR, save_car);
 688 }
 689
 690 static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
 691                 void __iomem *base_addr)
 692 {
 693         struct cyclades_port *info;
 694         struct tty_struct *tty;
 695         int index = cinfo->bus_index;
 696         u8 save_xir, channel, save_car, mdm_change, mdm_status;
 697
 698         /* determine the channel & change to that context */
 699         save_xir = readb(base_addr + (CyMIR << index));
 700         channel = save_xir & CyIRChannel;
 701         info = &cinfo->ports[channel + chip * 4];
 702         save_car = cyy_readb(info, CyCAR);
 703         cyy_writeb(info, CyCAR, save_xir);
 704
 705         mdm_change = cyy_readb(info, CyMISR);
 706         mdm_status = cyy_readb(info, CyMSVR1);
 707
 708         tty = tty_port_tty_get(&info->port);
 709         if (!tty)
 710                 goto end;
 711
 712         if (mdm_change & CyANY_DELTA) {
 713                 /* For statistics only */
 714                 if (mdm_change & CyDCD)
 715                         info->icount.dcd++;
 716                 if (mdm_change & CyCTS)
 717                         info->icount.cts++;
 718                 if (mdm_change & CyDSR)
 719                         info->icount.dsr++;
 720                 if (mdm_change & CyRI)
 721                         info->icount.rng++;
 722
 723                 wake_up_interruptible(&info->port.delta_msr_wait);
 724         }
 725
 726         if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
 727                 if (mdm_status & CyDCD)
 728                         wake_up_interruptible(&info->port.open_wait);
 729                 else
 730                         tty_hangup(tty);
 731         }
 732         if ((mdm_change & CyCTS) && tty_port_cts_enabled(&info->port)) {
 733                 if (tty->hw_stopped) {
 734                         if (mdm_status & CyCTS) {
 735                                 /* cy_start isn't used
 736                                    because... !!! */
 737                                 tty->hw_stopped = 0;
 738                                 cyy_writeb(info, CySRER,
 739                                         cyy_readb(info, CySRER) | CyTxRdy);
 740                                 tty_wakeup(tty);
 741                         }
 742                 } else {
 743                         if (!(mdm_status & CyCTS)) {
 744                                 /* cy_stop isn't used
 745                                    because ... !!! */
 746                                 tty->hw_stopped = 1;
 747                                 cyy_writeb(info, CySRER,
 748                                         cyy_readb(info, CySRER) & ~CyTxRdy);
 749                         }
 750                 }
 751         }
 752 /*      if (mdm_change & CyDSR) {
 753         }
 754         if (mdm_change & CyRI) {
 755         }*/
 756         tty_kref_put(tty);
 757 end:
 758         /* end of service */
 759         cyy_writeb(info, CyMIR, save_xir & 0x3f);
 760         cyy_writeb(info, CyCAR, save_car);
 761 }
 762
 763 /* The real interrupt service routine is called
 764    whenever the card wants its hand held--chars
 765    received, out buffer empty, modem change, etc.
 766  */
 767 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
 768 {
 769         int status;
 770         struct cyclades_card *cinfo = dev_id;
 771         void __iomem *base_addr, *card_base_addr;
 772         unsigned int chip, too_many, had_work;
 773         int index;
 774
 775         if (unlikely(cinfo == NULL)) {
 776 #ifdef CY_DEBUG_INTERRUPTS
 777                 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
 778                                 irq);
 779 #endif
 780                 return IRQ_NONE;        /* spurious interrupt */
 781         }
 782
 783         card_base_addr = cinfo->base_addr;
 784         index = cinfo->bus_index;
 785
 786         /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
 787         if (unlikely(card_base_addr == NULL))
 788                 return IRQ_HANDLED;
 789
 790         /* This loop checks all chips in the card.  Make a note whenever
 791            _any_ chip had some work to do, as this is considered an
 792            indication that there will be more to do.  Only when no chip
 793            has any work does this outermost loop exit.
 794          */
 795         do {
 796                 had_work = 0;
 797                 for (chip = 0; chip < cinfo->num_chips; chip++) {
 798                         base_addr = cinfo->base_addr +
 799                                         (cy_chip_offset[chip] << index);
 800                         too_many = 0;
 801                         while ((status = readb(base_addr +
 802                                                 (CySVRR << index))) != 0x00) {
 803                                 had_work++;
 804                         /* The purpose of the following test is to ensure that
 805                            no chip can monopolize the driver.  This forces the
 806                            chips to be checked in a round-robin fashion (after
 807                            draining each of a bunch (1000) of characters).
 808                          */
 809                                 if (1000 < too_many++)
 810                                         break;
 811                                 spin_lock(&cinfo->card_lock);
 812                                 if (status & CySRReceive) /* rx intr */
 813                                         cyy_chip_rx(cinfo, chip, base_addr);
 814                                 if (status & CySRTransmit) /* tx intr */
 815                                         cyy_chip_tx(cinfo, chip, base_addr);
 816                                 if (status & CySRModem) /* modem intr */
 817                                         cyy_chip_modem(cinfo, chip, base_addr);
 818                                 spin_unlock(&cinfo->card_lock);
 819                         }
 820                 }
 821         } while (had_work);
 822
 823         /* clear interrupts */
 824         spin_lock(&cinfo->card_lock);
 825         cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
 826         /* Cy_ClrIntr is 0x1800 */
 827         spin_unlock(&cinfo->card_lock);
 828         return IRQ_HANDLED;
 829 }                               /* cyy_interrupt */
 830
 831 static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
 832                 unsigned int clear)
 833 {
 834         struct cyclades_card *card = info->card;
 835         int channel = info->line - card->first_line;
 836         u32 rts, dtr, msvrr, msvrd;
 837
 838         channel &= 0x03;
 839
 840         if (info->rtsdtr_inv) {
 841                 msvrr = CyMSVR2;
 842                 msvrd = CyMSVR1;
 843                 rts = CyDTR;
 844                 dtr = CyRTS;
 845         } else {
 846                 msvrr = CyMSVR1;
 847                 msvrd = CyMSVR2;
 848                 rts = CyRTS;
 849                 dtr = CyDTR;
 850         }
 851         if (set & TIOCM_RTS) {
 852                 cyy_writeb(info, CyCAR, channel);
 853                 cyy_writeb(info, msvrr, rts);
 854         }
 855         if (clear & TIOCM_RTS) {
 856                 cyy_writeb(info, CyCAR, channel);
 857                 cyy_writeb(info, msvrr, ~rts);
 858         }
 859         if (set & TIOCM_DTR) {
 860                 cyy_writeb(info, CyCAR, channel);
 861                 cyy_writeb(info, msvrd, dtr);
 862 #ifdef CY_DEBUG_DTR
 863                 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
 864                 printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
 865                         cyy_readb(info, CyMSVR1),
 866                         cyy_readb(info, CyMSVR2));
 867 #endif
 868         }
 869         if (clear & TIOCM_DTR) {
 870                 cyy_writeb(info, CyCAR, channel);
 871                 cyy_writeb(info, msvrd, ~dtr);
 872 #ifdef CY_DEBUG_DTR
 873                 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
 874                 printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
 875                         cyy_readb(info, CyMSVR1),
 876                         cyy_readb(info, CyMSVR2));
 877 #endif
 878         }
 879 }
 880
 881 /***********************************************************/
 882 /********* End of block of Cyclom-Y specific code **********/
 883 /******** Start of block of Cyclades-Z specific code *******/
 884 /***********************************************************/
 885
 886 static int
 887 cyz_fetch_msg(struct cyclades_card *cinfo,
 888                 __u32 *channel, __u8 *cmd, __u32 *param)
 889 {
 890         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
 891         unsigned long loc_doorbell;
 892
 893         loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
 894         if (loc_doorbell) {
 895                 *cmd = (char)(0xff & loc_doorbell);
 896                 *channel = readl(&board_ctrl->fwcmd_channel);
 897                 *param = (__u32) readl(&board_ctrl->fwcmd_param);
 898                 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
 899                 return 1;
 900         }
 901         return 0;
 902 }                               /* cyz_fetch_msg */
 903
 904 static int
 905 cyz_issue_cmd(struct cyclades_card *cinfo,
 906                 __u32 channel, __u8 cmd, __u32 param)
 907 {
 908         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
 909         __u32 __iomem *pci_doorbell;
 910         unsigned int index;
 911
 912         if (!cyz_is_loaded(cinfo))
 913                 return -1;
 914
 915         index = 0;
 916         pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
 917         while ((readl(pci_doorbell) & 0xff) != 0) {
 918                 if (index++ == 1000)
 919                         return (int)(readl(pci_doorbell) & 0xff);
 920                 udelay(50L);
 921         }
 922         cy_writel(&board_ctrl->hcmd_channel, channel);
 923         cy_writel(&board_ctrl->hcmd_param, param);
 924         cy_writel(pci_doorbell, (long)cmd);
 925
 926         return 0;
 927 }                               /* cyz_issue_cmd */
 928
 929 static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
 930 {
 931         struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
 932         struct cyclades_card *cinfo = info->card;
 933         struct tty_port *port = &info->port;
 934         unsigned int char_count;
 935         int len;
 936 #ifdef BLOCKMOVE
 937         unsigned char *buf;
 938 #else
 939         char data;
 940 #endif
 941         __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
 942
 943         rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
 944         rx_put = readl(&buf_ctrl->rx_put);
 945         rx_bufsize = readl(&buf_ctrl->rx_bufsize);
 946         rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
 947         if (rx_put >= rx_get)
 948                 char_count = rx_put - rx_get;
 949         else
 950                 char_count = rx_put - rx_get + rx_bufsize;
 951
 952         if (char_count) {
 953 #ifdef CY_ENABLE_MONITORING
 954                 info->mon.int_count++;
 955                 info->mon.char_count += char_count;
 956                 if (char_count > info->mon.char_max)
 957                         info->mon.char_max = char_count;
 958                 info->mon.char_last = char_count;
 959 #endif
 960                 if (tty == NULL) {
 961                         /* flush received characters */
 962                         new_rx_get = (new_rx_get + char_count) &
 963                                         (rx_bufsize - 1);
 964                         info->rflush_count++;
 965                 } else {
 966 #ifdef BLOCKMOVE
 967                 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
 968                    for performance, but because of buffer boundaries, there
 969                    may be several steps to the operation */
 970                         while (1) {
 971                                 len = tty_prepare_flip_string(port, &buf,
 972                                                 char_count);
 973                                 if (!len)
 974                                         break;
 975
 976                                 len = min_t(unsigned int, min(len, char_count),
 977                                                 rx_bufsize - new_rx_get);
 978
 979                                 memcpy_fromio(buf, cinfo->base_addr +
 980                                                 rx_bufaddr + new_rx_get, len);
 981
 982                                 new_rx_get = (new_rx_get + len) &
 983                                                 (rx_bufsize - 1);
 984                                 char_count -= len;
 985                                 info->icount.rx += len;
 986                                 info->idle_stats.recv_bytes += len;
 987                         }
 988 #else
 989                         len = tty_buffer_request_room(port, char_count);
 990                         while (len--) {
 991                                 data = readb(cinfo->base_addr + rx_bufaddr +
 992                                                 new_rx_get);
 993                                 new_rx_get = (new_rx_get + 1) &
 994                                                         (rx_bufsize - 1);
 995                                 tty_insert_flip_char(tty, data, TTY_NORMAL);
 996                                 info->idle_stats.recv_bytes++;
 997                                 info->icount.rx++;
 998                         }
 999 #endif
1000 #ifdef CONFIG_CYZ_INTR
1001                 /* Recalculate the number of chars in the RX buffer and issue
1002                    a cmd in case it's higher than the RX high water mark */
1003                         rx_put = readl(&buf_ctrl->rx_put);
1004                         if (rx_put >= rx_get)
1005                                 char_count = rx_put - rx_get;
1006                         else
1007                                 char_count = rx_put - rx_get + rx_bufsize;
1008                         if (char_count >= readl(&buf_ctrl->rx_threshold) &&
1009                                         !timer_pending(&cyz_rx_full_timer[
1010                                                         info->line]))
1011                                 mod_timer(&cyz_rx_full_timer[info->line],
1012                                                 jiffies + 1);
1013 #endif
1014                         info->idle_stats.recv_idle = jiffies;
1015                         tty_schedule_flip(tty);
1016                 }
1017                 /* Update rx_get */
1018                 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1019         }
1020 }
1021
1022 static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
1023 {
1024         struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1025         struct cyclades_card *cinfo = info->card;
1026         u8 data;
1027         unsigned int char_count;
1028 #ifdef BLOCKMOVE
1029         int small_count;
1030 #endif
1031         __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1032
1033         if (info->xmit_cnt <= 0)        /* Nothing to transmit */
1034                 return;
1035
1036         tx_get = readl(&buf_ctrl->tx_get);
1037         tx_put = readl(&buf_ctrl->tx_put);
1038         tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1039         tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1040         if (tx_put >= tx_get)
1041                 char_count = tx_get - tx_put - 1 + tx_bufsize;
1042         else
1043                 char_count = tx_get - tx_put - 1;
1044
1045         if (char_count) {
1046
1047                 if (tty == NULL)
1048                         goto ztxdone;
1049
1050                 if (info->x_char) {     /* send special char */
1051                         data = info->x_char;
1052
1053                         cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1054                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
1055                         info->x_char = 0;
1056                         char_count--;
1057                         info->icount.tx++;
1058                 }
1059 #ifdef BLOCKMOVE
1060                 while (0 < (small_count = min_t(unsigned int,
1061                                 tx_bufsize - tx_put, min_t(unsigned int,
1062                                         (SERIAL_XMIT_SIZE - info->xmit_tail),
1063                                         min_t(unsigned int, info->xmit_cnt,
1064                                                 char_count))))) {
1065
1066                         memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1067                                         tx_put),
1068                                         &info->port.xmit_buf[info->xmit_tail],
1069                                         small_count);
1070
1071                         tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1072                         char_count -= small_count;
1073                         info->icount.tx += small_count;
1074                         info->xmit_cnt -= small_count;
1075                         info->xmit_tail = (info->xmit_tail + small_count) &
1076                                         (SERIAL_XMIT_SIZE - 1);
1077                 }
1078 #else
1079                 while (info->xmit_cnt && char_count) {
1080                         data = info->port.xmit_buf[info->xmit_tail];
1081                         info->xmit_cnt--;
1082                         info->xmit_tail = (info->xmit_tail + 1) &
1083                                         (SERIAL_XMIT_SIZE - 1);
1084
1085                         cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1086                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
1087                         char_count--;
1088                         info->icount.tx++;
1089                 }
1090 #endif
1091                 tty_wakeup(tty);
1092 ztxdone:
1093                 /* Update tx_put */
1094                 cy_writel(&buf_ctrl->tx_put, tx_put);
1095         }
1096 }
1097
1098 static void cyz_handle_cmd(struct cyclades_card *cinfo)
1099 {
1100         struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1101         struct tty_struct *tty;
1102         struct cyclades_port *info;
1103         __u32 channel, param, fw_ver;
1104         __u8 cmd;
1105         int special_count;
1106         int delta_count;
1107
1108         fw_ver = readl(&board_ctrl->fw_version);
1109
1110         while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1111                 special_count = 0;
1112                 delta_count = 0;
1113                 info = &cinfo->ports[channel];
1114                 tty = tty_port_tty_get(&info->port);
1115                 if (tty == NULL)
1116                         continue;
1117
1118                 switch (cmd) {
1119                 case C_CM_PR_ERROR:
1120                         tty_insert_flip_char(tty, 0, TTY_PARITY);
1121                         info->icount.rx++;
1122                         special_count++;
1123                         break;
1124                 case C_CM_FR_ERROR:
1125                         tty_insert_flip_char(tty, 0, TTY_FRAME);
1126                         info->icount.rx++;
1127                         special_count++;
1128                         break;
1129                 case C_CM_RXBRK:
1130                         tty_insert_flip_char(tty, 0, TTY_BREAK);
1131                         info->icount.rx++;
1132                         special_count++;
1133                         break;
1134                 case C_CM_MDCD:
1135                         info->icount.dcd++;
1136                         delta_count++;
1137                         if (info->port.flags & ASYNC_CHECK_CD) {
1138                                 u32 dcd = fw_ver > 241 ? param :
1139                                         readl(&info->u.cyz.ch_ctrl->rs_status);
1140                                 if (dcd & C_RS_DCD)
1141                                         wake_up_interruptible(&info->port.open_wait);
1142                                 else
1143                                         tty_hangup(tty);
1144                         }
1145                         break;
1146                 case C_CM_MCTS:
1147                         info->icount.cts++;
1148                         delta_count++;
1149                         break;
1150                 case C_CM_MRI:
1151                         info->icount.rng++;
1152                         delta_count++;
1153                         break;
1154                 case C_CM_MDSR:
1155                         info->icount.dsr++;
1156                         delta_count++;
1157                         break;
1158 #ifdef Z_WAKE
1159                 case C_CM_IOCTLW:
1160                         complete(&info->shutdown_wait);
1161                         break;
1162 #endif
1163 #ifdef CONFIG_CYZ_INTR
1164                 case C_CM_RXHIWM:
1165                 case C_CM_RXNNDT:
1166                 case C_CM_INTBACK2:
1167                         /* Reception Interrupt */
1168 #ifdef CY_DEBUG_INTERRUPTS
1169                         printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1170                                         "port %ld\n", info->card, channel);
1171 #endif
1172                         cyz_handle_rx(info, tty);
1173                         break;
1174                 case C_CM_TXBEMPTY:
1175                 case C_CM_TXLOWWM:
1176                 case C_CM_INTBACK:
1177                         /* Transmission Interrupt */
1178 #ifdef CY_DEBUG_INTERRUPTS
1179                         printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1180                                         "port %ld\n", info->card, channel);
1181 #endif
1182                         cyz_handle_tx(info, tty);
1183                         break;
1184 #endif                          /* CONFIG_CYZ_INTR */
1185                 case C_CM_FATAL:
1186                         /* should do something with this !!! */
1187                         break;
1188                 default:
1189                         break;
1190                 }
1191                 if (delta_count)
1192                         wake_up_interruptible(&info->port.delta_msr_wait);
1193                 if (special_count)
1194                         tty_schedule_flip(tty);
1195                 tty_kref_put(tty);
1196         }
1197 }
1198
1199 #ifdef CONFIG_CYZ_INTR
1200 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1201 {
1202         struct cyclades_card *cinfo = dev_id;
1203
1204         if (unlikely(!cyz_is_loaded(cinfo))) {
1205 #ifdef CY_DEBUG_INTERRUPTS
1206                 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1207                                 "(IRQ%d).\n", irq);
1208 #endif
1209                 return IRQ_NONE;
1210         }
1211
1212         /* Handle the interrupts */
1213         cyz_handle_cmd(cinfo);
1214
1215         return IRQ_HANDLED;
1216 }                               /* cyz_interrupt */
1217
1218 static void cyz_rx_restart(unsigned long arg)
1219 {
1220         struct cyclades_port *info = (struct cyclades_port *)arg;
1221         struct cyclades_card *card = info->card;
1222         int retval;
1223         __u32 channel = info->line - card->first_line;
1224         unsigned long flags;
1225
1226         spin_lock_irqsave(&card->card_lock, flags);
1227         retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1228         if (retval != 0) {
1229                 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1230                         info->line, retval);
1231         }
1232         spin_unlock_irqrestore(&card->card_lock, flags);
1233 }
1234
1235 #else                           /* CONFIG_CYZ_INTR */
1236
1237 static void cyz_poll(unsigned long arg)
1238 {
1239         struct cyclades_card *cinfo;
1240         struct cyclades_port *info;
1241         unsigned long expires = jiffies + HZ;
1242         unsigned int port, card;
1243
1244         for (card = 0; card < NR_CARDS; card++) {
1245                 cinfo = &cy_card[card];
1246
1247                 if (!cy_is_Z(cinfo))
1248                         continue;
1249                 if (!cyz_is_loaded(cinfo))
1250                         continue;
1251
1252         /* Skip first polling cycle to avoid racing conditions with the FW */
1253                 if (!cinfo->intr_enabled) {
1254                         cinfo->intr_enabled = 1;
1255                         continue;
1256                 }
1257
1258                 cyz_handle_cmd(cinfo);
1259
1260                 for (port = 0; port < cinfo->nports; port++) {
1261                         struct tty_struct *tty;
1262
1263                         info = &cinfo->ports[port];
1264                         tty = tty_port_tty_get(&info->port);
1265                         /* OK to pass NULL to the handle functions below.
1266                            They need to drop the data in that case. */
1267
1268                         if (!info->throttle)
1269                                 cyz_handle_rx(info, tty);
1270                         cyz_handle_tx(info, tty);
1271                         tty_kref_put(tty);
1272                 }
1273                 /* poll every 'cyz_polling_cycle' period */
1274                 expires = jiffies + cyz_polling_cycle;
1275         }
1276         mod_timer(&cyz_timerlist, expires);
1277 }                               /* cyz_poll */
1278
1279 #endif                          /* CONFIG_CYZ_INTR */
1280
1281 /********** End of block of Cyclades-Z specific code *********/
1282 /***********************************************************/
1283
1284 /* This is called whenever a port becomes active;
1285    interrupts are enabled and DTR & RTS are turned on.
1286  */
1287 static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1288 {
1289         struct cyclades_card *card;
1290         unsigned long flags;
1291         int retval = 0;
1292         int channel;
1293         unsigned long page;
1294
1295         card = info->card;
1296         channel = info->line - card->first_line;
1297
1298         page = get_zeroed_page(GFP_KERNEL);
1299         if (!page)
1300                 return -ENOMEM;
1301
1302         spin_lock_irqsave(&card->card_lock, flags);
1303
1304         if (info->port.flags & ASYNC_INITIALIZED)
1305                 goto errout;
1306
1307         if (!info->type) {
1308                 set_bit(TTY_IO_ERROR, &tty->flags);
1309                 goto errout;
1310         }
1311
1312         if (info->port.xmit_buf)
1313                 free_page(page);
1314         else
1315                 info->port.xmit_buf = (unsigned char *)page;
1316
1317         spin_unlock_irqrestore(&card->card_lock, flags);
1318
1319         cy_set_line_char(info, tty);
1320
1321         if (!cy_is_Z(card)) {
1322                 channel &= 0x03;
1323
1324                 spin_lock_irqsave(&card->card_lock, flags);
1325
1326                 cyy_writeb(info, CyCAR, channel);
1327
1328                 cyy_writeb(info, CyRTPR,
1329                         (info->default_timeout ? info->default_timeout : 0x02));
1330                 /* 10ms rx timeout */
1331
1332                 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1333
1334                 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1335
1336                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1337         } else {
1338                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1339
1340                 if (!cyz_is_loaded(card))
1341                         return -ENODEV;
1342
1343 #ifdef CY_DEBUG_OPEN
1344                 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1345                         "base_addr %p\n", card, channel, card->base_addr);
1346 #endif
1347                 spin_lock_irqsave(&card->card_lock, flags);
1348
1349                 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1350 #ifdef Z_WAKE
1351 #ifdef CONFIG_CYZ_INTR
1352                 cy_writel(&ch_ctrl->intr_enable,
1353                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1354                           C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1355 #else
1356                 cy_writel(&ch_ctrl->intr_enable,
1357                           C_IN_IOCTLW | C_IN_MDCD);
1358 #endif                          /* CONFIG_CYZ_INTR */
1359 #else
1360 #ifdef CONFIG_CYZ_INTR
1361                 cy_writel(&ch_ctrl->intr_enable,
1362                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1363                           C_IN_RXNNDT | C_IN_MDCD);
1364 #else
1365                 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1366 #endif                          /* CONFIG_CYZ_INTR */
1367 #endif                          /* Z_WAKE */
1368
1369                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1370                 if (retval != 0) {
1371                         printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1372                                 "%x\n", info->line, retval);
1373                 }
1374
1375                 /* Flush RX buffers before raising DTR and RTS */
1376                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1377                 if (retval != 0) {
1378                         printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1379                                 "%x\n", info->line, retval);
1380                 }
1381
1382                 /* set timeout !!! */
1383                 /* set RTS and DTR !!! */
1384                 tty_port_raise_dtr_rts(&info->port);
1385
1386                 /* enable send, recv, modem !!! */
1387         }
1388
1389         info->port.flags |= ASYNC_INITIALIZED;
1390
1391         clear_bit(TTY_IO_ERROR, &tty->flags);
1392         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1393         info->breakon = info->breakoff = 0;
1394         memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1395         info->idle_stats.in_use =
1396         info->idle_stats.recv_idle =
1397         info->idle_stats.xmit_idle = jiffies;
1398
1399         spin_unlock_irqrestore(&card->card_lock, flags);
1400
1401 #ifdef CY_DEBUG_OPEN
1402         printk(KERN_DEBUG "cyc startup done\n");
1403 #endif
1404         return 0;
1405
1406 errout:
1407         spin_unlock_irqrestore(&card->card_lock, flags);
1408         free_page(page);
1409         return retval;
1410 }                               /* startup */
1411
1412 static void start_xmit(struct cyclades_port *info)
1413 {
1414         struct cyclades_card *card = info->card;
1415         unsigned long flags;
1416         int channel = info->line - card->first_line;
1417
1418         if (!cy_is_Z(card)) {
1419                 spin_lock_irqsave(&card->card_lock, flags);
1420                 cyy_writeb(info, CyCAR, channel & 0x03);
1421                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1422                 spin_unlock_irqrestore(&card->card_lock, flags);
1423         } else {
1424 #ifdef CONFIG_CYZ_INTR
1425                 int retval;
1426
1427                 spin_lock_irqsave(&card->card_lock, flags);
1428                 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1429                 if (retval != 0) {
1430                         printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1431                                 "%x\n", info->line, retval);
1432                 }
1433                 spin_unlock_irqrestore(&card->card_lock, flags);
1434 #else                           /* CONFIG_CYZ_INTR */
1435                 /* Don't have to do anything at this time */
1436 #endif                          /* CONFIG_CYZ_INTR */
1437         }
1438 }                               /* start_xmit */
1439
1440 /*
1441  * This routine shuts down a serial port; interrupts are disabled,
1442  * and DTR is dropped if the hangup on close termio flag is on.
1443  */
1444 static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1445 {
1446         struct cyclades_card *card;
1447         unsigned long flags;
1448
1449         if (!(info->port.flags & ASYNC_INITIALIZED))
1450                 return;
1451
1452         card = info->card;
1453         if (!cy_is_Z(card)) {
1454                 spin_lock_irqsave(&card->card_lock, flags);
1455
1456                 /* Clear delta_msr_wait queue to avoid mem leaks. */
1457                 wake_up_interruptible(&info->port.delta_msr_wait);
1458
1459                 if (info->port.xmit_buf) {
1460                         unsigned char *temp;
1461                         temp = info->port.xmit_buf;
1462                         info->port.xmit_buf = NULL;
1463                         free_page((unsigned long)temp);
1464                 }
1465                 if (tty->termios.c_cflag & HUPCL)
1466                         cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1467
1468                 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1469                 /* it may be appropriate to clear _XMIT at
1470                    some later date (after testing)!!! */
1471
1472                 set_bit(TTY_IO_ERROR, &tty->flags);
1473                 info->port.flags &= ~ASYNC_INITIALIZED;
1474                 spin_unlock_irqrestore(&card->card_lock, flags);
1475         } else {
1476 #ifdef CY_DEBUG_OPEN
1477                 int channel = info->line - card->first_line;
1478                 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1479                         "base_addr %p\n", card, channel, card->base_addr);
1480 #endif
1481
1482                 if (!cyz_is_loaded(card))
1483                         return;
1484
1485                 spin_lock_irqsave(&card->card_lock, flags);
1486
1487                 if (info->port.xmit_buf) {
1488                         unsigned char *temp;
1489                         temp = info->port.xmit_buf;
1490                         info->port.xmit_buf = NULL;
1491                         free_page((unsigned long)temp);
1492                 }
1493
1494                 if (tty->termios.c_cflag & HUPCL)
1495                         tty_port_lower_dtr_rts(&info->port);
1496
1497                 set_bit(TTY_IO_ERROR, &tty->flags);
1498                 info->port.flags &= ~ASYNC_INITIALIZED;
1499
1500                 spin_unlock_irqrestore(&card->card_lock, flags);
1501         }
1502
1503 #ifdef CY_DEBUG_OPEN
1504         printk(KERN_DEBUG "cyc shutdown done\n");
1505 #endif
1506 }                               /* shutdown */
1507
1508 /*
1509  * ------------------------------------------------------------
1510  * cy_open() and friends
1511  * ------------------------------------------------------------
1512  */
1513
1514 /*
1515  * This routine is called whenever a serial port is opened.  It
1516  * performs the serial-specific initialization for the tty structure.
1517  */
1518 static int cy_open(struct tty_struct *tty, struct file *filp)
1519 {
1520         struct cyclades_port *info;
1521         unsigned int i, line = tty->index;
1522         int retval;
1523
1524         for (i = 0; i < NR_CARDS; i++)
1525                 if (line < cy_card[i].first_line + cy_card[i].nports &&
1526                                 line >= cy_card[i].first_line)
1527                         break;
1528         if (i >= NR_CARDS)
1529                 return -ENODEV;
1530         info = &cy_card[i].ports[line - cy_card[i].first_line];
1531         if (info->line < 0)
1532                 return -ENODEV;
1533
1534         /* If the card's firmware hasn't been loaded,
1535            treat it as absent from the system.  This
1536            will make the user pay attention.
1537          */
1538         if (cy_is_Z(info->card)) {
1539                 struct cyclades_card *cinfo = info->card;
1540                 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1541
1542                 if (!cyz_is_loaded(cinfo)) {
1543                         if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1544                                         readl(&firm_id->signature) ==
1545                                         ZFIRM_HLT) {
1546                                 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1547                                         "need an external power supply for "
1548                                         "this number of ports.\nFirmware "
1549                                         "halted.\n");
1550                         } else {
1551                                 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1552                                         "yet loaded\n");
1553                         }
1554                         return -ENODEV;
1555                 }
1556 #ifdef CONFIG_CYZ_INTR
1557                 else {
1558                 /* In case this Z board is operating in interrupt mode, its
1559                    interrupts should be enabled as soon as the first open
1560                    happens to one of its ports. */
1561                         if (!cinfo->intr_enabled) {
1562                                 u16 intr;
1563
1564                                 /* Enable interrupts on the PLX chip */
1565                                 intr = readw(&cinfo->ctl_addr.p9060->
1566                                                 intr_ctrl_stat) | 0x0900;
1567                                 cy_writew(&cinfo->ctl_addr.p9060->
1568                                                 intr_ctrl_stat, intr);
1569                                 /* Enable interrupts on the FW */
1570                                 retval = cyz_issue_cmd(cinfo, 0,
1571                                                 C_CM_IRQ_ENBL, 0L);
1572                                 if (retval != 0) {
1573                                         printk(KERN_ERR "cyc:IRQ enable retval "
1574                                                 "was %x\n", retval);
1575                                 }
1576                                 cinfo->intr_enabled = 1;
1577                         }
1578                 }
1579 #endif                          /* CONFIG_CYZ_INTR */
1580                 /* Make sure this Z port really exists in hardware */
1581                 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1582                         return -ENODEV;
1583         }
1584 #ifdef CY_DEBUG_OTHER
1585         printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1586 #endif
1587         tty->driver_data = info;
1588         if (serial_paranoia_check(info, tty->name, "cy_open"))
1589                 return -ENODEV;
1590
1591 #ifdef CY_DEBUG_OPEN
1592         printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1593                         info->port.count);
1594 #endif
1595         info->port.count++;
1596 #ifdef CY_DEBUG_COUNT
1597         printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1598                 current->pid, info->port.count);
1599 #endif
1600
1601         /*
1602          * If the port is the middle of closing, bail out now
1603          */
1604         if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1605                 wait_event_interruptible_tty(tty, info->port.close_wait,
1606                                 !(info->port.flags & ASYNC_CLOSING));
1607                 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1608         }
1609
1610         /*
1611          * Start up serial port
1612          */
1613         retval = cy_startup(info, tty);
1614         if (retval)
1615                 return retval;
1616
1617         retval = tty_port_block_til_ready(&info->port, tty, filp);
1618         if (retval) {
1619 #ifdef CY_DEBUG_OPEN
1620                 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1621                         "with %d\n", retval);
1622 #endif
1623                 return retval;
1624         }
1625
1626         info->throttle = 0;
1627         tty_port_tty_set(&info->port, tty);
1628
1629 #ifdef CY_DEBUG_OPEN
1630         printk(KERN_DEBUG "cyc:cy_open done\n");
1631 #endif
1632         return 0;
1633 }                               /* cy_open */
1634
1635 /*
1636  * cy_wait_until_sent() --- wait until the transmitter is empty
1637  */
1638 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1639 {
1640         struct cyclades_card *card;
1641         struct cyclades_port *info = tty->driver_data;
1642         unsigned long orig_jiffies;
1643         int char_time;
1644
1645         if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1646                 return;
1647
1648         if (info->xmit_fifo_size == 0)
1649                 return;         /* Just in case.... */
1650
1651         orig_jiffies = jiffies;
1652         /*
1653          * Set the check interval to be 1/5 of the estimated time to
1654          * send a single character, and make it at least 1.  The check
1655          * interval should also be less than the timeout.
1656          *
1657          * Note: we have to use pretty tight timings here to satisfy
1658          * the NIST-PCTS.
1659          */
1660         char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1661         char_time = char_time / 5;
1662         if (char_time <= 0)
1663                 char_time = 1;
1664         if (timeout < 0)
1665                 timeout = 0;
1666         if (timeout)
1667                 char_time = min(char_time, timeout);
1668         /*
1669          * If the transmitter hasn't cleared in twice the approximate
1670          * amount of time to send the entire FIFO, it probably won't
1671          * ever clear.  This assumes the UART isn't doing flow
1672          * control, which is currently the case.  Hence, if it ever
1673          * takes longer than info->timeout, this is probably due to a
1674          * UART bug of some kind.  So, we clamp the timeout parameter at
1675          * 2*info->timeout.
1676          */
1677         if (!timeout || timeout > 2 * info->timeout)
1678                 timeout = 2 * info->timeout;
1679
1680         card = info->card;
1681         if (!cy_is_Z(card)) {
1682                 while (cyy_readb(info, CySRER) & CyTxRdy) {
1683                         if (msleep_interruptible(jiffies_to_msecs(char_time)))
1684                                 break;
1685                         if (timeout && time_after(jiffies, orig_jiffies +
1686                                         timeout))
1687                                 break;
1688                 }
1689         }
1690         /* Run one more char cycle */
1691         msleep_interruptible(jiffies_to_msecs(char_time * 5));
1692 }
1693
1694 static void cy_flush_buffer(struct tty_struct *tty)
1695 {
1696         struct cyclades_port *info = tty->driver_data;
1697         struct cyclades_card *card;
1698         int channel, retval;
1699         unsigned long flags;
1700
1701 #ifdef CY_DEBUG_IO
1702         printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1703 #endif
1704
1705         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1706                 return;
1707
1708         card = info->card;
1709         channel = info->line - card->first_line;
1710
1711         spin_lock_irqsave(&card->card_lock, flags);
1712         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1713         spin_unlock_irqrestore(&card->card_lock, flags);
1714
1715         if (cy_is_Z(card)) {    /* If it is a Z card, flush the on-board
1716                                            buffers as well */
1717                 spin_lock_irqsave(&card->card_lock, flags);
1718                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1719                 if (retval != 0) {
1720                         printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1721                                 "was %x\n", info->line, retval);
1722                 }
1723                 spin_unlock_irqrestore(&card->card_lock, flags);
1724         }
1725         tty_wakeup(tty);
1726 }                               /* cy_flush_buffer */
1727
1728
1729 static void cy_do_close(struct tty_port *port)
1730 {
1731         struct cyclades_port *info = container_of(port, struct cyclades_port,
1732                                                                 port);
1733         struct cyclades_card *card;
1734         unsigned long flags;
1735         int channel;
1736
1737         card = info->card;
1738         channel = info->line - card->first_line;
1739         spin_lock_irqsave(&card->card_lock, flags);
1740
1741         if (!cy_is_Z(card)) {
1742                 /* Stop accepting input */
1743                 cyy_writeb(info, CyCAR, channel & 0x03);
1744                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1745                 if (info->port.flags & ASYNC_INITIALIZED) {
1746                         /* Waiting for on-board buffers to be empty before
1747                            closing the port */
1748                         spin_unlock_irqrestore(&card->card_lock, flags);
1749                         cy_wait_until_sent(port->tty, info->timeout);
1750                         spin_lock_irqsave(&card->card_lock, flags);
1751                 }
1752         } else {
1753 #ifdef Z_WAKE
1754                 /* Waiting for on-board buffers to be empty before closing
1755                    the port */
1756                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1757                 int retval;
1758
1759                 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1760                         retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1761                         if (retval != 0) {
1762                                 printk(KERN_DEBUG "cyc:cy_close retval on "
1763                                         "ttyC%d was %x\n", info->line, retval);
1764                         }
1765                         spin_unlock_irqrestore(&card->card_lock, flags);
1766                         wait_for_completion_interruptible(&info->shutdown_wait);
1767                         spin_lock_irqsave(&card->card_lock, flags);
1768                 }
1769 #endif
1770         }
1771         spin_unlock_irqrestore(&card->card_lock, flags);
1772         cy_shutdown(info, port->tty);
1773 }
1774
1775 /*
1776  * This routine is called when a particular tty device is closed.
1777  */
1778 static void cy_close(struct tty_struct *tty, struct file *filp)
1779 {
1780         struct cyclades_port *info = tty->driver_data;
1781         if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1782                 return;
1783         tty_port_close(&info->port, tty, filp);
1784 }                               /* cy_close */
1785
1786 /* This routine gets called when tty_write has put something into
1787  * the write_queue.  The characters may come from user space or
1788  * kernel space.
1789  *
1790  * This routine will return the number of characters actually
1791  * accepted for writing.
1792  *
1793  * If the port is not already transmitting stuff, start it off by
1794  * enabling interrupts.  The interrupt service routine will then
1795  * ensure that the characters are sent.
1796  * If the port is already active, there is no need to kick it.
1797  *
1798  */
1799 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1800 {
1801         struct cyclades_port *info = tty->driver_data;
1802         unsigned long flags;
1803         int c, ret = 0;
1804
1805 #ifdef CY_DEBUG_IO
1806         printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1807 #endif
1808
1809         if (serial_paranoia_check(info, tty->name, "cy_write"))
1810                 return 0;
1811
1812         if (!info->port.xmit_buf)
1813                 return 0;
1814
1815         spin_lock_irqsave(&info->card->card_lock, flags);
1816         while (1) {
1817                 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1818                 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1819
1820                 if (c <= 0)
1821                         break;
1822
1823                 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1824                 info->xmit_head = (info->xmit_head + c) &
1825                         (SERIAL_XMIT_SIZE - 1);
1826                 info->xmit_cnt += c;
1827                 buf += c;
1828                 count -= c;
1829                 ret += c;
1830         }
1831         spin_unlock_irqrestore(&info->card->card_lock, flags);
1832
1833         info->idle_stats.xmit_bytes += ret;
1834         info->idle_stats.xmit_idle = jiffies;
1835
1836         if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1837                 start_xmit(info);
1838
1839         return ret;
1840 }                               /* cy_write */
1841
1842 /*
1843  * This routine is called by the kernel to write a single
1844  * character to the tty device.  If the kernel uses this routine,
1845  * it must call the flush_chars() routine (if defined) when it is
1846  * done stuffing characters into the driver.  If there is no room
1847  * in the queue, the character is ignored.
1848  */
1849 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1850 {
1851         struct cyclades_port *info = tty->driver_data;
1852         unsigned long flags;
1853
1854 #ifdef CY_DEBUG_IO
1855         printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1856 #endif
1857
1858         if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1859                 return 0;
1860
1861         if (!info->port.xmit_buf)
1862                 return 0;
1863
1864         spin_lock_irqsave(&info->card->card_lock, flags);
1865         if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1866                 spin_unlock_irqrestore(&info->card->card_lock, flags);
1867                 return 0;
1868         }
1869
1870         info->port.xmit_buf[info->xmit_head++] = ch;
1871         info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1872         info->xmit_cnt++;
1873         info->idle_stats.xmit_bytes++;
1874         info->idle_stats.xmit_idle = jiffies;
1875         spin_unlock_irqrestore(&info->card->card_lock, flags);
1876         return 1;
1877 }                               /* cy_put_char */
1878
1879 /*
1880  * This routine is called by the kernel after it has written a
1881  * series of characters to the tty device using put_char().
1882  */
1883 static void cy_flush_chars(struct tty_struct *tty)
1884 {
1885         struct cyclades_port *info = tty->driver_data;
1886
1887 #ifdef CY_DEBUG_IO
1888         printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1889 #endif
1890
1891         if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1892                 return;
1893
1894         if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1895                         !info->port.xmit_buf)
1896                 return;
1897
1898         start_xmit(info);
1899 }                               /* cy_flush_chars */
1900
1901 /*
1902  * This routine returns the numbers of characters the tty driver
1903  * will accept for queuing to be written.  This number is subject
1904  * to change as output buffers get emptied, or if the output flow
1905  * control is activated.
1906  */
1907 static int cy_write_room(struct tty_struct *tty)
1908 {
1909         struct cyclades_port *info = tty->driver_data;
1910         int ret;
1911
1912 #ifdef CY_DEBUG_IO
1913         printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1914 #endif
1915
1916         if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1917                 return 0;
1918         ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1919         if (ret < 0)
1920                 ret = 0;
1921         return ret;
1922 }                               /* cy_write_room */
1923
1924 static int cy_chars_in_buffer(struct tty_struct *tty)
1925 {
1926         struct cyclades_port *info = tty->driver_data;
1927
1928         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1929                 return 0;
1930
1931 #ifdef Z_EXT_CHARS_IN_BUFFER
1932         if (!cy_is_Z(info->card)) {
1933 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
1934 #ifdef CY_DEBUG_IO
1935                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1936                         info->line, info->xmit_cnt);
1937 #endif
1938                 return info->xmit_cnt;
1939 #ifdef Z_EXT_CHARS_IN_BUFFER
1940         } else {
1941                 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1942                 int char_count;
1943                 __u32 tx_put, tx_get, tx_bufsize;
1944
1945                 tx_get = readl(&buf_ctrl->tx_get);
1946                 tx_put = readl(&buf_ctrl->tx_put);
1947                 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1948                 if (tx_put >= tx_get)
1949                         char_count = tx_put - tx_get;
1950                 else
1951                         char_count = tx_put - tx_get + tx_bufsize;
1952 #ifdef CY_DEBUG_IO
1953                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1954                         info->line, info->xmit_cnt + char_count);
1955 #endif
1956                 return info->xmit_cnt + char_count;
1957         }
1958 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
1959 }                               /* cy_chars_in_buffer */
1960
1961 /*
1962  * ------------------------------------------------------------
1963  * cy_ioctl() and friends
1964  * ------------------------------------------------------------
1965  */
1966
1967 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1968 {
1969         int co, co_val, bpr;
1970         __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
1971                         25000000);
1972
1973         if (baud == 0) {
1974                 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1975                 return;
1976         }
1977
1978         /* determine which prescaler to use */
1979         for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1980                 if (cy_clock / co_val / baud > 63)
1981                         break;
1982         }
1983
1984         bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1985         if (bpr > 255)
1986                 bpr = 255;
1987
1988         info->tbpr = info->rbpr = bpr;
1989         info->tco = info->rco = co;
1990 }
1991
1992 /*
1993  * This routine finds or computes the various line characteristics.
1994  * It used to be called config_setup
1995  */
1996 static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
1997 {
1998         struct cyclades_card *card;
1999         unsigned long flags;
2000         int channel;
2001         unsigned cflag, iflag;
2002         int baud, baud_rate = 0;
2003         int i;
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 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 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         struct cyclades_card *card;
3293         unsigned short cy_isa_irq, nboard;
3294         void __iomem *cy_isa_address;
3295         unsigned short i, j, k, cy_isa_nchan;
3296         int isparam = 0;
3297
3298         nboard = 0;
3299
3300         /* Check for module parameters */
3301         for (i = 0; i < NR_CARDS; i++) {
3302                 if (maddr[i] || i) {
3303                         isparam = 1;
3304                         cy_isa_addresses[i] = maddr[i];
3305                 }
3306                 if (!maddr[i])
3307                         break;
3308         }
3309
3310         /* scan the address table probing for Cyclom-Y/ISA boards */
3311         for (i = 0; i < NR_ISA_ADDRS; i++) {
3312                 unsigned int isa_address = cy_isa_addresses[i];
3313                 if (isa_address == 0x0000)
3314                         return nboard;
3315
3316                 /* probe for CD1400... */
3317                 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3318                 if (cy_isa_address == NULL) {
3319                         printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3320                                         "address\n");
3321                         continue;
3322                 }
3323                 cy_isa_nchan = CyPORTS_PER_CHIP *
3324                         cyy_init_card(cy_isa_address, 0);
3325                 if (cy_isa_nchan == 0) {
3326                         iounmap(cy_isa_address);
3327                         continue;
3328                 }
3329
3330                 if (isparam && i < NR_CARDS && irq[i])
3331                         cy_isa_irq = irq[i];
3332                 else
3333                         /* find out the board's irq by probing */
3334                         cy_isa_irq = detect_isa_irq(cy_isa_address);
3335                 if (cy_isa_irq == 0) {
3336                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3337                                 "IRQ could not be detected.\n",
3338                                 (unsigned long)cy_isa_address);
3339                         iounmap(cy_isa_address);
3340                         continue;
3341                 }
3342
3343                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3344                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3345                                 "more channels are available. Change NR_PORTS "
3346                                 "in cyclades.c and recompile kernel.\n",
3347                                 (unsigned long)cy_isa_address);
3348                         iounmap(cy_isa_address);
3349                         return nboard;
3350                 }
3351                 /* fill the next cy_card structure available */
3352                 for (j = 0; j < NR_CARDS; j++) {
3353                         card = &cy_card[j];
3354                         if (card->base_addr == NULL)
3355                                 break;
3356                 }
3357                 if (j == NR_CARDS) {    /* no more cy_cards available */
3358                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3359                                 "more cards can be used. Change NR_CARDS in "
3360                                 "cyclades.c and recompile kernel.\n",
3361                                 (unsigned long)cy_isa_address);
3362                         iounmap(cy_isa_address);
3363                         return nboard;
3364                 }
3365
3366                 /* allocate IRQ */
3367                 if (request_irq(cy_isa_irq, cyy_interrupt,
3368                                 0, "Cyclom-Y", card)) {
3369                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3370                                 "could not allocate IRQ#%d.\n",
3371                                 (unsigned long)cy_isa_address, cy_isa_irq);
3372                         iounmap(cy_isa_address);
3373                         return nboard;
3374                 }
3375
3376                 /* set cy_card */
3377                 card->base_addr = cy_isa_address;
3378                 card->ctl_addr.p9050 = NULL;
3379                 card->irq = (int)cy_isa_irq;
3380                 card->bus_index = 0;
3381                 card->first_line = cy_next_channel;
3382                 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3383                 card->nports = cy_isa_nchan;
3384                 if (cy_init_card(card)) {
3385                         card->base_addr = NULL;
3386                         free_irq(cy_isa_irq, card);
3387                         iounmap(cy_isa_address);
3388                         continue;
3389                 }
3390                 nboard++;
3391
3392                 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3393                         "%d channels starting from port %d\n",
3394                         j + 1, (unsigned long)cy_isa_address,
3395                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3396                         cy_isa_irq, cy_isa_nchan, cy_next_channel);
3397
3398                 for (k = 0, j = cy_next_channel;
3399                                 j < cy_next_channel + cy_isa_nchan; j++, k++)
3400                         tty_port_register_device(&card->ports[k].port,
3401                                         cy_serial_driver, j, NULL);
3402                 cy_next_channel += cy_isa_nchan;
3403         }
3404         return nboard;
3405 #else
3406         return 0;
3407 #endif                          /* CONFIG_ISA */
3408 }                               /* cy_detect_isa */
3409
3410 #ifdef CONFIG_PCI
3411 static inline int cyc_isfwstr(const char *str, unsigned int size)
3412 {
3413         unsigned int a;
3414
3415         for (a = 0; a < size && *str; a++, str++)
3416                 if (*str & 0x80)
3417                         return -EINVAL;
3418
3419         for (; a < size; a++, str++)
3420                 if (*str)
3421                         return -EINVAL;
3422
3423         return 0;
3424 }
3425
3426 static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3427                 unsigned int size)
3428 {
3429         for (; size > 0; size--) {
3430                 cy_writel(fpga, *data++);
3431                 udelay(10);
3432         }
3433 }
3434
3435 static void plx_init(struct pci_dev *pdev, int irq,
3436                 struct RUNTIME_9060 __iomem *addr)
3437 {
3438         /* Reset PLX */
3439         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3440         udelay(100L);
3441         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3442
3443         /* Reload Config. Registers from EEPROM */
3444         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3445         udelay(100L);
3446         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3447
3448         /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3449          * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3450          * registers. This will remain here until we find a permanent fix.
3451          */
3452         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3453 }
3454
3455 static int __cyz_load_fw(const struct firmware *fw,
3456                 const char *name, const u32 mailbox, void __iomem *base,
3457                 void __iomem *fpga)
3458 {
3459         const void *ptr = fw->data;
3460         const struct zfile_header *h = ptr;
3461         const struct zfile_config *c, *cs;
3462         const struct zfile_block *b, *bs;
3463         unsigned int a, tmp, len = fw->size;
3464 #define BAD_FW KERN_ERR "Bad firmware: "
3465         if (len < sizeof(*h)) {
3466                 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3467                 return -EINVAL;
3468         }
3469
3470         cs = ptr + h->config_offset;
3471         bs = ptr + h->block_offset;
3472
3473         if ((void *)(cs + h->n_config) > ptr + len ||
3474                         (void *)(bs + h->n_blocks) > ptr + len) {
3475                 printk(BAD_FW "too short");
3476                 return  -EINVAL;
3477         }
3478
3479         if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3480                         cyc_isfwstr(h->date, sizeof(h->date))) {
3481                 printk(BAD_FW "bad formatted header string\n");
3482                 return -EINVAL;
3483         }
3484
3485         if (strncmp(name, h->name, sizeof(h->name))) {
3486                 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3487                 return -EINVAL;
3488         }
3489
3490         tmp = 0;
3491         for (c = cs; c < cs + h->n_config; c++) {
3492                 for (a = 0; a < c->n_blocks; a++)
3493                         if (c->block_list[a] > h->n_blocks) {
3494                                 printk(BAD_FW "bad block ref number in cfgs\n");
3495                                 return -EINVAL;
3496                         }
3497                 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3498                         tmp++;
3499         }
3500         if (!tmp) {
3501                 printk(BAD_FW "nothing appropriate\n");
3502                 return -EINVAL;
3503         }
3504
3505         for (b = bs; b < bs + h->n_blocks; b++)
3506                 if (b->file_offset + b->size > len) {
3507                         printk(BAD_FW "bad block data offset\n");
3508                         return -EINVAL;
3509                 }
3510
3511         /* everything is OK, let's seek'n'load it */
3512         for (c = cs; c < cs + h->n_config; c++)
3513                 if (c->mailbox == mailbox && c->function == 0)
3514                         break;
3515
3516         for (a = 0; a < c->n_blocks; a++) {
3517                 b = &bs[c->block_list[a]];
3518                 if (b->type == ZBLOCK_FPGA) {
3519                         if (fpga != NULL)
3520                                 cyz_fpga_copy(fpga, ptr + b->file_offset,
3521                                                 b->size);
3522                 } else {
3523                         if (base != NULL)
3524                                 memcpy_toio(base + b->ram_offset,
3525                                                ptr + b->file_offset, b->size);
3526                 }
3527         }
3528 #undef BAD_FW
3529         return 0;
3530 }
3531
3532 static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3533                 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3534 {
3535         const struct firmware *fw;
3536         struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3537         struct CUSTOM_REG __iomem *cust = base_addr;
3538         struct ZFW_CTRL __iomem *pt_zfwctrl;
3539         void __iomem *tmp;
3540         u32 mailbox, status, nchan;
3541         unsigned int i;
3542         int retval;
3543
3544         retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3545         if (retval) {
3546                 dev_err(&pdev->dev, "can't get firmware\n");
3547                 goto err;
3548         }
3549
3550         /* Check whether the firmware is already loaded and running. If
3551            positive, skip this board */
3552         if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3553                 u32 cntval = readl(base_addr + 0x190);
3554
3555                 udelay(100);
3556                 if (cntval != readl(base_addr + 0x190)) {
3557                         /* FW counter is working, FW is running */
3558                         dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3559                                         "Skipping board.\n");
3560                         retval = 0;
3561                         goto err_rel;
3562                 }
3563         }
3564
3565         /* start boot */
3566         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3567                         ~0x00030800UL);
3568
3569         mailbox = readl(&ctl_addr->mail_box_0);
3570
3571         if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3572                 /* stops CPU and set window to beginning of RAM */
3573                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3574                 cy_writel(&cust->cpu_stop, 0);
3575                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3576                 udelay(100);
3577         }
3578
3579         plx_init(pdev, irq, ctl_addr);
3580
3581         if (mailbox != 0) {
3582                 /* load FPGA */
3583                 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3584                                 base_addr);
3585                 if (retval)
3586                         goto err_rel;
3587                 if (!__cyz_fpga_loaded(ctl_addr)) {
3588                         dev_err(&pdev->dev, "fw upload successful, but fw is "
3589                                         "not loaded\n");
3590                         goto err_rel;
3591                 }
3592         }
3593
3594         /* stops CPU and set window to beginning of RAM */
3595         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3596         cy_writel(&cust->cpu_stop, 0);
3597         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3598         udelay(100);
3599
3600         /* clear memory */
3601         for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3602                 cy_writeb(tmp, 255);
3603         if (mailbox != 0) {
3604                 /* set window to last 512K of RAM */
3605                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3606                 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3607                         cy_writeb(tmp, 255);
3608                 /* set window to beginning of RAM */
3609                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3610         }
3611
3612         retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3613         release_firmware(fw);
3614         if (retval)
3615                 goto err;
3616
3617         /* finish boot and start boards */
3618         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3619         cy_writel(&cust->cpu_start, 0);
3620         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3621         i = 0;
3622         while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3623                 msleep(100);
3624         if (status != ZFIRM_ID) {
3625                 if (status == ZFIRM_HLT) {
3626                         dev_err(&pdev->dev, "you need an external power supply "
3627                                 "for this number of ports. Firmware halted and "
3628                                 "board reset.\n");
3629                         retval = -EIO;
3630                         goto err;
3631                 }
3632                 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3633                                 "some more time\n", status);
3634                 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3635                                 i++ < 200)
3636                         msleep(100);
3637                 if (status != ZFIRM_ID) {
3638                         dev_err(&pdev->dev, "Board not started in 20 seconds! "
3639                                         "Giving up. (fid->signature = 0x%x)\n",
3640                                         status);
3641                         dev_info(&pdev->dev, "*** Warning ***: if you are "
3642                                 "upgrading the FW, please power cycle the "
3643                                 "system before loading the new FW to the "
3644                                 "Cyclades-Z.\n");
3645
3646                         if (__cyz_fpga_loaded(ctl_addr))
3647                                 plx_init(pdev, irq, ctl_addr);
3648
3649                         retval = -EIO;
3650                         goto err;
3651                 }
3652                 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3653                                 i / 10);
3654         }
3655         pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3656
3657         dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3658                         base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3659                         base_addr + readl(&fid->zfwctrl_addr));
3660
3661         nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3662         dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3663                 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3664
3665         if (nchan == 0) {
3666                 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3667                         "check the connection between the Z host card and the "
3668                         "serial expanders.\n");
3669
3670                 if (__cyz_fpga_loaded(ctl_addr))
3671                         plx_init(pdev, irq, ctl_addr);
3672
3673                 dev_info(&pdev->dev, "Null number of ports detected. Board "
3674                                 "reset.\n");
3675                 retval = 0;
3676                 goto err;
3677         }
3678
3679         cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3680         cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3681
3682         /*
3683            Early firmware failed to start looking for commands.
3684            This enables firmware interrupts for those commands.
3685          */
3686         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3687                         (1 << 17));
3688         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3689                         0x00030800UL);
3690
3691         return nchan;
3692 err_rel:
3693         release_firmware(fw);
3694 err:
3695         return retval;
3696 }
3697
3698 static int cy_pci_probe(struct pci_dev *pdev,
3699                 const struct pci_device_id *ent)
3700 {
3701         struct cyclades_card *card;
3702         void __iomem *addr0 = NULL, *addr2 = NULL;
3703         char *card_name = NULL;
3704         u32 uninitialized_var(mailbox);
3705         unsigned int device_id, nchan = 0, card_no, i, j;
3706         unsigned char plx_ver;
3707         int retval, irq;
3708
3709         retval = pci_enable_device(pdev);
3710         if (retval) {
3711                 dev_err(&pdev->dev, "cannot enable device\n");
3712                 goto err;
3713         }
3714
3715         /* read PCI configuration area */
3716         irq = pdev->irq;
3717         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3718
3719 #if defined(__alpha__)
3720         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
3721                 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3722                         "addresses on Alpha systems.\n");
3723                 retval = -EIO;
3724                 goto err_dis;
3725         }
3726 #endif
3727         if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3728                 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3729                         "addresses\n");
3730                 retval = -EIO;
3731                 goto err_dis;
3732         }
3733
3734         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3735                 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3736                                 "it...\n");
3737                 pdev->resource[2].flags &= ~IORESOURCE_IO;
3738         }
3739
3740         retval = pci_request_regions(pdev, "cyclades");
3741         if (retval) {
3742                 dev_err(&pdev->dev, "failed to reserve resources\n");
3743                 goto err_dis;
3744         }
3745
3746         retval = -EIO;
3747         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3748                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3749                 card_name = "Cyclom-Y";
3750
3751                 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3752                                 CyPCI_Yctl);
3753                 if (addr0 == NULL) {
3754                         dev_err(&pdev->dev, "can't remap ctl region\n");
3755                         goto err_reg;
3756                 }
3757                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3758                                 CyPCI_Ywin);
3759                 if (addr2 == NULL) {
3760                         dev_err(&pdev->dev, "can't remap base region\n");
3761                         goto err_unmap;
3762                 }
3763
3764                 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3765                 if (nchan == 0) {
3766                         dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3767                                         "Serial-Modules\n");
3768                         goto err_unmap;
3769                 }
3770         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3771                 struct RUNTIME_9060 __iomem *ctl_addr;
3772
3773                 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3774                                 CyPCI_Zctl);
3775                 if (addr0 == NULL) {
3776                         dev_err(&pdev->dev, "can't remap ctl region\n");
3777                         goto err_reg;
3778                 }
3779
3780                 /* Disable interrupts on the PLX before resetting it */
3781                 cy_writew(&ctl_addr->intr_ctrl_stat,
3782                                 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3783
3784                 plx_init(pdev, irq, addr0);
3785
3786                 mailbox = readl(&ctl_addr->mail_box_0);
3787
3788                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3789                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3790                 if (addr2 == NULL) {
3791                         dev_err(&pdev->dev, "can't remap base region\n");
3792                         goto err_unmap;
3793                 }
3794
3795                 if (mailbox == ZE_V1) {
3796                         card_name = "Cyclades-Ze";
3797                 } else {
3798                         card_name = "Cyclades-8Zo";
3799 #ifdef CY_PCI_DEBUG
3800                         if (mailbox == ZO_V1) {
3801                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3802                                 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3803                                         "id %lx, ver %lx\n", (ulong)(0xff &
3804                                         readl(&((struct CUSTOM_REG *)addr2)->
3805                                                 fpga_id)), (ulong)(0xff &
3806                                         readl(&((struct CUSTOM_REG *)addr2)->
3807                                                 fpga_version)));
3808                                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3809                         } else {
3810                                 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3811                                         "Cyclades-Z board.  FPGA not loaded\n");
3812                         }
3813 #endif
3814                         /* The following clears the firmware id word.  This
3815                            ensures that the driver will not attempt to talk to
3816                            the board until it has been properly initialized.
3817                          */
3818                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3819                                 cy_writel(addr2 + ID_ADDRESS, 0L);
3820                 }
3821
3822                 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3823                 if (retval <= 0)
3824                         goto err_unmap;
3825                 nchan = retval;
3826         }
3827
3828         if ((cy_next_channel + nchan) > NR_PORTS) {
3829                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3830                         "channels are available. Change NR_PORTS in "
3831                         "cyclades.c and recompile kernel.\n");
3832                 goto err_unmap;
3833         }
3834         /* fill the next cy_card structure available */
3835         for (card_no = 0; card_no < NR_CARDS; card_no++) {
3836                 card = &cy_card[card_no];
3837                 if (card->base_addr == NULL)
3838                         break;
3839         }
3840         if (card_no == NR_CARDS) {      /* no more cy_cards available */
3841                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3842                         "more cards can be used. Change NR_CARDS in "
3843                         "cyclades.c and recompile kernel.\n");
3844                 goto err_unmap;
3845         }
3846
3847         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3848                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3849                 /* allocate IRQ */
3850                 retval = request_irq(irq, cyy_interrupt,
3851                                 IRQF_SHARED, "Cyclom-Y", card);
3852                 if (retval) {
3853                         dev_err(&pdev->dev, "could not allocate IRQ\n");
3854                         goto err_unmap;
3855                 }
3856                 card->num_chips = nchan / CyPORTS_PER_CHIP;
3857         } else {
3858                 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3859                 struct ZFW_CTRL __iomem *zfw_ctrl;
3860
3861                 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3862
3863                 card->hw_ver = mailbox;
3864                 card->num_chips = (unsigned int)-1;
3865                 card->board_ctrl = &zfw_ctrl->board_ctrl;
3866 #ifdef CONFIG_CYZ_INTR
3867                 /* allocate IRQ only if board has an IRQ */
3868                 if (irq != 0 && irq != 255) {
3869                         retval = request_irq(irq, cyz_interrupt,
3870                                         IRQF_SHARED, "Cyclades-Z", card);
3871                         if (retval) {
3872                                 dev_err(&pdev->dev, "could not allocate IRQ\n");
3873                                 goto err_unmap;
3874                         }
3875                 }
3876 #endif                          /* CONFIG_CYZ_INTR */
3877         }
3878
3879         /* set cy_card */
3880         card->base_addr = addr2;
3881         card->ctl_addr.p9050 = addr0;
3882         card->irq = irq;
3883         card->bus_index = 1;
3884         card->first_line = cy_next_channel;
3885         card->nports = nchan;
3886         retval = cy_init_card(card);
3887         if (retval)
3888                 goto err_null;
3889
3890         pci_set_drvdata(pdev, card);
3891
3892         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3893                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3894                 /* enable interrupts in the PCI interface */
3895                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3896                 switch (plx_ver) {
3897                 case PLX_9050:
3898                         cy_writeb(addr0 + 0x4c, 0x43);
3899                         break;
3900
3901                 case PLX_9060:
3902                 case PLX_9080:
3903                 default:        /* Old boards, use PLX_9060 */
3904                 {
3905                         struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3906                         plx_init(pdev, irq, ctl_addr);
3907                         cy_writew(&ctl_addr->intr_ctrl_stat,
3908                                 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3909                         break;
3910                 }
3911                 }
3912         }
3913
3914         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3915                 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3916         for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3917                 tty_port_register_device(&card->ports[j].port,
3918                                 cy_serial_driver, i, &pdev->dev);
3919         cy_next_channel += nchan;
3920
3921         return 0;
3922 err_null:
3923         card->base_addr = NULL;
3924         free_irq(irq, card);
3925 err_unmap:
3926         iounmap(addr0);
3927         if (addr2)
3928                 iounmap(addr2);
3929 err_reg:
3930         pci_release_regions(pdev);
3931 err_dis:
3932         pci_disable_device(pdev);
3933 err:
3934         return retval;
3935 }
3936
3937 static void cy_pci_remove(struct pci_dev *pdev)
3938 {
3939         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3940         unsigned int i, channel;
3941
3942         /* non-Z with old PLX */
3943         if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3944                         PLX_9050)
3945                 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3946         else
3947 #ifndef CONFIG_CYZ_INTR
3948                 if (!cy_is_Z(cinfo))
3949 #endif
3950                 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3951                         readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3952                         ~0x0900);
3953
3954         iounmap(cinfo->base_addr);
3955         if (cinfo->ctl_addr.p9050)
3956                 iounmap(cinfo->ctl_addr.p9050);
3957         if (cinfo->irq
3958 #ifndef CONFIG_CYZ_INTR
3959                 && !cy_is_Z(cinfo)
3960 #endif /* CONFIG_CYZ_INTR */
3961                 )
3962                 free_irq(cinfo->irq, cinfo);
3963         pci_release_regions(pdev);
3964
3965         cinfo->base_addr = NULL;
3966         for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3967                         cinfo->nports; i++, channel++) {
3968                 tty_unregister_device(cy_serial_driver, i);
3969                 tty_port_destroy(&cinfo->ports[channel].port);
3970         }
3971         cinfo->nports = 0;
3972         kfree(cinfo->ports);
3973 }
3974
3975 static struct pci_driver cy_pci_driver = {
3976         .name = "cyclades",
3977         .id_table = cy_pci_dev_id,
3978         .probe = cy_pci_probe,
3979         .remove = cy_pci_remove
3980 };
3981 #endif
3982
3983 static int cyclades_proc_show(struct seq_file *m, void *v)
3984 {
3985         struct cyclades_port *info;
3986         unsigned int i, j;
3987         __u32 cur_jifs = jiffies;
3988
3989         seq_puts(m, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
3990                         "IdleIn  Overruns  Ldisc\n");
3991
3992         /* Output one line for each known port */
3993         for (i = 0; i < NR_CARDS; i++)
3994                 for (j = 0; j < cy_card[i].nports; j++) {
3995                         info = &cy_card[i].ports[j];
3996
3997                         if (info->port.count) {
3998                                 /* XXX is the ldisc num worth this? */
3999                                 struct tty_struct *tty;
4000                                 struct tty_ldisc *ld;
4001                                 int num = 0;
4002                                 tty = tty_port_tty_get(&info->port);
4003                                 if (tty) {
4004                                         ld = tty_ldisc_ref(tty);
4005                                         if (ld) {
4006                                                 num = ld->ops->num;
4007                                                 tty_ldisc_deref(ld);
4008                                         }
4009                                         tty_kref_put(tty);
4010                                 }
4011                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4012                                         "%10lu %8lu %9lu %6d\n", info->line,
4013                                         (cur_jifs - info->idle_stats.in_use) /
4014                                         HZ, info->idle_stats.xmit_bytes,
4015                                         (cur_jifs - info->idle_stats.xmit_idle)/
4016                                         HZ, info->idle_stats.recv_bytes,
4017                                         (cur_jifs - info->idle_stats.recv_idle)/
4018                                         HZ, info->idle_stats.overruns,
4019                                         num);
4020                         } else
4021                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4022                                         "%10lu %8lu %9lu %6ld\n",
4023                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4024                 }
4025         return 0;
4026 }
4027
4028 static int cyclades_proc_open(struct inode *inode, struct file *file)
4029 {
4030         return single_open(file, cyclades_proc_show, NULL);
4031 }
4032
4033 static const struct file_operations cyclades_proc_fops = {
4034         .owner          = THIS_MODULE,
4035         .open           = cyclades_proc_open,
4036         .read           = seq_read,
4037         .llseek         = seq_lseek,
4038         .release        = single_release,
4039 };
4040
4041 /* The serial driver boot-time initialization code!
4042     Hardware I/O ports are mapped to character special devices on a
4043     first found, first allocated manner.  That is, this code searches
4044     for Cyclom cards in the system.  As each is found, it is probed
4045     to discover how many chips (and thus how many ports) are present.
4046     These ports are mapped to the tty ports 32 and upward in monotonic
4047     fashion.  If an 8-port card is replaced with a 16-port card, the
4048     port mapping on a following card will shift.
4049
4050     This approach is different from what is used in the other serial
4051     device driver because the Cyclom is more properly a multiplexer,
4052     not just an aggregation of serial ports on one card.
4053
4054     If there are more cards with more ports than have been
4055     statically allocated above, a warning is printed and the
4056     extra ports are ignored.
4057  */
4058
4059 static const struct tty_operations cy_ops = {
4060         .open = cy_open,
4061         .close = cy_close,
4062         .write = cy_write,
4063         .put_char = cy_put_char,
4064         .flush_chars = cy_flush_chars,
4065         .write_room = cy_write_room,
4066         .chars_in_buffer = cy_chars_in_buffer,
4067         .flush_buffer = cy_flush_buffer,
4068         .ioctl = cy_ioctl,
4069         .throttle = cy_throttle,
4070         .unthrottle = cy_unthrottle,
4071         .set_termios = cy_set_termios,
4072         .stop = cy_stop,
4073         .start = cy_start,
4074         .hangup = cy_hangup,
4075         .break_ctl = cy_break,
4076         .wait_until_sent = cy_wait_until_sent,
4077         .tiocmget = cy_tiocmget,
4078         .tiocmset = cy_tiocmset,
4079         .get_icount = cy_get_icount,
4080         .proc_fops = &cyclades_proc_fops,
4081 };
4082
4083 static int __init cy_init(void)
4084 {
4085         unsigned int nboards;
4086         int retval = -ENOMEM;
4087
4088         cy_serial_driver = alloc_tty_driver(NR_PORTS);
4089         if (!cy_serial_driver)
4090                 goto err;
4091
4092         printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4093
4094         /* Initialize the tty_driver structure */
4095
4096         cy_serial_driver->driver_name = "cyclades";
4097         cy_serial_driver->name = "ttyC";
4098         cy_serial_driver->major = CYCLADES_MAJOR;
4099         cy_serial_driver->minor_start = 0;
4100         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4101         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4102         cy_serial_driver->init_termios = tty_std_termios;
4103         cy_serial_driver->init_termios.c_cflag =
4104             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4105         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4106         tty_set_operations(cy_serial_driver, &cy_ops);
4107
4108         retval = tty_register_driver(cy_serial_driver);
4109         if (retval) {
4110                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4111                 goto err_frtty;
4112         }
4113
4114         /* the code below is responsible to find the boards. Each different
4115            type of board has its own detection routine. If a board is found,
4116            the next cy_card structure available is set by the detection
4117            routine. These functions are responsible for checking the
4118            availability of cy_card and cy_port data structures and updating
4119            the cy_next_channel. */
4120
4121         /* look for isa boards */
4122         nboards = cy_detect_isa();
4123
4124 #ifdef CONFIG_PCI
4125         /* look for pci boards */
4126         retval = pci_register_driver(&cy_pci_driver);
4127         if (retval && !nboards) {
4128                 tty_unregister_driver(cy_serial_driver);
4129                 goto err_frtty;
4130         }
4131 #endif
4132
4133         return 0;
4134 err_frtty:
4135         put_tty_driver(cy_serial_driver);
4136 err:
4137         return retval;
4138 }                               /* cy_init */
4139
4140 static void __exit cy_cleanup_module(void)
4141 {
4142         struct cyclades_card *card;
4143         unsigned int i, e1;
4144
4145 #ifndef CONFIG_CYZ_INTR
4146         del_timer_sync(&cyz_timerlist);
4147 #endif /* CONFIG_CYZ_INTR */
4148
4149         e1 = tty_unregister_driver(cy_serial_driver);
4150         if (e1)
4151                 printk(KERN_ERR "failed to unregister Cyclades serial "
4152                                 "driver(%d)\n", e1);
4153
4154 #ifdef CONFIG_PCI
4155         pci_unregister_driver(&cy_pci_driver);
4156 #endif
4157
4158         for (i = 0; i < NR_CARDS; i++) {
4159                 card = &cy_card[i];
4160                 if (card->base_addr) {
4161                         /* clear interrupt */
4162                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4163                         iounmap(card->base_addr);
4164                         if (card->ctl_addr.p9050)
4165                                 iounmap(card->ctl_addr.p9050);
4166                         if (card->irq
4167 #ifndef CONFIG_CYZ_INTR
4168                                 && !cy_is_Z(card)
4169 #endif /* CONFIG_CYZ_INTR */
4170                                 )
4171                                 free_irq(card->irq, card);
4172                         for (e1 = card->first_line; e1 < card->first_line +
4173                                         card->nports; e1++)
4174                                 tty_unregister_device(cy_serial_driver, e1);
4175                         kfree(card->ports);
4176                 }
4177         }
4178
4179         put_tty_driver(cy_serial_driver);
4180 } /* cy_cleanup_module */
4181
4182 module_init(cy_init);
4183 module_exit(cy_cleanup_module);
4184
4185 MODULE_LICENSE("GPL");
4186 MODULE_VERSION(CY_VERSION);
4187 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4188 MODULE_FIRMWARE("cyzfirm.bin");