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