drivers/tty/cyclades.c

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