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