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 (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         printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty),
2865                         tty->ldisc.chars_in_buffer(tty), info->line);
2866 #endif
2867
2868         if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2869                 return;
2870
2871         card = info->card;
2872
2873         if (I_IXOFF(tty)) {
2874                 if (!cy_is_Z(card))
2875                         cy_send_xchar(tty, STOP_CHAR(tty));
2876                 else
2877                         info->throttle = 1;
2878         }
2879
2880         if (tty->termios.c_cflag & CRTSCTS) {
2881                 if (!cy_is_Z(card)) {
2882                         spin_lock_irqsave(&card->card_lock, flags);
2883                         cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2884                         spin_unlock_irqrestore(&card->card_lock, flags);
2885                 } else {
2886                         info->throttle = 1;
2887                 }
2888         }
2889 }                               /* cy_throttle */
2890
2891 /*
2892  * This routine notifies the tty driver that it should signal
2893  * that characters can now be sent to the tty without fear of
2894  * overrunning the input buffers of the line disciplines.
2895  */
2896 static void cy_unthrottle(struct tty_struct *tty)
2897 {
2898         struct cyclades_port *info = tty->driver_data;
2899         struct cyclades_card *card;
2900         unsigned long flags;
2901
2902 #ifdef CY_DEBUG_THROTTLE
2903         printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2904                 tty_name(tty), tty_chars_in_buffer(tty), info->line);
2905 #endif
2906
2907         if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2908                 return;
2909
2910         if (I_IXOFF(tty)) {
2911                 if (info->x_char)
2912                         info->x_char = 0;
2913                 else
2914                         cy_send_xchar(tty, START_CHAR(tty));
2915         }
2916
2917         if (tty->termios.c_cflag & CRTSCTS) {
2918                 card = info->card;
2919                 if (!cy_is_Z(card)) {
2920                         spin_lock_irqsave(&card->card_lock, flags);
2921                         cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2922                         spin_unlock_irqrestore(&card->card_lock, flags);
2923                 } else {
2924                         info->throttle = 0;
2925                 }
2926         }
2927 }                               /* cy_unthrottle */
2928
2929 /* cy_start and cy_stop provide software output flow control as a
2930    function of XON/XOFF, software CTS, and other such stuff.
2931 */
2932 static void cy_stop(struct tty_struct *tty)
2933 {
2934         struct cyclades_card *cinfo;
2935         struct cyclades_port *info = tty->driver_data;
2936         int channel;
2937         unsigned long flags;
2938
2939 #ifdef CY_DEBUG_OTHER
2940         printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2941 #endif
2942
2943         if (serial_paranoia_check(info, tty->name, "cy_stop"))
2944                 return;
2945
2946         cinfo = info->card;
2947         channel = info->line - cinfo->first_line;
2948         if (!cy_is_Z(cinfo)) {
2949                 spin_lock_irqsave(&cinfo->card_lock, flags);
2950                 cyy_writeb(info, CyCAR, channel & 0x03);
2951                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2952                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2953         }
2954 }                               /* cy_stop */
2955
2956 static void cy_start(struct tty_struct *tty)
2957 {
2958         struct cyclades_card *cinfo;
2959         struct cyclades_port *info = tty->driver_data;
2960         int channel;
2961         unsigned long flags;
2962
2963 #ifdef CY_DEBUG_OTHER
2964         printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
2965 #endif
2966
2967         if (serial_paranoia_check(info, tty->name, "cy_start"))
2968                 return;
2969
2970         cinfo = info->card;
2971         channel = info->line - cinfo->first_line;
2972         if (!cy_is_Z(cinfo)) {
2973                 spin_lock_irqsave(&cinfo->card_lock, flags);
2974                 cyy_writeb(info, CyCAR, channel & 0x03);
2975                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
2976                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2977         }
2978 }                               /* cy_start */
2979
2980 /*
2981  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
2982  */
2983 static void cy_hangup(struct tty_struct *tty)
2984 {
2985         struct cyclades_port *info = tty->driver_data;
2986
2987 #ifdef CY_DEBUG_OTHER
2988         printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
2989 #endif
2990
2991         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
2992                 return;
2993
2994         cy_flush_buffer(tty);
2995         cy_shutdown(info, tty);
2996         tty_port_hangup(&info->port);
2997 }                               /* cy_hangup */
2998
2999 static int cyy_carrier_raised(struct tty_port *port)
3000 {
3001         struct cyclades_port *info = container_of(port, struct cyclades_port,
3002                         port);
3003         struct cyclades_card *cinfo = info->card;
3004         unsigned long flags;
3005         int channel = info->line - cinfo->first_line;
3006         u32 cd;
3007
3008         spin_lock_irqsave(&cinfo->card_lock, flags);
3009         cyy_writeb(info, CyCAR, channel & 0x03);
3010         cd = cyy_readb(info, CyMSVR1) & CyDCD;
3011         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3012
3013         return cd;
3014 }
3015
3016 static void cyy_dtr_rts(struct tty_port *port, int raise)
3017 {
3018         struct cyclades_port *info = container_of(port, struct cyclades_port,
3019                         port);
3020         struct cyclades_card *cinfo = info->card;
3021         unsigned long flags;
3022
3023         spin_lock_irqsave(&cinfo->card_lock, flags);
3024         cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3025                         raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3026         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3027 }
3028
3029 static int cyz_carrier_raised(struct tty_port *port)
3030 {
3031         struct cyclades_port *info = container_of(port, struct cyclades_port,
3032                         port);
3033
3034         return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3035 }
3036
3037 static void cyz_dtr_rts(struct tty_port *port, int raise)
3038 {
3039         struct cyclades_port *info = container_of(port, struct cyclades_port,
3040                         port);
3041         struct cyclades_card *cinfo = info->card;
3042         struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3043         int ret, channel = info->line - cinfo->first_line;
3044         u32 rs;
3045
3046         rs = readl(&ch_ctrl->rs_control);
3047         if (raise)
3048                 rs |= C_RS_RTS | C_RS_DTR;
3049         else
3050                 rs &= ~(C_RS_RTS | C_RS_DTR);
3051         cy_writel(&ch_ctrl->rs_control, rs);
3052         ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3053         if (ret != 0)
3054                 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3055                                 __func__, info->line, ret);
3056 #ifdef CY_DEBUG_DTR
3057         printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3058 #endif
3059 }
3060
3061 static const struct tty_port_operations cyy_port_ops = {
3062         .carrier_raised = cyy_carrier_raised,
3063         .dtr_rts = cyy_dtr_rts,
3064         .shutdown = cy_do_close,
3065 };
3066
3067 static const struct tty_port_operations cyz_port_ops = {
3068         .carrier_raised = cyz_carrier_raised,
3069         .dtr_rts = cyz_dtr_rts,
3070         .shutdown = cy_do_close,
3071 };
3072
3073 /*
3074  * ---------------------------------------------------------------------
3075  * cy_init() and friends
3076  *
3077  * cy_init() is called at boot-time to initialize the serial driver.
3078  * ---------------------------------------------------------------------
3079  */
3080
3081 static int cy_init_card(struct cyclades_card *cinfo)
3082 {
3083         struct cyclades_port *info;
3084         unsigned int channel, port;
3085
3086         spin_lock_init(&cinfo->card_lock);
3087         cinfo->intr_enabled = 0;
3088
3089         cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3090                         GFP_KERNEL);
3091         if (cinfo->ports == NULL) {
3092                 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3093                 return -ENOMEM;
3094         }
3095
3096         for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3097                         channel++, port++) {
3098                 info = &cinfo->ports[channel];
3099                 tty_port_init(&info->port);
3100                 info->magic = CYCLADES_MAGIC;
3101                 info->card = cinfo;
3102                 info->line = port;
3103
3104                 info->port.closing_wait = CLOSING_WAIT_DELAY;
3105                 info->port.close_delay = 5 * HZ / 10;
3106                 info->port.flags = STD_COM_FLAGS;
3107                 init_completion(&info->shutdown_wait);
3108
3109                 if (cy_is_Z(cinfo)) {
3110                         struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3111                         struct ZFW_CTRL *zfw_ctrl;
3112
3113                         info->port.ops = &cyz_port_ops;
3114                         info->type = PORT_STARTECH;
3115
3116                         zfw_ctrl = cinfo->base_addr +
3117                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3118                         info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3119                         info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3120
3121                         if (cinfo->hw_ver == ZO_V1)
3122                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3123                         else
3124                                 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3125 #ifdef CONFIG_CYZ_INTR
3126                         setup_timer(&cyz_rx_full_timer[port],
3127                                 cyz_rx_restart, (unsigned long)info);
3128 #endif
3129                 } else {
3130                         unsigned short chip_number;
3131                         int index = cinfo->bus_index;
3132
3133                         info->port.ops = &cyy_port_ops;
3134                         info->type = PORT_CIRRUS;
3135                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3136                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3137                         info->cor2 = CyETC;
3138                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
3139
3140                         chip_number = channel / CyPORTS_PER_CHIP;
3141                         info->u.cyy.base_addr = cinfo->base_addr +
3142                                 (cy_chip_offset[chip_number] << index);
3143                         info->chip_rev = cyy_readb(info, CyGFRCR);
3144
3145                         if (info->chip_rev >= CD1400_REV_J) {
3146                                 /* It is a CD1400 rev. J or later */
3147                                 info->tbpr = baud_bpr_60[13];   /* Tx BPR */
3148                                 info->tco = baud_co_60[13];     /* Tx CO */
3149                                 info->rbpr = baud_bpr_60[13];   /* Rx BPR */
3150                                 info->rco = baud_co_60[13];     /* Rx CO */
3151                                 info->rtsdtr_inv = 1;
3152                         } else {
3153                                 info->tbpr = baud_bpr_25[13];   /* Tx BPR */
3154                                 info->tco = baud_co_25[13];     /* Tx CO */
3155                                 info->rbpr = baud_bpr_25[13];   /* Rx BPR */
3156                                 info->rco = baud_co_25[13];     /* Rx CO */
3157                                 info->rtsdtr_inv = 0;
3158                         }
3159                         info->read_status_mask = CyTIMEOUT | CySPECHAR |
3160                                 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3161                 }
3162
3163         }
3164
3165 #ifndef CONFIG_CYZ_INTR
3166         if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3167                 mod_timer(&cyz_timerlist, jiffies + 1);
3168 #ifdef CY_PCI_DEBUG
3169                 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3170 #endif
3171         }
3172 #endif
3173         return 0;
3174 }
3175
3176 /* initialize chips on Cyclom-Y card -- return number of valid
3177    chips (which is number of ports/4) */
3178 static unsigned short cyy_init_card(void __iomem *true_base_addr,
3179                 int index)
3180 {
3181         unsigned int chip_number;
3182         void __iomem *base_addr;
3183
3184         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3185         /* Cy_HwReset is 0x1400 */
3186         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3187         /* Cy_ClrIntr is 0x1800 */
3188         udelay(500L);
3189
3190         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3191                                                         chip_number++) {
3192                 base_addr =
3193                     true_base_addr + (cy_chip_offset[chip_number] << index);
3194                 mdelay(1);
3195                 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3196                         /*************
3197                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3198                         chip_number, (unsigned long)base_addr);
3199                         *************/
3200                         return chip_number;
3201                 }
3202
3203                 cy_writeb(base_addr + (CyGFRCR << index), 0);
3204                 udelay(10L);
3205
3206                 /* The Cyclom-16Y does not decode address bit 9 and therefore
3207                    cannot distinguish between references to chip 0 and a non-
3208                    existent chip 4.  If the preceding clearing of the supposed
3209                    chip 4 GFRCR register appears at chip 0, there is no chip 4
3210                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3211                  */
3212                 if (chip_number == 4 && readb(true_base_addr +
3213                                 (cy_chip_offset[0] << index) +
3214                                 (CyGFRCR << index)) == 0) {
3215                         return chip_number;
3216                 }
3217
3218                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3219                 mdelay(1);
3220
3221                 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3222                         /*
3223                            printk(" chip #%d at %#6lx is not responding ",
3224                            chip_number, (unsigned long)base_addr);
3225                            printk("(GFRCR stayed 0)\n",
3226                          */
3227                         return chip_number;
3228                 }
3229                 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3230                                 0x40) {
3231                         /*
3232                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
3233                                         "%#2x)\n",
3234                                         chip_number, (unsigned long)base_addr,
3235                                         base_addr[CyGFRCR<<index]);
3236                          */
3237                         return chip_number;
3238                 }
3239                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3240                 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3241                         /* It is a CD1400 rev. J or later */
3242                         /* Impossible to reach 5ms with this chip.
3243                            Changed to 2ms instead (f = 500 Hz). */
3244                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3245                 } else {
3246                         /* f = 200 Hz */
3247                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3248                 }
3249
3250                 /*
3251                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
3252                    chip_number, (unsigned long)base_addr,
3253                    readb(base_addr+(CyGFRCR<<index)));
3254                  */
3255         }
3256         return chip_number;
3257 }                               /* cyy_init_card */
3258
3259 /*
3260  * ---------------------------------------------------------------------
3261  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3262  * sets global variables and return the number of ISA boards found.
3263  * ---------------------------------------------------------------------
3264  */
3265 static int __init cy_detect_isa(void)
3266 {
3267 #ifdef CONFIG_ISA
3268         struct cyclades_card *card;
3269         unsigned short cy_isa_irq, nboard;
3270         void __iomem *cy_isa_address;
3271         unsigned short i, j, k, cy_isa_nchan;
3272         int isparam = 0;
3273
3274         nboard = 0;
3275
3276         /* Check for module parameters */
3277         for (i = 0; i < NR_CARDS; i++) {
3278                 if (maddr[i] || i) {
3279                         isparam = 1;
3280                         cy_isa_addresses[i] = maddr[i];
3281                 }
3282                 if (!maddr[i])
3283                         break;
3284         }
3285
3286         /* scan the address table probing for Cyclom-Y/ISA boards */
3287         for (i = 0; i < NR_ISA_ADDRS; i++) {
3288                 unsigned int isa_address = cy_isa_addresses[i];
3289                 if (isa_address == 0x0000)
3290                         return nboard;
3291
3292                 /* probe for CD1400... */
3293                 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3294                 if (cy_isa_address == NULL) {
3295                         printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3296                                         "address\n");
3297                         continue;
3298                 }
3299                 cy_isa_nchan = CyPORTS_PER_CHIP *
3300                         cyy_init_card(cy_isa_address, 0);
3301                 if (cy_isa_nchan == 0) {
3302                         iounmap(cy_isa_address);
3303                         continue;
3304                 }
3305
3306                 if (isparam && i < NR_CARDS && irq[i])
3307                         cy_isa_irq = irq[i];
3308                 else
3309                         /* find out the board's irq by probing */
3310                         cy_isa_irq = detect_isa_irq(cy_isa_address);
3311                 if (cy_isa_irq == 0) {
3312                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3313                                 "IRQ could not be detected.\n",
3314                                 (unsigned long)cy_isa_address);
3315                         iounmap(cy_isa_address);
3316                         continue;
3317                 }
3318
3319                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3320                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3321                                 "more channels are available. Change NR_PORTS "
3322                                 "in cyclades.c and recompile kernel.\n",
3323                                 (unsigned long)cy_isa_address);
3324                         iounmap(cy_isa_address);
3325                         return nboard;
3326                 }
3327                 /* fill the next cy_card structure available */
3328                 for (j = 0; j < NR_CARDS; j++) {
3329                         card = &cy_card[j];
3330                         if (card->base_addr == NULL)
3331                                 break;
3332                 }
3333                 if (j == NR_CARDS) {    /* no more cy_cards available */
3334                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3335                                 "more cards can be used. Change NR_CARDS in "
3336                                 "cyclades.c and recompile kernel.\n",
3337                                 (unsigned long)cy_isa_address);
3338                         iounmap(cy_isa_address);
3339                         return nboard;
3340                 }
3341
3342                 /* allocate IRQ */
3343                 if (request_irq(cy_isa_irq, cyy_interrupt,
3344                                 0, "Cyclom-Y", card)) {
3345                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3346                                 "could not allocate IRQ#%d.\n",
3347                                 (unsigned long)cy_isa_address, cy_isa_irq);
3348                         iounmap(cy_isa_address);
3349                         return nboard;
3350                 }
3351
3352                 /* set cy_card */
3353                 card->base_addr = cy_isa_address;
3354                 card->ctl_addr.p9050 = NULL;
3355                 card->irq = (int)cy_isa_irq;
3356                 card->bus_index = 0;
3357                 card->first_line = cy_next_channel;
3358                 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3359                 card->nports = cy_isa_nchan;
3360                 if (cy_init_card(card)) {
3361                         card->base_addr = NULL;
3362                         free_irq(cy_isa_irq, card);
3363                         iounmap(cy_isa_address);
3364                         continue;
3365                 }
3366                 nboard++;
3367
3368                 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3369                         "%d channels starting from port %d\n",
3370                         j + 1, (unsigned long)cy_isa_address,
3371                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3372                         cy_isa_irq, cy_isa_nchan, cy_next_channel);
3373
3374                 for (k = 0, j = cy_next_channel;
3375                                 j < cy_next_channel + cy_isa_nchan; j++, k++)
3376                         tty_port_register_device(&card->ports[k].port,
3377                                         cy_serial_driver, j, NULL);
3378                 cy_next_channel += cy_isa_nchan;
3379         }
3380         return nboard;
3381 #else
3382         return 0;
3383 #endif                          /* CONFIG_ISA */
3384 }                               /* cy_detect_isa */
3385
3386 #ifdef CONFIG_PCI
3387 static inline int cyc_isfwstr(const char *str, unsigned int size)
3388 {
3389         unsigned int a;
3390
3391         for (a = 0; a < size && *str; a++, str++)
3392                 if (*str & 0x80)
3393                         return -EINVAL;
3394
3395         for (; a < size; a++, str++)
3396                 if (*str)
3397                         return -EINVAL;
3398
3399         return 0;
3400 }
3401
3402 static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3403                 unsigned int size)
3404 {
3405         for (; size > 0; size--) {
3406                 cy_writel(fpga, *data++);
3407                 udelay(10);
3408         }
3409 }
3410
3411 static void plx_init(struct pci_dev *pdev, int irq,
3412                 struct RUNTIME_9060 __iomem *addr)
3413 {
3414         /* Reset PLX */
3415         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3416         udelay(100L);
3417         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3418
3419         /* Reload Config. Registers from EEPROM */
3420         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3421         udelay(100L);
3422         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3423
3424         /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3425          * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3426          * registers. This will remain here until we find a permanent fix.
3427          */
3428         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3429 }
3430
3431 static int __cyz_load_fw(const struct firmware *fw,
3432                 const char *name, const u32 mailbox, void __iomem *base,
3433                 void __iomem *fpga)
3434 {
3435         const void *ptr = fw->data;
3436         const struct zfile_header *h = ptr;
3437         const struct zfile_config *c, *cs;
3438         const struct zfile_block *b, *bs;
3439         unsigned int a, tmp, len = fw->size;
3440 #define BAD_FW KERN_ERR "Bad firmware: "
3441         if (len < sizeof(*h)) {
3442                 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3443                 return -EINVAL;
3444         }
3445
3446         cs = ptr + h->config_offset;
3447         bs = ptr + h->block_offset;
3448
3449         if ((void *)(cs + h->n_config) > ptr + len ||
3450                         (void *)(bs + h->n_blocks) > ptr + len) {
3451                 printk(BAD_FW "too short");
3452                 return  -EINVAL;
3453         }
3454
3455         if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3456                         cyc_isfwstr(h->date, sizeof(h->date))) {
3457                 printk(BAD_FW "bad formatted header string\n");
3458                 return -EINVAL;
3459         }
3460
3461         if (strncmp(name, h->name, sizeof(h->name))) {
3462                 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3463                 return -EINVAL;
3464         }
3465
3466         tmp = 0;
3467         for (c = cs; c < cs + h->n_config; c++) {
3468                 for (a = 0; a < c->n_blocks; a++)
3469                         if (c->block_list[a] > h->n_blocks) {
3470                                 printk(BAD_FW "bad block ref number in cfgs\n");
3471                                 return -EINVAL;
3472                         }
3473                 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3474                         tmp++;
3475         }
3476         if (!tmp) {
3477                 printk(BAD_FW "nothing appropriate\n");
3478                 return -EINVAL;
3479         }
3480
3481         for (b = bs; b < bs + h->n_blocks; b++)
3482                 if (b->file_offset + b->size > len) {
3483                         printk(BAD_FW "bad block data offset\n");
3484                         return -EINVAL;
3485                 }
3486
3487         /* everything is OK, let's seek'n'load it */
3488         for (c = cs; c < cs + h->n_config; c++)
3489                 if (c->mailbox == mailbox && c->function == 0)
3490                         break;
3491
3492         for (a = 0; a < c->n_blocks; a++) {
3493                 b = &bs[c->block_list[a]];
3494                 if (b->type == ZBLOCK_FPGA) {
3495                         if (fpga != NULL)
3496                                 cyz_fpga_copy(fpga, ptr + b->file_offset,
3497                                                 b->size);
3498                 } else {
3499                         if (base != NULL)
3500                                 memcpy_toio(base + b->ram_offset,
3501                                                ptr + b->file_offset, b->size);
3502                 }
3503         }
3504 #undef BAD_FW
3505         return 0;
3506 }
3507
3508 static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3509                 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3510 {
3511         const struct firmware *fw;
3512         struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3513         struct CUSTOM_REG __iomem *cust = base_addr;
3514         struct ZFW_CTRL __iomem *pt_zfwctrl;
3515         void __iomem *tmp;
3516         u32 mailbox, status, nchan;
3517         unsigned int i;
3518         int retval;
3519
3520         retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3521         if (retval) {
3522                 dev_err(&pdev->dev, "can't get firmware\n");
3523                 goto err;
3524         }
3525
3526         /* Check whether the firmware is already loaded and running. If
3527            positive, skip this board */
3528         if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3529                 u32 cntval = readl(base_addr + 0x190);
3530
3531                 udelay(100);
3532                 if (cntval != readl(base_addr + 0x190)) {
3533                         /* FW counter is working, FW is running */
3534                         dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3535                                         "Skipping board.\n");
3536                         retval = 0;
3537                         goto err_rel;
3538                 }
3539         }
3540
3541         /* start boot */
3542         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3543                         ~0x00030800UL);
3544
3545         mailbox = readl(&ctl_addr->mail_box_0);
3546
3547         if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3548                 /* stops CPU and set window to beginning of RAM */
3549                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3550                 cy_writel(&cust->cpu_stop, 0);
3551                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3552                 udelay(100);
3553         }
3554
3555         plx_init(pdev, irq, ctl_addr);
3556
3557         if (mailbox != 0) {
3558                 /* load FPGA */
3559                 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3560                                 base_addr);
3561                 if (retval)
3562                         goto err_rel;
3563                 if (!__cyz_fpga_loaded(ctl_addr)) {
3564                         dev_err(&pdev->dev, "fw upload successful, but fw is "
3565                                         "not loaded\n");
3566                         goto err_rel;
3567                 }
3568         }
3569
3570         /* stops CPU and set window to beginning of RAM */
3571         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3572         cy_writel(&cust->cpu_stop, 0);
3573         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3574         udelay(100);
3575
3576         /* clear memory */
3577         for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3578                 cy_writeb(tmp, 255);
3579         if (mailbox != 0) {
3580                 /* set window to last 512K of RAM */
3581                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3582                 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3583                         cy_writeb(tmp, 255);
3584                 /* set window to beginning of RAM */
3585                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3586         }
3587
3588         retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3589         release_firmware(fw);
3590         if (retval)
3591                 goto err;
3592
3593         /* finish boot and start boards */
3594         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3595         cy_writel(&cust->cpu_start, 0);
3596         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3597         i = 0;
3598         while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3599                 msleep(100);
3600         if (status != ZFIRM_ID) {
3601                 if (status == ZFIRM_HLT) {
3602                         dev_err(&pdev->dev, "you need an external power supply "
3603                                 "for this number of ports. Firmware halted and "
3604                                 "board reset.\n");
3605                         retval = -EIO;
3606                         goto err;
3607                 }
3608                 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3609                                 "some more time\n", status);
3610                 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3611                                 i++ < 200)
3612                         msleep(100);
3613                 if (status != ZFIRM_ID) {
3614                         dev_err(&pdev->dev, "Board not started in 20 seconds! "
3615                                         "Giving up. (fid->signature = 0x%x)\n",
3616                                         status);
3617                         dev_info(&pdev->dev, "*** Warning ***: if you are "
3618                                 "upgrading the FW, please power cycle the "
3619                                 "system before loading the new FW to the "
3620                                 "Cyclades-Z.\n");
3621
3622                         if (__cyz_fpga_loaded(ctl_addr))
3623                                 plx_init(pdev, irq, ctl_addr);
3624
3625                         retval = -EIO;
3626                         goto err;
3627                 }
3628                 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3629                                 i / 10);
3630         }
3631         pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3632
3633         dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3634                         base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3635                         base_addr + readl(&fid->zfwctrl_addr));
3636
3637         nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3638         dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3639                 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3640
3641         if (nchan == 0) {
3642                 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3643                         "check the connection between the Z host card and the "
3644                         "serial expanders.\n");
3645
3646                 if (__cyz_fpga_loaded(ctl_addr))
3647                         plx_init(pdev, irq, ctl_addr);
3648
3649                 dev_info(&pdev->dev, "Null number of ports detected. Board "
3650                                 "reset.\n");
3651                 retval = 0;
3652                 goto err;
3653         }
3654
3655         cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3656         cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3657
3658         /*
3659            Early firmware failed to start looking for commands.
3660            This enables firmware interrupts for those commands.
3661          */
3662         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3663                         (1 << 17));
3664         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3665                         0x00030800UL);
3666
3667         return nchan;
3668 err_rel:
3669         release_firmware(fw);
3670 err:
3671         return retval;
3672 }
3673
3674 static int cy_pci_probe(struct pci_dev *pdev,
3675                 const struct pci_device_id *ent)
3676 {
3677         struct cyclades_card *card;
3678         void __iomem *addr0 = NULL, *addr2 = NULL;
3679         char *card_name = NULL;
3680         u32 uninitialized_var(mailbox);
3681         unsigned int device_id, nchan = 0, card_no, i, j;
3682         unsigned char plx_ver;
3683         int retval, irq;
3684
3685         retval = pci_enable_device(pdev);
3686         if (retval) {
3687                 dev_err(&pdev->dev, "cannot enable device\n");
3688                 goto err;
3689         }
3690
3691         /* read PCI configuration area */
3692         irq = pdev->irq;
3693         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3694
3695 #if defined(__alpha__)
3696         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
3697                 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3698                         "addresses on Alpha systems.\n");
3699                 retval = -EIO;
3700                 goto err_dis;
3701         }
3702 #endif
3703         if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3704                 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3705                         "addresses\n");
3706                 retval = -EIO;
3707                 goto err_dis;
3708         }
3709
3710         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3711                 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3712                                 "it...\n");
3713                 pdev->resource[2].flags &= ~IORESOURCE_IO;
3714         }
3715
3716         retval = pci_request_regions(pdev, "cyclades");
3717         if (retval) {
3718                 dev_err(&pdev->dev, "failed to reserve resources\n");
3719                 goto err_dis;
3720         }
3721
3722         retval = -EIO;
3723         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3724                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3725                 card_name = "Cyclom-Y";
3726
3727                 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3728                                 CyPCI_Yctl);
3729                 if (addr0 == NULL) {
3730                         dev_err(&pdev->dev, "can't remap ctl region\n");
3731                         goto err_reg;
3732                 }
3733                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3734                                 CyPCI_Ywin);
3735                 if (addr2 == NULL) {
3736                         dev_err(&pdev->dev, "can't remap base region\n");
3737                         goto err_unmap;
3738                 }
3739
3740                 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3741                 if (nchan == 0) {
3742                         dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3743                                         "Serial-Modules\n");
3744                         goto err_unmap;
3745                 }
3746         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3747                 struct RUNTIME_9060 __iomem *ctl_addr;
3748
3749                 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3750                                 CyPCI_Zctl);
3751                 if (addr0 == NULL) {
3752                         dev_err(&pdev->dev, "can't remap ctl region\n");
3753                         goto err_reg;
3754                 }
3755
3756                 /* Disable interrupts on the PLX before resetting it */
3757                 cy_writew(&ctl_addr->intr_ctrl_stat,
3758                                 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3759
3760                 plx_init(pdev, irq, addr0);
3761
3762                 mailbox = readl(&ctl_addr->mail_box_0);
3763
3764                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3765                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3766                 if (addr2 == NULL) {
3767                         dev_err(&pdev->dev, "can't remap base region\n");
3768                         goto err_unmap;
3769                 }
3770
3771                 if (mailbox == ZE_V1) {
3772                         card_name = "Cyclades-Ze";
3773                 } else {
3774                         card_name = "Cyclades-8Zo";
3775 #ifdef CY_PCI_DEBUG
3776                         if (mailbox == ZO_V1) {
3777                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3778                                 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3779                                         "id %lx, ver %lx\n", (ulong)(0xff &
3780                                         readl(&((struct CUSTOM_REG *)addr2)->
3781                                                 fpga_id)), (ulong)(0xff &
3782                                         readl(&((struct CUSTOM_REG *)addr2)->
3783                                                 fpga_version)));
3784                                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3785                         } else {
3786                                 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3787                                         "Cyclades-Z board.  FPGA not loaded\n");
3788                         }
3789 #endif
3790                         /* The following clears the firmware id word.  This
3791                            ensures that the driver will not attempt to talk to
3792                            the board until it has been properly initialized.
3793                          */
3794                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3795                                 cy_writel(addr2 + ID_ADDRESS, 0L);
3796                 }
3797
3798                 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3799                 if (retval <= 0)
3800                         goto err_unmap;
3801                 nchan = retval;
3802         }
3803
3804         if ((cy_next_channel + nchan) > NR_PORTS) {
3805                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3806                         "channels are available. Change NR_PORTS in "
3807                         "cyclades.c and recompile kernel.\n");
3808                 goto err_unmap;
3809         }
3810         /* fill the next cy_card structure available */
3811         for (card_no = 0; card_no < NR_CARDS; card_no++) {
3812                 card = &cy_card[card_no];
3813                 if (card->base_addr == NULL)
3814                         break;
3815         }
3816         if (card_no == NR_CARDS) {      /* no more cy_cards available */
3817                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3818                         "more cards can be used. Change NR_CARDS in "
3819                         "cyclades.c and recompile kernel.\n");
3820                 goto err_unmap;
3821         }
3822
3823         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3824                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3825                 /* allocate IRQ */
3826                 retval = request_irq(irq, cyy_interrupt,
3827                                 IRQF_SHARED, "Cyclom-Y", card);
3828                 if (retval) {
3829                         dev_err(&pdev->dev, "could not allocate IRQ\n");
3830                         goto err_unmap;
3831                 }
3832                 card->num_chips = nchan / CyPORTS_PER_CHIP;
3833         } else {
3834                 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3835                 struct ZFW_CTRL __iomem *zfw_ctrl;
3836
3837                 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3838
3839                 card->hw_ver = mailbox;
3840                 card->num_chips = (unsigned int)-1;
3841                 card->board_ctrl = &zfw_ctrl->board_ctrl;
3842 #ifdef CONFIG_CYZ_INTR
3843                 /* allocate IRQ only if board has an IRQ */
3844                 if (irq != 0 && irq != 255) {
3845                         retval = request_irq(irq, cyz_interrupt,
3846                                         IRQF_SHARED, "Cyclades-Z", card);
3847                         if (retval) {
3848                                 dev_err(&pdev->dev, "could not allocate IRQ\n");
3849                                 goto err_unmap;
3850                         }
3851                 }
3852 #endif                          /* CONFIG_CYZ_INTR */
3853         }
3854
3855         /* set cy_card */
3856         card->base_addr = addr2;
3857         card->ctl_addr.p9050 = addr0;
3858         card->irq = irq;
3859         card->bus_index = 1;
3860         card->first_line = cy_next_channel;
3861         card->nports = nchan;
3862         retval = cy_init_card(card);
3863         if (retval)
3864                 goto err_null;
3865
3866         pci_set_drvdata(pdev, card);
3867
3868         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3869                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3870                 /* enable interrupts in the PCI interface */
3871                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3872                 switch (plx_ver) {
3873                 case PLX_9050:
3874                         cy_writeb(addr0 + 0x4c, 0x43);
3875                         break;
3876
3877                 case PLX_9060:
3878                 case PLX_9080:
3879                 default:        /* Old boards, use PLX_9060 */
3880                 {
3881                         struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3882                         plx_init(pdev, irq, ctl_addr);
3883                         cy_writew(&ctl_addr->intr_ctrl_stat,
3884                                 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3885                         break;
3886                 }
3887                 }
3888         }
3889
3890         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3891                 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3892         for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3893                 tty_port_register_device(&card->ports[j].port,
3894                                 cy_serial_driver, i, &pdev->dev);
3895         cy_next_channel += nchan;
3896
3897         return 0;
3898 err_null:
3899         card->base_addr = NULL;
3900         free_irq(irq, card);
3901 err_unmap:
3902         iounmap(addr0);
3903         if (addr2)
3904                 iounmap(addr2);
3905 err_reg:
3906         pci_release_regions(pdev);
3907 err_dis:
3908         pci_disable_device(pdev);
3909 err:
3910         return retval;
3911 }
3912
3913 static void cy_pci_remove(struct pci_dev *pdev)
3914 {
3915         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3916         unsigned int i, channel;
3917
3918         /* non-Z with old PLX */
3919         if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3920                         PLX_9050)
3921                 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3922         else
3923 #ifndef CONFIG_CYZ_INTR
3924                 if (!cy_is_Z(cinfo))
3925 #endif
3926                 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3927                         readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3928                         ~0x0900);
3929
3930         iounmap(cinfo->base_addr);
3931         if (cinfo->ctl_addr.p9050)
3932                 iounmap(cinfo->ctl_addr.p9050);
3933         if (cinfo->irq
3934 #ifndef CONFIG_CYZ_INTR
3935                 && !cy_is_Z(cinfo)
3936 #endif /* CONFIG_CYZ_INTR */
3937                 )
3938                 free_irq(cinfo->irq, cinfo);
3939         pci_release_regions(pdev);
3940
3941         cinfo->base_addr = NULL;
3942         for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3943                         cinfo->nports; i++, channel++) {
3944                 tty_unregister_device(cy_serial_driver, i);
3945                 tty_port_destroy(&cinfo->ports[channel].port);
3946         }
3947         cinfo->nports = 0;
3948         kfree(cinfo->ports);
3949 }
3950
3951 static struct pci_driver cy_pci_driver = {
3952         .name = "cyclades",
3953         .id_table = cy_pci_dev_id,
3954         .probe = cy_pci_probe,
3955         .remove = cy_pci_remove
3956 };
3957 #endif
3958
3959 static int cyclades_proc_show(struct seq_file *m, void *v)
3960 {
3961         struct cyclades_port *info;
3962         unsigned int i, j;
3963         __u32 cur_jifs = jiffies;
3964
3965         seq_puts(m, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
3966                         "IdleIn  Overruns  Ldisc\n");
3967
3968         /* Output one line for each known port */
3969         for (i = 0; i < NR_CARDS; i++)
3970                 for (j = 0; j < cy_card[i].nports; j++) {
3971                         info = &cy_card[i].ports[j];
3972
3973                         if (info->port.count) {
3974                                 /* XXX is the ldisc num worth this? */
3975                                 struct tty_struct *tty;
3976                                 struct tty_ldisc *ld;
3977                                 int num = 0;
3978                                 tty = tty_port_tty_get(&info->port);
3979                                 if (tty) {
3980                                         ld = tty_ldisc_ref(tty);
3981                                         if (ld) {
3982                                                 num = ld->ops->num;
3983                                                 tty_ldisc_deref(ld);
3984                                         }
3985                                         tty_kref_put(tty);
3986                                 }
3987                                 seq_printf(m, "%3d %8lu %10lu %8lu "
3988                                         "%10lu %8lu %9lu %6d\n", info->line,
3989                                         (cur_jifs - info->idle_stats.in_use) /
3990                                         HZ, info->idle_stats.xmit_bytes,
3991                                         (cur_jifs - info->idle_stats.xmit_idle)/
3992                                         HZ, info->idle_stats.recv_bytes,
3993                                         (cur_jifs - info->idle_stats.recv_idle)/
3994                                         HZ, info->idle_stats.overruns,
3995                                         num);
3996                         } else
3997                                 seq_printf(m, "%3d %8lu %10lu %8lu "
3998                                         "%10lu %8lu %9lu %6ld\n",
3999                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4000                 }
4001         return 0;
4002 }
4003
4004 static int cyclades_proc_open(struct inode *inode, struct file *file)
4005 {
4006         return single_open(file, cyclades_proc_show, NULL);
4007 }
4008
4009 static const struct file_operations cyclades_proc_fops = {
4010         .owner          = THIS_MODULE,
4011         .open           = cyclades_proc_open,
4012         .read           = seq_read,
4013         .llseek         = seq_lseek,
4014         .release        = single_release,
4015 };
4016
4017 /* The serial driver boot-time initialization code!
4018     Hardware I/O ports are mapped to character special devices on a
4019     first found, first allocated manner.  That is, this code searches
4020     for Cyclom cards in the system.  As each is found, it is probed
4021     to discover how many chips (and thus how many ports) are present.
4022     These ports are mapped to the tty ports 32 and upward in monotonic
4023     fashion.  If an 8-port card is replaced with a 16-port card, the
4024     port mapping on a following card will shift.
4025
4026     This approach is different from what is used in the other serial
4027     device driver because the Cyclom is more properly a multiplexer,
4028     not just an aggregation of serial ports on one card.
4029
4030     If there are more cards with more ports than have been
4031     statically allocated above, a warning is printed and the
4032     extra ports are ignored.
4033  */
4034
4035 static const struct tty_operations cy_ops = {
4036         .open = cy_open,
4037         .close = cy_close,
4038         .write = cy_write,
4039         .put_char = cy_put_char,
4040         .flush_chars = cy_flush_chars,
4041         .write_room = cy_write_room,
4042         .chars_in_buffer = cy_chars_in_buffer,
4043         .flush_buffer = cy_flush_buffer,
4044         .ioctl = cy_ioctl,
4045         .throttle = cy_throttle,
4046         .unthrottle = cy_unthrottle,
4047         .set_termios = cy_set_termios,
4048         .stop = cy_stop,
4049         .start = cy_start,
4050         .hangup = cy_hangup,
4051         .break_ctl = cy_break,
4052         .wait_until_sent = cy_wait_until_sent,
4053         .tiocmget = cy_tiocmget,
4054         .tiocmset = cy_tiocmset,
4055         .get_icount = cy_get_icount,
4056         .proc_fops = &cyclades_proc_fops,
4057 };
4058
4059 static int __init cy_init(void)
4060 {
4061         unsigned int nboards;
4062         int retval = -ENOMEM;
4063
4064         cy_serial_driver = alloc_tty_driver(NR_PORTS);
4065         if (!cy_serial_driver)
4066                 goto err;
4067
4068         printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4069
4070         /* Initialize the tty_driver structure */
4071
4072         cy_serial_driver->driver_name = "cyclades";
4073         cy_serial_driver->name = "ttyC";
4074         cy_serial_driver->major = CYCLADES_MAJOR;
4075         cy_serial_driver->minor_start = 0;
4076         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4077         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4078         cy_serial_driver->init_termios = tty_std_termios;
4079         cy_serial_driver->init_termios.c_cflag =
4080             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4081         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4082         tty_set_operations(cy_serial_driver, &cy_ops);
4083
4084         retval = tty_register_driver(cy_serial_driver);
4085         if (retval) {
4086                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4087                 goto err_frtty;
4088         }
4089
4090         /* the code below is responsible to find the boards. Each different
4091            type of board has its own detection routine. If a board is found,
4092            the next cy_card structure available is set by the detection
4093            routine. These functions are responsible for checking the
4094            availability of cy_card and cy_port data structures and updating
4095            the cy_next_channel. */
4096
4097         /* look for isa boards */
4098         nboards = cy_detect_isa();
4099
4100 #ifdef CONFIG_PCI
4101         /* look for pci boards */
4102         retval = pci_register_driver(&cy_pci_driver);
4103         if (retval && !nboards) {
4104                 tty_unregister_driver(cy_serial_driver);
4105                 goto err_frtty;
4106         }
4107 #endif
4108
4109         return 0;
4110 err_frtty:
4111         put_tty_driver(cy_serial_driver);
4112 err:
4113         return retval;
4114 }                               /* cy_init */
4115
4116 static void __exit cy_cleanup_module(void)
4117 {
4118         struct cyclades_card *card;
4119         unsigned int i, e1;
4120
4121 #ifndef CONFIG_CYZ_INTR
4122         del_timer_sync(&cyz_timerlist);
4123 #endif /* CONFIG_CYZ_INTR */
4124
4125         e1 = tty_unregister_driver(cy_serial_driver);
4126         if (e1)
4127                 printk(KERN_ERR "failed to unregister Cyclades serial "
4128                                 "driver(%d)\n", e1);
4129
4130 #ifdef CONFIG_PCI
4131         pci_unregister_driver(&cy_pci_driver);
4132 #endif
4133
4134         for (i = 0; i < NR_CARDS; i++) {
4135                 card = &cy_card[i];
4136                 if (card->base_addr) {
4137                         /* clear interrupt */
4138                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4139                         iounmap(card->base_addr);
4140                         if (card->ctl_addr.p9050)
4141                                 iounmap(card->ctl_addr.p9050);
4142                         if (card->irq
4143 #ifndef CONFIG_CYZ_INTR
4144                                 && !cy_is_Z(card)
4145 #endif /* CONFIG_CYZ_INTR */
4146                                 )
4147                                 free_irq(card->irq, card);
4148                         for (e1 = card->first_line; e1 < card->first_line +
4149                                         card->nports; e1++)
4150                                 tty_unregister_device(cy_serial_driver, e1);
4151                         kfree(card->ports);
4152                 }
4153         }
4154
4155         put_tty_driver(cy_serial_driver);
4156 } /* cy_cleanup_module */
4157
4158 module_init(cy_init);
4159 module_exit(cy_cleanup_module);
4160
4161 MODULE_LICENSE("GPL");
4162 MODULE_VERSION(CY_VERSION);
4163 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4164 MODULE_FIRMWARE("cyzfirm.bin");