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