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