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