Root/drivers/tty/cyclades.c

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

Archive Download this file



interactive