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