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