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