drivers/tty/cyclades.c

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