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