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_hw_array(maddr, long, iomem, NULL, 0);
 160 module_param_hw_array(irq, int, irq, 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_flip_buffer_push(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_flip_buffer_push(&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_flip_buffer_push(&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         card = info->card;
1979         channel = info->line - card->first_line;
1980
1981         if (!cy_is_Z(card)) {
1982                 u32 cflags;
1983
1984                 /* baud rate */
1985                 baud = tty_get_baud_rate(tty);
1986                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
1987                                 ASYNC_SPD_CUST) {
1988                         if (info->custom_divisor)
1989                                 baud_rate = info->baud / info->custom_divisor;
1990                         else
1991                                 baud_rate = info->baud;
1992                 } else if (baud > CD1400_MAX_SPEED) {
1993                         baud = CD1400_MAX_SPEED;
1994                 }
1995                 /* find the baud index */
1996                 for (i = 0; i < 20; i++) {
1997                         if (baud == baud_table[i])
1998                                 break;
1999                 }
2000                 if (i == 20)
2001                         i = 19; /* CD1400_MAX_SPEED */
2002
2003                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2004                                 ASYNC_SPD_CUST) {
2005                         cyy_baud_calc(info, baud_rate);
2006                 } else {
2007                         if (info->chip_rev >= CD1400_REV_J) {
2008                                 /* It is a CD1400 rev. J or later */
2009                                 info->tbpr = baud_bpr_60[i];    /* Tx BPR */
2010                                 info->tco = baud_co_60[i];      /* Tx CO */
2011                                 info->rbpr = baud_bpr_60[i];    /* Rx BPR */
2012                                 info->rco = baud_co_60[i];      /* Rx CO */
2013                         } else {
2014                                 info->tbpr = baud_bpr_25[i];    /* Tx BPR */
2015                                 info->tco = baud_co_25[i];      /* Tx CO */
2016                                 info->rbpr = baud_bpr_25[i];    /* Rx BPR */
2017                                 info->rco = baud_co_25[i];      /* Rx CO */
2018                         }
2019                 }
2020                 if (baud_table[i] == 134) {
2021                         /* get it right for 134.5 baud */
2022                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2023                                         2;
2024                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2025                                 ASYNC_SPD_CUST) {
2026                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2027                                         baud_rate) + 2;
2028                 } else if (baud_table[i]) {
2029                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2030                                         baud_table[i]) + 2;
2031                         /* this needs to be propagated into the card info */
2032                 } else {
2033                         info->timeout = 0;
2034                 }
2035                 /* By tradition (is it a standard?) a baud rate of zero
2036                    implies the line should be/has been closed.  A bit
2037                    later in this routine such a test is performed. */
2038
2039                 /* byte size and parity */
2040                 info->cor5 = 0;
2041                 info->cor4 = 0;
2042                 /* receive threshold */
2043                 info->cor3 = (info->default_threshold ?
2044                                 info->default_threshold : baud_cor3[i]);
2045                 info->cor2 = CyETC;
2046                 switch (cflag & CSIZE) {
2047                 case CS5:
2048                         info->cor1 = Cy_5_BITS;
2049                         break;
2050                 case CS6:
2051                         info->cor1 = Cy_6_BITS;
2052                         break;
2053                 case CS7:
2054                         info->cor1 = Cy_7_BITS;
2055                         break;
2056                 case CS8:
2057                         info->cor1 = Cy_8_BITS;
2058                         break;
2059                 }
2060                 if (cflag & CSTOPB)
2061                         info->cor1 |= Cy_2_STOP;
2062
2063                 if (cflag & PARENB) {
2064                         if (cflag & PARODD)
2065                                 info->cor1 |= CyPARITY_O;
2066                         else
2067                                 info->cor1 |= CyPARITY_E;
2068                 } else
2069                         info->cor1 |= CyPARITY_NONE;
2070
2071                 /* CTS flow control flag */
2072                 tty_port_set_cts_flow(&info->port, cflag & CRTSCTS);
2073                 if (cflag & CRTSCTS)
2074                         info->cor2 |= CyCtsAE;
2075                 else
2076                         info->cor2 &= ~CyCtsAE;
2077                 tty_port_set_check_carrier(&info->port, ~cflag & CLOCAL);
2078
2079          /***********************************************
2080             The hardware option, CyRtsAO, presents RTS when
2081             the chip has characters to send.  Since most modems
2082             use RTS as reverse (inbound) flow control, this
2083             option is not used.  If inbound flow control is
2084             necessary, DTR can be programmed to provide the
2085             appropriate signals for use with a non-standard
2086             cable.  Contact Marcio Saito for details.
2087          ***********************************************/
2088
2089                 channel &= 0x03;
2090
2091                 spin_lock_irqsave(&card->card_lock, flags);
2092                 cyy_writeb(info, CyCAR, channel);
2093
2094                 /* tx and rx baud rate */
2095
2096                 cyy_writeb(info, CyTCOR, info->tco);
2097                 cyy_writeb(info, CyTBPR, info->tbpr);
2098                 cyy_writeb(info, CyRCOR, info->rco);
2099                 cyy_writeb(info, CyRBPR, info->rbpr);
2100
2101                 /* set line characteristics  according configuration */
2102
2103                 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2104                 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2105                 cyy_writeb(info, CyCOR1, info->cor1);
2106                 cyy_writeb(info, CyCOR2, info->cor2);
2107                 cyy_writeb(info, CyCOR3, info->cor3);
2108                 cyy_writeb(info, CyCOR4, info->cor4);
2109                 cyy_writeb(info, CyCOR5, info->cor5);
2110
2111                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2112                                 CyCOR3ch);
2113
2114                 /* !!! Is this needed? */
2115                 cyy_writeb(info, CyCAR, channel);
2116                 cyy_writeb(info, CyRTPR,
2117                         (info->default_timeout ? info->default_timeout : 0x02));
2118                 /* 10ms rx timeout */
2119
2120                 cflags = CyCTS;
2121                 if (!C_CLOCAL(tty))
2122                         cflags |= CyDSR | CyRI | CyDCD;
2123                 /* without modem intr */
2124                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2125                 /* act on 1->0 modem transitions */
2126                 if ((cflag & CRTSCTS) && info->rflow)
2127                         cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2128                 else
2129                         cyy_writeb(info, CyMCOR1, cflags);
2130                 /* act on 0->1 modem transitions */
2131                 cyy_writeb(info, CyMCOR2, cflags);
2132
2133                 if (i == 0)     /* baud rate is zero, turn off line */
2134                         cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2135                 else
2136                         cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2137
2138                 clear_bit(TTY_IO_ERROR, &tty->flags);
2139                 spin_unlock_irqrestore(&card->card_lock, flags);
2140
2141         } else {
2142                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2143                 __u32 sw_flow;
2144                 int retval;
2145
2146                 if (!cyz_is_loaded(card))
2147                         return;
2148
2149                 /* baud rate */
2150                 baud = tty_get_baud_rate(tty);
2151                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2152                                 ASYNC_SPD_CUST) {
2153                         if (info->custom_divisor)
2154                                 baud_rate = info->baud / info->custom_divisor;
2155                         else
2156                                 baud_rate = info->baud;
2157                 } else if (baud > CYZ_MAX_SPEED) {
2158                         baud = CYZ_MAX_SPEED;
2159                 }
2160                 cy_writel(&ch_ctrl->comm_baud, baud);
2161
2162                 if (baud == 134) {
2163                         /* get it right for 134.5 baud */
2164                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2165                                         2;
2166                 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2167                                 ASYNC_SPD_CUST) {
2168                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2169                                         baud_rate) + 2;
2170                 } else if (baud) {
2171                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
2172                                         baud) + 2;
2173                         /* this needs to be propagated into the card info */
2174                 } else {
2175                         info->timeout = 0;
2176                 }
2177
2178                 /* byte size and parity */
2179                 switch (cflag & CSIZE) {
2180                 case CS5:
2181                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2182                         break;
2183                 case CS6:
2184                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2185                         break;
2186                 case CS7:
2187                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2188                         break;
2189                 case CS8:
2190                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2191                         break;
2192                 }
2193                 if (cflag & CSTOPB) {
2194                         cy_writel(&ch_ctrl->comm_data_l,
2195                                   readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2196                 } else {
2197                         cy_writel(&ch_ctrl->comm_data_l,
2198                                   readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2199                 }
2200                 if (cflag & PARENB) {
2201                         if (cflag & PARODD)
2202                                 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2203                         else
2204                                 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2205                 } else
2206                         cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2207
2208                 /* CTS flow control flag */
2209                 if (cflag & CRTSCTS) {
2210                         cy_writel(&ch_ctrl->hw_flow,
2211                                 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2212                 } else {
2213                         cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2214                                         ~(C_RS_CTS | C_RS_RTS));
2215                 }
2216                 /* As the HW flow control is done in firmware, the driver
2217                    doesn't need to care about it */
2218                 tty_port_set_cts_flow(&info->port, 0);
2219
2220                 /* XON/XOFF/XANY flow control flags */
2221                 sw_flow = 0;
2222                 if (iflag & IXON) {
2223                         sw_flow |= C_FL_OXX;
2224                         if (iflag & IXANY)
2225                                 sw_flow |= C_FL_OIXANY;
2226                 }
2227                 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2228
2229                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2230                 if (retval != 0) {
2231                         printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2232                                 "was %x\n", info->line, retval);
2233                 }
2234
2235                 /* CD sensitivity */
2236                 tty_port_set_check_carrier(&info->port, ~cflag & CLOCAL);
2237
2238                 if (baud == 0) {        /* baud rate is zero, turn off line */
2239                         cy_writel(&ch_ctrl->rs_control,
2240                                   readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2241 #ifdef CY_DEBUG_DTR
2242                         printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2243 #endif
2244                 } else {
2245                         cy_writel(&ch_ctrl->rs_control,
2246                                   readl(&ch_ctrl->rs_control) | C_RS_DTR);
2247 #ifdef CY_DEBUG_DTR
2248                         printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2249 #endif
2250                 }
2251
2252                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2253                 if (retval != 0) {
2254                         printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2255                                 "was %x\n", info->line, retval);
2256                 }
2257
2258                 clear_bit(TTY_IO_ERROR, &tty->flags);
2259         }
2260 }                               /* set_line_char */
2261
2262 static int cy_get_serial_info(struct cyclades_port *info,
2263                 struct serial_struct __user *retinfo)
2264 {
2265         struct cyclades_card *cinfo = info->card;
2266         struct serial_struct tmp = {
2267                 .type = info->type,
2268                 .line = info->line,
2269                 .port = (info->card - cy_card) * 0x100 + info->line -
2270                         cinfo->first_line,
2271                 .irq = cinfo->irq,
2272                 .flags = info->port.flags,
2273                 .close_delay = info->port.close_delay,
2274                 .closing_wait = info->port.closing_wait,
2275                 .baud_base = info->baud,
2276                 .custom_divisor = info->custom_divisor,
2277         };
2278         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2279 }
2280
2281 static int
2282 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2283                 struct serial_struct __user *new_info)
2284 {
2285         struct serial_struct new_serial;
2286         int old_flags;
2287         int ret;
2288
2289         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2290                 return -EFAULT;
2291
2292         mutex_lock(&info->port.mutex);
2293
2294         old_flags = info->port.flags;
2295
2296         if (!capable(CAP_SYS_ADMIN)) {
2297                 if (new_serial.close_delay != info->port.close_delay ||
2298                                 new_serial.baud_base != info->baud ||
2299                                 (new_serial.flags & ASYNC_FLAGS &
2300                                         ~ASYNC_USR_MASK) !=
2301                                 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2302                 {
2303                         mutex_unlock(&info->port.mutex);
2304                         return -EPERM;
2305                 }
2306                 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2307                                 (new_serial.flags & ASYNC_USR_MASK);
2308                 info->baud = new_serial.baud_base;
2309                 info->custom_divisor = new_serial.custom_divisor;
2310                 goto check_and_exit;
2311         }
2312
2313         /*
2314          * OK, past this point, all the error checking has been done.
2315          * At this point, we start making changes.....
2316          */
2317
2318         info->baud = new_serial.baud_base;
2319         info->custom_divisor = new_serial.custom_divisor;
2320         info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2321                         (new_serial.flags & ASYNC_FLAGS);
2322         info->port.close_delay = new_serial.close_delay * HZ / 100;
2323         info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2324
2325 check_and_exit:
2326         if (tty_port_initialized(&info->port)) {
2327                 if ((new_serial.flags ^ old_flags) & ASYNC_SPD_MASK) {
2328                         /* warn about deprecation unless clearing */
2329                         if (new_serial.flags & ASYNC_SPD_MASK)
2330                                 dev_warn_ratelimited(tty->dev, "use of SPD flags is deprecated\n");
2331                 }
2332                 cy_set_line_char(info, tty);
2333                 ret = 0;
2334         } else {
2335                 ret = cy_startup(info, tty);
2336         }
2337         mutex_unlock(&info->port.mutex);
2338         return ret;
2339 }                               /* set_serial_info */
2340
2341 /*
2342  * get_lsr_info - get line status register info
2343  *
2344  * Purpose: Let user call ioctl() to get info when the UART physically
2345  *          is emptied.  On bus types like RS485, the transmitter must
2346  *          release the bus after transmitting. This must be done when
2347  *          the transmit shift register is empty, not be done when the
2348  *          transmit holding register is empty.  This functionality
2349  *          allows an RS485 driver to be written in user space.
2350  */
2351 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2352 {
2353         struct cyclades_card *card = info->card;
2354         unsigned int result;
2355         unsigned long flags;
2356         u8 status;
2357
2358         if (!cy_is_Z(card)) {
2359                 spin_lock_irqsave(&card->card_lock, flags);
2360                 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2361                 spin_unlock_irqrestore(&card->card_lock, flags);
2362                 result = (status ? 0 : TIOCSER_TEMT);
2363         } else {
2364                 /* Not supported yet */
2365                 return -EINVAL;
2366         }
2367         return put_user(result, value);
2368 }
2369
2370 static int cy_tiocmget(struct tty_struct *tty)
2371 {
2372         struct cyclades_port *info = tty->driver_data;
2373         struct cyclades_card *card;
2374         int result;
2375
2376         if (serial_paranoia_check(info, tty->name, __func__))
2377                 return -ENODEV;
2378
2379         card = info->card;
2380
2381         if (!cy_is_Z(card)) {
2382                 unsigned long flags;
2383                 int channel = info->line - card->first_line;
2384                 u8 status;
2385
2386                 spin_lock_irqsave(&card->card_lock, flags);
2387                 cyy_writeb(info, CyCAR, channel & 0x03);
2388                 status = cyy_readb(info, CyMSVR1);
2389                 status |= cyy_readb(info, CyMSVR2);
2390                 spin_unlock_irqrestore(&card->card_lock, flags);
2391
2392                 if (info->rtsdtr_inv) {
2393                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2394                                 ((status & CyDTR) ? TIOCM_RTS : 0);
2395                 } else {
2396                         result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2397                                 ((status & CyDTR) ? TIOCM_DTR : 0);
2398                 }
2399                 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2400                         ((status & CyRI) ? TIOCM_RNG : 0) |
2401                         ((status & CyDSR) ? TIOCM_DSR : 0) |
2402                         ((status & CyCTS) ? TIOCM_CTS : 0);
2403         } else {
2404                 u32 lstatus;
2405
2406                 if (!cyz_is_loaded(card)) {
2407                         result = -ENODEV;
2408                         goto end;
2409                 }
2410
2411                 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2412                 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2413                         ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2414                         ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2415                         ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2416                         ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2417                         ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2418         }
2419 end:
2420         return result;
2421 }                               /* cy_tiomget */
2422
2423 static int
2424 cy_tiocmset(struct tty_struct *tty,
2425                 unsigned int set, unsigned int clear)
2426 {
2427         struct cyclades_port *info = tty->driver_data;
2428         struct cyclades_card *card;
2429         unsigned long flags;
2430
2431         if (serial_paranoia_check(info, tty->name, __func__))
2432                 return -ENODEV;
2433
2434         card = info->card;
2435         if (!cy_is_Z(card)) {
2436                 spin_lock_irqsave(&card->card_lock, flags);
2437                 cyy_change_rts_dtr(info, set, clear);
2438                 spin_unlock_irqrestore(&card->card_lock, flags);
2439         } else {
2440                 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2441                 int retval, channel = info->line - card->first_line;
2442                 u32 rs;
2443
2444                 if (!cyz_is_loaded(card))
2445                         return -ENODEV;
2446
2447                 spin_lock_irqsave(&card->card_lock, flags);
2448                 rs = readl(&ch_ctrl->rs_control);
2449                 if (set & TIOCM_RTS)
2450                         rs |= C_RS_RTS;
2451                 if (clear & TIOCM_RTS)
2452                         rs &= ~C_RS_RTS;
2453                 if (set & TIOCM_DTR) {
2454                         rs |= C_RS_DTR;
2455 #ifdef CY_DEBUG_DTR
2456                         printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2457 #endif
2458                 }
2459                 if (clear & TIOCM_DTR) {
2460                         rs &= ~C_RS_DTR;
2461 #ifdef CY_DEBUG_DTR
2462                         printk(KERN_DEBUG "cyc:set_modem_info clearing "
2463                                 "Z DTR\n");
2464 #endif
2465                 }
2466                 cy_writel(&ch_ctrl->rs_control, rs);
2467                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2468                 spin_unlock_irqrestore(&card->card_lock, flags);
2469                 if (retval != 0) {
2470                         printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2471                                 "was %x\n", info->line, retval);
2472                 }
2473         }
2474         return 0;
2475 }
2476
2477 /*
2478  * cy_break() --- routine which turns the break handling on or off
2479  */
2480 static int cy_break(struct tty_struct *tty, int break_state)
2481 {
2482         struct cyclades_port *info = tty->driver_data;
2483         struct cyclades_card *card;
2484         unsigned long flags;
2485         int retval = 0;
2486
2487         if (serial_paranoia_check(info, tty->name, "cy_break"))
2488                 return -EINVAL;
2489
2490         card = info->card;
2491
2492         spin_lock_irqsave(&card->card_lock, flags);
2493         if (!cy_is_Z(card)) {
2494                 /* Let the transmit ISR take care of this (since it
2495                    requires stuffing characters into the output stream).
2496                  */
2497                 if (break_state == -1) {
2498                         if (!info->breakon) {
2499                                 info->breakon = 1;
2500                                 if (!info->xmit_cnt) {
2501                                         spin_unlock_irqrestore(&card->card_lock, flags);
2502                                         start_xmit(info);
2503                                         spin_lock_irqsave(&card->card_lock, flags);
2504                                 }
2505                         }
2506                 } else {
2507                         if (!info->breakoff) {
2508                                 info->breakoff = 1;
2509                                 if (!info->xmit_cnt) {
2510                                         spin_unlock_irqrestore(&card->card_lock, flags);
2511                                         start_xmit(info);
2512                                         spin_lock_irqsave(&card->card_lock, flags);
2513                                 }
2514                         }
2515                 }
2516         } else {
2517                 if (break_state == -1) {
2518                         retval = cyz_issue_cmd(card,
2519                                 info->line - card->first_line,
2520                                 C_CM_SET_BREAK, 0L);
2521                         if (retval != 0) {
2522                                 printk(KERN_ERR "cyc:cy_break (set) retval on "
2523                                         "ttyC%d was %x\n", info->line, retval);
2524                         }
2525                 } else {
2526                         retval = cyz_issue_cmd(card,
2527                                 info->line - card->first_line,
2528                                 C_CM_CLR_BREAK, 0L);
2529                         if (retval != 0) {
2530                                 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2531                                         "on ttyC%d was %x\n", info->line,
2532                                         retval);
2533                         }
2534                 }
2535         }
2536         spin_unlock_irqrestore(&card->card_lock, flags);
2537         return retval;
2538 }                               /* cy_break */
2539
2540 static int set_threshold(struct cyclades_port *info, unsigned long value)
2541 {
2542         struct cyclades_card *card = info->card;
2543         unsigned long flags;
2544
2545         if (!cy_is_Z(card)) {
2546                 info->cor3 &= ~CyREC_FIFO;
2547                 info->cor3 |= value & CyREC_FIFO;
2548
2549                 spin_lock_irqsave(&card->card_lock, flags);
2550                 cyy_writeb(info, CyCOR3, info->cor3);
2551                 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2552                 spin_unlock_irqrestore(&card->card_lock, flags);
2553         }
2554         return 0;
2555 }                               /* set_threshold */
2556
2557 static int get_threshold(struct cyclades_port *info,
2558                                                 unsigned long __user *value)
2559 {
2560         struct cyclades_card *card = info->card;
2561
2562         if (!cy_is_Z(card)) {
2563                 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2564                 return put_user(tmp, value);
2565         }
2566         return 0;
2567 }                               /* get_threshold */
2568
2569 static int set_timeout(struct cyclades_port *info, unsigned long value)
2570 {
2571         struct cyclades_card *card = info->card;
2572         unsigned long flags;
2573
2574         if (!cy_is_Z(card)) {
2575                 spin_lock_irqsave(&card->card_lock, flags);
2576                 cyy_writeb(info, CyRTPR, value & 0xff);
2577                 spin_unlock_irqrestore(&card->card_lock, flags);
2578         }
2579         return 0;
2580 }                               /* set_timeout */
2581
2582 static int get_timeout(struct cyclades_port *info,
2583                                                 unsigned long __user *value)
2584 {
2585         struct cyclades_card *card = info->card;
2586
2587         if (!cy_is_Z(card)) {
2588                 u8 tmp = cyy_readb(info, CyRTPR);
2589                 return put_user(tmp, value);
2590         }
2591         return 0;
2592 }                               /* get_timeout */
2593
2594 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2595                 struct cyclades_icount *cprev)
2596 {
2597         struct cyclades_icount cnow;
2598         unsigned long flags;
2599         int ret;
2600
2601         spin_lock_irqsave(&info->card->card_lock, flags);
2602         cnow = info->icount;    /* atomic copy */
2603         spin_unlock_irqrestore(&info->card->card_lock, flags);
2604
2605         ret =   ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2606                 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2607                 ((arg & TIOCM_CD)  && (cnow.dcd != cprev->dcd)) ||
2608                 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2609
2610         *cprev = cnow;
2611
2612         return ret;
2613 }
2614
2615 /*
2616  * This routine allows the tty driver to implement device-
2617  * specific ioctl's.  If the ioctl number passed in cmd is
2618  * not recognized by the driver, it should return ENOIOCTLCMD.
2619  */
2620 static int
2621 cy_ioctl(struct tty_struct *tty,
2622          unsigned int cmd, unsigned long arg)
2623 {
2624         struct cyclades_port *info = tty->driver_data;
2625         struct cyclades_icount cnow;    /* kernel counter temps */
2626         int ret_val = 0;
2627         unsigned long flags;
2628         void __user *argp = (void __user *)arg;
2629
2630         if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2631                 return -ENODEV;
2632
2633 #ifdef CY_DEBUG_OTHER
2634         printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2635                 info->line, cmd, arg);
2636 #endif
2637
2638         switch (cmd) {
2639         case CYGETMON:
2640                 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2641                         ret_val = -EFAULT;
2642                         break;
2643                 }
2644                 memset(&info->mon, 0, sizeof(info->mon));
2645                 break;
2646         case CYGETTHRESH:
2647                 ret_val = get_threshold(info, argp);
2648                 break;
2649         case CYSETTHRESH:
2650                 ret_val = set_threshold(info, arg);
2651                 break;
2652         case CYGETDEFTHRESH:
2653                 ret_val = put_user(info->default_threshold,
2654                                 (unsigned long __user *)argp);
2655                 break;
2656         case CYSETDEFTHRESH:
2657                 info->default_threshold = arg & 0x0f;
2658                 break;
2659         case CYGETTIMEOUT:
2660                 ret_val = get_timeout(info, argp);
2661                 break;
2662         case CYSETTIMEOUT:
2663                 ret_val = set_timeout(info, arg);
2664                 break;
2665         case CYGETDEFTIMEOUT:
2666                 ret_val = put_user(info->default_timeout,
2667                                 (unsigned long __user *)argp);
2668                 break;
2669         case CYSETDEFTIMEOUT:
2670                 info->default_timeout = arg & 0xff;
2671                 break;
2672         case CYSETRFLOW:
2673                 info->rflow = (int)arg;
2674                 break;
2675         case CYGETRFLOW:
2676                 ret_val = info->rflow;
2677                 break;
2678         case CYSETRTSDTR_INV:
2679                 info->rtsdtr_inv = (int)arg;
2680                 break;
2681         case CYGETRTSDTR_INV:
2682                 ret_val = info->rtsdtr_inv;
2683                 break;
2684         case CYGETCD1400VER:
2685                 ret_val = info->chip_rev;
2686                 break;
2687 #ifndef CONFIG_CYZ_INTR
2688         case CYZSETPOLLCYCLE:
2689                 if (arg > LONG_MAX / HZ)
2690                         return -ENODEV;
2691                 cyz_polling_cycle = (arg * HZ) / 1000;
2692                 break;
2693         case CYZGETPOLLCYCLE:
2694                 ret_val = (cyz_polling_cycle * 1000) / HZ;
2695                 break;
2696 #endif                          /* CONFIG_CYZ_INTR */
2697         case CYSETWAIT:
2698                 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2699                 break;
2700         case CYGETWAIT:
2701                 ret_val = info->port.closing_wait / (HZ / 100);
2702                 break;
2703         case TIOCGSERIAL:
2704                 ret_val = cy_get_serial_info(info, argp);
2705                 break;
2706         case TIOCSSERIAL:
2707                 ret_val = cy_set_serial_info(info, tty, argp);
2708                 break;
2709         case TIOCSERGETLSR:     /* Get line status register */
2710                 ret_val = get_lsr_info(info, argp);
2711                 break;
2712                 /*
2713                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2714                  * - mask passed in arg for lines of interest
2715                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2716                  * Caller should use TIOCGICOUNT to see which one it was
2717                  */
2718         case TIOCMIWAIT:
2719                 spin_lock_irqsave(&info->card->card_lock, flags);
2720                 /* note the counters on entry */
2721                 cnow = info->icount;
2722                 spin_unlock_irqrestore(&info->card->card_lock, flags);
2723                 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2724                                 cy_cflags_changed(info, arg, &cnow));
2725                 break;
2726
2727                 /*
2728                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2729                  * Return: write counters to the user passed counter struct
2730                  * NB: both 1->0 and 0->1 transitions are counted except for
2731                  *     RI where only 0->1 is counted.
2732                  */
2733         default:
2734                 ret_val = -ENOIOCTLCMD;
2735         }
2736
2737 #ifdef CY_DEBUG_OTHER
2738         printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2739 #endif
2740         return ret_val;
2741 }                               /* cy_ioctl */
2742
2743 static int cy_get_icount(struct tty_struct *tty,
2744                                 struct serial_icounter_struct *sic)
2745 {
2746         struct cyclades_port *info = tty->driver_data;
2747         struct cyclades_icount cnow;    /* Used to snapshot */
2748         unsigned long flags;
2749
2750         spin_lock_irqsave(&info->card->card_lock, flags);
2751         cnow = info->icount;
2752         spin_unlock_irqrestore(&info->card->card_lock, flags);
2753
2754         sic->cts = cnow.cts;
2755         sic->dsr = cnow.dsr;
2756         sic->rng = cnow.rng;
2757         sic->dcd = cnow.dcd;
2758         sic->rx = cnow.rx;
2759         sic->tx = cnow.tx;
2760         sic->frame = cnow.frame;
2761         sic->overrun = cnow.overrun;
2762         sic->parity = cnow.parity;
2763         sic->brk = cnow.brk;
2764         sic->buf_overrun = cnow.buf_overrun;
2765         return 0;
2766 }
2767
2768 /*
2769  * This routine allows the tty driver to be notified when
2770  * device's termios settings have changed.  Note that a
2771  * well-designed tty driver should be prepared to accept the case
2772  * where old == NULL, and try to do something rational.
2773  */
2774 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2775 {
2776         struct cyclades_port *info = tty->driver_data;
2777
2778 #ifdef CY_DEBUG_OTHER
2779         printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2780 #endif
2781
2782         cy_set_line_char(info, tty);
2783
2784         if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
2785                 tty->hw_stopped = 0;
2786                 cy_start(tty);
2787         }
2788 #if 0
2789         /*
2790          * No need to wake up processes in open wait, since they
2791          * sample the CLOCAL flag once, and don't recheck it.
2792          * XXX  It's not clear whether the current behavior is correct
2793          * or not.  Hence, this may change.....
2794          */
2795         if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
2796                 wake_up_interruptible(&info->port.open_wait);
2797 #endif
2798 }                               /* cy_set_termios */
2799
2800 /* This function is used to send a high-priority XON/XOFF character to
2801    the device.
2802 */
2803 static void cy_send_xchar(struct tty_struct *tty, char ch)
2804 {
2805         struct cyclades_port *info = tty->driver_data;
2806         struct cyclades_card *card;
2807         int channel;
2808
2809         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2810                 return;
2811
2812         info->x_char = ch;
2813
2814         if (ch)
2815                 cy_start(tty);
2816
2817         card = info->card;
2818         channel = info->line - card->first_line;
2819
2820         if (cy_is_Z(card)) {
2821                 if (ch == STOP_CHAR(tty))
2822                         cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2823                 else if (ch == START_CHAR(tty))
2824                         cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2825         }
2826 }
2827
2828 /* This routine is called by the upper-layer tty layer to signal
2829    that incoming characters should be throttled because the input
2830    buffers are close to full.
2831  */
2832 static void cy_throttle(struct tty_struct *tty)
2833 {
2834         struct cyclades_port *info = tty->driver_data;
2835         struct cyclades_card *card;
2836         unsigned long flags;
2837
2838 #ifdef CY_DEBUG_THROTTLE
2839         printk(KERN_DEBUG "cyc:throttle %s ...ttyC%d\n", tty_name(tty),
2840                          info->line);
2841 #endif
2842
2843         if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2844                 return;
2845
2846         card = info->card;
2847
2848         if (I_IXOFF(tty)) {
2849                 if (!cy_is_Z(card))
2850                         cy_send_xchar(tty, STOP_CHAR(tty));
2851                 else
2852                         info->throttle = 1;
2853         }
2854
2855         if (C_CRTSCTS(tty)) {
2856                 if (!cy_is_Z(card)) {
2857                         spin_lock_irqsave(&card->card_lock, flags);
2858                         cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2859                         spin_unlock_irqrestore(&card->card_lock, flags);
2860                 } else {
2861                         info->throttle = 1;
2862                 }
2863         }
2864 }                               /* cy_throttle */
2865
2866 /*
2867  * This routine notifies the tty driver that it should signal
2868  * that characters can now be sent to the tty without fear of
2869  * overrunning the input buffers of the line disciplines.
2870  */
2871 static void cy_unthrottle(struct tty_struct *tty)
2872 {
2873         struct cyclades_port *info = tty->driver_data;
2874         struct cyclades_card *card;
2875         unsigned long flags;
2876
2877 #ifdef CY_DEBUG_THROTTLE
2878         printk(KERN_DEBUG "cyc:unthrottle %s ...ttyC%d\n",
2879                 tty_name(tty), info->line);
2880 #endif
2881
2882         if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2883                 return;
2884
2885         if (I_IXOFF(tty)) {
2886                 if (info->x_char)
2887                         info->x_char = 0;
2888                 else
2889                         cy_send_xchar(tty, START_CHAR(tty));
2890         }
2891
2892         if (C_CRTSCTS(tty)) {
2893                 card = info->card;
2894                 if (!cy_is_Z(card)) {
2895                         spin_lock_irqsave(&card->card_lock, flags);
2896                         cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2897                         spin_unlock_irqrestore(&card->card_lock, flags);
2898                 } else {
2899                         info->throttle = 0;
2900                 }
2901         }
2902 }                               /* cy_unthrottle */
2903
2904 /* cy_start and cy_stop provide software output flow control as a
2905    function of XON/XOFF, software CTS, and other such stuff.
2906 */
2907 static void cy_stop(struct tty_struct *tty)
2908 {
2909         struct cyclades_card *cinfo;
2910         struct cyclades_port *info = tty->driver_data;
2911         int channel;
2912         unsigned long flags;
2913
2914 #ifdef CY_DEBUG_OTHER
2915         printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2916 #endif
2917
2918         if (serial_paranoia_check(info, tty->name, "cy_stop"))
2919                 return;
2920
2921         cinfo = info->card;
2922         channel = info->line - cinfo->first_line;
2923         if (!cy_is_Z(cinfo)) {
2924                 spin_lock_irqsave(&cinfo->card_lock, flags);
2925                 cyy_writeb(info, CyCAR, channel & 0x03);
2926                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2927                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2928         }
2929 }                               /* cy_stop */
2930
2931 static void cy_start(struct tty_struct *tty)
2932 {
2933         struct cyclades_card *cinfo;
2934         struct cyclades_port *info = tty->driver_data;
2935         int channel;
2936         unsigned long flags;
2937
2938 #ifdef CY_DEBUG_OTHER
2939         printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
2940 #endif
2941
2942         if (serial_paranoia_check(info, tty->name, "cy_start"))
2943                 return;
2944
2945         cinfo = info->card;
2946         channel = info->line - cinfo->first_line;
2947         if (!cy_is_Z(cinfo)) {
2948                 spin_lock_irqsave(&cinfo->card_lock, flags);
2949                 cyy_writeb(info, CyCAR, channel & 0x03);
2950                 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
2951                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2952         }
2953 }                               /* cy_start */
2954
2955 /*
2956  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
2957  */
2958 static void cy_hangup(struct tty_struct *tty)
2959 {
2960         struct cyclades_port *info = tty->driver_data;
2961
2962 #ifdef CY_DEBUG_OTHER
2963         printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
2964 #endif
2965
2966         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
2967                 return;
2968
2969         cy_flush_buffer(tty);
2970         cy_shutdown(info, tty);
2971         tty_port_hangup(&info->port);
2972 }                               /* cy_hangup */
2973
2974 static int cyy_carrier_raised(struct tty_port *port)
2975 {
2976         struct cyclades_port *info = container_of(port, struct cyclades_port,
2977                         port);
2978         struct cyclades_card *cinfo = info->card;
2979         unsigned long flags;
2980         int channel = info->line - cinfo->first_line;
2981         u32 cd;
2982
2983         spin_lock_irqsave(&cinfo->card_lock, flags);
2984         cyy_writeb(info, CyCAR, channel & 0x03);
2985         cd = cyy_readb(info, CyMSVR1) & CyDCD;
2986         spin_unlock_irqrestore(&cinfo->card_lock, flags);
2987
2988         return cd;
2989 }
2990
2991 static void cyy_dtr_rts(struct tty_port *port, int raise)
2992 {
2993         struct cyclades_port *info = container_of(port, struct cyclades_port,
2994                         port);
2995         struct cyclades_card *cinfo = info->card;
2996         unsigned long flags;
2997
2998         spin_lock_irqsave(&cinfo->card_lock, flags);
2999         cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3000                         raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3001         spin_unlock_irqrestore(&cinfo->card_lock, flags);
3002 }
3003
3004 static int cyz_carrier_raised(struct tty_port *port)
3005 {
3006         struct cyclades_port *info = container_of(port, struct cyclades_port,
3007                         port);
3008
3009         return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3010 }
3011
3012 static void cyz_dtr_rts(struct tty_port *port, int raise)
3013 {
3014         struct cyclades_port *info = container_of(port, struct cyclades_port,
3015                         port);
3016         struct cyclades_card *cinfo = info->card;
3017         struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3018         int ret, channel = info->line - cinfo->first_line;
3019         u32 rs;
3020
3021         rs = readl(&ch_ctrl->rs_control);
3022         if (raise)
3023                 rs |= C_RS_RTS | C_RS_DTR;
3024         else
3025                 rs &= ~(C_RS_RTS | C_RS_DTR);
3026         cy_writel(&ch_ctrl->rs_control, rs);
3027         ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3028         if (ret != 0)
3029                 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3030                                 __func__, info->line, ret);
3031 #ifdef CY_DEBUG_DTR
3032         printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3033 #endif
3034 }
3035
3036 static const struct tty_port_operations cyy_port_ops = {
3037         .carrier_raised = cyy_carrier_raised,
3038         .dtr_rts = cyy_dtr_rts,
3039         .shutdown = cy_do_close,
3040 };
3041
3042 static const struct tty_port_operations cyz_port_ops = {
3043         .carrier_raised = cyz_carrier_raised,
3044         .dtr_rts = cyz_dtr_rts,
3045         .shutdown = cy_do_close,
3046 };
3047
3048 /*
3049  * ---------------------------------------------------------------------
3050  * cy_init() and friends
3051  *
3052  * cy_init() is called at boot-time to initialize the serial driver.
3053  * ---------------------------------------------------------------------
3054  */
3055
3056 static int cy_init_card(struct cyclades_card *cinfo)
3057 {
3058         struct cyclades_port *info;
3059         unsigned int channel, port;
3060
3061         spin_lock_init(&cinfo->card_lock);
3062         cinfo->intr_enabled = 0;
3063
3064         cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3065                         GFP_KERNEL);
3066         if (cinfo->ports == NULL) {
3067                 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3068                 return -ENOMEM;
3069         }
3070
3071         for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3072                         channel++, port++) {
3073                 info = &cinfo->ports[channel];
3074                 tty_port_init(&info->port);
3075                 info->magic = CYCLADES_MAGIC;
3076                 info->card = cinfo;
3077                 info->line = port;
3078
3079                 info->port.closing_wait = CLOSING_WAIT_DELAY;
3080                 info->port.close_delay = 5 * HZ / 10;
3081                 init_completion(&info->shutdown_wait);
3082
3083                 if (cy_is_Z(cinfo)) {
3084                         struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3085                         struct ZFW_CTRL *zfw_ctrl;
3086
3087                         info->port.ops = &cyz_port_ops;
3088                         info->type = PORT_STARTECH;
3089
3090                         zfw_ctrl = cinfo->base_addr +
3091                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3092                         info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3093                         info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3094
3095                         if (cinfo->hw_ver == ZO_V1)
3096                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3097                         else
3098                                 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3099 #ifdef CONFIG_CYZ_INTR
3100                         setup_timer(&cyz_rx_full_timer[port],
3101                                 cyz_rx_restart, (unsigned long)info);
3102 #endif
3103                 } else {
3104                         unsigned short chip_number;
3105                         int index = cinfo->bus_index;
3106
3107                         info->port.ops = &cyy_port_ops;
3108                         info->type = PORT_CIRRUS;
3109                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3110                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3111                         info->cor2 = CyETC;
3112                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
3113
3114                         chip_number = channel / CyPORTS_PER_CHIP;
3115                         info->u.cyy.base_addr = cinfo->base_addr +
3116                                 (cy_chip_offset[chip_number] << index);
3117                         info->chip_rev = cyy_readb(info, CyGFRCR);
3118
3119                         if (info->chip_rev >= CD1400_REV_J) {
3120                                 /* It is a CD1400 rev. J or later */
3121                                 info->tbpr = baud_bpr_60[13];   /* Tx BPR */
3122                                 info->tco = baud_co_60[13];     /* Tx CO */
3123                                 info->rbpr = baud_bpr_60[13];   /* Rx BPR */
3124                                 info->rco = baud_co_60[13];     /* Rx CO */
3125                                 info->rtsdtr_inv = 1;
3126                         } else {
3127                                 info->tbpr = baud_bpr_25[13];   /* Tx BPR */
3128                                 info->tco = baud_co_25[13];     /* Tx CO */
3129                                 info->rbpr = baud_bpr_25[13];   /* Rx BPR */
3130                                 info->rco = baud_co_25[13];     /* Rx CO */
3131                                 info->rtsdtr_inv = 0;
3132                         }
3133                         info->read_status_mask = CyTIMEOUT | CySPECHAR |
3134                                 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3135                 }
3136
3137         }
3138
3139 #ifndef CONFIG_CYZ_INTR
3140         if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3141                 mod_timer(&cyz_timerlist, jiffies + 1);
3142 #ifdef CY_PCI_DEBUG
3143                 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3144 #endif
3145         }
3146 #endif
3147         return 0;
3148 }
3149
3150 /* initialize chips on Cyclom-Y card -- return number of valid
3151    chips (which is number of ports/4) */
3152 static unsigned short cyy_init_card(void __iomem *true_base_addr,
3153                 int index)
3154 {
3155         unsigned int chip_number;
3156         void __iomem *base_addr;
3157
3158         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3159         /* Cy_HwReset is 0x1400 */
3160         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3161         /* Cy_ClrIntr is 0x1800 */
3162         udelay(500L);
3163
3164         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3165                                                         chip_number++) {
3166                 base_addr =
3167                     true_base_addr + (cy_chip_offset[chip_number] << index);
3168                 mdelay(1);
3169                 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3170                         /*************
3171                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3172                         chip_number, (unsigned long)base_addr);
3173                         *************/
3174                         return chip_number;
3175                 }
3176
3177                 cy_writeb(base_addr + (CyGFRCR << index), 0);
3178                 udelay(10L);
3179
3180                 /* The Cyclom-16Y does not decode address bit 9 and therefore
3181                    cannot distinguish between references to chip 0 and a non-
3182                    existent chip 4.  If the preceding clearing of the supposed
3183                    chip 4 GFRCR register appears at chip 0, there is no chip 4
3184                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3185                  */
3186                 if (chip_number == 4 && readb(true_base_addr +
3187                                 (cy_chip_offset[0] << index) +
3188                                 (CyGFRCR << index)) == 0) {
3189                         return chip_number;
3190                 }
3191
3192                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3193                 mdelay(1);
3194
3195                 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3196                         /*
3197                            printk(" chip #%d at %#6lx is not responding ",
3198                            chip_number, (unsigned long)base_addr);
3199                            printk("(GFRCR stayed 0)\n",
3200                          */
3201                         return chip_number;
3202                 }
3203                 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3204                                 0x40) {
3205                         /*
3206                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
3207                                         "%#2x)\n",
3208                                         chip_number, (unsigned long)base_addr,
3209                                         base_addr[CyGFRCR<<index]);
3210                          */
3211                         return chip_number;
3212                 }
3213                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3214                 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3215                         /* It is a CD1400 rev. J or later */
3216                         /* Impossible to reach 5ms with this chip.
3217                            Changed to 2ms instead (f = 500 Hz). */
3218                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3219                 } else {
3220                         /* f = 200 Hz */
3221                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3222                 }
3223
3224                 /*
3225                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
3226                    chip_number, (unsigned long)base_addr,
3227                    readb(base_addr+(CyGFRCR<<index)));
3228                  */
3229         }
3230         return chip_number;
3231 }                               /* cyy_init_card */
3232
3233 /*
3234  * ---------------------------------------------------------------------
3235  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3236  * sets global variables and return the number of ISA boards found.
3237  * ---------------------------------------------------------------------
3238  */
3239 static int __init cy_detect_isa(void)
3240 {
3241 #ifdef CONFIG_ISA
3242         struct cyclades_card *card;
3243         unsigned short cy_isa_irq, nboard;
3244         void __iomem *cy_isa_address;
3245         unsigned short i, j, k, cy_isa_nchan;
3246         int isparam = 0;
3247
3248         nboard = 0;
3249
3250         /* Check for module parameters */
3251         for (i = 0; i < NR_CARDS; i++) {
3252                 if (maddr[i] || i) {
3253                         isparam = 1;
3254                         cy_isa_addresses[i] = maddr[i];
3255                 }
3256                 if (!maddr[i])
3257                         break;
3258         }
3259
3260         /* scan the address table probing for Cyclom-Y/ISA boards */
3261         for (i = 0; i < NR_ISA_ADDRS; i++) {
3262                 unsigned int isa_address = cy_isa_addresses[i];
3263                 if (isa_address == 0x0000)
3264                         return nboard;
3265
3266                 /* probe for CD1400... */
3267                 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3268                 if (cy_isa_address == NULL) {
3269                         printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3270                                         "address\n");
3271                         continue;
3272                 }
3273                 cy_isa_nchan = CyPORTS_PER_CHIP *
3274                         cyy_init_card(cy_isa_address, 0);
3275                 if (cy_isa_nchan == 0) {
3276                         iounmap(cy_isa_address);
3277                         continue;
3278                 }
3279
3280                 if (isparam && i < NR_CARDS && irq[i])
3281                         cy_isa_irq = irq[i];
3282                 else
3283                         /* find out the board's irq by probing */
3284                         cy_isa_irq = detect_isa_irq(cy_isa_address);
3285                 if (cy_isa_irq == 0) {
3286                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3287                                 "IRQ could not be detected.\n",
3288                                 (unsigned long)cy_isa_address);
3289                         iounmap(cy_isa_address);
3290                         continue;
3291                 }
3292
3293                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3294                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3295                                 "more channels are available. Change NR_PORTS "
3296                                 "in cyclades.c and recompile kernel.\n",
3297                                 (unsigned long)cy_isa_address);
3298                         iounmap(cy_isa_address);
3299                         return nboard;
3300                 }
3301                 /* fill the next cy_card structure available */
3302                 for (j = 0; j < NR_CARDS; j++) {
3303                         card = &cy_card[j];
3304                         if (card->base_addr == NULL)
3305                                 break;
3306                 }
3307                 if (j == NR_CARDS) {    /* no more cy_cards available */
3308                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3309                                 "more cards can be used. Change NR_CARDS in "
3310                                 "cyclades.c and recompile kernel.\n",
3311                                 (unsigned long)cy_isa_address);
3312                         iounmap(cy_isa_address);
3313                         return nboard;
3314                 }
3315
3316                 /* allocate IRQ */
3317                 if (request_irq(cy_isa_irq, cyy_interrupt,
3318                                 0, "Cyclom-Y", card)) {
3319                         printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3320                                 "could not allocate IRQ#%d.\n",
3321                                 (unsigned long)cy_isa_address, cy_isa_irq);
3322                         iounmap(cy_isa_address);
3323                         return nboard;
3324                 }
3325
3326                 /* set cy_card */
3327                 card->base_addr = cy_isa_address;
3328                 card->ctl_addr.p9050 = NULL;
3329                 card->irq = (int)cy_isa_irq;
3330                 card->bus_index = 0;
3331                 card->first_line = cy_next_channel;
3332                 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3333                 card->nports = cy_isa_nchan;
3334                 if (cy_init_card(card)) {
3335                         card->base_addr = NULL;
3336                         free_irq(cy_isa_irq, card);
3337                         iounmap(cy_isa_address);
3338                         continue;
3339                 }
3340                 nboard++;
3341
3342                 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3343                         "%d channels starting from port %d\n",
3344                         j + 1, (unsigned long)cy_isa_address,
3345                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3346                         cy_isa_irq, cy_isa_nchan, cy_next_channel);
3347
3348                 for (k = 0, j = cy_next_channel;
3349                                 j < cy_next_channel + cy_isa_nchan; j++, k++)
3350                         tty_port_register_device(&card->ports[k].port,
3351                                         cy_serial_driver, j, NULL);
3352                 cy_next_channel += cy_isa_nchan;
3353         }
3354         return nboard;
3355 #else
3356         return 0;
3357 #endif                          /* CONFIG_ISA */
3358 }                               /* cy_detect_isa */
3359
3360 #ifdef CONFIG_PCI
3361 static inline int cyc_isfwstr(const char *str, unsigned int size)
3362 {
3363         unsigned int a;
3364
3365         for (a = 0; a < size && *str; a++, str++)
3366                 if (*str & 0x80)
3367                         return -EINVAL;
3368
3369         for (; a < size; a++, str++)
3370                 if (*str)
3371                         return -EINVAL;
3372
3373         return 0;
3374 }
3375
3376 static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3377                 unsigned int size)
3378 {
3379         for (; size > 0; size--) {
3380                 cy_writel(fpga, *data++);
3381                 udelay(10);
3382         }
3383 }
3384
3385 static void plx_init(struct pci_dev *pdev, int irq,
3386                 struct RUNTIME_9060 __iomem *addr)
3387 {
3388         /* Reset PLX */
3389         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3390         udelay(100L);
3391         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3392
3393         /* Reload Config. Registers from EEPROM */
3394         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3395         udelay(100L);
3396         cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3397
3398         /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3399          * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3400          * registers. This will remain here until we find a permanent fix.
3401          */
3402         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3403 }
3404
3405 static int __cyz_load_fw(const struct firmware *fw,
3406                 const char *name, const u32 mailbox, void __iomem *base,
3407                 void __iomem *fpga)
3408 {
3409         const void *ptr = fw->data;
3410         const struct zfile_header *h = ptr;
3411         const struct zfile_config *c, *cs;
3412         const struct zfile_block *b, *bs;
3413         unsigned int a, tmp, len = fw->size;
3414 #define BAD_FW KERN_ERR "Bad firmware: "
3415         if (len < sizeof(*h)) {
3416                 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3417                 return -EINVAL;
3418         }
3419
3420         cs = ptr + h->config_offset;
3421         bs = ptr + h->block_offset;
3422
3423         if ((void *)(cs + h->n_config) > ptr + len ||
3424                         (void *)(bs + h->n_blocks) > ptr + len) {
3425                 printk(BAD_FW "too short");
3426                 return  -EINVAL;
3427         }
3428
3429         if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3430                         cyc_isfwstr(h->date, sizeof(h->date))) {
3431                 printk(BAD_FW "bad formatted header string\n");
3432                 return -EINVAL;
3433         }
3434
3435         if (strncmp(name, h->name, sizeof(h->name))) {
3436                 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3437                 return -EINVAL;
3438         }
3439
3440         tmp = 0;
3441         for (c = cs; c < cs + h->n_config; c++) {
3442                 for (a = 0; a < c->n_blocks; a++)
3443                         if (c->block_list[a] > h->n_blocks) {
3444                                 printk(BAD_FW "bad block ref number in cfgs\n");
3445                                 return -EINVAL;
3446                         }
3447                 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3448                         tmp++;
3449         }
3450         if (!tmp) {
3451                 printk(BAD_FW "nothing appropriate\n");
3452                 return -EINVAL;
3453         }
3454
3455         for (b = bs; b < bs + h->n_blocks; b++)
3456                 if (b->file_offset + b->size > len) {
3457                         printk(BAD_FW "bad block data offset\n");
3458                         return -EINVAL;
3459                 }
3460
3461         /* everything is OK, let's seek'n'load it */
3462         for (c = cs; c < cs + h->n_config; c++)
3463                 if (c->mailbox == mailbox && c->function == 0)
3464                         break;
3465
3466         for (a = 0; a < c->n_blocks; a++) {
3467                 b = &bs[c->block_list[a]];
3468                 if (b->type == ZBLOCK_FPGA) {
3469                         if (fpga != NULL)
3470                                 cyz_fpga_copy(fpga, ptr + b->file_offset,
3471                                                 b->size);
3472                 } else {
3473                         if (base != NULL)
3474                                 memcpy_toio(base + b->ram_offset,
3475                                                ptr + b->file_offset, b->size);
3476                 }
3477         }
3478 #undef BAD_FW
3479         return 0;
3480 }
3481
3482 static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3483                 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3484 {
3485         const struct firmware *fw;
3486         struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3487         struct CUSTOM_REG __iomem *cust = base_addr;
3488         struct ZFW_CTRL __iomem *pt_zfwctrl;
3489         void __iomem *tmp;
3490         u32 mailbox, status, nchan;
3491         unsigned int i;
3492         int retval;
3493
3494         retval = reject_firmware(&fw, "/*(DEBLOBBED)*/", &pdev->dev);
3495         if (retval) {
3496                 dev_err(&pdev->dev, "can't get firmware\n");
3497                 goto err;
3498         }
3499
3500         /* Check whether the firmware is already loaded and running. If
3501            positive, skip this board */
3502         if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3503                 u32 cntval = readl(base_addr + 0x190);
3504
3505                 udelay(100);
3506                 if (cntval != readl(base_addr + 0x190)) {
3507                         /* FW counter is working, FW is running */
3508                         dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3509                                         "Skipping board.\n");
3510                         retval = 0;
3511                         goto err_rel;
3512                 }
3513         }
3514
3515         /* start boot */
3516         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3517                         ~0x00030800UL);
3518
3519         mailbox = readl(&ctl_addr->mail_box_0);
3520
3521         if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3522                 /* stops CPU and set window to beginning of RAM */
3523                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3524                 cy_writel(&cust->cpu_stop, 0);
3525                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3526                 udelay(100);
3527         }
3528
3529         plx_init(pdev, irq, ctl_addr);
3530
3531         if (mailbox != 0) {
3532                 /* load FPGA */
3533                 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3534                                 base_addr);
3535                 if (retval)
3536                         goto err_rel;
3537                 if (!__cyz_fpga_loaded(ctl_addr)) {
3538                         dev_err(&pdev->dev, "fw upload successful, but fw is "
3539                                         "not loaded\n");
3540                         goto err_rel;
3541                 }
3542         }
3543
3544         /* stops CPU and set window to beginning of RAM */
3545         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3546         cy_writel(&cust->cpu_stop, 0);
3547         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3548         udelay(100);
3549
3550         /* clear memory */
3551         for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3552                 cy_writeb(tmp, 255);
3553         if (mailbox != 0) {
3554                 /* set window to last 512K of RAM */
3555                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3556                 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3557                         cy_writeb(tmp, 255);
3558                 /* set window to beginning of RAM */
3559                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3560         }
3561
3562         retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3563         release_firmware(fw);
3564         if (retval)
3565                 goto err;
3566
3567         /* finish boot and start boards */
3568         cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3569         cy_writel(&cust->cpu_start, 0);
3570         cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3571         i = 0;
3572         while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3573                 msleep(100);
3574         if (status != ZFIRM_ID) {
3575                 if (status == ZFIRM_HLT) {
3576                         dev_err(&pdev->dev, "you need an external power supply "
3577                                 "for this number of ports. Firmware halted and "
3578                                 "board reset.\n");
3579                         retval = -EIO;
3580                         goto err;
3581                 }
3582                 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3583                                 "some more time\n", status);
3584                 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3585                                 i++ < 200)
3586                         msleep(100);
3587                 if (status != ZFIRM_ID) {
3588                         dev_err(&pdev->dev, "Board not started in 20 seconds! "
3589                                         "Giving up. (fid->signature = 0x%x)\n",
3590                                         status);
3591                         dev_info(&pdev->dev, "*** Warning ***: if you are "
3592                                 "upgrading the FW, please power cycle the "
3593                                 "system before loading the new FW to the "
3594                                 "Cyclades-Z.\n");
3595
3596                         if (__cyz_fpga_loaded(ctl_addr))
3597                                 plx_init(pdev, irq, ctl_addr);
3598
3599                         retval = -EIO;
3600                         goto err;
3601                 }
3602                 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3603                                 i / 10);
3604         }
3605         pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3606
3607         dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3608                         base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3609                         base_addr + readl(&fid->zfwctrl_addr));
3610
3611         nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3612         dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3613                 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3614
3615         if (nchan == 0) {
3616                 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3617                         "check the connection between the Z host card and the "
3618                         "serial expanders.\n");
3619
3620                 if (__cyz_fpga_loaded(ctl_addr))
3621                         plx_init(pdev, irq, ctl_addr);
3622
3623                 dev_info(&pdev->dev, "Null number of ports detected. Board "
3624                                 "reset.\n");
3625                 retval = 0;
3626                 goto err;
3627         }
3628
3629         cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3630         cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3631
3632         /*
3633            Early firmware failed to start looking for commands.
3634            This enables firmware interrupts for those commands.
3635          */
3636         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3637                         (1 << 17));
3638         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3639                         0x00030800UL);
3640
3641         return nchan;
3642 err_rel:
3643         release_firmware(fw);
3644 err:
3645         return retval;
3646 }
3647
3648 static int cy_pci_probe(struct pci_dev *pdev,
3649                 const struct pci_device_id *ent)
3650 {
3651         struct cyclades_card *card;
3652         void __iomem *addr0 = NULL, *addr2 = NULL;
3653         char *card_name = NULL;
3654         u32 mailbox;
3655         unsigned int device_id, nchan = 0, card_no, i, j;
3656         unsigned char plx_ver;
3657         int retval, irq;
3658
3659         retval = pci_enable_device(pdev);
3660         if (retval) {
3661                 dev_err(&pdev->dev, "cannot enable device\n");
3662                 goto err;
3663         }
3664
3665         /* read PCI configuration area */
3666         irq = pdev->irq;
3667         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3668
3669 #if defined(__alpha__)
3670         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
3671                 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3672                         "addresses on Alpha systems.\n");
3673                 retval = -EIO;
3674                 goto err_dis;
3675         }
3676 #endif
3677         if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3678                 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3679                         "addresses\n");
3680                 retval = -EIO;
3681                 goto err_dis;
3682         }
3683
3684         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3685                 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3686                                 "it...\n");
3687                 pdev->resource[2].flags &= ~IORESOURCE_IO;
3688         }
3689
3690         retval = pci_request_regions(pdev, "cyclades");
3691         if (retval) {
3692                 dev_err(&pdev->dev, "failed to reserve resources\n");
3693                 goto err_dis;
3694         }
3695
3696         retval = -EIO;
3697         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3698                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3699                 card_name = "Cyclom-Y";
3700
3701                 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3702                                 CyPCI_Yctl);
3703                 if (addr0 == NULL) {
3704                         dev_err(&pdev->dev, "can't remap ctl region\n");
3705                         goto err_reg;
3706                 }
3707                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3708                                 CyPCI_Ywin);
3709                 if (addr2 == NULL) {
3710                         dev_err(&pdev->dev, "can't remap base region\n");
3711                         goto err_unmap;
3712                 }
3713
3714                 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3715                 if (nchan == 0) {
3716                         dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3717                                         "Serial-Modules\n");
3718                         goto err_unmap;
3719                 }
3720         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3721                 struct RUNTIME_9060 __iomem *ctl_addr;
3722
3723                 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3724                                 CyPCI_Zctl);
3725                 if (addr0 == NULL) {
3726                         dev_err(&pdev->dev, "can't remap ctl region\n");
3727                         goto err_reg;
3728                 }
3729
3730                 /* Disable interrupts on the PLX before resetting it */
3731                 cy_writew(&ctl_addr->intr_ctrl_stat,
3732                                 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3733
3734                 plx_init(pdev, irq, addr0);
3735
3736                 mailbox = readl(&ctl_addr->mail_box_0);
3737
3738                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3739                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3740                 if (addr2 == NULL) {
3741                         dev_err(&pdev->dev, "can't remap base region\n");
3742                         goto err_unmap;
3743                 }
3744
3745                 if (mailbox == ZE_V1) {
3746                         card_name = "Cyclades-Ze";
3747                 } else {
3748                         card_name = "Cyclades-8Zo";
3749 #ifdef CY_PCI_DEBUG
3750                         if (mailbox == ZO_V1) {
3751                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3752                                 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3753                                         "id %lx, ver %lx\n", (ulong)(0xff &
3754                                         readl(&((struct CUSTOM_REG *)addr2)->
3755                                                 fpga_id)), (ulong)(0xff &
3756                                         readl(&((struct CUSTOM_REG *)addr2)->
3757                                                 fpga_version)));
3758                                 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3759                         } else {
3760                                 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3761                                         "Cyclades-Z board.  FPGA not loaded\n");
3762                         }
3763 #endif
3764                         /* The following clears the firmware id word.  This
3765                            ensures that the driver will not attempt to talk to
3766                            the board until it has been properly initialized.
3767                          */
3768                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3769                                 cy_writel(addr2 + ID_ADDRESS, 0L);
3770                 }
3771
3772                 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3773                 if (retval <= 0)
3774                         goto err_unmap;
3775                 nchan = retval;
3776         }
3777
3778         if ((cy_next_channel + nchan) > NR_PORTS) {
3779                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3780                         "channels are available. Change NR_PORTS in "
3781                         "cyclades.c and recompile kernel.\n");
3782                 goto err_unmap;
3783         }
3784         /* fill the next cy_card structure available */
3785         for (card_no = 0; card_no < NR_CARDS; card_no++) {
3786                 card = &cy_card[card_no];
3787                 if (card->base_addr == NULL)
3788                         break;
3789         }
3790         if (card_no == NR_CARDS) {      /* no more cy_cards available */
3791                 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3792                         "more cards can be used. Change NR_CARDS in "
3793                         "cyclades.c and recompile kernel.\n");
3794                 goto err_unmap;
3795         }
3796
3797         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3798                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3799                 /* allocate IRQ */
3800                 retval = request_irq(irq, cyy_interrupt,
3801                                 IRQF_SHARED, "Cyclom-Y", card);
3802                 if (retval) {
3803                         dev_err(&pdev->dev, "could not allocate IRQ\n");
3804                         goto err_unmap;
3805                 }
3806                 card->num_chips = nchan / CyPORTS_PER_CHIP;
3807         } else {
3808                 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3809                 struct ZFW_CTRL __iomem *zfw_ctrl;
3810
3811                 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3812
3813                 card->hw_ver = mailbox;
3814                 card->num_chips = (unsigned int)-1;
3815                 card->board_ctrl = &zfw_ctrl->board_ctrl;
3816 #ifdef CONFIG_CYZ_INTR
3817                 /* allocate IRQ only if board has an IRQ */
3818                 if (irq != 0 && irq != 255) {
3819                         retval = request_irq(irq, cyz_interrupt,
3820                                         IRQF_SHARED, "Cyclades-Z", card);
3821                         if (retval) {
3822                                 dev_err(&pdev->dev, "could not allocate IRQ\n");
3823                                 goto err_unmap;
3824                         }
3825                 }
3826 #endif                          /* CONFIG_CYZ_INTR */
3827         }
3828
3829         /* set cy_card */
3830         card->base_addr = addr2;
3831         card->ctl_addr.p9050 = addr0;
3832         card->irq = irq;
3833         card->bus_index = 1;
3834         card->first_line = cy_next_channel;
3835         card->nports = nchan;
3836         retval = cy_init_card(card);
3837         if (retval)
3838                 goto err_null;
3839
3840         pci_set_drvdata(pdev, card);
3841
3842         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3843                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3844                 /* enable interrupts in the PCI interface */
3845                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3846                 switch (plx_ver) {
3847                 case PLX_9050:
3848                         cy_writeb(addr0 + 0x4c, 0x43);
3849                         break;
3850
3851                 case PLX_9060:
3852                 case PLX_9080:
3853                 default:        /* Old boards, use PLX_9060 */
3854                 {
3855                         struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3856                         plx_init(pdev, irq, ctl_addr);
3857                         cy_writew(&ctl_addr->intr_ctrl_stat,
3858                                 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3859                         break;
3860                 }
3861                 }
3862         }
3863
3864         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3865                 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3866         for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3867                 tty_port_register_device(&card->ports[j].port,
3868                                 cy_serial_driver, i, &pdev->dev);
3869         cy_next_channel += nchan;
3870
3871         return 0;
3872 err_null:
3873         card->base_addr = NULL;
3874         free_irq(irq, card);
3875 err_unmap:
3876         iounmap(addr0);
3877         if (addr2)
3878                 iounmap(addr2);
3879 err_reg:
3880         pci_release_regions(pdev);
3881 err_dis:
3882         pci_disable_device(pdev);
3883 err:
3884         return retval;
3885 }
3886
3887 static void cy_pci_remove(struct pci_dev *pdev)
3888 {
3889         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3890         unsigned int i, channel;
3891
3892         /* non-Z with old PLX */
3893         if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3894                         PLX_9050)
3895                 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3896         else
3897 #ifndef CONFIG_CYZ_INTR
3898                 if (!cy_is_Z(cinfo))
3899 #endif
3900                 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3901                         readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3902                         ~0x0900);
3903
3904         iounmap(cinfo->base_addr);
3905         if (cinfo->ctl_addr.p9050)
3906                 iounmap(cinfo->ctl_addr.p9050);
3907         if (cinfo->irq
3908 #ifndef CONFIG_CYZ_INTR
3909                 && !cy_is_Z(cinfo)
3910 #endif /* CONFIG_CYZ_INTR */
3911                 )
3912                 free_irq(cinfo->irq, cinfo);
3913         pci_release_regions(pdev);
3914
3915         cinfo->base_addr = NULL;
3916         for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3917                         cinfo->nports; i++, channel++) {
3918                 tty_unregister_device(cy_serial_driver, i);
3919                 tty_port_destroy(&cinfo->ports[channel].port);
3920         }
3921         cinfo->nports = 0;
3922         kfree(cinfo->ports);
3923 }
3924
3925 static struct pci_driver cy_pci_driver = {
3926         .name = "cyclades",
3927         .id_table = cy_pci_dev_id,
3928         .probe = cy_pci_probe,
3929         .remove = cy_pci_remove
3930 };
3931 #endif
3932
3933 static int cyclades_proc_show(struct seq_file *m, void *v)
3934 {
3935         struct cyclades_port *info;
3936         unsigned int i, j;
3937         __u32 cur_jifs = jiffies;
3938
3939         seq_puts(m, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
3940                         "IdleIn  Overruns  Ldisc\n");
3941
3942         /* Output one line for each known port */
3943         for (i = 0; i < NR_CARDS; i++)
3944                 for (j = 0; j < cy_card[i].nports; j++) {
3945                         info = &cy_card[i].ports[j];
3946
3947                         if (info->port.count) {
3948                                 /* XXX is the ldisc num worth this? */
3949                                 struct tty_struct *tty;
3950                                 struct tty_ldisc *ld;
3951                                 int num = 0;
3952                                 tty = tty_port_tty_get(&info->port);
3953                                 if (tty) {
3954                                         ld = tty_ldisc_ref(tty);
3955                                         if (ld) {
3956                                                 num = ld->ops->num;
3957                                                 tty_ldisc_deref(ld);
3958                                         }
3959                                         tty_kref_put(tty);
3960                                 }
3961                                 seq_printf(m, "%3d %8lu %10lu %8lu "
3962                                         "%10lu %8lu %9lu %6d\n", info->line,
3963                                         (cur_jifs - info->idle_stats.in_use) /
3964                                         HZ, info->idle_stats.xmit_bytes,
3965                                         (cur_jifs - info->idle_stats.xmit_idle)/
3966                                         HZ, info->idle_stats.recv_bytes,
3967                                         (cur_jifs - info->idle_stats.recv_idle)/
3968                                         HZ, info->idle_stats.overruns,
3969                                         num);
3970                         } else
3971                                 seq_printf(m, "%3d %8lu %10lu %8lu "
3972                                         "%10lu %8lu %9lu %6ld\n",
3973                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
3974                 }
3975         return 0;
3976 }
3977
3978 static int cyclades_proc_open(struct inode *inode, struct file *file)
3979 {
3980         return single_open(file, cyclades_proc_show, NULL);
3981 }
3982
3983 static const struct file_operations cyclades_proc_fops = {
3984         .owner          = THIS_MODULE,
3985         .open           = cyclades_proc_open,
3986         .read           = seq_read,
3987         .llseek         = seq_lseek,
3988         .release        = single_release,
3989 };
3990
3991 /* The serial driver boot-time initialization code!
3992     Hardware I/O ports are mapped to character special devices on a
3993     first found, first allocated manner.  That is, this code searches
3994     for Cyclom cards in the system.  As each is found, it is probed
3995     to discover how many chips (and thus how many ports) are present.
3996     These ports are mapped to the tty ports 32 and upward in monotonic
3997     fashion.  If an 8-port card is replaced with a 16-port card, the
3998     port mapping on a following card will shift.
3999
4000     This approach is different from what is used in the other serial
4001     device driver because the Cyclom is more properly a multiplexer,
4002     not just an aggregation of serial ports on one card.
4003
4004     If there are more cards with more ports than have been
4005     statically allocated above, a warning is printed and the
4006     extra ports are ignored.
4007  */
4008
4009 static const struct tty_operations cy_ops = {
4010         .open = cy_open,
4011         .close = cy_close,
4012         .write = cy_write,
4013         .put_char = cy_put_char,
4014         .flush_chars = cy_flush_chars,
4015         .write_room = cy_write_room,
4016         .chars_in_buffer = cy_chars_in_buffer,
4017         .flush_buffer = cy_flush_buffer,
4018         .ioctl = cy_ioctl,
4019         .throttle = cy_throttle,
4020         .unthrottle = cy_unthrottle,
4021         .set_termios = cy_set_termios,
4022         .stop = cy_stop,
4023         .start = cy_start,
4024         .hangup = cy_hangup,
4025         .break_ctl = cy_break,
4026         .wait_until_sent = cy_wait_until_sent,
4027         .tiocmget = cy_tiocmget,
4028         .tiocmset = cy_tiocmset,
4029         .get_icount = cy_get_icount,
4030         .proc_fops = &cyclades_proc_fops,
4031 };
4032
4033 static int __init cy_init(void)
4034 {
4035         unsigned int nboards;
4036         int retval = -ENOMEM;
4037
4038         cy_serial_driver = alloc_tty_driver(NR_PORTS);
4039         if (!cy_serial_driver)
4040                 goto err;
4041
4042         printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4043
4044         /* Initialize the tty_driver structure */
4045
4046         cy_serial_driver->driver_name = "cyclades";
4047         cy_serial_driver->name = "ttyC";
4048         cy_serial_driver->major = CYCLADES_MAJOR;
4049         cy_serial_driver->minor_start = 0;
4050         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4051         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4052         cy_serial_driver->init_termios = tty_std_termios;
4053         cy_serial_driver->init_termios.c_cflag =
4054             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4055         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4056         tty_set_operations(cy_serial_driver, &cy_ops);
4057
4058         retval = tty_register_driver(cy_serial_driver);
4059         if (retval) {
4060                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4061                 goto err_frtty;
4062         }
4063
4064         /* the code below is responsible to find the boards. Each different
4065            type of board has its own detection routine. If a board is found,
4066            the next cy_card structure available is set by the detection
4067            routine. These functions are responsible for checking the
4068            availability of cy_card and cy_port data structures and updating
4069            the cy_next_channel. */
4070
4071         /* look for isa boards */
4072         nboards = cy_detect_isa();
4073
4074 #ifdef CONFIG_PCI
4075         /* look for pci boards */
4076         retval = pci_register_driver(&cy_pci_driver);
4077         if (retval && !nboards) {
4078                 tty_unregister_driver(cy_serial_driver);
4079                 goto err_frtty;
4080         }
4081 #endif
4082
4083         return 0;
4084 err_frtty:
4085         put_tty_driver(cy_serial_driver);
4086 err:
4087         return retval;
4088 }                               /* cy_init */
4089
4090 static void __exit cy_cleanup_module(void)
4091 {
4092         struct cyclades_card *card;
4093         unsigned int i, e1;
4094
4095 #ifndef CONFIG_CYZ_INTR
4096         del_timer_sync(&cyz_timerlist);
4097 #endif /* CONFIG_CYZ_INTR */
4098
4099         e1 = tty_unregister_driver(cy_serial_driver);
4100         if (e1)
4101                 printk(KERN_ERR "failed to unregister Cyclades serial "
4102                                 "driver(%d)\n", e1);
4103
4104 #ifdef CONFIG_PCI
4105         pci_unregister_driver(&cy_pci_driver);
4106 #endif
4107
4108         for (i = 0; i < NR_CARDS; i++) {
4109                 card = &cy_card[i];
4110                 if (card->base_addr) {
4111                         /* clear interrupt */
4112                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4113                         iounmap(card->base_addr);
4114                         if (card->ctl_addr.p9050)
4115                                 iounmap(card->ctl_addr.p9050);
4116                         if (card->irq
4117 #ifndef CONFIG_CYZ_INTR
4118                                 && !cy_is_Z(card)
4119 #endif /* CONFIG_CYZ_INTR */
4120                                 )
4121                                 free_irq(card->irq, card);
4122                         for (e1 = card->first_line; e1 < card->first_line +
4123                                         card->nports; e1++)
4124                                 tty_unregister_device(cy_serial_driver, e1);
4125                         kfree(card->ports);
4126                 }
4127         }
4128
4129         put_tty_driver(cy_serial_driver);
4130 } /* cy_cleanup_module */
4131
4132 module_init(cy_init);
4133 module_exit(cy_cleanup_module);
4134
4135 MODULE_LICENSE("GPL");
4136 MODULE_VERSION(CY_VERSION);
4137 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4138 /*(DEBLOBBED)*/