drivers/tty/cyclades.c

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