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