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                                         tty_port_tty_hangup(&info->port, false);
1129                         }
1130                         break;
1131                 case C_CM_MCTS:
1132                         info->icount.cts++;
1133                         delta_count++;
1134                         break;
1135                 case C_CM_MRI:
1136                         info->icount.rng++;
1137                         delta_count++;
1138                         break;
1139                 case C_CM_MDSR:
1140                         info->icount.dsr++;
1141                         delta_count++;
1142                         break;
1143 #ifdef Z_WAKE
1144                 case C_CM_IOCTLW:
1145                         complete(&info->shutdown_wait);
1146                         break;
1147 #endif
1148 #ifdef CONFIG_CYZ_INTR
1149                 case C_CM_RXHIWM:
1150                 case C_CM_RXNNDT:
1151                 case C_CM_INTBACK2:
1152                         /* Reception Interrupt */
1153 #ifdef CY_DEBUG_INTERRUPTS
1154                         printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1155                                         "port %ld\n", info->card, channel);
1156 #endif
1157                         cyz_handle_rx(info);
1158                         break;
1159                 case C_CM_TXBEMPTY:
1160                 case C_CM_TXLOWWM:
1161                 case C_CM_INTBACK:
1162                         /* Transmission Interrupt */
1163 #ifdef CY_DEBUG_INTERRUPTS
1164                         printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1165                                         "port %ld\n", info->card, channel);
1166 #endif
1167                         cyz_handle_tx(info);
1168                         break;
1169 #endif                          /* CONFIG_CYZ_INTR */
1170                 case C_CM_FATAL:
1171                         /* should do something with this !!! */
1172                         break;
1173                 default:
1174                         break;
1175                 }
1176                 if (delta_count)
1177                         wake_up_interruptible(&info->port.delta_msr_wait);
1178                 if (special_count)
1179                         tty_schedule_flip(&info->port);
1180         }
1181 }
1182
1183 #ifdef CONFIG_CYZ_INTR
1184 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1185 {
1186         struct cyclades_card *cinfo = dev_id;
1187
1188         if (unlikely(!cyz_is_loaded(cinfo))) {
1189 #ifdef CY_DEBUG_INTERRUPTS
1190                 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1191                                 "(IRQ%d).\n", irq);
1192 #endif
1193                 return IRQ_NONE;
1194         }
1195
1196         /* Handle the interrupts */
1197         cyz_handle_cmd(cinfo);
1198
1199         return IRQ_HANDLED;
1200 }                               /* cyz_interrupt */
1201
1202 static void cyz_rx_restart(unsigned long arg)
1203 {
1204         struct cyclades_port *info = (struct cyclades_port *)arg;
1205         struct cyclades_card *card = info->card;
1206         int retval;
1207         __u32 channel = info->line - card->first_line;
1208         unsigned long flags;
1209
1210         spin_lock_irqsave(&card->card_lock, flags);
1211         retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1212         if (retval != 0) {
1213                 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1214                         info->line, retval);
1215         }
1216         spin_unlock_irqrestore(&card->card_lock, flags);
1217 }
1218
1219 #else                           /* CONFIG_CYZ_INTR */
1220
1221 static void cyz_poll(unsigned long arg)
1222 {
1223         struct cyclades_card *cinfo;
1224         struct cyclades_port *info;
1225         unsigned long expires = jiffies + HZ;
1226         unsigned int port, card;
1227
1228         for (card = 0; card < NR_CARDS; card++) {
1229                 cinfo = &cy_card[card];
1230
1231                 if (!cy_is_Z(cinfo))
1232                         continue;
1233                 if (!cyz_is_loaded(cinfo))
1234                         continue;
1235
1236         /* Skip first polling cycle to avoid racing conditions with the FW */
1237                 if (!cinfo->intr_enabled) {
1238                         cinfo->intr_enabled = 1;
1239                         continue;
1240                 }
1241
1242                 cyz_handle_cmd(cinfo);
1243
1244                 for (port = 0; port < cinfo->nports; port++) {
1245                         info = &cinfo->ports[port];
1246
1247                         if (!info->throttle)
1248                                 cyz_handle_rx(info);
1249                         cyz_handle_tx(info);
1250                 }
1251                 /* poll every 'cyz_polling_cycle' period */
1252                 expires = jiffies + cyz_polling_cycle;
1253         }
1254         mod_timer(&cyz_timerlist, expires);
1255 }                               /* cyz_poll */
1256
1257 #endif                          /* CONFIG_CYZ_INTR */
1258
1259 /********** End of block of Cyclades-Z specific code *********/
1260 /***********************************************************/
1261
1262 /* This is called whenever a port becomes active;
1263    interrupts are enabled and DTR & RTS are turned on.
1264  */
1265 static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1266 {
1267         struct cyclades_card *card;
1268         unsigned long flags;
1269         int retval = 0;
1270         int channel;
1271         unsigned long page;
1272
1273         card = info->card;
1274         channel = info->line - card->first_line;
1275
1276         page = get_zeroed_page(GFP_KERNEL);
1277         if (!page)
1278                 return -ENOMEM;
1279
1280         spin_lock_irqsave(&card->card_lock, flags);
1281
1282         if (info->port.flags & ASYNC_INITIALIZED)
1283                 goto errout;
1284
1285         if (!info->type) {
1286                 set_bit(TTY_IO_ERROR, &tty->flags);
1287                 goto errout;
1288         }
1289
1290         if (info->port.xmit_buf)
1291                 free_page(page);
1292         else
1293                 info->port.xmit_buf = (unsigned char *)page;
1294
1295         spin_unlock_irqrestore(&card->card_lock, flags);
1296
1297         cy_set_line_char(info, tty);
1298
1299         if (!cy_is_Z(card)) {
1300                 channel &= 0x03;
1301
1302                 spin_lock_irqsave(&card->card_lock, flags);
1303
1304                 cyy_writeb(info, CyCAR, channel);
1305
1306                 cyy_writeb(info, CyRTPR,
1307                         (info->default_timeout ? info->default_timeout : 0x02));
1308                 /* 10ms rx timeout */
1309
1310                 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1311
1312                 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1313
1314                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1315         } else {
1316                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1317
1318                 if (!cyz_is_loaded(card))
1319                         return -ENODEV;
1320
1321 #ifdef CY_DEBUG_OPEN
1322                 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1323                         "base_addr %p\n", card, channel, card->base_addr);
1324 #endif
1325                 spin_lock_irqsave(&card->card_lock, flags);
1326
1327                 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1328 #ifdef Z_WAKE
1329 #ifdef CONFIG_CYZ_INTR
1330                 cy_writel(&ch_ctrl->intr_enable,
1331                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1332                           C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1333 #else
1334                 cy_writel(&ch_ctrl->intr_enable,
1335                           C_IN_IOCTLW | C_IN_MDCD);
1336 #endif                          /* CONFIG_CYZ_INTR */
1337 #else
1338 #ifdef CONFIG_CYZ_INTR
1339                 cy_writel(&ch_ctrl->intr_enable,
1340                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1341                           C_IN_RXNNDT | C_IN_MDCD);
1342 #else
1343                 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1344 #endif                          /* CONFIG_CYZ_INTR */
1345 #endif                          /* Z_WAKE */
1346
1347                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1348                 if (retval != 0) {
1349                         printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1350                                 "%x\n", info->line, retval);
1351                 }
1352
1353                 /* Flush RX buffers before raising DTR and RTS */
1354                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1355                 if (retval != 0) {
1356                         printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1357                                 "%x\n", info->line, retval);
1358                 }
1359
1360                 /* set timeout !!! */
1361                 /* set RTS and DTR !!! */
1362                 tty_port_raise_dtr_rts(&info->port);
1363
1364                 /* enable send, recv, modem !!! */
1365         }
1366
1367         info->port.flags |= ASYNC_INITIALIZED;
1368
1369         clear_bit(TTY_IO_ERROR, &tty->flags);
1370         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1371         info->breakon = info->breakoff = 0;
1372         memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1373         info->idle_stats.in_use =
1374         info->idle_stats.recv_idle =
1375         info->idle_stats.xmit_idle = jiffies;
1376
1377         spin_unlock_irqrestore(&card->card_lock, flags);
1378
1379 #ifdef CY_DEBUG_OPEN
1380         printk(KERN_DEBUG "cyc startup done\n");
1381 #endif
1382         return 0;
1383
1384 errout:
1385         spin_unlock_irqrestore(&card->card_lock, flags);
1386         free_page(page);
1387         return retval;
1388 }                               /* startup */
1389
1390 static void start_xmit(struct cyclades_port *info)
1391 {
1392         struct cyclades_card *card = info->card;
1393         unsigned long flags;
1394         int channel = info->line - card->first_line;
1395
1396         if (!cy_is_Z(card)) {
1397                 spin_lock_irqsave(&card->card_lock, flags);
1398                 cyy_writeb(info, CyCAR, channel & 0x03);
1399                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1400                 spin_unlock_irqrestore(&card->card_lock, flags);
1401         } else {
1402 #ifdef CONFIG_CYZ_INTR
1403                 int retval;
1404
1405                 spin_lock_irqsave(&card->card_lock, flags);
1406                 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1407                 if (retval != 0) {
1408                         printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1409                                 "%x\n", info->line, retval);
1410                 }
1411                 spin_unlock_irqrestore(&card->card_lock, flags);
1412 #else                           /* CONFIG_CYZ_INTR */
1413                 /* Don't have to do anything at this time */
1414 #endif                          /* CONFIG_CYZ_INTR */
1415         }
1416 }                               /* start_xmit */
1417
1418 /*
1419  * This routine shuts down a serial port; interrupts are disabled,
1420  * and DTR is dropped if the hangup on close termio flag is on.
1421  */
1422 static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1423 {
1424         struct cyclades_card *card;
1425         unsigned long flags;
1426
1427         if (!(info->port.flags & ASYNC_INITIALIZED))
1428                 return;
1429
1430         card = info->card;
1431         if (!cy_is_Z(card)) {
1432                 spin_lock_irqsave(&card->card_lock, flags);
1433
1434                 /* Clear delta_msr_wait queue to avoid mem leaks. */
1435                 wake_up_interruptible(&info->port.delta_msr_wait);
1436
1437                 if (info->port.xmit_buf) {
1438                         unsigned char *temp;
1439                         temp = info->port.xmit_buf;
1440                         info->port.xmit_buf = NULL;
1441                         free_page((unsigned long)temp);
1442                 }
1443                 if (tty->termios.c_cflag & HUPCL)
1444                         cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1445
1446                 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1447                 /* it may be appropriate to clear _XMIT at
1448                    some later date (after testing)!!! */
1449
1450                 set_bit(TTY_IO_ERROR, &tty->flags);
1451                 info->port.flags &= ~ASYNC_INITIALIZED;
1452                 spin_unlock_irqrestore(&card->card_lock, flags);
1453         } else {
1454 #ifdef CY_DEBUG_OPEN
1455                 int channel = info->line - card->first_line;
1456                 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1457                         "base_addr %p\n", card, channel, card->base_addr);
1458 #endif
1459
1460                 if (!cyz_is_loaded(card))
1461                         return;
1462
1463                 spin_lock_irqsave(&card->card_lock, flags);
1464
1465                 if (info->port.xmit_buf) {
1466                         unsigned char *temp;
1467                         temp = info->port.xmit_buf;
1468                         info->port.xmit_buf = NULL;
1469                         free_page((unsigned long)temp);
1470                 }
1471
1472                 if (tty->termios.c_cflag & HUPCL)
1473                         tty_port_lower_dtr_rts(&info->port);
1474
1475                 set_bit(TTY_IO_ERROR, &tty->flags);
1476                 info->port.flags &= ~ASYNC_INITIALIZED;
1477
1478                 spin_unlock_irqrestore(&card->card_lock, flags);
1479         }
1480
1481 #ifdef CY_DEBUG_OPEN
1482         printk(KERN_DEBUG "cyc shutdown done\n");
1483 #endif
1484 }                               /* shutdown */
1485
1486 /*
1487  * ------------------------------------------------------------
1488  * cy_open() and friends
1489  * ------------------------------------------------------------
1490  */
1491
1492 /*
1493  * This routine is called whenever a serial port is opened.  It
1494  * performs the serial-specific initialization for the tty structure.
1495  */
1496 static int cy_open(struct tty_struct *tty, struct file *filp)
1497 {
1498         struct cyclades_port *info;
1499         unsigned int i, line = tty->index;
1500         int retval;
1501
1502         for (i = 0; i < NR_CARDS; i++)
1503                 if (line < cy_card[i].first_line + cy_card[i].nports &&
1504                                 line >= cy_card[i].first_line)
1505                         break;
1506         if (i >= NR_CARDS)
1507                 return -ENODEV;
1508         info = &cy_card[i].ports[line - cy_card[i].first_line];
1509         if (info->line < 0)
1510                 return -ENODEV;
1511
1512         /* If the card's firmware hasn't been loaded,
1513            treat it as absent from the system.  This
1514            will make the user pay attention.
1515          */
1516         if (cy_is_Z(info->card)) {
1517                 struct cyclades_card *cinfo = info->card;
1518                 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1519
1520                 if (!cyz_is_loaded(cinfo)) {
1521                         if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1522                                         readl(&firm_id->signature) ==
1523                                         ZFIRM_HLT) {
1524                                 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1525                                         "need an external power supply for "
1526                                         "this number of ports.\nFirmware "
1527                                         "halted.\n");
1528                         } else {
1529                                 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1530                                         "yet loaded\n");
1531                         }
1532                         return -ENODEV;
1533                 }
1534 #ifdef CONFIG_CYZ_INTR
1535                 else {
1536                 /* In case this Z board is operating in interrupt mode, its
1537                    interrupts should be enabled as soon as the first open
1538                    happens to one of its ports. */
1539                         if (!cinfo->intr_enabled) {
1540                                 u16 intr;
1541
1542                                 /* Enable interrupts on the PLX chip */
1543                                 intr = readw(&cinfo->ctl_addr.p9060->
1544                                                 intr_ctrl_stat) | 0x0900;
1545                                 cy_writew(&cinfo->ctl_addr.p9060->
1546                                                 intr_ctrl_stat, intr);
1547                                 /* Enable interrupts on the FW */
1548                                 retval = cyz_issue_cmd(cinfo, 0,
1549                                                 C_CM_IRQ_ENBL, 0L);
1550                                 if (retval != 0) {
1551                                         printk(KERN_ERR "cyc:IRQ enable retval "
1552                                                 "was %x\n", retval);
1553                                 }
1554                                 cinfo->intr_enabled = 1;
1555                         }
1556                 }
1557 #endif                          /* CONFIG_CYZ_INTR */
1558                 /* Make sure this Z port really exists in hardware */
1559                 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1560                         return -ENODEV;
1561         }
1562 #ifdef CY_DEBUG_OTHER
1563         printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1564 #endif
1565         tty->driver_data = info;
1566         if (serial_paranoia_check(info, tty->name, "cy_open"))
1567                 return -ENODEV;
1568
1569 #ifdef CY_DEBUG_OPEN
1570         printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1571                         info->port.count);
1572 #endif
1573         info->port.count++;
1574 #ifdef CY_DEBUG_COUNT
1575         printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1576                 current->pid, info->port.count);
1577 #endif
1578
1579         /*
1580          * If the port is the middle of closing, bail out now
1581          */
1582         if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1583                 wait_event_interruptible_tty(tty, info->port.close_wait,
1584                                 !(info->port.flags & ASYNC_CLOSING));
1585                 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1586         }
1587
1588         /*
1589          * Start up serial port
1590          */
1591         retval = cy_startup(info, tty);
1592         if (retval)
1593                 return retval;
1594
1595         retval = tty_port_block_til_ready(&info->port, tty, filp);
1596         if (retval) {
1597 #ifdef CY_DEBUG_OPEN
1598                 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1599                         "with %d\n", retval);
1600 #endif
1601                 return retval;
1602         }
1603
1604         info->throttle = 0;
1605         tty_port_tty_set(&info->port, tty);
1606
1607 #ifdef CY_DEBUG_OPEN
1608         printk(KERN_DEBUG "cyc:cy_open done\n");
1609 #endif
1610         return 0;
1611 }                               /* cy_open */
1612
1613 /*
1614  * cy_wait_until_sent() --- wait until the transmitter is empty
1615  */
1616 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1617 {
1618         struct cyclades_card *card;
1619         struct cyclades_port *info = tty->driver_data;
1620         unsigned long orig_jiffies;
1621         int char_time;
1622
1623         if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1624                 return;
1625
1626         if (info->xmit_fifo_size == 0)
1627                 return;         /* Just in case.... */
1628
1629         orig_jiffies = jiffies;
1630         /*
1631          * Set the check interval to be 1/5 of the estimated time to
1632          * send a single character, and make it at least 1.  The check
1633          * interval should also be less than the timeout.
1634          *
1635          * Note: we have to use pretty tight timings here to satisfy
1636          * the NIST-PCTS.
1637          */
1638         char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1639         char_time = char_time / 5;
1640         if (char_time <= 0)
1641                 char_time = 1;
1642         if (timeout < 0)
1643                 timeout = 0;
1644         if (timeout)
1645                 char_time = min(char_time, timeout);
1646         /*
1647          * If the transmitter hasn't cleared in twice the approximate
1648          * amount of time to send the entire FIFO, it probably won't
1649          * ever clear.  This assumes the UART isn't doing flow
1650          * control, which is currently the case.  Hence, if it ever
1651          * takes longer than info->timeout, this is probably due to a
1652          * UART bug of some kind.  So, we clamp the timeout parameter at
1653          * 2*info->timeout.
1654          */
1655         if (!timeout || timeout > 2 * info->timeout)
1656                 timeout = 2 * info->timeout;
1657
1658         card = info->card;
1659         if (!cy_is_Z(card)) {
1660                 while (cyy_readb(info, CySRER) & CyTxRdy) {
1661                         if (msleep_interruptible(jiffies_to_msecs(char_time)))
1662                                 break;
1663                         if (timeout && time_after(jiffies, orig_jiffies +
1664                                         timeout))
1665                                 break;
1666                 }
1667         }
1668         /* Run one more char cycle */
1669         msleep_interruptible(jiffies_to_msecs(char_time * 5));
1670 }
1671
1672 static void cy_flush_buffer(struct tty_struct *tty)
1673 {
1674         struct cyclades_port *info = tty->driver_data;
1675         struct cyclades_card *card;
1676         int channel, retval;
1677         unsigned long flags;
1678
1679 #ifdef CY_DEBUG_IO
1680         printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1681 #endif
1682
1683         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1684                 return;
1685
1686         card = info->card;
1687         channel = info->line - card->first_line;
1688
1689         spin_lock_irqsave(&card->card_lock, flags);
1690         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1691         spin_unlock_irqrestore(&card->card_lock, flags);
1692
1693         if (cy_is_Z(card)) {    /* If it is a Z card, flush the on-board
1694                                            buffers as well */
1695                 spin_lock_irqsave(&card->card_lock, flags);
1696                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1697                 if (retval != 0) {
1698                         printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1699                                 "was %x\n", info->line, retval);
1700                 }
1701                 spin_unlock_irqrestore(&card->card_lock, flags);
1702         }
1703         tty_wakeup(tty);
1704 }                               /* cy_flush_buffer */
1705
1706
1707 static void cy_do_close(struct tty_port *port)
1708 {
1709         struct cyclades_port *info = container_of(port, struct cyclades_port,
1710                                                                 port);
1711         struct cyclades_card *card;
1712         unsigned long flags;
1713         int channel;
1714
1715         card = info->card;
1716         channel = info->line - card->first_line;
1717         spin_lock_irqsave(&card->card_lock, flags);
1718
1719         if (!cy_is_Z(card)) {
1720                 /* Stop accepting input */
1721                 cyy_writeb(info, CyCAR, channel & 0x03);
1722                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1723                 if (info->port.flags & ASYNC_INITIALIZED) {
1724                         /* Waiting for on-board buffers to be empty before
1725                            closing the port */
1726                         spin_unlock_irqrestore(&card->card_lock, flags);
1727                         cy_wait_until_sent(port->tty, info->timeout);
1728                         spin_lock_irqsave(&card->card_lock, flags);
1729                 }
1730         } else {
1731 #ifdef Z_WAKE
1732                 /* Waiting for on-board buffers to be empty before closing
1733                    the port */
1734                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1735                 int retval;
1736
1737                 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1738                         retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1739                         if (retval != 0) {
1740                                 printk(KERN_DEBUG "cyc:cy_close retval on "
1741                                         "ttyC%d was %x\n", info->line, retval);
1742                         }
1743                         spin_unlock_irqrestore(&card->card_lock, flags);
1744                         wait_for_completion_interruptible(&info->shutdown_wait);
1745                         spin_lock_irqsave(&card->card_lock, flags);
1746                 }
1747 #endif
1748         }
1749         spin_unlock_irqrestore(&card->card_lock, flags);
1750         cy_shutdown(info, port->tty);
1751 }
1752
1753 /*
1754  * This routine is called when a particular tty device is closed.
1755  */
1756 static void cy_close(struct tty_struct *tty, struct file *filp)
1757 {
1758         struct cyclades_port *info = tty->driver_data;
1759         if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1760                 return;
1761         tty_port_close(&info->port, tty, filp);
1762 }                               /* cy_close */
1763
1764 /* This routine gets called when tty_write has put something into
1765  * the write_queue.  The characters may come from user space or
1766  * kernel space.
1767  *
1768  * This routine will return the number of characters actually
1769  * accepted for writing.
1770  *
1771  * If the port is not already transmitting stuff, start it off by
1772  * enabling interrupts.  The interrupt service routine will then
1773  * ensure that the characters are sent.
1774  * If the port is already active, there is no need to kick it.
1775  *
1776  */
1777 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1778 {
1779         struct cyclades_port *info = tty->driver_data;
1780         unsigned long flags;
1781         int c, ret = 0;
1782
1783 #ifdef CY_DEBUG_IO
1784         printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1785 #endif
1786
1787         if (serial_paranoia_check(info, tty->name, "cy_write"))
1788                 return 0;
1789
1790         if (!info->port.xmit_buf)
1791                 return 0;
1792
1793         spin_lock_irqsave(&info->card->card_lock, flags);
1794         while (1) {
1795                 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1796                 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1797
1798                 if (c <= 0)
1799                         break;
1800
1801                 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1802                 info->xmit_head = (info->xmit_head + c) &
1803                         (SERIAL_XMIT_SIZE - 1);
1804                 info->xmit_cnt += c;
1805                 buf += c;
1806                 count -= c;
1807                 ret += c;
1808         }
1809         spin_unlock_irqrestore(&info->card->card_lock, flags);
1810
1811         info->idle_stats.xmit_bytes += ret;
1812         info->idle_stats.xmit_idle = jiffies;
1813
1814         if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1815                 start_xmit(info);
1816
1817         return ret;
1818 }                               /* cy_write */
1819
1820 /*
1821  * This routine is called by the kernel to write a single
1822  * character to the tty device.  If the kernel uses this routine,
1823  * it must call the flush_chars() routine (if defined) when it is
1824  * done stuffing characters into the driver.  If there is no room
1825  * in the queue, the character is ignored.
1826  */
1827 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1828 {
1829         struct cyclades_port *info = tty->driver_data;
1830         unsigned long flags;
1831
1832 #ifdef CY_DEBUG_IO
1833         printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1834 #endif
1835
1836         if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1837                 return 0;
1838
1839         if (!info->port.xmit_buf)
1840                 return 0;
1841
1842         spin_lock_irqsave(&info->card->card_lock, flags);
1843         if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1844                 spin_unlock_irqrestore(&info->card->card_lock, flags);
1845                 return 0;
1846         }
1847
1848         info->port.xmit_buf[info->xmit_head++] = ch;
1849         info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1850         info->xmit_cnt++;
1851         info->idle_stats.xmit_bytes++;
1852         info->idle_stats.xmit_idle = jiffies;
1853         spin_unlock_irqrestore(&info->card->card_lock, flags);
1854         return 1;
1855 }                               /* cy_put_char */
1856
1857 /*
1858  * This routine is called by the kernel after it has written a
1859  * series of characters to the tty device using put_char().
1860  */
1861 static void cy_flush_chars(struct tty_struct *tty)
1862 {
1863         struct cyclades_port *info = tty->driver_data;
1864
1865 #ifdef CY_DEBUG_IO
1866         printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1867 #endif
1868
1869         if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1870                 return;
1871
1872         if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1873                         !info->port.xmit_buf)
1874                 return;
1875
1876         start_xmit(info);
1877 }                               /* cy_flush_chars */
1878
1879 /*
1880  * This routine returns the numbers of characters the tty driver
1881  * will accept for queuing to be written.  This number is subject
1882  * to change as output buffers get emptied, or if the output flow
1883  * control is activated.
1884  */
1885 static int cy_write_room(struct tty_struct *tty)
1886 {
1887         struct cyclades_port *info = tty->driver_data;
1888         int ret;
1889
1890 #ifdef CY_DEBUG_IO
1891         printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1892 #endif
1893
1894         if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1895                 return 0;
1896         ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1897         if (ret < 0)
1898                 ret = 0;
1899         return ret;
1900 }                               /* cy_write_room */
1901
1902 static int cy_chars_in_buffer(struct tty_struct *tty)
1903 {
1904         struct cyclades_port *info = tty->driver_data;
1905
1906         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1907                 return 0;
1908
1909 #ifdef Z_EXT_CHARS_IN_BUFFER
1910         if (!cy_is_Z(info->card)) {
1911 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
1912 #ifdef CY_DEBUG_IO
1913                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1914                         info->line, info->xmit_cnt);
1915 #endif
1916                 return info->xmit_cnt;
1917 #ifdef Z_EXT_CHARS_IN_BUFFER
1918         } else {
1919                 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1920                 int char_count;
1921                 __u32 tx_put, tx_get, tx_bufsize;
1922
1923                 tx_get = readl(&buf_ctrl->tx_get);
1924                 tx_put = readl(&buf_ctrl->tx_put);
1925                 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1926                 if (tx_put >= tx_get)
1927                         char_count = tx_put - tx_get;
1928                 else
1929                         char_count = tx_put - tx_get + tx_bufsize;
1930 #ifdef CY_DEBUG_IO
1931                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1932                         info->line, info->xmit_cnt + char_count);
1933 #endif
1934                 return info->xmit_cnt + char_count;
1935         }
1936 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
1937 }                               /* cy_chars_in_buffer */
1938
1939 /*
1940  * ------------------------------------------------------------
1941  * cy_ioctl() and friends
1942  * ------------------------------------------------------------
1943  */
1944
1945 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1946 {
1947         int co, co_val, bpr;
1948         __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
1949                         25000000);
1950
1951         if (baud == 0) {
1952                 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1953                 return;
1954         }
1955
1956         /* determine which prescaler to use */
1957         for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1958                 if (cy_clock / co_val / baud > 63)
1959                         break;
1960         }
1961
1962         bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1963         if (bpr > 255)
1964                 bpr = 255;
1965
1966         info->tbpr = info->rbpr = bpr;
1967         info->tco = info->rco = co;
1968 }
1969
1970 /*
1971  * This routine finds or computes the various line characteristics.
1972  * It used to be called config_setup
1973  */
1974 static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
1975 {
1976         struct cyclades_card *card;
1977         unsigned long flags;
1978         int channel;
1979         unsigned cflag, iflag;
1980         int baud, baud_rate = 0;
1981         int i;
1982
1983         if (info->line == -1)
1984                 return;
1985
1986         cflag = tty->termios.c_cflag;
1987         iflag = tty->termios.c_iflag;
1988
1989         /*
1990          * Set up the tty->alt_speed kludge
1991          */
1992         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1993                 tty->alt_speed = 57600;
1994         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1995                 tty->alt_speed = 115200;
1996         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1997                 tty->alt_speed = 230400;
1998         if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1999                 tty->alt_speed = 460800;
2000
2001         card = info->card;
2002         channel = info->line - card->first_line;
2003
2004         if (!cy_is_Z(card)) {
2005                 u32 cflags;
2006
2007                 /* baud rate */
2008                 baud = tty_get_baud_rate(tty);
2009                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2010                                 ASYNC_SPD_CUST) {
2011                         if (info->custom_divisor)
2012                                 baud_rate = info->baud / info->custom_divisor;
2013                         else
2014                                 baud_rate = info->baud;
2015                 } else if (baud > CD1400_MAX_SPEED) {
2016                         baud = CD1400_MAX_SPEED;
2017                 }
2018                 /* find the baud index */
2019                 for (i = 0; i < 20; i++) {
2020                         if (baud == baud_table[i])
2021                                 break;
2022                 }
2023                 if (i == 20)
2024                         i = 19; /* CD1400_MAX_SPEED */
2025
2026                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2027                                 ASYNC_SPD_CUST) {
2028                         cyy_baud_calc(info, baud_rate);
2029                 } else {
2030                         if (info->chip_rev >= CD1400_REV_J) {
2031                                 /* It is a CD1400 rev. J or later */
2032                                 info->tbpr = baud_bpr_60[i];    /* Tx BPR */
2033                                 info->tco = baud_co_60[i];      /* Tx CO */
2034                                 info->rbpr = baud_bpr_60[i];    /* Rx BPR */
2035                                 info->rco = baud_co_60[i];      /* Rx CO */
2036                         } else {
2037                                 info->tbpr = baud_bpr_25[i];    /* Tx BPR */
2038                                 info->tco = baud_co_25[i];      /* Tx CO */
2039                                 info->rbpr = baud_bpr_25[i];    /* Rx BPR */
2040                                 info->rco = baud_co_25[i];      /* Rx CO */
2041                         }
2042                 }
2043                 if (baud_table[i] == 134) {
2044                         /* get it right for 134.5 baud */
2045                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2046                                         2;
2047                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2048                                 ASYNC_SPD_CUST) {
2049                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2050                                         baud_rate) + 2;
2051                 } else if (baud_table[i]) {
2052                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2053                                         baud_table[i]) + 2;
2054                         /* this needs to be propagated into the card info */
2055                 } else {
2056                         info->timeout = 0;
2057                 }
2058                 /* By tradition (is it a standard?) a baud rate of zero
2059                    implies the line should be/has been closed.  A bit
2060                    later in this routine such a test is performed. */
2061
2062                 /* byte size and parity */
2063                 info->cor5 = 0;
2064                 info->cor4 = 0;
2065                 /* receive threshold */
2066                 info->cor3 = (info->default_threshold ?
2067                                 info->default_threshold : baud_cor3[i]);
2068                 info->cor2 = CyETC;
2069                 switch (cflag & CSIZE) {
2070                 case CS5:
2071                         info->cor1 = Cy_5_BITS;
2072                         break;
2073                 case CS6:
2074                         info->cor1 = Cy_6_BITS;
2075                         break;
2076                 case CS7:
2077                         info->cor1 = Cy_7_BITS;
2078                         break;
2079                 case CS8:
2080                         info->cor1 = Cy_8_BITS;
2081                         break;
2082                 }
2083                 if (cflag & CSTOPB)
2084                         info->cor1 |= Cy_2_STOP;
2085
2086                 if (cflag & PARENB) {
2087                         if (cflag & PARODD)
2088                                 info->cor1 |= CyPARITY_O;
2089                         else
2090                                 info->cor1 |= CyPARITY_E;
2091                 } else
2092                         info->cor1 |= CyPARITY_NONE;
2093
2094                 /* CTS flow control flag */
2095                 if (cflag & CRTSCTS) {
2096                         info->port.flags |= ASYNC_CTS_FLOW;
2097                         info->cor2 |= CyCtsAE;
2098                 } else {
2099                         info->port.flags &= ~ASYNC_CTS_FLOW;
2100                         info->cor2 &= ~CyCtsAE;
2101                 }
2102                 if (cflag & CLOCAL)
2103                         info->port.flags &= ~ASYNC_CHECK_CD;
2104                 else
2105                         info->port.flags |= ASYNC_CHECK_CD;
2106
2107          /***********************************************
2108             The hardware option, CyRtsAO, presents RTS when
2109             the chip has characters to send.  Since most modems
2110             use RTS as reverse (inbound) flow control, this
2111             option is not used.  If inbound flow control is
2112             necessary, DTR can be programmed to provide the
2113             appropriate signals for use with a non-standard
2114             cable.  Contact Marcio Saito for details.
2115          ***********************************************/
2116
2117                 channel &= 0x03;
2118
2119                 spin_lock_irqsave(&card->card_lock, flags);
2120                 cyy_writeb(info, CyCAR, channel);
2121
2122                 /* tx and rx baud rate */
2123
2124                 cyy_writeb(info, CyTCOR, info->tco);
2125                 cyy_writeb(info, CyTBPR, info->tbpr);
2126                 cyy_writeb(info, CyRCOR, info->rco);
2127                 cyy_writeb(info, CyRBPR, info->rbpr);
2128
2129                 /* set line characteristics  according configuration */
2130
2131                 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2132                 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2133                 cyy_writeb(info, CyCOR1, info->cor1);
2134                 cyy_writeb(info, CyCOR2, info->cor2);
2135                 cyy_writeb(info, CyCOR3, info->cor3);
2136                 cyy_writeb(info, CyCOR4, info->cor4);
2137                 cyy_writeb(info, CyCOR5, info->cor5);
2138
2139                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2140                                 CyCOR3ch);
2141
2142                 /* !!! Is this needed? */
2143                 cyy_writeb(info, CyCAR, channel);
2144                 cyy_writeb(info, CyRTPR,
2145                         (info->default_timeout ? info->default_timeout : 0x02));
2146                 /* 10ms rx timeout */
2147
2148                 cflags = CyCTS;
2149                 if (!C_CLOCAL(tty))
2150                         cflags |= CyDSR | CyRI | CyDCD;
2151                 /* without modem intr */
2152                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2153                 /* act on 1->0 modem transitions */
2154                 if ((cflag & CRTSCTS) && info->rflow)
2155                         cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2156                 else
2157                         cyy_writeb(info, CyMCOR1, cflags);
2158                 /* act on 0->1 modem transitions */
2159                 cyy_writeb(info, CyMCOR2, cflags);
2160
2161                 if (i == 0)     /* baud rate is zero, turn off line */
2162                         cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2163                 else
2164                         cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2165
2166                 clear_bit(TTY_IO_ERROR, &tty->flags);
2167                 spin_unlock_irqrestore(&card->card_lock, flags);
2168
2169         } else {
2170                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2171                 __u32 sw_flow;
2172                 int retval;
2173
2174                 if (!cyz_is_loaded(card))
2175                         return;
2176
2177                 /* baud rate */
2178                 baud = tty_get_baud_rate(tty);
2179                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2180                                 ASYNC_SPD_CUST) {
2181                         if (info->custom_divisor)
2182                                 baud_rate = info->baud / info->custom_divisor;
2183                         else
2184                                 baud_rate = info->baud;
2185                 } else if (baud > CYZ_MAX_SPEED) {
2186                         baud = CYZ_MAX_SPEED;
2187                 }
2188                 cy_writel(&ch_ctrl->comm_baud, baud);
2189
2190                 if (baud == 134) {
2191                         /* get it right for 134.5 baud */
2192                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2193                                         2;
2194                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2195                                 ASYNC_SPD_CUST) {
2196                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2197                                         baud_rate) + 2;
2198                 } else if (baud) {
2199                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2200                                         baud) + 2;
2201                         /* this needs to be propagated into the card info */
2202                 } else {
2203                         info->timeout = 0;
2204                 }
2205
2206                 /* byte size and parity */
2207                 switch (cflag & CSIZE) {
2208                 case CS5:
2209                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2210                         break;
2211                 case CS6:
2212                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2213                         break;
2214                 case CS7:
2215                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2216                         break;
2217                 case CS8:
2218                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2219                         break;
2220                 }
2221                 if (cflag & CSTOPB) {
2222                         cy_writel(&ch_ctrl->comm_data_l,
2223                                   readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2224                 } else {
2225                         cy_writel(&ch_ctrl->comm_data_l,
2226                                   readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2227                 }
2228                 if (cflag & PARENB) {
2229                         if (cflag & PARODD)
2230                                 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2231                         else
2232                                 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2233                 } else
2234                         cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2235
2236                 /* CTS flow control flag */
2237                 if (cflag & CRTSCTS) {
2238                         cy_writel(&ch_ctrl->hw_flow,
2239                                 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2240                 } else {
2241                         cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2242                                         ~(C_RS_CTS | C_RS_RTS));
2243                 }
2244                 /* As the HW flow control is done in firmware, the driver
2245                    doesn't need to care about it */
2246                 info->port.flags &= ~ASYNC_CTS_FLOW;
2247
2248                 /* XON/XOFF/XANY flow control flags */
2249                 sw_flow = 0;
2250                 if (iflag & IXON) {
2251                         sw_flow |= C_FL_OXX;
2252                         if (iflag & IXANY)
2253                                 sw_flow |= C_FL_OIXANY;
2254                 }
2255                 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2256
2257                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2258                 if (retval != 0) {
2259                         printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2260                                 "was %x\n", info->line, retval);
2261                 }
2262
2263                 /* CD sensitivity */
2264                 if (cflag & CLOCAL)
2265                         info->port.flags &= ~ASYNC_CHECK_CD;
2266                 else
2267                         info->port.flags |= ASYNC_CHECK_CD;
2268
2269                 if (baud == 0) {        /* baud rate is zero, turn off line */
2270                         cy_writel(&ch_ctrl->rs_control,
2271                                   readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2272 #ifdef CY_DEBUG_DTR
2273                         printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2274 #endif
2275                 } else {
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 raising Z DTR\n");
2280 #endif
2281                 }
2282
2283                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2284                 if (retval != 0) {
2285                         printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2286                                 "was %x\n", info->line, retval);
2287                 }
2288
2289                 clear_bit(TTY_IO_ERROR, &tty->flags);
2290         }
2291 }                               /* set_line_char */
2292
2293 static int cy_get_serial_info(struct cyclades_port *info,
2294                 struct serial_struct __user *retinfo)
2295 {
2296         struct cyclades_card *cinfo = info->card;
2297         struct serial_struct tmp = {
2298                 .type = info->type,
2299                 .line = info->line,
2300                 .port = (info->card - cy_card) * 0x100 + info->line -
2301                         cinfo->first_line,
2302                 .irq = cinfo->irq,
2303                 .flags = info->port.flags,
2304                 .close_delay = info->port.close_delay,
2305                 .closing_wait = info->port.closing_wait,
2306                 .baud_base = info->baud,
2307                 .custom_divisor = info->custom_divisor,
2308                 .hub6 = 0,              /*!!! */
2309         };
2310         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2311 }
2312
2313 static int
2314 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2315                 struct serial_struct __user *new_info)
2316 {
2317         struct serial_struct new_serial;
2318         int ret;
2319
2320         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2321                 return -EFAULT;
2322
2323         mutex_lock(&info->port.mutex);
2324         if (!capable(CAP_SYS_ADMIN)) {
2325                 if (new_serial.close_delay != info->port.close_delay ||
2326                                 new_serial.baud_base != info->baud ||
2327                                 (new_serial.flags & ASYNC_FLAGS &
2328                                         ~ASYNC_USR_MASK) !=
2329                                 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2330                 {
2331                         mutex_unlock(&info->port.mutex);
2332                         return -EPERM;
2333                 }
2334                 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2335                                 (new_serial.flags & ASYNC_USR_MASK);
2336                 info->baud = new_serial.baud_base;
2337                 info->custom_divisor = new_serial.custom_divisor;
2338                 goto check_and_exit;
2339         }
2340
2341         /*
2342          * OK, past this point, all the error checking has been done.
2343          * At this point, we start making changes.....
2344          */
2345
2346         info->baud = new_serial.baud_base;
2347         info->custom_divisor = new_serial.custom_divisor;
2348         info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2349                         (new_serial.flags & ASYNC_FLAGS);
2350         info->port.close_delay = new_serial.close_delay * HZ / 100;
2351         info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2352
2353 check_and_exit:
2354         if (info->port.flags & ASYNC_INITIALIZED) {
2355                 cy_set_line_char(info, tty);
2356                 ret = 0;
2357         } else {
2358                 ret = cy_startup(info, tty);
2359         }
2360         mutex_unlock(&info->port.mutex);
2361         return ret;
2362 }                               /* set_serial_info */
2363
2364 /*
2365  * get_lsr_info - get line status register info
2366  *
2367  * Purpose: Let user call ioctl() to get info when the UART physically
2368  *          is emptied.  On bus types like RS485, the transmitter must
2369  *          release the bus after transmitting. This must be done when
2370  *          the transmit shift register is empty, not be done when the
2371  *          transmit holding register is empty.  This functionality
2372  *          allows an RS485 driver to be written in user space.
2373  */
2374 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2375 {
2376         struct cyclades_card *card = info->card;
2377         unsigned int result;
2378         unsigned long flags;
2379         u8 status;
2380
2381         if (!cy_is_Z(card)) {
2382                 spin_lock_irqsave(&card->card_lock, flags);
2383                 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2384                 spin_unlock_irqrestore(&card->card_lock, flags);
2385                 result = (status ? 0 : TIOCSER_TEMT);
2386         } else {
2387                 /* Not supported yet */
2388                 return -EINVAL;
2389         }
2390         return put_user(result, value);
2391 }
2392
2393 static int cy_tiocmget(struct tty_struct *tty)
2394 {
2395         struct cyclades_port *info = tty->driver_data;
2396         struct cyclades_card *card;
2397         int result;
2398
2399         if (serial_paranoia_check(info, tty->name, __func__))
2400                 return -ENODEV;
2401
2402         card = info->card;
2403
2404         if (!cy_is_Z(card)) {
2405                 unsigned long flags;
2406                 int channel = info->line - card->first_line;
2407                 u8 status;
2408
2409                 spin_lock_irqsave(&card->card_lock, flags);
2410                 cyy_writeb(info, CyCAR, channel & 0x03);
2411                 status = cyy_readb(info, CyMSVR1);
2412                 status |= cyy_readb(info, CyMSVR2);
2413                 spin_unlock_irqrestore(&card->card_lock, flags);
2414
2415                 if (info->rtsdtr_inv) {
2416                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2417                                 ((status & CyDTR) ? TIOCM_RTS : 0);
2418                 } else {
2419                         result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2420                                 ((status & CyDTR) ? TIOCM_DTR : 0);
2421                 }
2422                 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2423                         ((status & CyRI) ? TIOCM_RNG : 0) |
2424                         ((status & CyDSR) ? TIOCM_DSR : 0) |
2425                         ((status & CyCTS) ? TIOCM_CTS : 0);
2426         } else {
2427                 u32 lstatus;
2428
2429                 if (!cyz_is_loaded(card)) {
2430                         result = -ENODEV;
2431                         goto end;
2432                 }
2433
2434                 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2435                 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2436                         ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2437                         ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2438                         ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2439                         ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2440                         ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2441         }
2442 end:
2443         return result;
2444 }                               /* cy_tiomget */
2445
2446 static int
2447 cy_tiocmset(struct tty_struct *tty,
2448                 unsigned int set, unsigned int clear)
2449 {
2450         struct cyclades_port *info = tty->driver_data;
2451         struct cyclades_card *card;
2452         unsigned long flags;
2453
2454         if (serial_paranoia_check(info, tty->name, __func__))
2455                 return -ENODEV;
2456
2457         card = info->card;
2458         if (!cy_is_Z(card)) {
2459                 spin_lock_irqsave(&card->card_lock, flags);
2460                 cyy_change_rts_dtr(info, set, clear);
2461                 spin_unlock_irqrestore(&card->card_lock, flags);
2462         } else {
2463                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2464                 int retval, channel = info->line - card->first_line;
2465                 u32 rs;
2466
2467                 if (!cyz_is_loaded(card))
2468                         return -ENODEV;
2469
2470                 spin_lock_irqsave(&card->card_lock, flags);
2471                 rs = readl(&ch_ctrl->rs_control);
2472                 if (set & TIOCM_RTS)
2473                         rs |= C_RS_RTS;
2474                 if (clear & TIOCM_RTS)
2475                         rs &= ~C_RS_RTS;
2476                 if (set & TIOCM_DTR) {
2477                         rs |= C_RS_DTR;
2478 #ifdef CY_DEBUG_DTR
2479                         printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2480 #endif
2481                 }
2482                 if (clear & TIOCM_DTR) {
2483                         rs &= ~C_RS_DTR;
2484 #ifdef CY_DEBUG_DTR
2485                         printk(KERN_DEBUG "cyc:set_modem_info clearing "
2486                                 "Z DTR\n");
2487 #endif
2488                 }
2489                 cy_writel(&ch_ctrl->rs_control, rs);
2490                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2491                 spin_unlock_irqrestore(&card->card_lock, flags);
2492                 if (retval != 0) {
2493                         printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2494                                 "was %x\n", info->line, retval);
2495                 }
2496         }
2497         return 0;
2498 }
2499
2500 /*
2501  * cy_break() --- routine which turns the break handling on or off
2502  */
2503 static int cy_break(struct tty_struct *tty, int break_state)
2504 {
2505         struct cyclades_port *info = tty->driver_data;
2506         struct cyclades_card *card;
2507         unsigned long flags;
2508         int retval = 0;
2509
2510         if (serial_paranoia_check(info, tty->name, "cy_break"))
2511                 return -EINVAL;
2512
2513         card = info->card;
2514
2515         spin_lock_irqsave(&card->card_lock, flags);
2516         if (!cy_is_Z(card)) {
2517                 /* Let the transmit ISR take care of this (since it
2518                    requires stuffing characters into the output stream).
2519                  */
2520                 if (break_state == -1) {
2521                         if (!info->breakon) {
2522                                 info->breakon = 1;
2523                                 if (!info->xmit_cnt) {
2524                                         spin_unlock_irqrestore(&card->card_lock, flags);
2525                                         start_xmit(info);
2526                                         spin_lock_irqsave(&card->card_lock, flags);
2527                                 }
2528                         }
2529                 } else {
2530                         if (!info->breakoff) {
2531                                 info->breakoff = 1;
2532                                 if (!info->xmit_cnt) {
2533                                         spin_unlock_irqrestore(&card->card_lock, flags);
2534                                         start_xmit(info);
2535                                         spin_lock_irqsave(&card->card_lock, flags);
2536                                 }
2537                         }
2538                 }
2539         } else {
2540                 if (break_state == -1) {
2541                         retval = cyz_issue_cmd(card,
2542                                 info->line - card->first_line,
2543                                 C_CM_SET_BREAK, 0L);
2544                         if (retval != 0) {
2545                                 printk(KERN_ERR "cyc:cy_break (set) retval on "
2546                                         "ttyC%d was %x\n", info->line, retval);
2547                         }
2548                 } else {
2549                         retval = cyz_issue_cmd(card,
2550                                 info->line - card->first_line,
2551                                 C_CM_CLR_BREAK, 0L);
2552                         if (retval != 0) {
2553                                 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2554                                         "on ttyC%d was %x\n", info->line,
2555                                         retval);
2556                         }
2557                 }
2558         }
2559         spin_unlock_irqrestore(&card->card_lock, flags);
2560         return retval;
2561 }                               /* cy_break */
2562
2563 static int set_threshold(struct cyclades_port *info, unsigned long value)
2564 {
2565         struct cyclades_card *card = info->card;
2566         unsigned long flags;
2567
2568         if (!cy_is_Z(card)) {
2569                 info->cor3 &= ~CyREC_FIFO;
2570                 info->cor3 |= value & CyREC_FIFO;
2571
2572                 spin_lock_irqsave(&card->card_lock, flags);
2573                 cyy_writeb(info, CyCOR3, info->cor3);
2574                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2575                 spin_unlock_irqrestore(&card->card_lock, flags);
2576         }
2577         return 0;
2578 }                               /* set_threshold */
2579
2580 static int get_threshold(struct cyclades_port *info,
2581                                                 unsigned long __user *value)
2582 {
2583         struct cyclades_card *card = info->card;
2584
2585         if (!cy_is_Z(card)) {
2586                 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2587                 return put_user(tmp, value);
2588         }
2589         return 0;
2590 }                               /* get_threshold */
2591
2592 static int set_timeout(struct cyclades_port *info, unsigned long value)
2593 {
2594         struct cyclades_card *card = info->card;
2595         unsigned long flags;
2596
2597         if (!cy_is_Z(card)) {
2598                 spin_lock_irqsave(&card->card_lock, flags);
2599                 cyy_writeb(info, CyRTPR, value & 0xff);
2600                 spin_unlock_irqrestore(&card->card_lock, flags);
2601         }
2602         return 0;
2603 }                               /* set_timeout */
2604
2605 static int get_timeout(struct cyclades_port *info,
2606                                                 unsigned long __user *value)
2607 {
2608         struct cyclades_card *card = info->card;
2609
2610         if (!cy_is_Z(card)) {
2611                 u8 tmp = cyy_readb(info, CyRTPR);
2612                 return put_user(tmp, value);
2613         }
2614         return 0;
2615 }                               /* get_timeout */
2616
2617 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2618                 struct cyclades_icount *cprev)
2619 {
2620         struct cyclades_icount cnow;
2621         unsigned long flags;
2622         int ret;
2623
2624         spin_lock_irqsave(&info->card->card_lock, flags);
2625         cnow = info->icount;    /* atomic copy */
2626         spin_unlock_irqrestore(&info->card->card_lock, flags);
2627
2628         ret =   ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2629                 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2630                 ((arg & TIOCM_CD)  && (cnow.dcd != cprev->dcd)) ||
2631                 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2632
2633         *cprev = cnow;
2634
2635         return ret;
2636 }
2637
2638 /*
2639  * This routine allows the tty driver to implement device-
2640  * specific ioctl's.  If the ioctl number passed in cmd is
2641  * not recognized by the driver, it should return ENOIOCTLCMD.
2642  */
2643 static int
2644 cy_ioctl(struct tty_struct *tty,
2645          unsigned int cmd, unsigned long arg)
2646 {
2647         struct cyclades_port *info = tty->driver_data;
2648         struct cyclades_icount cnow;    /* kernel counter temps */
2649         int ret_val = 0;
2650         unsigned long flags;
2651         void __user *argp = (void __user *)arg;
2652
2653         if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2654                 return -ENODEV;
2655
2656 #ifdef CY_DEBUG_OTHER
2657         printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2658                 info->line, cmd, arg);
2659 #endif
2660
2661         switch (cmd) {
2662         case CYGETMON:
2663                 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2664                         ret_val = -EFAULT;
2665                         break;
2666                 }
2667                 memset(&info->mon, 0, sizeof(info->mon));
2668                 break;
2669         case CYGETTHRESH:
2670                 ret_val = get_threshold(info, argp);
2671                 break;
2672         case CYSETTHRESH:
2673                 ret_val = set_threshold(info, arg);
2674                 break;
2675         case CYGETDEFTHRESH:
2676                 ret_val = put_user(info->default_threshold,
2677                                 (unsigned long __user *)argp);
2678                 break;
2679         case CYSETDEFTHRESH:
2680                 info->default_threshold = arg & 0x0f;
2681                 break;
2682         case CYGETTIMEOUT:
2683                 ret_val = get_timeout(info, argp);
2684                 break;
2685         case CYSETTIMEOUT:
2686                 ret_val = set_timeout(info, arg);
2687                 break;
2688         case CYGETDEFTIMEOUT:
2689                 ret_val = put_user(info->default_timeout,
2690                                 (unsigned long __user *)argp);
2691                 break;
2692         case CYSETDEFTIMEOUT:
2693                 info->default_timeout = arg & 0xff;
2694                 break;
2695         case CYSETRFLOW:
2696                 info->rflow = (int)arg;
2697                 break;
2698         case CYGETRFLOW:
2699                 ret_val = info->rflow;
2700                 break;
2701         case CYSETRTSDTR_INV:
2702                 info->rtsdtr_inv = (int)arg;
2703                 break;
2704         case CYGETRTSDTR_INV:
2705                 ret_val = info->rtsdtr_inv;
2706                 break;
2707         case CYGETCD1400VER:
2708                 ret_val = info->chip_rev;
2709                 break;
2710 #ifndef CONFIG_CYZ_INTR
2711         case CYZSETPOLLCYCLE:
2712                 if (arg > LONG_MAX / HZ)
2713                         return -ENODEV;
2714                 cyz_polling_cycle = (arg * HZ) / 1000;
2715                 break;
2716         case CYZGETPOLLCYCLE:
2717                 ret_val = (cyz_polling_cycle * 1000) / HZ;
2718                 break;
2719 #endif                          /* CONFIG_CYZ_INTR */
2720         case CYSETWAIT:
2721                 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2722                 break;
2723         case CYGETWAIT:
2724                 ret_val = info->port.closing_wait / (HZ / 100);
2725                 break;
2726         case TIOCGSERIAL:
2727                 ret_val = cy_get_serial_info(info, argp);
2728                 break;
2729         case TIOCSSERIAL:
2730                 ret_val = cy_set_serial_info(info, tty, argp);
2731                 break;
2732         case TIOCSERGETLSR:     /* Get line status register */
2733                 ret_val = get_lsr_info(info, argp);
2734                 break;
2735                 /*
2736                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2737                  * - mask passed in arg for lines of interest
2738                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2739                  * Caller should use TIOCGICOUNT to see which one it was
2740                  */
2741         case TIOCMIWAIT:
2742                 spin_lock_irqsave(&info->card->card_lock, flags);
2743                 /* note the counters on entry */
2744                 cnow = info->icount;
2745                 spin_unlock_irqrestore(&info->card->card_lock, flags);
2746                 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2747                                 cy_cflags_changed(info, arg, &cnow));
2748                 break;
2749
2750                 /*
2751                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2752                  * Return: write counters to the user passed counter struct
2753                  * NB: both 1->0 and 0->1 transitions are counted except for
2754                  *     RI where only 0->1 is counted.
2755                  */
2756         default:
2757                 ret_val = -ENOIOCTLCMD;
2758         }
2759
2760 #ifdef CY_DEBUG_OTHER
2761         printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2762 #endif
2763         return ret_val;
2764 }                               /* cy_ioctl */
2765
2766 static int cy_get_icount(struct tty_struct *tty,
2767                                 struct serial_icounter_struct *sic)
2768 {
2769         struct cyclades_port *info = tty->driver_data;
2770         struct cyclades_icount cnow;    /* Used to snapshot */
2771         unsigned long flags;
2772
2773         spin_lock_irqsave(&info->card->card_lock, flags);
2774         cnow = info->icount;
2775         spin_unlock_irqrestore(&info->card->card_lock, flags);
2776
2777         sic->cts = cnow.cts;
2778         sic->dsr = cnow.dsr;
2779         sic->rng = cnow.rng;
2780         sic->dcd = cnow.dcd;
2781         sic->rx = cnow.rx;
2782         sic->tx = cnow.tx;
2783         sic->frame = cnow.frame;
2784         sic->overrun = cnow.overrun;
2785         sic->parity = cnow.parity;
2786         sic->brk = cnow.brk;
2787         sic->buf_overrun = cnow.buf_overrun;
2788         return 0;
2789 }
2790
2791 /*
2792  * This routine allows the tty driver to be notified when
2793  * device's termios settings have changed.  Note that a
2794  * well-designed tty driver should be prepared to accept the case
2795  * where old == NULL, and try to do something rational.
2796  */
2797 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2798 {
2799         struct cyclades_port *info = tty->driver_data;
2800
2801 #ifdef CY_DEBUG_OTHER
2802         printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2803 #endif
2804
2805         cy_set_line_char(info, tty);
2806
2807         if ((old_termios->c_cflag & CRTSCTS) &&
2808                         !(tty->termios.c_cflag & CRTSCTS)) {
2809                 tty->hw_stopped = 0;
2810                 cy_start(tty);
2811         }
2812 #if 0
2813         /*
2814          * No need to wake up processes in open wait, since they
2815          * sample the CLOCAL flag once, and don't recheck it.
2816          * XXX  It's not clear whether the current behavior is correct
2817          * or not.  Hence, this may change.....
2818          */
2819         if (!(old_termios->c_cflag & CLOCAL) &&
2820             (tty->termios.c_cflag & CLOCAL))
2821                 wake_up_interruptible(&info->port.open_wait);
2822 #endif
2823 }                               /* cy_set_termios */
2824
2825 /* This function is used to send a high-priority XON/XOFF character to
2826    the device.
2827 */
2828 static void cy_send_xchar(struct tty_struct *tty, char ch)
2829 {
2830         struct cyclades_port *info = tty->driver_data;
2831         struct cyclades_card *card;
2832         int channel;
2833
2834         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2835                 return;
2836
2837         info->x_char = ch;
2838
2839         if (ch)
2840                 cy_start(tty);
2841
2842         card = info->card;
2843         channel = info->line - card->first_line;
2844
2845         if (cy_is_Z(card)) {
2846                 if (ch == STOP_CHAR(tty))
2847                         cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2848                 else if (ch == START_CHAR(tty))
2849                         cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2850         }
2851 }
2852
2853 /* This routine is called by the upper-layer tty layer to signal
2854    that incoming characters should be throttled because the input
2855    buffers are close to full.
2856  */
2857 static void cy_throttle(struct tty_struct *tty)
2858 {
2859         struct cyclades_port *info = tty->driver_data;
2860         struct cyclades_card *card;
2861         unsigned long flags;
2862
2863 #ifdef CY_DEBUG_THROTTLE
2864         char buf[64];
2865
2866         printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2867                         tty->ldisc.chars_in_buffer(tty), info->line);
2868 #endif
2869
2870         if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2871                 return;
2872
2873         card = info->card;
2874
2875         if (I_IXOFF(tty)) {
2876                 if (!cy_is_Z(card))
2877                         cy_send_xchar(tty, STOP_CHAR(tty));
2878                 else
2879                         info->throttle = 1;
2880         }
2881
2882         if (tty->termios.c_cflag & CRTSCTS) {
2883                 if (!cy_is_Z(card)) {
2884                         spin_lock_irqsave(&card->card_lock, flags);
2885                         cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2886                         spin_unlock_irqrestore(&card->card_lock, flags);
2887                 } else {
2888                         info->throttle = 1;
2889                 }
2890         }
2891 }                               /* cy_throttle */
2892
2893 /*
2894  * This routine notifies the tty driver that it should signal
2895  * that characters can now be sent to the tty without fear of
2896  * overrunning the input buffers of the line disciplines.
2897  */
2898 static void cy_unthrottle(struct tty_struct *tty)
2899 {
2900         struct cyclades_port *info = tty->driver_data;
2901         struct cyclades_card *card;
2902         unsigned long flags;
2903
2904 #ifdef CY_DEBUG_THROTTLE
2905         char buf[64];
2906
2907         printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2908                 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2909 #endif
2910
2911         if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2912                 return;
2913
2914         if (I_IXOFF(tty)) {
2915                 if (info->x_char)
2916                         info->x_char = 0;
2917                 else
2918                         cy_send_xchar(tty, START_CHAR(tty));
2919         }
2920
2921         if (tty->termios.c_cflag & CRTSCTS) {
2922                 card = info->card;
2923                 if (!cy_is_Z(card)) {
2924                         spin_lock_irqsave(&card->card_lock, flags);
2925                         cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2926                         spin_unlock_irqrestore(&card->card_lock, flags);
2927                 } else {
2928                         info->throttle = 0;
2929                 }
2930         }
2931 }                               /* cy_unthrottle */
2932
2933 /* cy_start and cy_stop provide software output flow control as a
2934    function of XON/XOFF, software CTS, and other such stuff.
2935 */
2936 static void cy_stop(struct tty_struct *tty)
2937 {
2938         struct cyclades_card *cinfo;
2939         struct cyclades_port *info = tty->driver_data;
2940         int channel;
2941         unsigned long flags;
2942
2943 #ifdef CY_DEBUG_OTHER
2944         printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2945 #endif
2946
2947         if (serial_paranoia_check(info, tty->name, "cy_stop"))
2948                 return;
2949
2950         cinfo = info->card;
2951         channel = info->line - cinfo->first_line;
2952         if (!cy_is_Z(cinfo)) {
2953                 spin_lock_irqsave(&cinfo->card_lock, flags);
2954                 cyy_writeb(info, CyCAR, channel & 0x03);
2955                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2956                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2957         }
2958 }                               /* cy_stop */
2959
2960 static void cy_start(struct tty_struct *tty)
2961 {
2962         struct cyclades_card *cinfo;
2963         struct cyclades_port *info = tty->driver_data;
2964         int channel;
2965         unsigned long flags;
2966
2967 #ifdef CY_DEBUG_OTHER
2968         printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
2969 #endif
2970
2971         if (serial_paranoia_check(info, tty->name, "cy_start"))
2972                 return;
2973
2974         cinfo = info->card;
2975         channel = info->line - cinfo->first_line;
2976         if (!cy_is_Z(cinfo)) {
2977                 spin_lock_irqsave(&cinfo->card_lock, flags);
2978                 cyy_writeb(info, CyCAR, channel & 0x03);
2979                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
2980                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2981         }
2982 }                               /* cy_start */
2983
2984 /*
2985  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
2986  */
2987 static void cy_hangup(struct tty_struct *tty)
2988 {
2989         struct cyclades_port *info = tty->driver_data;
2990
2991 #ifdef CY_DEBUG_OTHER
2992         printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
2993 #endif
2994
2995         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
2996                 return;
2997
2998         cy_flush_buffer(tty);
2999         cy_shutdown(info, tty);
3000         tty_port_hangup(&info->port);
3001 }                               /* cy_hangup */
3002
3003 static int cyy_carrier_raised(struct tty_port *port)
3004 {
3005         struct cyclades_port *info = container_of(port, struct cyclades_port,
3006                         port);
3007         struct cyclades_card *cinfo = info->card;
3008         unsigned long flags;
3009         int channel = info->line - cinfo->first_line;
3010         u32 cd;
3011
3012         spin_lock_irqsave(&cinfo->card_lock, flags);
3013         cyy_writeb(info, CyCAR, channel & 0x03);
3014         cd = cyy_readb(info, CyMSVR1) & CyDCD;
3015         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3016
3017         return cd;
3018 }
3019
3020 static void cyy_dtr_rts(struct tty_port *port, int raise)
3021 {
3022         struct cyclades_port *info = container_of(port, struct cyclades_port,
3023                         port);
3024         struct cyclades_card *cinfo = info->card;
3025         unsigned long flags;
3026
3027         spin_lock_irqsave(&cinfo->card_lock, flags);
3028         cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3029                         raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3030         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3031 }
3032
3033 static int cyz_carrier_raised(struct tty_port *port)
3034 {
3035         struct cyclades_port *info = container_of(port, struct cyclades_port,
3036                         port);
3037
3038         return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3039 }
3040
3041 static void cyz_dtr_rts(struct tty_port *port, int raise)
3042 {
3043         struct cyclades_port *info = container_of(port, struct cyclades_port,
3044                         port);
3045         struct cyclades_card *cinfo = info->card;
3046         struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3047         int ret, channel = info->line - cinfo->first_line;
3048         u32 rs;
3049
3050         rs = readl(&ch_ctrl->rs_control);
3051         if (raise)
3052                 rs |= C_RS_RTS | C_RS_DTR;
3053         else
3054                 rs &= ~(C_RS_RTS | C_RS_DTR);
3055         cy_writel(&ch_ctrl->rs_control, rs);
3056         ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3057         if (ret != 0)
3058                 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3059                                 __func__, info->line, ret);
3060 #ifdef CY_DEBUG_DTR
3061         printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3062 #endif
3063 }
3064
3065 static const struct tty_port_operations cyy_port_ops = {
3066         .carrier_raised = cyy_carrier_raised,
3067         .dtr_rts = cyy_dtr_rts,
3068         .shutdown = cy_do_close,
3069 };
3070
3071 static const struct tty_port_operations cyz_port_ops = {
3072         .carrier_raised = cyz_carrier_raised,
3073         .dtr_rts = cyz_dtr_rts,
3074         .shutdown = cy_do_close,
3075 };
3076
3077 /*
3078  * ---------------------------------------------------------------------
3079  * cy_init() and friends
3080  *
3081  * cy_init() is called at boot-time to initialize the serial driver.
3082  * ---------------------------------------------------------------------
3083  */
3084
3085 static int cy_init_card(struct cyclades_card *cinfo)
3086 {
3087         struct cyclades_port *info;
3088         unsigned int channel, port;
3089
3090         spin_lock_init(&cinfo->card_lock);
3091         cinfo->intr_enabled = 0;
3092
3093         cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3094                         GFP_KERNEL);
3095         if (cinfo->ports == NULL) {
3096                 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3097                 return -ENOMEM;
3098         }
3099
3100         for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3101                         channel++, port++) {
3102                 info = &cinfo->ports[channel];
3103                 tty_port_init(&info->port);
3104                 info->magic = CYCLADES_MAGIC;
3105                 info->card = cinfo;
3106                 info->line = port;
3107
3108                 info->port.closing_wait = CLOSING_WAIT_DELAY;
3109                 info->port.close_delay = 5 * HZ / 10;
3110                 info->port.flags = STD_COM_FLAGS;
3111                 init_completion(&info->shutdown_wait);
3112
3113                 if (cy_is_Z(cinfo)) {
3114                         struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3115                         struct ZFW_CTRL *zfw_ctrl;
3116
3117                         info->port.ops = &cyz_port_ops;
3118                         info->type = PORT_STARTECH;
3119
3120                         zfw_ctrl = cinfo->base_addr +
3121                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3122                         info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3123                         info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3124
3125                         if (cinfo->hw_ver == ZO_V1)
3126                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3127                         else
3128                                 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3129 #ifdef CONFIG_CYZ_INTR
3130                         setup_timer(&cyz_rx_full_timer[port],
3131                                 cyz_rx_restart, (unsigned long)info);
3132 #endif
3133                 } else {
3134                         unsigned short chip_number;
3135                         int index = cinfo->bus_index;
3136
3137                         info->port.ops = &cyy_port_ops;
3138                         info->type = PORT_CIRRUS;
3139                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3140                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3141                         info->cor2 = CyETC;
3142                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
3143
3144                         chip_number = channel / CyPORTS_PER_CHIP;
3145                         info->u.cyy.base_addr = cinfo->base_addr +
3146                                 (cy_chip_offset[chip_number] << index);
3147                         info->chip_rev = cyy_readb(info, CyGFRCR);
3148
3149                         if (info->chip_rev >= CD1400_REV_J) {
3150                                 /* It is a CD1400 rev. J or later */
3151                                 info->tbpr = baud_bpr_60[13];   /* Tx BPR */
3152                                 info->tco = baud_co_60[13];     /* Tx CO */
3153                                 info->rbpr = baud_bpr_60[13];   /* Rx BPR */
3154                                 info->rco = baud_co_60[13];     /* Rx CO */
3155                                 info->rtsdtr_inv = 1;
3156                         } else {
3157                                 info->tbpr = baud_bpr_25[13];   /* Tx BPR */
3158                                 info->tco = baud_co_25[13];     /* Tx CO */
3159                                 info->rbpr = baud_bpr_25[13];   /* Rx BPR */
3160                                 info->rco = baud_co_25[13];     /* Rx CO */
3161                                 info->rtsdtr_inv = 0;
3162                         }
3163                         info->read_status_mask = CyTIMEOUT | CySPECHAR |
3164                                 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3165                 }
3166
3167         }
3168
3169 #ifndef CONFIG_CYZ_INTR
3170         if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3171                 mod_timer(&cyz_timerlist, jiffies + 1);
3172 #ifdef CY_PCI_DEBUG
3173                 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3174 #endif
3175         }
3176 #endif
3177         return 0;
3178 }
3179
3180 /* initialize chips on Cyclom-Y card -- return number of valid
3181    chips (which is number of ports/4) */
3182 static unsigned short cyy_init_card(void __iomem *true_base_addr,
3183                 int index)
3184 {
3185         unsigned int chip_number;
3186         void __iomem *base_addr;
3187
3188         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3189         /* Cy_HwReset is 0x1400 */
3190         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3191         /* Cy_ClrIntr is 0x1800 */
3192         udelay(500L);
3193
3194         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3195                                                         chip_number++) {
3196                 base_addr =
3197                     true_base_addr + (cy_chip_offset[chip_number] << index);
3198                 mdelay(1);
3199                 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3200                         /*************
3201                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3202                         chip_number, (unsigned long)base_addr);
3203                         *************/
3204                         return chip_number;
3205                 }
3206
3207                 cy_writeb(base_addr + (CyGFRCR << index), 0);
3208                 udelay(10L);
3209
3210                 /* The Cyclom-16Y does not decode address bit 9 and therefore
3211                    cannot distinguish between references to chip 0 and a non-
3212                    existent chip 4.  If the preceding clearing of the supposed
3213                    chip 4 GFRCR register appears at chip 0, there is no chip 4
3214                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3215                  */
3216                 if (chip_number == 4 && readb(true_base_addr +
3217                                 (cy_chip_offset[0] << index) +
3218                                 (CyGFRCR << index)) == 0) {
3219                         return chip_number;
3220                 }
3221
3222                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3223                 mdelay(1);
3224
3225                 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3226                         /*
3227                            printk(" chip #%d at %#6lx is not responding ",
3228                            chip_number, (unsigned long)base_addr);
3229                            printk("(GFRCR stayed 0)\n",
3230                          */
3231                         return chip_number;
3232                 }
3233                 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3234                                 0x40) {
3235                         /*
3236                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
3237                                         "%#2x)\n",
3238                                         chip_number, (unsigned long)base_addr,
3239                                         base_addr[CyGFRCR<<index]);
3240                          */
3241                         return chip_number;
3242                 }
3243                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3244                 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3245                         /* It is a CD1400 rev. J or later */
3246                         /* Impossible to reach 5ms with this chip.
3247                            Changed to 2ms instead (f = 500 Hz). */
3248                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3249                 } else {
3250                         /* f = 200 Hz */
3251                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3252                 }
3253
3254                 /*
3255                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
3256                    chip_number, (unsigned long)base_addr,
3257                    readb(base_addr+(CyGFRCR<<index)));
3258                  */
3259         }
3260         return chip_number;
3261 }                               /* cyy_init_card */
3262
3263 /*
3264  * ---------------------------------------------------------------------
3265  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3266  * sets global variables and return the number of ISA boards found.
3267  * ---------------------------------------------------------------------
3268  */
3269 static int __init cy_detect_isa(void)
3270 {
3271 #ifdef CONFIG_ISA
3272         struct cyclades_card *card;
3273         unsigned short cy_isa_irq, nboard;
3274         void __iomem *cy_isa_address;
3275         unsigned short i, j, k, cy_isa_nchan;
3276         int isparam = 0;
3277
3278         nboard = 0;
3279
3280         /* Check for module parameters */
3281         for (i = 0; i < NR_CARDS; i++) {
3282                 if (maddr[i] || i) {
3283                         isparam = 1;
3284                         cy_isa_addresses[i] = maddr[i];
3285                 }
3286                 if (!maddr[i])
3287                         break;
3288         }
3289
3290         /* scan the address table probing for Cyclom-Y/ISA boards */
3291         for (i = 0; i < NR_ISA_ADDRS; i++) {
3292                 unsigned int isa_address = cy_isa_addresses[i];
3293                 if (isa_address == 0x0000)
3294                         return nboard;
3295
3296                 /* probe for CD1400... */
3297                 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3298                 if (cy_isa_address == NULL) {
3299                         printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3300                                         "address\n");
3301                         continue;
3302                 }
3303                 cy_isa_nchan = CyPORTS_PER_CHIP *
3304                         cyy_init_card(cy_isa_address, 0);
3305                 if (cy_isa_nchan == 0) {
3306                         iounmap(cy_isa_address);
3307                         continue;
3308                 }
3309
3310                 if (isparam && i < NR_CARDS && irq[i])
3311                         cy_isa_irq = irq[i];
3312                 else
3313                         /* find out the board's irq by probing */
3314                         cy_isa_irq = detect_isa_irq(cy_isa_address);
3315                 if (cy_isa_irq == 0) {
3316                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3317                                 "IRQ could not be detected.\n",
3318                                 (unsigned long)cy_isa_address);
3319                         iounmap(cy_isa_address);
3320                         continue;
3321                 }
3322
3323                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3324                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3325                                 "more channels are available. Change NR_PORTS "
3326                                 "in cyclades.c and recompile kernel.\n",
3327                                 (unsigned long)cy_isa_address);
3328                         iounmap(cy_isa_address);
3329                         return nboard;
3330                 }
3331                 /* fill the next cy_card structure available */
3332                 for (j = 0; j < NR_CARDS; j++) {
3333                         card = &cy_card[j];
3334                         if (card->base_addr == NULL)
3335                                 break;
3336                 }
3337                 if (j == NR_CARDS) {    /* no more cy_cards available */
3338                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3339                                 "more cards can be used. Change NR_CARDS in "
3340                                 "cyclades.c and recompile kernel.\n",
3341                                 (unsigned long)cy_isa_address);
3342                         iounmap(cy_isa_address);
3343                         return nboard;
3344                 }
3345
3346                 /* allocate IRQ */
3347                 if (request_irq(cy_isa_irq, cyy_interrupt,
3348                                 0, "Cyclom-Y", card)) {
3349                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3350                                 "could not allocate IRQ#%d.\n",
3351                                 (unsigned long)cy_isa_address, cy_isa_irq);
3352                         iounmap(cy_isa_address);
3353                         return nboard;
3354                 }
3355
3356                 /* set cy_card */
3357                 card->base_addr = cy_isa_address;
3358                 card->ctl_addr.p9050 = NULL;
3359                 card->irq = (int)cy_isa_irq;
3360                 card->bus_index = 0;
3361                 card->first_line = cy_next_channel;
3362                 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3363                 card->nports = cy_isa_nchan;
3364                 if (cy_init_card(card)) {
3365                         card->base_addr = NULL;
3366                         free_irq(cy_isa_irq, card);
3367                         iounmap(cy_isa_address);
3368                         continue;
3369                 }
3370                 nboard++;
3371
3372                 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3373                         "%d channels starting from port %d\n",
3374                         j + 1, (unsigned long)cy_isa_address,
3375                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3376                         cy_isa_irq, cy_isa_nchan, cy_next_channel);
3377
3378                 for (k = 0, j = cy_next_channel;
3379                                 j < cy_next_channel + cy_isa_nchan; j++, k++)
3380                         tty_port_register_device(&card->ports[k].port,
3381                                         cy_serial_driver, j, NULL);
3382                 cy_next_channel += cy_isa_nchan;
3383         }
3384         return nboard;
3385 #else
3386         return 0;
3387 #endif                          /* CONFIG_ISA */
3388 }                               /* cy_detect_isa */
3389
3390 #ifdef CONFIG_PCI
3391 static inline int cyc_isfwstr(const char *str, unsigned int size)
3392 {
3393         unsigned int a;
3394
3395         for (a = 0; a < size && *str; a++, str++)
3396                 if (*str & 0x80)
3397                         return -EINVAL;
3398
3399         for (; a < size; a++, str++)
3400                 if (*str)
3401                         return -EINVAL;
3402
3403         return 0;
3404 }
3405
3406 static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3407                 unsigned int size)
3408 {
3409         for (; size > 0; size--) {
3410                 cy_writel(fpga, *data++);
3411                 udelay(10);
3412         }
3413 }
3414
3415 static void plx_init(struct pci_dev *pdev, int irq,
3416                 struct RUNTIME_9060 __iomem *addr)
3417 {
3418         /* Reset PLX */
3419         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3420         udelay(100L);
3421         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3422
3423         /* Reload Config. Registers from EEPROM */
3424         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3425         udelay(100L);
3426         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3427
3428         /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3429          * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3430          * registers. This will remain here until we find a permanent fix.
3431          */
3432         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3433 }
3434
3435 static int __cyz_load_fw(const struct firmware *fw,
3436                 const char *name, const u32 mailbox, void __iomem *base,
3437                 void __iomem *fpga)
3438 {
3439         const void *ptr = fw->data;
3440         const struct zfile_header *h = ptr;
3441         const struct zfile_config *c, *cs;
3442         const struct zfile_block *b, *bs;
3443         unsigned int a, tmp, len = fw->size;
3444 #define BAD_FW KERN_ERR "Bad firmware: "
3445         if (len < sizeof(*h)) {
3446                 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3447                 return -EINVAL;
3448         }
3449
3450         cs = ptr + h->config_offset;
3451         bs = ptr + h->block_offset;
3452
3453         if ((void *)(cs + h->n_config) > ptr + len ||
3454                         (void *)(bs + h->n_blocks) > ptr + len) {
3455                 printk(BAD_FW "too short");
3456                 return  -EINVAL;
3457         }
3458
3459         if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3460                         cyc_isfwstr(h->date, sizeof(h->date))) {
3461                 printk(BAD_FW "bad formatted header string\n");
3462                 return -EINVAL;
3463         }
3464
3465         if (strncmp(name, h->name, sizeof(h->name))) {
3466                 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3467                 return -EINVAL;
3468         }
3469
3470         tmp = 0;
3471         for (c = cs; c < cs + h->n_config; c++) {
3472                 for (a = 0; a < c->n_blocks; a++)
3473                         if (c->block_list[a] > h->n_blocks) {
3474                                 printk(BAD_FW "bad block ref number in cfgs\n");
3475                                 return -EINVAL;
3476                         }
3477                 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3478                         tmp++;
3479         }
3480         if (!tmp) {
3481                 printk(BAD_FW "nothing appropriate\n");
3482                 return -EINVAL;
3483         }
3484
3485         for (b = bs; b < bs + h->n_blocks; b++)
3486                 if (b->file_offset + b->size > len) {
3487                         printk(BAD_FW "bad block data offset\n");
3488                         return -EINVAL;
3489                 }
3490
3491         /* everything is OK, let's seek'n'load it */
3492         for (c = cs; c < cs + h->n_config; c++)
3493                 if (c->mailbox == mailbox && c->function == 0)
3494                         break;
3495
3496         for (a = 0; a < c->n_blocks; a++) {
3497                 b = &bs[c->block_list[a]];
3498                 if (b->type == ZBLOCK_FPGA) {
3499                         if (fpga != NULL)
3500                                 cyz_fpga_copy(fpga, ptr + b->file_offset,
3501                                                 b->size);
3502                 } else {
3503                         if (base != NULL)
3504                                 memcpy_toio(base + b->ram_offset,
3505                                                ptr + b->file_offset, b->size);
3506                 }
3507         }
3508 #undef BAD_FW
3509         return 0;
3510 }
3511
3512 static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3513                 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3514 {
3515         const struct firmware *fw;
3516         struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3517         struct CUSTOM_REG __iomem *cust = base_addr;
3518         struct ZFW_CTRL __iomem *pt_zfwctrl;
3519         void __iomem *tmp;
3520         u32 mailbox, status, nchan;
3521         unsigned int i;
3522         int retval;
3523
3524         retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3525         if (retval) {
3526                 dev_err(&pdev->dev, "can't get firmware\n");
3527                 goto err;
3528         }
3529
3530         /* Check whether the firmware is already loaded and running. If
3531            positive, skip this board */
3532         if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3533                 u32 cntval = readl(base_addr + 0x190);
3534
3535                 udelay(100);
3536                 if (cntval != readl(base_addr + 0x190)) {
3537                         /* FW counter is working, FW is running */
3538                         dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3539                                         "Skipping board.\n");
3540                         retval = 0;
3541                         goto err_rel;
3542                 }
3543         }
3544
3545         /* start boot */
3546         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3547                         ~0x00030800UL);
3548
3549         mailbox = readl(&ctl_addr->mail_box_0);
3550
3551         if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3552                 /* stops CPU and set window to beginning of RAM */
3553                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3554                 cy_writel(&cust->cpu_stop, 0);
3555                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3556                 udelay(100);
3557         }
3558
3559         plx_init(pdev, irq, ctl_addr);
3560
3561         if (mailbox != 0) {
3562                 /* load FPGA */
3563                 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3564                                 base_addr);
3565                 if (retval)
3566                         goto err_rel;
3567                 if (!__cyz_fpga_loaded(ctl_addr)) {
3568                         dev_err(&pdev->dev, "fw upload successful, but fw is "
3569                                         "not loaded\n");
3570                         goto err_rel;
3571                 }
3572         }
3573
3574         /* stops CPU and set window to beginning of RAM */
3575         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3576         cy_writel(&cust->cpu_stop, 0);
3577         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3578         udelay(100);
3579
3580         /* clear memory */
3581         for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3582                 cy_writeb(tmp, 255);
3583         if (mailbox != 0) {
3584                 /* set window to last 512K of RAM */
3585                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3586                 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3587                         cy_writeb(tmp, 255);
3588                 /* set window to beginning of RAM */
3589                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3590         }
3591
3592         retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3593         release_firmware(fw);
3594         if (retval)
3595                 goto err;
3596
3597         /* finish boot and start boards */
3598         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3599         cy_writel(&cust->cpu_start, 0);
3600         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3601         i = 0;
3602         while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3603                 msleep(100);
3604         if (status != ZFIRM_ID) {
3605                 if (status == ZFIRM_HLT) {
3606                         dev_err(&pdev->dev, "you need an external power supply "
3607                                 "for this number of ports. Firmware halted and "
3608                                 "board reset.\n");
3609                         retval = -EIO;
3610                         goto err;
3611                 }
3612                 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3613                                 "some more time\n", status);
3614                 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3615                                 i++ < 200)
3616                         msleep(100);
3617                 if (status != ZFIRM_ID) {
3618                         dev_err(&pdev->dev, "Board not started in 20 seconds! "
3619                                         "Giving up. (fid->signature = 0x%x)\n",
3620                                         status);
3621                         dev_info(&pdev->dev, "*** Warning ***: if you are "
3622                                 "upgrading the FW, please power cycle the "
3623                                 "system before loading the new FW to the "
3624                                 "Cyclades-Z.\n");
3625
3626                         if (__cyz_fpga_loaded(ctl_addr))
3627                                 plx_init(pdev, irq, ctl_addr);
3628
3629                         retval = -EIO;
3630                         goto err;
3631                 }
3632                 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3633                                 i / 10);
3634         }
3635         pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3636
3637         dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3638                         base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3639                         base_addr + readl(&fid->zfwctrl_addr));
3640
3641         nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3642         dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3643                 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3644
3645         if (nchan == 0) {
3646                 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3647                         "check the connection between the Z host card and the "
3648                         "serial expanders.\n");
3649
3650                 if (__cyz_fpga_loaded(ctl_addr))
3651                         plx_init(pdev, irq, ctl_addr);
3652
3653                 dev_info(&pdev->dev, "Null number of ports detected. Board "
3654                                 "reset.\n");
3655                 retval = 0;
3656                 goto err;
3657         }
3658
3659         cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3660         cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3661
3662         /*
3663            Early firmware failed to start looking for commands.
3664            This enables firmware interrupts for those commands.
3665          */
3666         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3667                         (1 << 17));
3668         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3669                         0x00030800UL);
3670
3671         return nchan;
3672 err_rel:
3673         release_firmware(fw);
3674 err:
3675         return retval;
3676 }
3677
3678 static int cy_pci_probe(struct pci_dev *pdev,
3679                 const struct pci_device_id *ent)
3680 {
3681         struct cyclades_card *card;
3682         void __iomem *addr0 = NULL, *addr2 = NULL;
3683         char *card_name = NULL;
3684         u32 uninitialized_var(mailbox);
3685         unsigned int device_id, nchan = 0, card_no, i, j;
3686         unsigned char plx_ver;
3687         int retval, irq;
3688
3689         retval = pci_enable_device(pdev);
3690         if (retval) {
3691                 dev_err(&pdev->dev, "cannot enable device\n");
3692                 goto err;
3693         }
3694
3695         /* read PCI configuration area */
3696         irq = pdev->irq;
3697         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3698
3699 #if defined(__alpha__)
3700         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
3701                 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3702                         "addresses on Alpha systems.\n");
3703                 retval = -EIO;
3704                 goto err_dis;
3705         }
3706 #endif
3707         if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3708                 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3709                         "addresses\n");
3710                 retval = -EIO;
3711                 goto err_dis;
3712         }
3713
3714         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3715                 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3716                                 "it...\n");
3717                 pdev->resource[2].flags &= ~IORESOURCE_IO;
3718         }
3719
3720         retval = pci_request_regions(pdev, "cyclades");
3721         if (retval) {
3722                 dev_err(&pdev->dev, "failed to reserve resources\n");
3723                 goto err_dis;
3724         }
3725
3726         retval = -EIO;
3727         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3728                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3729                 card_name = "Cyclom-Y";
3730
3731                 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3732                                 CyPCI_Yctl);
3733                 if (addr0 == NULL) {
3734                         dev_err(&pdev->dev, "can't remap ctl region\n");
3735                         goto err_reg;
3736                 }
3737                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3738                                 CyPCI_Ywin);
3739                 if (addr2 == NULL) {
3740                         dev_err(&pdev->dev, "can't remap base region\n");
3741                         goto err_unmap;
3742                 }
3743
3744                 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3745                 if (nchan == 0) {
3746                         dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3747                                         "Serial-Modules\n");
3748                         goto err_unmap;
3749                 }
3750         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3751                 struct RUNTIME_9060 __iomem *ctl_addr;
3752
3753                 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3754                                 CyPCI_Zctl);
3755                 if (addr0 == NULL) {
3756                         dev_err(&pdev->dev, "can't remap ctl region\n");
3757                         goto err_reg;
3758                 }
3759
3760                 /* Disable interrupts on the PLX before resetting it */
3761                 cy_writew(&ctl_addr->intr_ctrl_stat,
3762                                 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3763
3764                 plx_init(pdev, irq, addr0);
3765
3766                 mailbox = readl(&ctl_addr->mail_box_0);
3767
3768                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3769                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3770                 if (addr2 == NULL) {
3771                         dev_err(&pdev->dev, "can't remap base region\n");
3772                         goto err_unmap;
3773                 }
3774
3775                 if (mailbox == ZE_V1) {
3776                         card_name = "Cyclades-Ze";
3777                 } else {
3778                         card_name = "Cyclades-8Zo";
3779 #ifdef CY_PCI_DEBUG
3780                         if (mailbox == ZO_V1) {
3781                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3782                                 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3783                                         "id %lx, ver %lx\n", (ulong)(0xff &
3784                                         readl(&((struct CUSTOM_REG *)addr2)->
3785                                                 fpga_id)), (ulong)(0xff &
3786                                         readl(&((struct CUSTOM_REG *)addr2)->
3787                                                 fpga_version)));
3788                                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3789                         } else {
3790                                 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3791                                         "Cyclades-Z board.  FPGA not loaded\n");
3792                         }
3793 #endif
3794                         /* The following clears the firmware id word.  This
3795                            ensures that the driver will not attempt to talk to
3796                            the board until it has been properly initialized.
3797                          */
3798                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3799                                 cy_writel(addr2 + ID_ADDRESS, 0L);
3800                 }
3801
3802                 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3803                 if (retval <= 0)
3804                         goto err_unmap;
3805                 nchan = retval;
3806         }
3807
3808         if ((cy_next_channel + nchan) > NR_PORTS) {
3809                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3810                         "channels are available. Change NR_PORTS in "
3811                         "cyclades.c and recompile kernel.\n");
3812                 goto err_unmap;
3813         }
3814         /* fill the next cy_card structure available */
3815         for (card_no = 0; card_no < NR_CARDS; card_no++) {
3816                 card = &cy_card[card_no];
3817                 if (card->base_addr == NULL)
3818                         break;
3819         }
3820         if (card_no == NR_CARDS) {      /* no more cy_cards available */
3821                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3822                         "more cards can be used. Change NR_CARDS in "
3823                         "cyclades.c and recompile kernel.\n");
3824                 goto err_unmap;
3825         }
3826
3827         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3828                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3829                 /* allocate IRQ */
3830                 retval = request_irq(irq, cyy_interrupt,
3831                                 IRQF_SHARED, "Cyclom-Y", card);
3832                 if (retval) {
3833                         dev_err(&pdev->dev, "could not allocate IRQ\n");
3834                         goto err_unmap;
3835                 }
3836                 card->num_chips = nchan / CyPORTS_PER_CHIP;
3837         } else {
3838                 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3839                 struct ZFW_CTRL __iomem *zfw_ctrl;
3840
3841                 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3842
3843                 card->hw_ver = mailbox;
3844                 card->num_chips = (unsigned int)-1;
3845                 card->board_ctrl = &zfw_ctrl->board_ctrl;
3846 #ifdef CONFIG_CYZ_INTR
3847                 /* allocate IRQ only if board has an IRQ */
3848                 if (irq != 0 && irq != 255) {
3849                         retval = request_irq(irq, cyz_interrupt,
3850                                         IRQF_SHARED, "Cyclades-Z", card);
3851                         if (retval) {
3852                                 dev_err(&pdev->dev, "could not allocate IRQ\n");
3853                                 goto err_unmap;
3854                         }
3855                 }
3856 #endif                          /* CONFIG_CYZ_INTR */
3857         }
3858
3859         /* set cy_card */
3860         card->base_addr = addr2;
3861         card->ctl_addr.p9050 = addr0;
3862         card->irq = irq;
3863         card->bus_index = 1;
3864         card->first_line = cy_next_channel;
3865         card->nports = nchan;
3866         retval = cy_init_card(card);
3867         if (retval)
3868                 goto err_null;
3869
3870         pci_set_drvdata(pdev, card);
3871
3872         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3873                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3874                 /* enable interrupts in the PCI interface */
3875                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3876                 switch (plx_ver) {
3877                 case PLX_9050:
3878                         cy_writeb(addr0 + 0x4c, 0x43);
3879                         break;
3880
3881                 case PLX_9060:
3882                 case PLX_9080:
3883                 default:        /* Old boards, use PLX_9060 */
3884                 {
3885                         struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3886                         plx_init(pdev, irq, ctl_addr);
3887                         cy_writew(&ctl_addr->intr_ctrl_stat,
3888                                 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3889                         break;
3890                 }
3891                 }
3892         }
3893
3894         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3895                 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3896         for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3897                 tty_port_register_device(&card->ports[j].port,
3898                                 cy_serial_driver, i, &pdev->dev);
3899         cy_next_channel += nchan;
3900
3901         return 0;
3902 err_null:
3903         card->base_addr = NULL;
3904         free_irq(irq, card);
3905 err_unmap:
3906         iounmap(addr0);
3907         if (addr2)
3908                 iounmap(addr2);
3909 err_reg:
3910         pci_release_regions(pdev);
3911 err_dis:
3912         pci_disable_device(pdev);
3913 err:
3914         return retval;
3915 }
3916
3917 static void cy_pci_remove(struct pci_dev *pdev)
3918 {
3919         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3920         unsigned int i, channel;
3921
3922         /* non-Z with old PLX */
3923         if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3924                         PLX_9050)
3925                 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3926         else
3927 #ifndef CONFIG_CYZ_INTR
3928                 if (!cy_is_Z(cinfo))
3929 #endif
3930                 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3931                         readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3932                         ~0x0900);
3933
3934         iounmap(cinfo->base_addr);
3935         if (cinfo->ctl_addr.p9050)
3936                 iounmap(cinfo->ctl_addr.p9050);
3937         if (cinfo->irq
3938 #ifndef CONFIG_CYZ_INTR
3939                 && !cy_is_Z(cinfo)
3940 #endif /* CONFIG_CYZ_INTR */
3941                 )
3942                 free_irq(cinfo->irq, cinfo);
3943         pci_release_regions(pdev);
3944
3945         cinfo->base_addr = NULL;
3946         for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3947                         cinfo->nports; i++, channel++) {
3948                 tty_unregister_device(cy_serial_driver, i);
3949                 tty_port_destroy(&cinfo->ports[channel].port);
3950         }
3951         cinfo->nports = 0;
3952         kfree(cinfo->ports);
3953 }
3954
3955 static struct pci_driver cy_pci_driver = {
3956         .name = "cyclades",
3957         .id_table = cy_pci_dev_id,
3958         .probe = cy_pci_probe,
3959         .remove = cy_pci_remove
3960 };
3961 #endif
3962
3963 static int cyclades_proc_show(struct seq_file *m, void *v)
3964 {
3965         struct cyclades_port *info;
3966         unsigned int i, j;
3967         __u32 cur_jifs = jiffies;
3968
3969         seq_puts(m, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
3970                         "IdleIn  Overruns  Ldisc\n");
3971
3972         /* Output one line for each known port */
3973         for (i = 0; i < NR_CARDS; i++)
3974                 for (j = 0; j < cy_card[i].nports; j++) {
3975                         info = &cy_card[i].ports[j];
3976
3977                         if (info->port.count) {
3978                                 /* XXX is the ldisc num worth this? */
3979                                 struct tty_struct *tty;
3980                                 struct tty_ldisc *ld;
3981                                 int num = 0;
3982                                 tty = tty_port_tty_get(&info->port);
3983                                 if (tty) {
3984                                         ld = tty_ldisc_ref(tty);
3985                                         if (ld) {
3986                                                 num = ld->ops->num;
3987                                                 tty_ldisc_deref(ld);
3988                                         }
3989                                         tty_kref_put(tty);
3990                                 }
3991                                 seq_printf(m, "%3d %8lu %10lu %8lu "
3992                                         "%10lu %8lu %9lu %6d\n", info->line,
3993                                         (cur_jifs - info->idle_stats.in_use) /
3994                                         HZ, info->idle_stats.xmit_bytes,
3995                                         (cur_jifs - info->idle_stats.xmit_idle)/
3996                                         HZ, info->idle_stats.recv_bytes,
3997                                         (cur_jifs - info->idle_stats.recv_idle)/
3998                                         HZ, info->idle_stats.overruns,
3999                                         num);
4000                         } else
4001                                 seq_printf(m, "%3d %8lu %10lu %8lu "
4002                                         "%10lu %8lu %9lu %6ld\n",
4003                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4004                 }
4005         return 0;
4006 }
4007
4008 static int cyclades_proc_open(struct inode *inode, struct file *file)
4009 {
4010         return single_open(file, cyclades_proc_show, NULL);
4011 }
4012
4013 static const struct file_operations cyclades_proc_fops = {
4014         .owner          = THIS_MODULE,
4015         .open           = cyclades_proc_open,
4016         .read           = seq_read,
4017         .llseek         = seq_lseek,
4018         .release        = single_release,
4019 };
4020
4021 /* The serial driver boot-time initialization code!
4022     Hardware I/O ports are mapped to character special devices on a
4023     first found, first allocated manner.  That is, this code searches
4024     for Cyclom cards in the system.  As each is found, it is probed
4025     to discover how many chips (and thus how many ports) are present.
4026     These ports are mapped to the tty ports 32 and upward in monotonic
4027     fashion.  If an 8-port card is replaced with a 16-port card, the
4028     port mapping on a following card will shift.
4029
4030     This approach is different from what is used in the other serial
4031     device driver because the Cyclom is more properly a multiplexer,
4032     not just an aggregation of serial ports on one card.
4033
4034     If there are more cards with more ports than have been
4035     statically allocated above, a warning is printed and the
4036     extra ports are ignored.
4037  */
4038
4039 static const struct tty_operations cy_ops = {
4040         .open = cy_open,
4041         .close = cy_close,
4042         .write = cy_write,
4043         .put_char = cy_put_char,
4044         .flush_chars = cy_flush_chars,
4045         .write_room = cy_write_room,
4046         .chars_in_buffer = cy_chars_in_buffer,
4047         .flush_buffer = cy_flush_buffer,
4048         .ioctl = cy_ioctl,
4049         .throttle = cy_throttle,
4050         .unthrottle = cy_unthrottle,
4051         .set_termios = cy_set_termios,
4052         .stop = cy_stop,
4053         .start = cy_start,
4054         .hangup = cy_hangup,
4055         .break_ctl = cy_break,
4056         .wait_until_sent = cy_wait_until_sent,
4057         .tiocmget = cy_tiocmget,
4058         .tiocmset = cy_tiocmset,
4059         .get_icount = cy_get_icount,
4060         .proc_fops = &cyclades_proc_fops,
4061 };
4062
4063 static int __init cy_init(void)
4064 {
4065         unsigned int nboards;
4066         int retval = -ENOMEM;
4067
4068         cy_serial_driver = alloc_tty_driver(NR_PORTS);
4069         if (!cy_serial_driver)
4070                 goto err;
4071
4072         printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4073
4074         /* Initialize the tty_driver structure */
4075
4076         cy_serial_driver->driver_name = "cyclades";
4077         cy_serial_driver->name = "ttyC";
4078         cy_serial_driver->major = CYCLADES_MAJOR;
4079         cy_serial_driver->minor_start = 0;
4080         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4081         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4082         cy_serial_driver->init_termios = tty_std_termios;
4083         cy_serial_driver->init_termios.c_cflag =
4084             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4085         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4086         tty_set_operations(cy_serial_driver, &cy_ops);
4087
4088         retval = tty_register_driver(cy_serial_driver);
4089         if (retval) {
4090                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4091                 goto err_frtty;
4092         }
4093
4094         /* the code below is responsible to find the boards. Each different
4095            type of board has its own detection routine. If a board is found,
4096            the next cy_card structure available is set by the detection
4097            routine. These functions are responsible for checking the
4098            availability of cy_card and cy_port data structures and updating
4099            the cy_next_channel. */
4100
4101         /* look for isa boards */
4102         nboards = cy_detect_isa();
4103
4104 #ifdef CONFIG_PCI
4105         /* look for pci boards */
4106         retval = pci_register_driver(&cy_pci_driver);
4107         if (retval && !nboards) {
4108                 tty_unregister_driver(cy_serial_driver);
4109                 goto err_frtty;
4110         }
4111 #endif
4112
4113         return 0;
4114 err_frtty:
4115         put_tty_driver(cy_serial_driver);
4116 err:
4117         return retval;
4118 }                               /* cy_init */
4119
4120 static void __exit cy_cleanup_module(void)
4121 {
4122         struct cyclades_card *card;
4123         unsigned int i, e1;
4124
4125 #ifndef CONFIG_CYZ_INTR
4126         del_timer_sync(&cyz_timerlist);
4127 #endif /* CONFIG_CYZ_INTR */
4128
4129         e1 = tty_unregister_driver(cy_serial_driver);
4130         if (e1)
4131                 printk(KERN_ERR "failed to unregister Cyclades serial "
4132                                 "driver(%d)\n", e1);
4133
4134 #ifdef CONFIG_PCI
4135         pci_unregister_driver(&cy_pci_driver);
4136 #endif
4137
4138         for (i = 0; i < NR_CARDS; i++) {
4139                 card = &cy_card[i];
4140                 if (card->base_addr) {
4141                         /* clear interrupt */
4142                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4143                         iounmap(card->base_addr);
4144                         if (card->ctl_addr.p9050)
4145                                 iounmap(card->ctl_addr.p9050);
4146                         if (card->irq
4147 #ifndef CONFIG_CYZ_INTR
4148                                 && !cy_is_Z(card)
4149 #endif /* CONFIG_CYZ_INTR */
4150                                 )
4151                                 free_irq(card->irq, card);
4152                         for (e1 = card->first_line; e1 < card->first_line +
4153                                         card->nports; e1++)
4154                                 tty_unregister_device(cy_serial_driver, e1);
4155                         kfree(card->ports);
4156                 }
4157         }
4158
4159         put_tty_driver(cy_serial_driver);
4160 } /* cy_cleanup_module */
4161
4162 module_init(cy_init);
4163 module_exit(cy_cleanup_module);
4164
4165 MODULE_LICENSE("GPL");
4166 MODULE_VERSION(CY_VERSION);
4167 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4168 MODULE_FIRMWARE("cyzfirm.bin");