3 #undef Z_EXT_CHARS_IN_BUFFER
6 * linux/drivers/char/cyclades.c
8 * This file contains the driver for the Cyclades async multiport
11 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
12 * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
14 * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
16 * Much of the design and some of the code came from serial.c
17 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
18 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
19 * and then fixed as suggested by Michael K. Johnson 12/12/92.
20 * Converted to pci probing and cleaned up by Jiri Slaby.
24 #define CY_VERSION "2.6"
26 /* If you need to install more boards than NR_CARDS, change the constant
27 in the definition below. No other change is necessary to support up to
28 eight boards. Beyond that you'll have to extend cy_isa_addresses. */
33 If the total number of ports is larger than NR_PORTS, change this
34 constant in the definition below. No other change is necessary to
35 support more boards/ports. */
43 #define SERIAL_PARANOIA_CHECK
45 #undef CY_DEBUG_THROTTLE
50 #undef CY_DEBUG_WAIT_UNTIL_SENT
51 #undef CY_DEBUG_INTERRUPTS
53 #undef CY_ENABLE_MONITORING
59 #include <linux/module.h>
60 #include <linux/errno.h>
61 #include <linux/signal.h>
62 #include <linux/sched.h>
63 #include <linux/timer.h>
64 #include <linux/interrupt.h>
65 #include <linux/tty.h>
66 #include <linux/tty_flip.h>
67 #include <linux/serial.h>
68 #include <linux/smp_lock.h>
69 #include <linux/major.h>
70 #include <linux/string.h>
71 #include <linux/fcntl.h>
72 #include <linux/ptrace.h>
73 #include <linux/cyclades.h>
75 #include <linux/ioport.h>
76 #include <linux/init.h>
77 #include <linux/delay.h>
78 #include <linux/spinlock.h>
79 #include <linux/bitops.h>
80 #include <linux/firmware.h>
81 #include <linux/device.h>
84 #include <linux/uaccess.h>
86 #include <linux/kernel.h>
87 #include <linux/pci.h>
89 #include <linux/stat.h>
90 #include <linux/proc_fs.h>
91 #include <linux/seq_file.h>
93 static void cy_send_xchar(struct tty_struct *tty, char ch);
95 #ifndef SERIAL_XMIT_SIZE
96 #define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
99 #define STD_COM_FLAGS (0)
102 #define ZL_MAX_BLOCKS 16
103 #define DRIVER_VERSION 0x02010203
104 #define RAM_SIZE 0x80000
111 struct zfile_header {
120 } __attribute__ ((packed));
122 struct zfile_config {
127 u32 block_list[ZL_MAX_BLOCKS];
128 } __attribute__ ((packed));
135 } __attribute__ ((packed));
137 static struct tty_driver *cy_serial_driver;
140 /* This is the address lookup table. The driver will probe for
141 Cyclom-Y/ISA boards at all addresses in here. If you want the
142 driver to probe addresses at a different address, add it to
143 this table. If the driver is probing some other board and
144 causing problems, remove the offending address from this table.
147 static unsigned int cy_isa_addresses[] = {
156 0, 0, 0, 0, 0, 0, 0, 0
159 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
162 static long maddr[NR_CARDS];
163 static int irq[NR_CARDS];
165 module_param_array(maddr, long, NULL, 0);
166 module_param_array(irq, int, NULL, 0);
169 #endif /* CONFIG_ISA */
171 /* This is the per-card data structure containing address, irq, number of
172 channels, etc. This driver supports a maximum of NR_CARDS cards.
174 static struct cyclades_card cy_card[NR_CARDS];
176 static int cy_next_channel; /* next minor available */
179 * This is used to look up the divisor speeds and the timeouts
180 * We're normally limited to 15 distinct baud rates. The extra
181 * are accessed via settings in info->port.flags.
182 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
183 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
187 static const int baud_table[] = {
188 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
189 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
193 static const char baud_co_25[] = { /* 25 MHz clock option table */
194 /* value => 00 01 02 03 04 */
195 /* divide by 8 32 128 512 2048 */
196 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
197 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
200 static const char baud_bpr_25[] = { /* 25 MHz baud rate period table */
201 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
202 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
205 static const char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
206 /* value => 00 01 02 03 04 */
207 /* divide by 8 32 128 512 2048 */
208 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
209 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
213 static const char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
214 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
215 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
219 static const char baud_cor3[] = { /* receive threshold */
220 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
221 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
226 * The Cyclades driver implements HW flow control as any serial driver.
227 * The cyclades_port structure member rflow and the vector rflow_thr
228 * allows us to take advantage of a special feature in the CD1400 to avoid
229 * data loss even when the system interrupt latency is too high. These flags
230 * are to be used only with very special applications. Setting these flags
231 * requires the use of a special cable (DTR and RTS reversed). In the new
232 * CD1400-based boards (rev. 6.00 or later), there is no need for special
236 static const char rflow_thr[] = { /* rflow threshold */
237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
242 /* The Cyclom-Ye has placed the sequential chips in non-sequential
243 * address order. This look-up table overcomes that problem.
245 static const unsigned int cy_chip_offset[] = { 0x0000,
255 /* PCI related definitions */
258 static const struct pci_device_id cy_pci_dev_id[] = {
260 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
262 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },
264 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },
266 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },
268 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },
270 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },
272 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },
274 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },
275 { } /* end of table */
277 MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
280 static void cy_start(struct tty_struct *);
281 static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
282 static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
284 static unsigned detect_isa_irq(void __iomem *);
285 #endif /* CONFIG_ISA */
287 #ifndef CONFIG_CYZ_INTR
288 static void cyz_poll(unsigned long);
290 /* The Cyclades-Z polling cycle is defined by this variable */
291 static long cyz_polling_cycle = CZ_DEF_POLL;
293 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
295 #else /* CONFIG_CYZ_INTR */
296 static void cyz_rx_restart(unsigned long);
297 static struct timer_list cyz_rx_full_timer[NR_PORTS];
298 #endif /* CONFIG_CYZ_INTR */
300 static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
302 struct cyclades_card *card = port->card;
304 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
307 static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
309 struct cyclades_card *card = port->card;
311 return readb(port->u.cyy.base_addr + (reg << card->bus_index));
314 static inline bool cy_is_Z(struct cyclades_card *card)
316 return card->num_chips == (unsigned int)-1;
319 static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
321 return readl(&ctl_addr->init_ctrl) & (1 << 17);
324 static inline bool cyz_fpga_loaded(struct cyclades_card *card)
326 return __cyz_fpga_loaded(card->ctl_addr.p9060);
329 static inline bool cyz_is_loaded(struct cyclades_card *card)
331 struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
333 return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
334 readl(&fw_id->signature) == ZFIRM_ID;
337 static inline int serial_paranoia_check(struct cyclades_port *info,
338 const char *name, const char *routine)
340 #ifdef SERIAL_PARANOIA_CHECK
342 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
343 "in %s\n", name, routine);
347 if (info->magic != CYCLADES_MAGIC) {
348 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
349 "struct (%s) in %s\n", name, routine);
356 /***********************************************************/
357 /********* Start of block of Cyclom-Y specific code ********/
359 /* This routine waits up to 1000 micro-seconds for the previous
360 command to the Cirrus chip to complete and then issues the
361 new command. An error is returned if the previous command
362 didn't finish within the time limit.
364 This function is only called from inside spinlock-protected code.
366 static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
368 void __iomem *ccr = base_addr + (CyCCR << index);
371 /* Check to see that the previous command has completed */
372 for (i = 0; i < 100; i++) {
377 /* if the CCR never cleared, the previous command
378 didn't finish within the "reasonable time" */
382 /* Issue the new command */
388 static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
390 return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
391 port->card->bus_index);
395 /* ISA interrupt detection code */
396 static unsigned detect_isa_irq(void __iomem *address)
399 unsigned long irqs, flags;
400 int save_xir, save_car;
401 int index = 0; /* IRQ probing is only for ISA */
403 /* forget possible initially masked and pending IRQ */
404 irq = probe_irq_off(probe_irq_on());
406 /* Clear interrupts on the board first */
407 cy_writeb(address + (Cy_ClrIntr << index), 0);
408 /* Cy_ClrIntr is 0x1800 */
410 irqs = probe_irq_on();
414 /* Enable the Tx interrupts on the CD1400 */
415 local_irq_save(flags);
416 cy_writeb(address + (CyCAR << index), 0);
417 __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
419 cy_writeb(address + (CyCAR << index), 0);
420 cy_writeb(address + (CySRER << index),
421 readb(address + (CySRER << index)) | CyTxRdy);
422 local_irq_restore(flags);
427 /* Check which interrupt is in use */
428 irq = probe_irq_off(irqs);
431 save_xir = (u_char) readb(address + (CyTIR << index));
432 save_car = readb(address + (CyCAR << index));
433 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
434 cy_writeb(address + (CySRER << index),
435 readb(address + (CySRER << index)) & ~CyTxRdy);
436 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
437 cy_writeb(address + (CyCAR << index), (save_car));
438 cy_writeb(address + (Cy_ClrIntr << index), 0);
439 /* Cy_ClrIntr is 0x1800 */
441 return (irq > 0) ? irq : 0;
443 #endif /* CONFIG_ISA */
445 static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
446 void __iomem *base_addr)
448 struct cyclades_port *info;
449 struct tty_struct *tty;
450 int len, index = cinfo->bus_index;
451 u8 ivr, save_xir, channel, save_car, data, char_count;
453 #ifdef CY_DEBUG_INTERRUPTS
454 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
456 /* determine the channel & change to that context */
457 save_xir = readb(base_addr + (CyRIR << index));
458 channel = save_xir & CyIRChannel;
459 info = &cinfo->ports[channel + chip * 4];
460 save_car = cyy_readb(info, CyCAR);
461 cyy_writeb(info, CyCAR, save_xir);
462 ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
464 tty = tty_port_tty_get(&info->port);
465 /* if there is nowhere to put the data, discard it */
467 if (ivr == CyIVRRxEx) { /* exception */
468 data = cyy_readb(info, CyRDSR);
469 } else { /* normal character reception */
470 char_count = cyy_readb(info, CyRDCR);
472 data = cyy_readb(info, CyRDSR);
476 /* there is an open port for this data */
477 if (ivr == CyIVRRxEx) { /* exception */
478 data = cyy_readb(info, CyRDSR);
480 /* For statistics only */
483 else if (data & CyFRAME)
484 info->icount.frame++;
485 else if (data & CyPARITY)
486 info->icount.parity++;
487 else if (data & CyOVERRUN)
488 info->icount.overrun++;
490 if (data & info->ignore_status_mask) {
495 if (tty_buffer_request_room(tty, 1)) {
496 if (data & info->read_status_mask) {
497 if (data & CyBREAK) {
498 tty_insert_flip_char(tty,
499 cyy_readb(info, CyRDSR),
502 if (info->port.flags & ASYNC_SAK)
504 } else if (data & CyFRAME) {
505 tty_insert_flip_char(tty,
506 cyy_readb(info, CyRDSR),
509 info->idle_stats.frame_errs++;
510 } else if (data & CyPARITY) {
511 /* Pieces of seven... */
512 tty_insert_flip_char(tty,
513 cyy_readb(info, CyRDSR),
516 info->idle_stats.parity_errs++;
517 } else if (data & CyOVERRUN) {
518 tty_insert_flip_char(tty, 0,
521 /* If the flip buffer itself is
522 overflowing, we still lose
523 the next incoming character.
525 tty_insert_flip_char(tty,
526 cyy_readb(info, CyRDSR),
529 info->idle_stats.overruns++;
530 /* These two conditions may imply */
531 /* a normal read should be done. */
532 /* } else if(data & CyTIMEOUT) { */
533 /* } else if(data & CySPECHAR) { */
535 tty_insert_flip_char(tty, 0,
540 tty_insert_flip_char(tty, 0, TTY_NORMAL);
544 /* there was a software buffer overrun and nothing
545 * could be done about it!!! */
546 info->icount.buf_overrun++;
547 info->idle_stats.overruns++;
549 } else { /* normal character reception */
550 /* load # chars available from the chip */
551 char_count = cyy_readb(info, CyRDCR);
553 #ifdef CY_ENABLE_MONITORING
554 ++info->mon.int_count;
555 info->mon.char_count += char_count;
556 if (char_count > info->mon.char_max)
557 info->mon.char_max = char_count;
558 info->mon.char_last = char_count;
560 len = tty_buffer_request_room(tty, char_count);
562 data = cyy_readb(info, CyRDSR);
563 tty_insert_flip_char(tty, data, TTY_NORMAL);
564 info->idle_stats.recv_bytes++;
570 info->idle_stats.recv_idle = jiffies;
572 tty_schedule_flip(tty);
576 cyy_writeb(info, CyRIR, save_xir & 0x3f);
577 cyy_writeb(info, CyCAR, save_car);
580 static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
581 void __iomem *base_addr)
583 struct cyclades_port *info;
584 struct tty_struct *tty;
585 int char_count, index = cinfo->bus_index;
586 u8 save_xir, channel, save_car, outch;
588 /* Since we only get here when the transmit buffer
589 is empty, we know we can always stuff a dozen
591 #ifdef CY_DEBUG_INTERRUPTS
592 printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
595 /* determine the channel & change to that context */
596 save_xir = readb(base_addr + (CyTIR << index));
597 channel = save_xir & CyIRChannel;
598 save_car = readb(base_addr + (CyCAR << index));
599 cy_writeb(base_addr + (CyCAR << index), save_xir);
601 /* validate the port# (as configured and open) */
602 if (channel + chip * 4 >= cinfo->nports) {
603 cy_writeb(base_addr + (CySRER << index),
604 readb(base_addr + (CySRER << index)) & ~CyTxRdy);
607 info = &cinfo->ports[channel + chip * 4];
608 tty = tty_port_tty_get(&info->port);
610 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
614 /* load the on-chip space for outbound data */
615 char_count = info->xmit_fifo_size;
617 if (info->x_char) { /* send special char */
618 outch = info->x_char;
619 cyy_writeb(info, CyTDR, outch);
625 if (info->breakon || info->breakoff) {
627 cyy_writeb(info, CyTDR, 0);
628 cyy_writeb(info, CyTDR, 0x81);
632 if (info->breakoff) {
633 cyy_writeb(info, CyTDR, 0);
634 cyy_writeb(info, CyTDR, 0x83);
640 while (char_count-- > 0) {
641 if (!info->xmit_cnt) {
642 if (cyy_readb(info, CySRER) & CyTxMpty) {
643 cyy_writeb(info, CySRER,
644 cyy_readb(info, CySRER) & ~CyTxMpty);
646 cyy_writeb(info, CySRER, CyTxMpty |
647 (cyy_readb(info, CySRER) & ~CyTxRdy));
651 if (info->port.xmit_buf == NULL) {
652 cyy_writeb(info, CySRER,
653 cyy_readb(info, CySRER) & ~CyTxRdy);
656 if (tty->stopped || tty->hw_stopped) {
657 cyy_writeb(info, CySRER,
658 cyy_readb(info, CySRER) & ~CyTxRdy);
661 /* Because the Embedded Transmit Commands have been enabled,
662 * we must check to see if the escape character, NULL, is being
663 * sent. If it is, we must ensure that there is room for it to
664 * be doubled in the output stream. Therefore we no longer
665 * advance the pointer when the character is fetched, but
666 * rather wait until after the check for a NULL output
667 * character. This is necessary because there may not be room
668 * for the two chars needed to send a NULL.)
670 outch = info->port.xmit_buf[info->xmit_tail];
673 info->xmit_tail = (info->xmit_tail + 1) &
674 (SERIAL_XMIT_SIZE - 1);
675 cyy_writeb(info, CyTDR, outch);
678 if (char_count > 1) {
680 info->xmit_tail = (info->xmit_tail + 1) &
681 (SERIAL_XMIT_SIZE - 1);
682 cyy_writeb(info, CyTDR, outch);
683 cyy_writeb(info, CyTDR, 0);
695 cyy_writeb(info, CyTIR, save_xir & 0x3f);
696 cyy_writeb(info, CyCAR, save_car);
699 static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
700 void __iomem *base_addr)
702 struct cyclades_port *info;
703 struct tty_struct *tty;
704 int index = cinfo->bus_index;
705 u8 save_xir, channel, save_car, mdm_change, mdm_status;
707 /* determine the channel & change to that context */
708 save_xir = readb(base_addr + (CyMIR << index));
709 channel = save_xir & CyIRChannel;
710 info = &cinfo->ports[channel + chip * 4];
711 save_car = cyy_readb(info, CyCAR);
712 cyy_writeb(info, CyCAR, save_xir);
714 mdm_change = cyy_readb(info, CyMISR);
715 mdm_status = cyy_readb(info, CyMSVR1);
717 tty = tty_port_tty_get(&info->port);
721 if (mdm_change & CyANY_DELTA) {
722 /* For statistics only */
723 if (mdm_change & CyDCD)
725 if (mdm_change & CyCTS)
727 if (mdm_change & CyDSR)
729 if (mdm_change & CyRI)
732 wake_up_interruptible(&info->delta_msr_wait);
735 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
736 if (mdm_status & CyDCD)
737 wake_up_interruptible(&info->port.open_wait);
741 if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
742 if (tty->hw_stopped) {
743 if (mdm_status & CyCTS) {
744 /* cy_start isn't used
747 cyy_writeb(info, CySRER,
748 cyy_readb(info, CySRER) | CyTxRdy);
752 if (!(mdm_status & CyCTS)) {
753 /* cy_stop isn't used
756 cyy_writeb(info, CySRER,
757 cyy_readb(info, CySRER) & ~CyTxRdy);
761 /* if (mdm_change & CyDSR) {
763 if (mdm_change & CyRI) {
768 cyy_writeb(info, CyMIR, save_xir & 0x3f);
769 cyy_writeb(info, CyCAR, save_car);
772 /* The real interrupt service routine is called
773 whenever the card wants its hand held--chars
774 received, out buffer empty, modem change, etc.
776 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
779 struct cyclades_card *cinfo = dev_id;
780 void __iomem *base_addr, *card_base_addr;
781 unsigned int chip, too_many, had_work;
784 if (unlikely(cinfo == NULL)) {
785 #ifdef CY_DEBUG_INTERRUPTS
786 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
789 return IRQ_NONE; /* spurious interrupt */
792 card_base_addr = cinfo->base_addr;
793 index = cinfo->bus_index;
795 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
796 if (unlikely(card_base_addr == NULL))
799 /* This loop checks all chips in the card. Make a note whenever
800 _any_ chip had some work to do, as this is considered an
801 indication that there will be more to do. Only when no chip
802 has any work does this outermost loop exit.
806 for (chip = 0; chip < cinfo->num_chips; chip++) {
807 base_addr = cinfo->base_addr +
808 (cy_chip_offset[chip] << index);
810 while ((status = readb(base_addr +
811 (CySVRR << index))) != 0x00) {
813 /* The purpose of the following test is to ensure that
814 no chip can monopolize the driver. This forces the
815 chips to be checked in a round-robin fashion (after
816 draining each of a bunch (1000) of characters).
818 if (1000 < too_many++)
820 spin_lock(&cinfo->card_lock);
821 if (status & CySRReceive) /* rx intr */
822 cyy_chip_rx(cinfo, chip, base_addr);
823 if (status & CySRTransmit) /* tx intr */
824 cyy_chip_tx(cinfo, chip, base_addr);
825 if (status & CySRModem) /* modem intr */
826 cyy_chip_modem(cinfo, chip, base_addr);
827 spin_unlock(&cinfo->card_lock);
832 /* clear interrupts */
833 spin_lock(&cinfo->card_lock);
834 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
835 /* Cy_ClrIntr is 0x1800 */
836 spin_unlock(&cinfo->card_lock);
838 } /* cyy_interrupt */
840 static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
843 struct cyclades_card *card = info->card;
844 int channel = info->line - card->first_line;
845 u32 rts, dtr, msvrr, msvrd;
849 if (info->rtsdtr_inv) {
860 if (set & TIOCM_RTS) {
861 cyy_writeb(info, CyCAR, channel);
862 cyy_writeb(info, msvrr, rts);
864 if (clear & TIOCM_RTS) {
865 cyy_writeb(info, CyCAR, channel);
866 cyy_writeb(info, msvrr, ~rts);
868 if (set & TIOCM_DTR) {
869 cyy_writeb(info, CyCAR, channel);
870 cyy_writeb(info, msvrd, dtr);
872 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
873 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
874 cyy_readb(info, CyMSVR1),
875 cyy_readb(info, CyMSVR2));
878 if (clear & TIOCM_DTR) {
879 cyy_writeb(info, CyCAR, channel);
880 cyy_writeb(info, msvrd, ~dtr);
882 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
883 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
884 cyy_readb(info, CyMSVR1),
885 cyy_readb(info, CyMSVR2));
890 /***********************************************************/
891 /********* End of block of Cyclom-Y specific code **********/
892 /******** Start of block of Cyclades-Z specific code *******/
893 /***********************************************************/
896 cyz_fetch_msg(struct cyclades_card *cinfo,
897 __u32 *channel, __u8 *cmd, __u32 *param)
899 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
900 unsigned long loc_doorbell;
902 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
904 *cmd = (char)(0xff & loc_doorbell);
905 *channel = readl(&board_ctrl->fwcmd_channel);
906 *param = (__u32) readl(&board_ctrl->fwcmd_param);
907 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
911 } /* cyz_fetch_msg */
914 cyz_issue_cmd(struct cyclades_card *cinfo,
915 __u32 channel, __u8 cmd, __u32 param)
917 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
918 __u32 __iomem *pci_doorbell;
921 if (!cyz_is_loaded(cinfo))
925 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
926 while ((readl(pci_doorbell) & 0xff) != 0) {
928 return (int)(readl(pci_doorbell) & 0xff);
931 cy_writel(&board_ctrl->hcmd_channel, channel);
932 cy_writel(&board_ctrl->hcmd_param, param);
933 cy_writel(pci_doorbell, (long)cmd);
936 } /* cyz_issue_cmd */
938 static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
940 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
941 struct cyclades_card *cinfo = info->card;
942 unsigned int char_count;
949 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
951 rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
952 rx_put = readl(&buf_ctrl->rx_put);
953 rx_bufsize = readl(&buf_ctrl->rx_bufsize);
954 rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
955 if (rx_put >= rx_get)
956 char_count = rx_put - rx_get;
958 char_count = rx_put - rx_get + rx_bufsize;
961 #ifdef CY_ENABLE_MONITORING
962 info->mon.int_count++;
963 info->mon.char_count += char_count;
964 if (char_count > info->mon.char_max)
965 info->mon.char_max = char_count;
966 info->mon.char_last = char_count;
969 /* flush received characters */
970 new_rx_get = (new_rx_get + char_count) &
972 info->rflush_count++;
975 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
976 for performance, but because of buffer boundaries, there
977 may be several steps to the operation */
979 len = tty_prepare_flip_string(tty, &buf,
984 len = min_t(unsigned int, min(len, char_count),
985 rx_bufsize - new_rx_get);
987 memcpy_fromio(buf, cinfo->base_addr +
988 rx_bufaddr + new_rx_get, len);
990 new_rx_get = (new_rx_get + len) &
993 info->icount.rx += len;
994 info->idle_stats.recv_bytes += len;
997 len = tty_buffer_request_room(tty, char_count);
999 data = readb(cinfo->base_addr + rx_bufaddr +
1001 new_rx_get = (new_rx_get + 1) &
1003 tty_insert_flip_char(tty, data, TTY_NORMAL);
1004 info->idle_stats.recv_bytes++;
1008 #ifdef CONFIG_CYZ_INTR
1009 /* Recalculate the number of chars in the RX buffer and issue
1010 a cmd in case it's higher than the RX high water mark */
1011 rx_put = readl(&buf_ctrl->rx_put);
1012 if (rx_put >= rx_get)
1013 char_count = rx_put - rx_get;
1015 char_count = rx_put - rx_get + rx_bufsize;
1016 if (char_count >= readl(&buf_ctrl->rx_threshold) &&
1017 !timer_pending(&cyz_rx_full_timer[
1019 mod_timer(&cyz_rx_full_timer[info->line],
1022 info->idle_stats.recv_idle = jiffies;
1023 tty_schedule_flip(tty);
1026 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1030 static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
1032 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1033 struct cyclades_card *cinfo = info->card;
1035 unsigned int char_count;
1039 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1041 if (info->xmit_cnt <= 0) /* Nothing to transmit */
1044 tx_get = readl(&buf_ctrl->tx_get);
1045 tx_put = readl(&buf_ctrl->tx_put);
1046 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1047 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1048 if (tx_put >= tx_get)
1049 char_count = tx_get - tx_put - 1 + tx_bufsize;
1051 char_count = tx_get - tx_put - 1;
1058 if (info->x_char) { /* send special char */
1059 data = info->x_char;
1061 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1062 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1068 while (0 < (small_count = min_t(unsigned int,
1069 tx_bufsize - tx_put, min_t(unsigned int,
1070 (SERIAL_XMIT_SIZE - info->xmit_tail),
1071 min_t(unsigned int, info->xmit_cnt,
1074 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1076 &info->port.xmit_buf[info->xmit_tail],
1079 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1080 char_count -= small_count;
1081 info->icount.tx += small_count;
1082 info->xmit_cnt -= small_count;
1083 info->xmit_tail = (info->xmit_tail + small_count) &
1084 (SERIAL_XMIT_SIZE - 1);
1087 while (info->xmit_cnt && char_count) {
1088 data = info->port.xmit_buf[info->xmit_tail];
1090 info->xmit_tail = (info->xmit_tail + 1) &
1091 (SERIAL_XMIT_SIZE - 1);
1093 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1094 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1102 cy_writel(&buf_ctrl->tx_put, tx_put);
1106 static void cyz_handle_cmd(struct cyclades_card *cinfo)
1108 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1109 struct tty_struct *tty;
1110 struct cyclades_port *info;
1111 __u32 channel, param, fw_ver;
1116 fw_ver = readl(&board_ctrl->fw_version);
1118 while (cyz_fetch_msg(cinfo, &channel, &cmd, ¶m) == 1) {
1121 info = &cinfo->ports[channel];
1122 tty = tty_port_tty_get(&info->port);
1128 tty_insert_flip_char(tty, 0, TTY_PARITY);
1133 tty_insert_flip_char(tty, 0, TTY_FRAME);
1138 tty_insert_flip_char(tty, 0, TTY_BREAK);
1145 if (info->port.flags & ASYNC_CHECK_CD) {
1146 u32 dcd = fw_ver > 241 ? param :
1147 readl(&info->u.cyz.ch_ctrl->rs_status);
1149 wake_up_interruptible(&info->port.open_wait);
1168 complete(&info->shutdown_wait);
1171 #ifdef CONFIG_CYZ_INTR
1175 /* Reception Interrupt */
1176 #ifdef CY_DEBUG_INTERRUPTS
1177 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1178 "port %ld\n", info->card, channel);
1180 cyz_handle_rx(info, tty);
1185 /* Transmission Interrupt */
1186 #ifdef CY_DEBUG_INTERRUPTS
1187 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1188 "port %ld\n", info->card, channel);
1190 cyz_handle_tx(info, tty);
1192 #endif /* CONFIG_CYZ_INTR */
1194 /* should do something with this !!! */
1200 wake_up_interruptible(&info->delta_msr_wait);
1202 tty_schedule_flip(tty);
1207 #ifdef CONFIG_CYZ_INTR
1208 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1210 struct cyclades_card *cinfo = dev_id;
1212 if (unlikely(!cyz_is_loaded(cinfo))) {
1213 #ifdef CY_DEBUG_INTERRUPTS
1214 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1220 /* Handle the interrupts */
1221 cyz_handle_cmd(cinfo);
1224 } /* cyz_interrupt */
1226 static void cyz_rx_restart(unsigned long arg)
1228 struct cyclades_port *info = (struct cyclades_port *)arg;
1229 struct cyclades_card *card = info->card;
1231 __u32 channel = info->line - card->first_line;
1232 unsigned long flags;
1234 spin_lock_irqsave(&card->card_lock, flags);
1235 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1237 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1238 info->line, retval);
1240 spin_unlock_irqrestore(&card->card_lock, flags);
1243 #else /* CONFIG_CYZ_INTR */
1245 static void cyz_poll(unsigned long arg)
1247 struct cyclades_card *cinfo;
1248 struct cyclades_port *info;
1249 unsigned long expires = jiffies + HZ;
1250 unsigned int port, card;
1252 for (card = 0; card < NR_CARDS; card++) {
1253 cinfo = &cy_card[card];
1255 if (!cy_is_Z(cinfo))
1257 if (!cyz_is_loaded(cinfo))
1260 /* Skip first polling cycle to avoid racing conditions with the FW */
1261 if (!cinfo->intr_enabled) {
1262 cinfo->intr_enabled = 1;
1266 cyz_handle_cmd(cinfo);
1268 for (port = 0; port < cinfo->nports; port++) {
1269 struct tty_struct *tty;
1271 info = &cinfo->ports[port];
1272 tty = tty_port_tty_get(&info->port);
1273 /* OK to pass NULL to the handle functions below.
1274 They need to drop the data in that case. */
1276 if (!info->throttle)
1277 cyz_handle_rx(info, tty);
1278 cyz_handle_tx(info, tty);
1281 /* poll every 'cyz_polling_cycle' period */
1282 expires = jiffies + cyz_polling_cycle;
1284 mod_timer(&cyz_timerlist, expires);
1287 #endif /* CONFIG_CYZ_INTR */
1289 /********** End of block of Cyclades-Z specific code *********/
1290 /***********************************************************/
1292 /* This is called whenever a port becomes active;
1293 interrupts are enabled and DTR & RTS are turned on.
1295 static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1297 struct cyclades_card *card;
1298 unsigned long flags;
1304 channel = info->line - card->first_line;
1306 page = get_zeroed_page(GFP_KERNEL);
1310 spin_lock_irqsave(&card->card_lock, flags);
1312 if (info->port.flags & ASYNC_INITIALIZED)
1316 set_bit(TTY_IO_ERROR, &tty->flags);
1320 if (info->port.xmit_buf)
1323 info->port.xmit_buf = (unsigned char *)page;
1325 spin_unlock_irqrestore(&card->card_lock, flags);
1327 cy_set_line_char(info, tty);
1329 if (!cy_is_Z(card)) {
1332 spin_lock_irqsave(&card->card_lock, flags);
1334 cyy_writeb(info, CyCAR, channel);
1336 cyy_writeb(info, CyRTPR,
1337 (info->default_timeout ? info->default_timeout : 0x02));
1338 /* 10ms rx timeout */
1340 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1342 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1344 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1346 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1348 if (!cyz_is_loaded(card))
1351 #ifdef CY_DEBUG_OPEN
1352 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1353 "base_addr %p\n", card, channel, card->base_addr);
1355 spin_lock_irqsave(&card->card_lock, flags);
1357 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1359 #ifdef CONFIG_CYZ_INTR
1360 cy_writel(&ch_ctrl->intr_enable,
1361 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1362 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1364 cy_writel(&ch_ctrl->intr_enable,
1365 C_IN_IOCTLW | C_IN_MDCD);
1366 #endif /* CONFIG_CYZ_INTR */
1368 #ifdef CONFIG_CYZ_INTR
1369 cy_writel(&ch_ctrl->intr_enable,
1370 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1371 C_IN_RXNNDT | C_IN_MDCD);
1373 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1374 #endif /* CONFIG_CYZ_INTR */
1377 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1379 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1380 "%x\n", info->line, retval);
1383 /* Flush RX buffers before raising DTR and RTS */
1384 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1386 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1387 "%x\n", info->line, retval);
1390 /* set timeout !!! */
1391 /* set RTS and DTR !!! */
1392 tty_port_raise_dtr_rts(&info->port);
1394 /* enable send, recv, modem !!! */
1397 info->port.flags |= ASYNC_INITIALIZED;
1399 clear_bit(TTY_IO_ERROR, &tty->flags);
1400 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1401 info->breakon = info->breakoff = 0;
1402 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1403 info->idle_stats.in_use =
1404 info->idle_stats.recv_idle =
1405 info->idle_stats.xmit_idle = jiffies;
1407 spin_unlock_irqrestore(&card->card_lock, flags);
1409 #ifdef CY_DEBUG_OPEN
1410 printk(KERN_DEBUG "cyc startup done\n");
1415 spin_unlock_irqrestore(&card->card_lock, flags);
1420 static void start_xmit(struct cyclades_port *info)
1422 struct cyclades_card *card = info->card;
1423 unsigned long flags;
1424 int channel = info->line - card->first_line;
1426 if (!cy_is_Z(card)) {
1427 spin_lock_irqsave(&card->card_lock, flags);
1428 cyy_writeb(info, CyCAR, channel & 0x03);
1429 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1430 spin_unlock_irqrestore(&card->card_lock, flags);
1432 #ifdef CONFIG_CYZ_INTR
1435 spin_lock_irqsave(&card->card_lock, flags);
1436 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1438 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1439 "%x\n", info->line, retval);
1441 spin_unlock_irqrestore(&card->card_lock, flags);
1442 #else /* CONFIG_CYZ_INTR */
1443 /* Don't have to do anything at this time */
1444 #endif /* CONFIG_CYZ_INTR */
1449 * This routine shuts down a serial port; interrupts are disabled,
1450 * and DTR is dropped if the hangup on close termio flag is on.
1452 static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1454 struct cyclades_card *card;
1455 unsigned long flags;
1458 if (!(info->port.flags & ASYNC_INITIALIZED))
1462 channel = info->line - card->first_line;
1463 if (!cy_is_Z(card)) {
1464 spin_lock_irqsave(&card->card_lock, flags);
1466 /* Clear delta_msr_wait queue to avoid mem leaks. */
1467 wake_up_interruptible(&info->delta_msr_wait);
1469 if (info->port.xmit_buf) {
1470 unsigned char *temp;
1471 temp = info->port.xmit_buf;
1472 info->port.xmit_buf = NULL;
1473 free_page((unsigned long)temp);
1475 if (tty->termios->c_cflag & HUPCL)
1476 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1478 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1479 /* it may be appropriate to clear _XMIT at
1480 some later date (after testing)!!! */
1482 set_bit(TTY_IO_ERROR, &tty->flags);
1483 info->port.flags &= ~ASYNC_INITIALIZED;
1484 spin_unlock_irqrestore(&card->card_lock, flags);
1486 #ifdef CY_DEBUG_OPEN
1487 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1488 "base_addr %p\n", card, channel, card->base_addr);
1491 if (!cyz_is_loaded(card))
1494 spin_lock_irqsave(&card->card_lock, flags);
1496 if (info->port.xmit_buf) {
1497 unsigned char *temp;
1498 temp = info->port.xmit_buf;
1499 info->port.xmit_buf = NULL;
1500 free_page((unsigned long)temp);
1503 if (tty->termios->c_cflag & HUPCL)
1504 tty_port_lower_dtr_rts(&info->port);
1506 set_bit(TTY_IO_ERROR, &tty->flags);
1507 info->port.flags &= ~ASYNC_INITIALIZED;
1509 spin_unlock_irqrestore(&card->card_lock, flags);
1512 #ifdef CY_DEBUG_OPEN
1513 printk(KERN_DEBUG "cyc shutdown done\n");
1518 * ------------------------------------------------------------
1519 * cy_open() and friends
1520 * ------------------------------------------------------------
1524 * This routine is called whenever a serial port is opened. It
1525 * performs the serial-specific initialization for the tty structure.
1527 static int cy_open(struct tty_struct *tty, struct file *filp)
1529 struct cyclades_port *info;
1530 unsigned int i, line;
1534 if (tty->index < 0 || NR_PORTS <= line)
1537 for (i = 0; i < NR_CARDS; i++)
1538 if (line < cy_card[i].first_line + cy_card[i].nports &&
1539 line >= cy_card[i].first_line)
1543 info = &cy_card[i].ports[line - cy_card[i].first_line];
1547 /* If the card's firmware hasn't been loaded,
1548 treat it as absent from the system. This
1549 will make the user pay attention.
1551 if (cy_is_Z(info->card)) {
1552 struct cyclades_card *cinfo = info->card;
1553 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1555 if (!cyz_is_loaded(cinfo)) {
1556 if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1557 readl(&firm_id->signature) ==
1559 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1560 "need an external power supply for "
1561 "this number of ports.\nFirmware "
1564 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1569 #ifdef CONFIG_CYZ_INTR
1571 /* In case this Z board is operating in interrupt mode, its
1572 interrupts should be enabled as soon as the first open
1573 happens to one of its ports. */
1574 if (!cinfo->intr_enabled) {
1577 /* Enable interrupts on the PLX chip */
1578 intr = readw(&cinfo->ctl_addr.p9060->
1579 intr_ctrl_stat) | 0x0900;
1580 cy_writew(&cinfo->ctl_addr.p9060->
1581 intr_ctrl_stat, intr);
1582 /* Enable interrupts on the FW */
1583 retval = cyz_issue_cmd(cinfo, 0,
1586 printk(KERN_ERR "cyc:IRQ enable retval "
1587 "was %x\n", retval);
1589 cinfo->intr_enabled = 1;
1592 #endif /* CONFIG_CYZ_INTR */
1593 /* Make sure this Z port really exists in hardware */
1594 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1597 #ifdef CY_DEBUG_OTHER
1598 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1600 tty->driver_data = info;
1601 if (serial_paranoia_check(info, tty->name, "cy_open"))
1604 #ifdef CY_DEBUG_OPEN
1605 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1609 #ifdef CY_DEBUG_COUNT
1610 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1611 current->pid, info->port.count);
1615 * If the port is the middle of closing, bail out now
1617 if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1618 wait_event_interruptible(info->port.close_wait,
1619 !(info->port.flags & ASYNC_CLOSING));
1620 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1624 * Start up serial port
1626 retval = cy_startup(info, tty);
1630 retval = tty_port_block_til_ready(&info->port, tty, filp);
1632 #ifdef CY_DEBUG_OPEN
1633 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1634 "with %d\n", retval);
1640 tty_port_tty_set(&info->port, tty);
1642 #ifdef CY_DEBUG_OPEN
1643 printk(KERN_DEBUG "cyc:cy_open done\n");
1649 * cy_wait_until_sent() --- wait until the transmitter is empty
1651 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1653 struct cyclades_card *card;
1654 struct cyclades_port *info = tty->driver_data;
1655 unsigned long orig_jiffies;
1658 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1661 if (info->xmit_fifo_size == 0)
1662 return; /* Just in case.... */
1664 orig_jiffies = jiffies;
1667 * Set the check interval to be 1/5 of the estimated time to
1668 * send a single character, and make it at least 1. The check
1669 * interval should also be less than the timeout.
1671 * Note: we have to use pretty tight timings here to satisfy
1674 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1675 char_time = char_time / 5;
1681 char_time = min(char_time, timeout);
1683 * If the transmitter hasn't cleared in twice the approximate
1684 * amount of time to send the entire FIFO, it probably won't
1685 * ever clear. This assumes the UART isn't doing flow
1686 * control, which is currently the case. Hence, if it ever
1687 * takes longer than info->timeout, this is probably due to a
1688 * UART bug of some kind. So, we clamp the timeout parameter at
1691 if (!timeout || timeout > 2 * info->timeout)
1692 timeout = 2 * info->timeout;
1693 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1694 printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
1695 timeout, char_time, jiffies);
1698 if (!cy_is_Z(card)) {
1699 while (cyy_readb(info, CySRER) & CyTxRdy) {
1700 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1701 printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
1703 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1705 if (timeout && time_after(jiffies, orig_jiffies +
1710 /* Run one more char cycle */
1711 msleep_interruptible(jiffies_to_msecs(char_time * 5));
1713 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1714 printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
1718 static void cy_flush_buffer(struct tty_struct *tty)
1720 struct cyclades_port *info = tty->driver_data;
1721 struct cyclades_card *card;
1722 int channel, retval;
1723 unsigned long flags;
1726 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1729 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1733 channel = info->line - card->first_line;
1735 spin_lock_irqsave(&card->card_lock, flags);
1736 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1737 spin_unlock_irqrestore(&card->card_lock, flags);
1739 if (cy_is_Z(card)) { /* If it is a Z card, flush the on-board
1741 spin_lock_irqsave(&card->card_lock, flags);
1742 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1744 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1745 "was %x\n", info->line, retval);
1747 spin_unlock_irqrestore(&card->card_lock, flags);
1750 } /* cy_flush_buffer */
1754 * This routine is called when a particular tty device is closed.
1756 static void cy_close(struct tty_struct *tty, struct file *filp)
1758 struct cyclades_port *info = tty->driver_data;
1759 struct cyclades_card *card;
1760 unsigned long flags;
1763 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1768 if (!tty_port_close_start(&info->port, tty, filp))
1771 channel = info->line - card->first_line;
1772 spin_lock_irqsave(&card->card_lock, flags);
1774 if (!cy_is_Z(card)) {
1775 /* Stop accepting input */
1776 cyy_writeb(info, CyCAR, channel & 0x03);
1777 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1778 if (info->port.flags & ASYNC_INITIALIZED) {
1779 /* Waiting for on-board buffers to be empty before
1781 spin_unlock_irqrestore(&card->card_lock, flags);
1782 cy_wait_until_sent(tty, info->timeout);
1783 spin_lock_irqsave(&card->card_lock, flags);
1787 /* Waiting for on-board buffers to be empty before closing
1789 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1792 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1793 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1795 printk(KERN_DEBUG "cyc:cy_close retval on "
1796 "ttyC%d was %x\n", info->line, retval);
1798 spin_unlock_irqrestore(&card->card_lock, flags);
1799 wait_for_completion_interruptible(&info->shutdown_wait);
1800 spin_lock_irqsave(&card->card_lock, flags);
1805 spin_unlock_irqrestore(&card->card_lock, flags);
1806 cy_shutdown(info, tty);
1807 cy_flush_buffer(tty);
1809 tty_port_tty_set(&info->port, NULL);
1811 tty_port_close_end(&info->port, tty);
1814 /* This routine gets called when tty_write has put something into
1815 * the write_queue. The characters may come from user space or
1818 * This routine will return the number of characters actually
1819 * accepted for writing.
1821 * If the port is not already transmitting stuff, start it off by
1822 * enabling interrupts. The interrupt service routine will then
1823 * ensure that the characters are sent.
1824 * If the port is already active, there is no need to kick it.
1827 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1829 struct cyclades_port *info = tty->driver_data;
1830 unsigned long flags;
1834 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1837 if (serial_paranoia_check(info, tty->name, "cy_write"))
1840 if (!info->port.xmit_buf)
1843 spin_lock_irqsave(&info->card->card_lock, flags);
1845 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1846 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1851 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1852 info->xmit_head = (info->xmit_head + c) &
1853 (SERIAL_XMIT_SIZE - 1);
1854 info->xmit_cnt += c;
1859 spin_unlock_irqrestore(&info->card->card_lock, flags);
1861 info->idle_stats.xmit_bytes += ret;
1862 info->idle_stats.xmit_idle = jiffies;
1864 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1871 * This routine is called by the kernel to write a single
1872 * character to the tty device. If the kernel uses this routine,
1873 * it must call the flush_chars() routine (if defined) when it is
1874 * done stuffing characters into the driver. If there is no room
1875 * in the queue, the character is ignored.
1877 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1879 struct cyclades_port *info = tty->driver_data;
1880 unsigned long flags;
1883 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1886 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1889 if (!info->port.xmit_buf)
1892 spin_lock_irqsave(&info->card->card_lock, flags);
1893 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1894 spin_unlock_irqrestore(&info->card->card_lock, flags);
1898 info->port.xmit_buf[info->xmit_head++] = ch;
1899 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1901 info->idle_stats.xmit_bytes++;
1902 info->idle_stats.xmit_idle = jiffies;
1903 spin_unlock_irqrestore(&info->card->card_lock, flags);
1908 * This routine is called by the kernel after it has written a
1909 * series of characters to the tty device using put_char().
1911 static void cy_flush_chars(struct tty_struct *tty)
1913 struct cyclades_port *info = tty->driver_data;
1916 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1919 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1922 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1923 !info->port.xmit_buf)
1927 } /* cy_flush_chars */
1930 * This routine returns the numbers of characters the tty driver
1931 * will accept for queuing to be written. This number is subject
1932 * to change as output buffers get emptied, or if the output flow
1933 * control is activated.
1935 static int cy_write_room(struct tty_struct *tty)
1937 struct cyclades_port *info = tty->driver_data;
1941 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1944 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1946 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1950 } /* cy_write_room */
1952 static int cy_chars_in_buffer(struct tty_struct *tty)
1954 struct cyclades_port *info = tty->driver_data;
1956 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1959 #ifdef Z_EXT_CHARS_IN_BUFFER
1960 if (!cy_is_Z(info->card)) {
1961 #endif /* Z_EXT_CHARS_IN_BUFFER */
1963 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1964 info->line, info->xmit_cnt);
1966 return info->xmit_cnt;
1967 #ifdef Z_EXT_CHARS_IN_BUFFER
1969 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1971 __u32 tx_put, tx_get, tx_bufsize;
1974 tx_get = readl(&buf_ctrl->tx_get);
1975 tx_put = readl(&buf_ctrl->tx_put);
1976 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1977 if (tx_put >= tx_get)
1978 char_count = tx_put - tx_get;
1980 char_count = tx_put - tx_get + tx_bufsize;
1982 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1983 info->line, info->xmit_cnt + char_count);
1986 return info->xmit_cnt + char_count;
1988 #endif /* Z_EXT_CHARS_IN_BUFFER */
1989 } /* cy_chars_in_buffer */
1992 * ------------------------------------------------------------
1993 * cy_ioctl() and friends
1994 * ------------------------------------------------------------
1997 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1999 int co, co_val, bpr;
2000 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
2004 info->tbpr = info->tco = info->rbpr = info->rco = 0;
2008 /* determine which prescaler to use */
2009 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
2010 if (cy_clock / co_val / baud > 63)
2014 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
2018 info->tbpr = info->rbpr = bpr;
2019 info->tco = info->rco = co;
2023 * This routine finds or computes the various line characteristics.
2024 * It used to be called config_setup
2026 static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
2028 struct cyclades_card *card;
2029 unsigned long flags;
2031 unsigned cflag, iflag;
2032 int baud, baud_rate = 0;
2035 if (!tty->termios) /* XXX can this happen at all? */
2038 if (info->line == -1)
2041 cflag = tty->termios->c_cflag;
2042 iflag = tty->termios->c_iflag;
2045 * Set up the tty->alt_speed kludge
2047 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2048 tty->alt_speed = 57600;
2049 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2050 tty->alt_speed = 115200;
2051 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2052 tty->alt_speed = 230400;
2053 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2054 tty->alt_speed = 460800;
2057 channel = info->line - card->first_line;
2059 if (!cy_is_Z(card)) {
2061 baud = tty_get_baud_rate(tty);
2062 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2064 if (info->custom_divisor)
2065 baud_rate = info->baud / info->custom_divisor;
2067 baud_rate = info->baud;
2068 } else if (baud > CD1400_MAX_SPEED) {
2069 baud = CD1400_MAX_SPEED;
2071 /* find the baud index */
2072 for (i = 0; i < 20; i++) {
2073 if (baud == baud_table[i])
2077 i = 19; /* CD1400_MAX_SPEED */
2079 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2081 cyy_baud_calc(info, baud_rate);
2083 if (info->chip_rev >= CD1400_REV_J) {
2084 /* It is a CD1400 rev. J or later */
2085 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
2086 info->tco = baud_co_60[i]; /* Tx CO */
2087 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
2088 info->rco = baud_co_60[i]; /* Rx CO */
2090 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
2091 info->tco = baud_co_25[i]; /* Tx CO */
2092 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
2093 info->rco = baud_co_25[i]; /* Rx CO */
2096 if (baud_table[i] == 134) {
2097 /* get it right for 134.5 baud */
2098 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2100 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2102 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2104 } else if (baud_table[i]) {
2105 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2107 /* this needs to be propagated into the card info */
2111 /* By tradition (is it a standard?) a baud rate of zero
2112 implies the line should be/has been closed. A bit
2113 later in this routine such a test is performed. */
2115 /* byte size and parity */
2118 /* receive threshold */
2119 info->cor3 = (info->default_threshold ?
2120 info->default_threshold : baud_cor3[i]);
2122 switch (cflag & CSIZE) {
2124 info->cor1 = Cy_5_BITS;
2127 info->cor1 = Cy_6_BITS;
2130 info->cor1 = Cy_7_BITS;
2133 info->cor1 = Cy_8_BITS;
2137 info->cor1 |= Cy_2_STOP;
2139 if (cflag & PARENB) {
2141 info->cor1 |= CyPARITY_O;
2143 info->cor1 |= CyPARITY_E;
2145 info->cor1 |= CyPARITY_NONE;
2147 /* CTS flow control flag */
2148 if (cflag & CRTSCTS) {
2149 info->port.flags |= ASYNC_CTS_FLOW;
2150 info->cor2 |= CyCtsAE;
2152 info->port.flags &= ~ASYNC_CTS_FLOW;
2153 info->cor2 &= ~CyCtsAE;
2156 info->port.flags &= ~ASYNC_CHECK_CD;
2158 info->port.flags |= ASYNC_CHECK_CD;
2160 /***********************************************
2161 The hardware option, CyRtsAO, presents RTS when
2162 the chip has characters to send. Since most modems
2163 use RTS as reverse (inbound) flow control, this
2164 option is not used. If inbound flow control is
2165 necessary, DTR can be programmed to provide the
2166 appropriate signals for use with a non-standard
2167 cable. Contact Marcio Saito for details.
2168 ***********************************************/
2172 spin_lock_irqsave(&card->card_lock, flags);
2173 cyy_writeb(info, CyCAR, channel);
2175 /* tx and rx baud rate */
2177 cyy_writeb(info, CyTCOR, info->tco);
2178 cyy_writeb(info, CyTBPR, info->tbpr);
2179 cyy_writeb(info, CyRCOR, info->rco);
2180 cyy_writeb(info, CyRBPR, info->rbpr);
2182 /* set line characteristics according configuration */
2184 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2185 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2186 cyy_writeb(info, CyCOR1, info->cor1);
2187 cyy_writeb(info, CyCOR2, info->cor2);
2188 cyy_writeb(info, CyCOR3, info->cor3);
2189 cyy_writeb(info, CyCOR4, info->cor4);
2190 cyy_writeb(info, CyCOR5, info->cor5);
2192 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2195 /* !!! Is this needed? */
2196 cyy_writeb(info, CyCAR, channel);
2197 cyy_writeb(info, CyRTPR,
2198 (info->default_timeout ? info->default_timeout : 0x02));
2199 /* 10ms rx timeout */
2201 if (C_CLOCAL(tty)) {
2202 /* without modem intr */
2203 cyy_writeb(info, CySRER,
2204 cyy_readb(info, CySRER) | CyMdmCh);
2205 /* act on 1->0 modem transitions */
2206 if ((cflag & CRTSCTS) && info->rflow) {
2207 cyy_writeb(info, CyMCOR1,
2208 (CyCTS | rflow_thr[i]));
2210 cyy_writeb(info, CyMCOR1,
2213 /* act on 0->1 modem transitions */
2214 cyy_writeb(info, CyMCOR2, CyCTS);
2216 /* without modem intr */
2217 cyy_writeb(info, CySRER,
2218 cyy_readb(info, CySRER) | CyMdmCh);
2219 /* act on 1->0 modem transitions */
2220 if ((cflag & CRTSCTS) && info->rflow) {
2221 cyy_writeb(info, CyMCOR1,
2222 (CyDSR | CyCTS | CyRI | CyDCD |
2225 cyy_writeb(info, CyMCOR1,
2226 CyDSR | CyCTS | CyRI | CyDCD);
2228 /* act on 0->1 modem transitions */
2229 cyy_writeb(info, CyMCOR2,
2230 CyDSR | CyCTS | CyRI | CyDCD);
2233 if (i == 0) /* baud rate is zero, turn off line */
2234 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2236 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2238 clear_bit(TTY_IO_ERROR, &tty->flags);
2239 spin_unlock_irqrestore(&card->card_lock, flags);
2242 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2246 if (!cyz_is_loaded(card))
2250 baud = tty_get_baud_rate(tty);
2251 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2253 if (info->custom_divisor)
2254 baud_rate = info->baud / info->custom_divisor;
2256 baud_rate = info->baud;
2257 } else if (baud > CYZ_MAX_SPEED) {
2258 baud = CYZ_MAX_SPEED;
2260 cy_writel(&ch_ctrl->comm_baud, baud);
2263 /* get it right for 134.5 baud */
2264 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2266 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2268 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2271 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2273 /* this needs to be propagated into the card info */
2278 /* byte size and parity */
2279 switch (cflag & CSIZE) {
2281 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2284 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2287 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2290 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2293 if (cflag & CSTOPB) {
2294 cy_writel(&ch_ctrl->comm_data_l,
2295 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2297 cy_writel(&ch_ctrl->comm_data_l,
2298 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2300 if (cflag & PARENB) {
2302 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2304 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2306 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2308 /* CTS flow control flag */
2309 if (cflag & CRTSCTS) {
2310 cy_writel(&ch_ctrl->hw_flow,
2311 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2313 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2314 ~(C_RS_CTS | C_RS_RTS));
2316 /* As the HW flow control is done in firmware, the driver
2317 doesn't need to care about it */
2318 info->port.flags &= ~ASYNC_CTS_FLOW;
2320 /* XON/XOFF/XANY flow control flags */
2323 sw_flow |= C_FL_OXX;
2325 sw_flow |= C_FL_OIXANY;
2327 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2329 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2331 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2332 "was %x\n", info->line, retval);
2335 /* CD sensitivity */
2337 info->port.flags &= ~ASYNC_CHECK_CD;
2339 info->port.flags |= ASYNC_CHECK_CD;
2341 if (baud == 0) { /* baud rate is zero, turn off line */
2342 cy_writel(&ch_ctrl->rs_control,
2343 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2345 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2348 cy_writel(&ch_ctrl->rs_control,
2349 readl(&ch_ctrl->rs_control) | C_RS_DTR);
2351 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2355 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2357 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2358 "was %x\n", info->line, retval);
2361 clear_bit(TTY_IO_ERROR, &tty->flags);
2363 } /* set_line_char */
2365 static int cy_get_serial_info(struct cyclades_port *info,
2366 struct serial_struct __user *retinfo)
2368 struct cyclades_card *cinfo = info->card;
2369 struct serial_struct tmp = {
2372 .port = (info->card - cy_card) * 0x100 + info->line -
2375 .flags = info->port.flags,
2376 .close_delay = info->port.close_delay,
2377 .closing_wait = info->port.closing_wait,
2378 .baud_base = info->baud,
2379 .custom_divisor = info->custom_divisor,
2382 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2386 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2387 struct serial_struct __user *new_info)
2389 struct serial_struct new_serial;
2391 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2394 if (!capable(CAP_SYS_ADMIN)) {
2395 if (new_serial.close_delay != info->port.close_delay ||
2396 new_serial.baud_base != info->baud ||
2397 (new_serial.flags & ASYNC_FLAGS &
2399 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2401 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2402 (new_serial.flags & ASYNC_USR_MASK);
2403 info->baud = new_serial.baud_base;
2404 info->custom_divisor = new_serial.custom_divisor;
2405 goto check_and_exit;
2409 * OK, past this point, all the error checking has been done.
2410 * At this point, we start making changes.....
2413 info->baud = new_serial.baud_base;
2414 info->custom_divisor = new_serial.custom_divisor;
2415 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2416 (new_serial.flags & ASYNC_FLAGS);
2417 info->port.close_delay = new_serial.close_delay * HZ / 100;
2418 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2421 if (info->port.flags & ASYNC_INITIALIZED) {
2422 cy_set_line_char(info, tty);
2425 return cy_startup(info, tty);
2427 } /* set_serial_info */
2430 * get_lsr_info - get line status register info
2432 * Purpose: Let user call ioctl() to get info when the UART physically
2433 * is emptied. On bus types like RS485, the transmitter must
2434 * release the bus after transmitting. This must be done when
2435 * the transmit shift register is empty, not be done when the
2436 * transmit holding register is empty. This functionality
2437 * allows an RS485 driver to be written in user space.
2439 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2441 struct cyclades_card *card = info->card;
2442 unsigned int result;
2443 unsigned long flags;
2446 if (!cy_is_Z(card)) {
2447 spin_lock_irqsave(&card->card_lock, flags);
2448 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2449 spin_unlock_irqrestore(&card->card_lock, flags);
2450 result = (status ? 0 : TIOCSER_TEMT);
2452 /* Not supported yet */
2455 return put_user(result, (unsigned long __user *)value);
2458 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
2460 struct cyclades_port *info = tty->driver_data;
2461 struct cyclades_card *card;
2464 if (serial_paranoia_check(info, tty->name, __func__))
2470 if (!cy_is_Z(card)) {
2471 unsigned long flags;
2472 int channel = info->line - card->first_line;
2475 spin_lock_irqsave(&card->card_lock, flags);
2476 cyy_writeb(info, CyCAR, channel & 0x03);
2477 status = cyy_readb(info, CyMSVR1);
2478 status |= cyy_readb(info, CyMSVR2);
2479 spin_unlock_irqrestore(&card->card_lock, flags);
2481 if (info->rtsdtr_inv) {
2482 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2483 ((status & CyDTR) ? TIOCM_RTS : 0);
2485 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2486 ((status & CyDTR) ? TIOCM_DTR : 0);
2488 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2489 ((status & CyRI) ? TIOCM_RNG : 0) |
2490 ((status & CyDSR) ? TIOCM_DSR : 0) |
2491 ((status & CyCTS) ? TIOCM_CTS : 0);
2495 if (!cyz_is_loaded(card)) {
2500 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2501 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2502 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2503 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2504 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2505 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2506 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2514 cy_tiocmset(struct tty_struct *tty, struct file *file,
2515 unsigned int set, unsigned int clear)
2517 struct cyclades_port *info = tty->driver_data;
2518 struct cyclades_card *card;
2519 unsigned long flags;
2521 if (serial_paranoia_check(info, tty->name, __func__))
2525 if (!cy_is_Z(card)) {
2526 spin_lock_irqsave(&card->card_lock, flags);
2527 cyy_change_rts_dtr(info, set, clear);
2528 spin_unlock_irqrestore(&card->card_lock, flags);
2530 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2531 int retval, channel = info->line - card->first_line;
2534 if (!cyz_is_loaded(card))
2537 spin_lock_irqsave(&card->card_lock, flags);
2538 rs = readl(&ch_ctrl->rs_control);
2539 if (set & TIOCM_RTS)
2541 if (clear & TIOCM_RTS)
2543 if (set & TIOCM_DTR) {
2546 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2549 if (clear & TIOCM_DTR) {
2552 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2556 cy_writel(&ch_ctrl->rs_control, rs);
2557 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2558 spin_unlock_irqrestore(&card->card_lock, flags);
2560 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2561 "was %x\n", info->line, retval);
2568 * cy_break() --- routine which turns the break handling on or off
2570 static int cy_break(struct tty_struct *tty, int break_state)
2572 struct cyclades_port *info = tty->driver_data;
2573 struct cyclades_card *card;
2574 unsigned long flags;
2577 if (serial_paranoia_check(info, tty->name, "cy_break"))
2582 spin_lock_irqsave(&card->card_lock, flags);
2583 if (!cy_is_Z(card)) {
2584 /* Let the transmit ISR take care of this (since it
2585 requires stuffing characters into the output stream).
2587 if (break_state == -1) {
2588 if (!info->breakon) {
2590 if (!info->xmit_cnt) {
2591 spin_unlock_irqrestore(&card->card_lock, flags);
2593 spin_lock_irqsave(&card->card_lock, flags);
2597 if (!info->breakoff) {
2599 if (!info->xmit_cnt) {
2600 spin_unlock_irqrestore(&card->card_lock, flags);
2602 spin_lock_irqsave(&card->card_lock, flags);
2607 if (break_state == -1) {
2608 retval = cyz_issue_cmd(card,
2609 info->line - card->first_line,
2610 C_CM_SET_BREAK, 0L);
2612 printk(KERN_ERR "cyc:cy_break (set) retval on "
2613 "ttyC%d was %x\n", info->line, retval);
2616 retval = cyz_issue_cmd(card,
2617 info->line - card->first_line,
2618 C_CM_CLR_BREAK, 0L);
2620 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2621 "on ttyC%d was %x\n", info->line,
2626 spin_unlock_irqrestore(&card->card_lock, flags);
2630 static int set_threshold(struct cyclades_port *info, unsigned long value)
2632 struct cyclades_card *card = info->card;
2633 unsigned long flags;
2635 if (!cy_is_Z(card)) {
2636 info->cor3 &= ~CyREC_FIFO;
2637 info->cor3 |= value & CyREC_FIFO;
2639 spin_lock_irqsave(&card->card_lock, flags);
2640 cyy_writeb(info, CyCOR3, info->cor3);
2641 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2642 spin_unlock_irqrestore(&card->card_lock, flags);
2645 } /* set_threshold */
2647 static int get_threshold(struct cyclades_port *info,
2648 unsigned long __user *value)
2650 struct cyclades_card *card = info->card;
2652 if (!cy_is_Z(card)) {
2653 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2654 return put_user(tmp, value);
2657 } /* get_threshold */
2659 static int set_timeout(struct cyclades_port *info, unsigned long value)
2661 struct cyclades_card *card = info->card;
2662 unsigned long flags;
2664 if (!cy_is_Z(card)) {
2665 spin_lock_irqsave(&card->card_lock, flags);
2666 cyy_writeb(info, CyRTPR, value & 0xff);
2667 spin_unlock_irqrestore(&card->card_lock, flags);
2672 static int get_timeout(struct cyclades_port *info,
2673 unsigned long __user *value)
2675 struct cyclades_card *card = info->card;
2677 if (!cy_is_Z(card)) {
2678 u8 tmp = cyy_readb(info, CyRTPR);
2679 return put_user(tmp, value);
2684 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2685 struct cyclades_icount *cprev)
2687 struct cyclades_icount cnow;
2688 unsigned long flags;
2691 spin_lock_irqsave(&info->card->card_lock, flags);
2692 cnow = info->icount; /* atomic copy */
2693 spin_unlock_irqrestore(&info->card->card_lock, flags);
2695 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2696 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2697 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2698 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2706 * This routine allows the tty driver to implement device-
2707 * specific ioctl's. If the ioctl number passed in cmd is
2708 * not recognized by the driver, it should return ENOIOCTLCMD.
2711 cy_ioctl(struct tty_struct *tty, struct file *file,
2712 unsigned int cmd, unsigned long arg)
2714 struct cyclades_port *info = tty->driver_data;
2715 struct cyclades_icount cnow; /* kernel counter temps */
2717 unsigned long flags;
2718 void __user *argp = (void __user *)arg;
2720 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2723 #ifdef CY_DEBUG_OTHER
2724 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2725 info->line, cmd, arg);
2731 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2735 memset(&info->mon, 0, sizeof(info->mon));
2738 ret_val = get_threshold(info, argp);
2741 ret_val = set_threshold(info, arg);
2743 case CYGETDEFTHRESH:
2744 ret_val = put_user(info->default_threshold,
2745 (unsigned long __user *)argp);
2747 case CYSETDEFTHRESH:
2748 info->default_threshold = arg & 0x0f;
2751 ret_val = get_timeout(info, argp);
2754 ret_val = set_timeout(info, arg);
2756 case CYGETDEFTIMEOUT:
2757 ret_val = put_user(info->default_timeout,
2758 (unsigned long __user *)argp);
2760 case CYSETDEFTIMEOUT:
2761 info->default_timeout = arg & 0xff;
2764 info->rflow = (int)arg;
2767 ret_val = info->rflow;
2769 case CYSETRTSDTR_INV:
2770 info->rtsdtr_inv = (int)arg;
2772 case CYGETRTSDTR_INV:
2773 ret_val = info->rtsdtr_inv;
2775 case CYGETCD1400VER:
2776 ret_val = info->chip_rev;
2778 #ifndef CONFIG_CYZ_INTR
2779 case CYZSETPOLLCYCLE:
2780 cyz_polling_cycle = (arg * HZ) / 1000;
2782 case CYZGETPOLLCYCLE:
2783 ret_val = (cyz_polling_cycle * 1000) / HZ;
2785 #endif /* CONFIG_CYZ_INTR */
2787 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2790 ret_val = info->port.closing_wait / (HZ / 100);
2793 ret_val = cy_get_serial_info(info, argp);
2796 ret_val = cy_set_serial_info(info, tty, argp);
2798 case TIOCSERGETLSR: /* Get line status register */
2799 ret_val = get_lsr_info(info, argp);
2802 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2803 * - mask passed in arg for lines of interest
2804 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2805 * Caller should use TIOCGICOUNT to see which one it was
2808 spin_lock_irqsave(&info->card->card_lock, flags);
2809 /* note the counters on entry */
2810 cnow = info->icount;
2811 spin_unlock_irqrestore(&info->card->card_lock, flags);
2812 ret_val = wait_event_interruptible(info->delta_msr_wait,
2813 cy_cflags_changed(info, arg, &cnow));
2817 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2818 * Return: write counters to the user passed counter struct
2819 * NB: both 1->0 and 0->1 transitions are counted except for
2820 * RI where only 0->1 is counted.
2823 struct serial_icounter_struct sic = { };
2825 spin_lock_irqsave(&info->card->card_lock, flags);
2826 cnow = info->icount;
2827 spin_unlock_irqrestore(&info->card->card_lock, flags);
2835 sic.frame = cnow.frame;
2836 sic.overrun = cnow.overrun;
2837 sic.parity = cnow.parity;
2839 sic.buf_overrun = cnow.buf_overrun;
2841 if (copy_to_user(argp, &sic, sizeof(sic)))
2846 ret_val = -ENOIOCTLCMD;
2850 #ifdef CY_DEBUG_OTHER
2851 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2857 * This routine allows the tty driver to be notified when
2858 * device's termios settings have changed. Note that a
2859 * well-designed tty driver should be prepared to accept the case
2860 * where old == NULL, and try to do something rational.
2862 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2864 struct cyclades_port *info = tty->driver_data;
2866 #ifdef CY_DEBUG_OTHER
2867 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2870 cy_set_line_char(info, tty);
2872 if ((old_termios->c_cflag & CRTSCTS) &&
2873 !(tty->termios->c_cflag & CRTSCTS)) {
2874 tty->hw_stopped = 0;
2879 * No need to wake up processes in open wait, since they
2880 * sample the CLOCAL flag once, and don't recheck it.
2881 * XXX It's not clear whether the current behavior is correct
2882 * or not. Hence, this may change.....
2884 if (!(old_termios->c_cflag & CLOCAL) &&
2885 (tty->termios->c_cflag & CLOCAL))
2886 wake_up_interruptible(&info->port.open_wait);
2888 } /* cy_set_termios */
2890 /* This function is used to send a high-priority XON/XOFF character to
2893 static void cy_send_xchar(struct tty_struct *tty, char ch)
2895 struct cyclades_port *info = tty->driver_data;
2896 struct cyclades_card *card;
2899 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2908 channel = info->line - card->first_line;
2910 if (cy_is_Z(card)) {
2911 if (ch == STOP_CHAR(tty))
2912 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2913 else if (ch == START_CHAR(tty))
2914 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2918 /* This routine is called by the upper-layer tty layer to signal
2919 that incoming characters should be throttled because the input
2920 buffers are close to full.
2922 static void cy_throttle(struct tty_struct *tty)
2924 struct cyclades_port *info = tty->driver_data;
2925 struct cyclades_card *card;
2926 unsigned long flags;
2928 #ifdef CY_DEBUG_THROTTLE
2931 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2932 tty->ldisc.chars_in_buffer(tty), info->line);
2935 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2942 cy_send_xchar(tty, STOP_CHAR(tty));
2947 if (tty->termios->c_cflag & CRTSCTS) {
2948 if (!cy_is_Z(card)) {
2949 spin_lock_irqsave(&card->card_lock, flags);
2950 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2951 spin_unlock_irqrestore(&card->card_lock, flags);
2959 * This routine notifies the tty driver that it should signal
2960 * that characters can now be sent to the tty without fear of
2961 * overrunning the input buffers of the line disciplines.
2963 static void cy_unthrottle(struct tty_struct *tty)
2965 struct cyclades_port *info = tty->driver_data;
2966 struct cyclades_card *card;
2967 unsigned long flags;
2969 #ifdef CY_DEBUG_THROTTLE
2972 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2973 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2976 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2983 cy_send_xchar(tty, START_CHAR(tty));
2986 if (tty->termios->c_cflag & CRTSCTS) {
2988 if (!cy_is_Z(card)) {
2989 spin_lock_irqsave(&card->card_lock, flags);
2990 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2991 spin_unlock_irqrestore(&card->card_lock, flags);
2996 } /* cy_unthrottle */
2998 /* cy_start and cy_stop provide software output flow control as a
2999 function of XON/XOFF, software CTS, and other such stuff.
3001 static void cy_stop(struct tty_struct *tty)
3003 struct cyclades_card *cinfo;
3004 struct cyclades_port *info = tty->driver_data;
3006 unsigned long flags;
3008 #ifdef CY_DEBUG_OTHER
3009 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
3012 if (serial_paranoia_check(info, tty->name, "cy_stop"))
3016 channel = info->line - cinfo->first_line;
3017 if (!cy_is_Z(cinfo)) {
3018 spin_lock_irqsave(&cinfo->card_lock, flags);
3019 cyy_writeb(info, CyCAR, channel & 0x03);
3020 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
3021 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3025 static void cy_start(struct tty_struct *tty)
3027 struct cyclades_card *cinfo;
3028 struct cyclades_port *info = tty->driver_data;
3030 unsigned long flags;
3032 #ifdef CY_DEBUG_OTHER
3033 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
3036 if (serial_paranoia_check(info, tty->name, "cy_start"))
3040 channel = info->line - cinfo->first_line;
3041 if (!cy_is_Z(cinfo)) {
3042 spin_lock_irqsave(&cinfo->card_lock, flags);
3043 cyy_writeb(info, CyCAR, channel & 0x03);
3044 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
3045 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3050 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
3052 static void cy_hangup(struct tty_struct *tty)
3054 struct cyclades_port *info = tty->driver_data;
3056 #ifdef CY_DEBUG_OTHER
3057 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
3060 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3063 cy_flush_buffer(tty);
3064 cy_shutdown(info, tty);
3065 tty_port_hangup(&info->port);
3068 static int cyy_carrier_raised(struct tty_port *port)
3070 struct cyclades_port *info = container_of(port, struct cyclades_port,
3072 struct cyclades_card *cinfo = info->card;
3073 unsigned long flags;
3074 int channel = info->line - cinfo->first_line;
3077 spin_lock_irqsave(&cinfo->card_lock, flags);
3078 cyy_writeb(info, CyCAR, channel & 0x03);
3079 cd = cyy_readb(info, CyMSVR1) & CyDCD;
3080 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3085 static void cyy_dtr_rts(struct tty_port *port, int raise)
3087 struct cyclades_port *info = container_of(port, struct cyclades_port,
3089 struct cyclades_card *cinfo = info->card;
3090 unsigned long flags;
3092 spin_lock_irqsave(&cinfo->card_lock, flags);
3093 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3094 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3095 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3098 static int cyz_carrier_raised(struct tty_port *port)
3100 struct cyclades_port *info = container_of(port, struct cyclades_port,
3103 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3106 static void cyz_dtr_rts(struct tty_port *port, int raise)
3108 struct cyclades_port *info = container_of(port, struct cyclades_port,
3110 struct cyclades_card *cinfo = info->card;
3111 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3112 int ret, channel = info->line - cinfo->first_line;
3115 rs = readl(&ch_ctrl->rs_control);
3117 rs |= C_RS_RTS | C_RS_DTR;
3119 rs &= ~(C_RS_RTS | C_RS_DTR);
3120 cy_writel(&ch_ctrl->rs_control, rs);
3121 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3123 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3124 __func__, info->line, ret);
3126 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3130 static const struct tty_port_operations cyy_port_ops = {
3131 .carrier_raised = cyy_carrier_raised,
3132 .dtr_rts = cyy_dtr_rts,
3135 static const struct tty_port_operations cyz_port_ops = {
3136 .carrier_raised = cyz_carrier_raised,
3137 .dtr_rts = cyz_dtr_rts,
3141 * ---------------------------------------------------------------------
3142 * cy_init() and friends
3144 * cy_init() is called at boot-time to initialize the serial driver.
3145 * ---------------------------------------------------------------------
3148 static int __devinit cy_init_card(struct cyclades_card *cinfo)
3150 struct cyclades_port *info;
3151 unsigned int channel, port;
3153 spin_lock_init(&cinfo->card_lock);
3154 cinfo->intr_enabled = 0;
3156 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3158 if (cinfo->ports == NULL) {
3159 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3163 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3164 channel++, port++) {
3165 info = &cinfo->ports[channel];
3166 tty_port_init(&info->port);
3167 info->magic = CYCLADES_MAGIC;
3171 info->port.closing_wait = CLOSING_WAIT_DELAY;
3172 info->port.close_delay = 5 * HZ / 10;
3173 info->port.flags = STD_COM_FLAGS;
3174 init_completion(&info->shutdown_wait);
3175 init_waitqueue_head(&info->delta_msr_wait);
3177 if (cy_is_Z(cinfo)) {
3178 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3179 struct ZFW_CTRL *zfw_ctrl;
3181 info->port.ops = &cyz_port_ops;
3182 info->type = PORT_STARTECH;
3184 zfw_ctrl = cinfo->base_addr +
3185 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3186 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3187 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3189 if (cinfo->hw_ver == ZO_V1)
3190 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3192 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3193 #ifdef CONFIG_CYZ_INTR
3194 setup_timer(&cyz_rx_full_timer[port],
3195 cyz_rx_restart, (unsigned long)info);
3198 unsigned short chip_number;
3199 int index = cinfo->bus_index;
3201 info->port.ops = &cyy_port_ops;
3202 info->type = PORT_CIRRUS;
3203 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3204 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3206 info->cor3 = 0x08; /* _very_ small rcv threshold */
3208 chip_number = channel / CyPORTS_PER_CHIP;
3209 info->u.cyy.base_addr = cinfo->base_addr +
3210 (cy_chip_offset[chip_number] << index);
3211 info->chip_rev = cyy_readb(info, CyGFRCR);
3213 if (info->chip_rev >= CD1400_REV_J) {
3214 /* It is a CD1400 rev. J or later */
3215 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
3216 info->tco = baud_co_60[13]; /* Tx CO */
3217 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
3218 info->rco = baud_co_60[13]; /* Rx CO */
3219 info->rtsdtr_inv = 1;
3221 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
3222 info->tco = baud_co_25[13]; /* Tx CO */
3223 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
3224 info->rco = baud_co_25[13]; /* Rx CO */
3225 info->rtsdtr_inv = 0;
3227 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3228 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3233 #ifndef CONFIG_CYZ_INTR
3234 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3235 mod_timer(&cyz_timerlist, jiffies + 1);
3237 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3244 /* initialize chips on Cyclom-Y card -- return number of valid
3245 chips (which is number of ports/4) */
3246 static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
3249 unsigned int chip_number;
3250 void __iomem *base_addr;
3252 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3253 /* Cy_HwReset is 0x1400 */
3254 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3255 /* Cy_ClrIntr is 0x1800 */
3258 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3261 true_base_addr + (cy_chip_offset[chip_number] << index);
3263 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3265 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3266 chip_number, (unsigned long)base_addr);
3271 cy_writeb(base_addr + (CyGFRCR << index), 0);
3274 /* The Cyclom-16Y does not decode address bit 9 and therefore
3275 cannot distinguish between references to chip 0 and a non-
3276 existent chip 4. If the preceding clearing of the supposed
3277 chip 4 GFRCR register appears at chip 0, there is no chip 4
3278 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3280 if (chip_number == 4 && readb(true_base_addr +
3281 (cy_chip_offset[0] << index) +
3282 (CyGFRCR << index)) == 0) {
3286 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3289 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3291 printk(" chip #%d at %#6lx is not responding ",
3292 chip_number, (unsigned long)base_addr);
3293 printk("(GFRCR stayed 0)\n",
3297 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3300 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3302 chip_number, (unsigned long)base_addr,
3303 base_addr[CyGFRCR<<index]);
3307 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3308 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3309 /* It is a CD1400 rev. J or later */
3310 /* Impossible to reach 5ms with this chip.
3311 Changed to 2ms instead (f = 500 Hz). */
3312 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3315 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3319 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3320 chip_number, (unsigned long)base_addr,
3321 readb(base_addr+(CyGFRCR<<index)));
3325 } /* cyy_init_card */
3328 * ---------------------------------------------------------------------
3329 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3330 * sets global variables and return the number of ISA boards found.
3331 * ---------------------------------------------------------------------
3333 static int __init cy_detect_isa(void)
3336 unsigned short cy_isa_irq, nboard;
3337 void __iomem *cy_isa_address;
3338 unsigned short i, j, cy_isa_nchan;
3346 /* Check for module parameters */
3347 for (i = 0; i < NR_CARDS; i++) {
3348 if (maddr[i] || i) {
3350 cy_isa_addresses[i] = maddr[i];
3357 /* scan the address table probing for Cyclom-Y/ISA boards */
3358 for (i = 0; i < NR_ISA_ADDRS; i++) {
3359 unsigned int isa_address = cy_isa_addresses[i];
3360 if (isa_address == 0x0000)
3363 /* probe for CD1400... */
3364 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3365 if (cy_isa_address == NULL) {
3366 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3370 cy_isa_nchan = CyPORTS_PER_CHIP *
3371 cyy_init_card(cy_isa_address, 0);
3372 if (cy_isa_nchan == 0) {
3373 iounmap(cy_isa_address);
3377 if (isparam && irq[i])
3378 cy_isa_irq = irq[i];
3381 /* find out the board's irq by probing */
3382 cy_isa_irq = detect_isa_irq(cy_isa_address);
3383 if (cy_isa_irq == 0) {
3384 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3385 "IRQ could not be detected.\n",
3386 (unsigned long)cy_isa_address);
3387 iounmap(cy_isa_address);
3391 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3392 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3393 "more channels are available. Change NR_PORTS "
3394 "in cyclades.c and recompile kernel.\n",
3395 (unsigned long)cy_isa_address);
3396 iounmap(cy_isa_address);
3399 /* fill the next cy_card structure available */
3400 for (j = 0; j < NR_CARDS; j++) {
3401 if (cy_card[j].base_addr == NULL)
3404 if (j == NR_CARDS) { /* no more cy_cards available */
3405 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3406 "more cards can be used. Change NR_CARDS in "
3407 "cyclades.c and recompile kernel.\n",
3408 (unsigned long)cy_isa_address);
3409 iounmap(cy_isa_address);
3414 if (request_irq(cy_isa_irq, cyy_interrupt,
3415 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
3416 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3417 "could not allocate IRQ#%d.\n",
3418 (unsigned long)cy_isa_address, cy_isa_irq);
3419 iounmap(cy_isa_address);
3424 cy_card[j].base_addr = cy_isa_address;
3425 cy_card[j].ctl_addr.p9050 = NULL;
3426 cy_card[j].irq = (int)cy_isa_irq;
3427 cy_card[j].bus_index = 0;
3428 cy_card[j].first_line = cy_next_channel;
3429 cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3430 cy_card[j].nports = cy_isa_nchan;
3431 if (cy_init_card(&cy_card[j])) {
3432 cy_card[j].base_addr = NULL;
3433 free_irq(cy_isa_irq, &cy_card[j]);
3434 iounmap(cy_isa_address);
3439 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3440 "%d channels starting from port %d\n",
3441 j + 1, (unsigned long)cy_isa_address,
3442 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3443 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3445 for (j = cy_next_channel;
3446 j < cy_next_channel + cy_isa_nchan; j++)
3447 tty_register_device(cy_serial_driver, j, NULL);
3448 cy_next_channel += cy_isa_nchan;
3453 #endif /* CONFIG_ISA */
3454 } /* cy_detect_isa */
3457 static inline int __devinit cyc_isfwstr(const char *str, unsigned int size)
3461 for (a = 0; a < size && *str; a++, str++)
3465 for (; a < size; a++, str++)
3472 static inline void __devinit cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3475 for (; size > 0; size--) {
3476 cy_writel(fpga, *data++);
3481 static void __devinit plx_init(struct pci_dev *pdev, int irq,
3482 struct RUNTIME_9060 __iomem *addr)
3485 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3487 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3489 /* Reload Config. Registers from EEPROM */
3490 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3492 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3494 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3495 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3496 * registers. This will remain here until we find a permanent fix.
3498 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3501 static int __devinit __cyz_load_fw(const struct firmware *fw,
3502 const char *name, const u32 mailbox, void __iomem *base,
3505 const void *ptr = fw->data;
3506 const struct zfile_header *h = ptr;
3507 const struct zfile_config *c, *cs;
3508 const struct zfile_block *b, *bs;
3509 unsigned int a, tmp, len = fw->size;
3510 #define BAD_FW KERN_ERR "Bad firmware: "
3511 if (len < sizeof(*h)) {
3512 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3516 cs = ptr + h->config_offset;
3517 bs = ptr + h->block_offset;
3519 if ((void *)(cs + h->n_config) > ptr + len ||
3520 (void *)(bs + h->n_blocks) > ptr + len) {
3521 printk(BAD_FW "too short");
3525 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3526 cyc_isfwstr(h->date, sizeof(h->date))) {
3527 printk(BAD_FW "bad formatted header string\n");
3531 if (strncmp(name, h->name, sizeof(h->name))) {
3532 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3537 for (c = cs; c < cs + h->n_config; c++) {
3538 for (a = 0; a < c->n_blocks; a++)
3539 if (c->block_list[a] > h->n_blocks) {
3540 printk(BAD_FW "bad block ref number in cfgs\n");
3543 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3547 printk(BAD_FW "nothing appropriate\n");
3551 for (b = bs; b < bs + h->n_blocks; b++)
3552 if (b->file_offset + b->size > len) {
3553 printk(BAD_FW "bad block data offset\n");
3557 /* everything is OK, let's seek'n'load it */
3558 for (c = cs; c < cs + h->n_config; c++)
3559 if (c->mailbox == mailbox && c->function == 0)
3562 for (a = 0; a < c->n_blocks; a++) {
3563 b = &bs[c->block_list[a]];
3564 if (b->type == ZBLOCK_FPGA) {
3566 cyz_fpga_copy(fpga, ptr + b->file_offset,
3570 memcpy_toio(base + b->ram_offset,
3571 ptr + b->file_offset, b->size);
3578 static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3579 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3581 const struct firmware *fw;
3582 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3583 struct CUSTOM_REG __iomem *cust = base_addr;
3584 struct ZFW_CTRL __iomem *pt_zfwctrl;
3586 u32 mailbox, status, nchan;
3590 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3592 dev_err(&pdev->dev, "can't get firmware\n");
3596 /* Check whether the firmware is already loaded and running. If
3597 positive, skip this board */
3598 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3599 u32 cntval = readl(base_addr + 0x190);
3602 if (cntval != readl(base_addr + 0x190)) {
3603 /* FW counter is working, FW is running */
3604 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3605 "Skipping board.\n");
3612 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3615 mailbox = readl(&ctl_addr->mail_box_0);
3617 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3618 /* stops CPU and set window to beginning of RAM */
3619 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3620 cy_writel(&cust->cpu_stop, 0);
3621 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3625 plx_init(pdev, irq, ctl_addr);
3629 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3633 if (!__cyz_fpga_loaded(ctl_addr)) {
3634 dev_err(&pdev->dev, "fw upload successful, but fw is "
3640 /* stops CPU and set window to beginning of RAM */
3641 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3642 cy_writel(&cust->cpu_stop, 0);
3643 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3647 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3648 cy_writeb(tmp, 255);
3650 /* set window to last 512K of RAM */
3651 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3652 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3653 cy_writeb(tmp, 255);
3654 /* set window to beginning of RAM */
3655 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3658 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3659 release_firmware(fw);
3663 /* finish boot and start boards */
3664 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3665 cy_writel(&cust->cpu_start, 0);
3666 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3668 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3670 if (status != ZFIRM_ID) {
3671 if (status == ZFIRM_HLT) {
3672 dev_err(&pdev->dev, "you need an external power supply "
3673 "for this number of ports. Firmware halted and "
3678 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3679 "some more time\n", status);
3680 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3683 if (status != ZFIRM_ID) {
3684 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3685 "Giving up. (fid->signature = 0x%x)\n",
3687 dev_info(&pdev->dev, "*** Warning ***: if you are "
3688 "upgrading the FW, please power cycle the "
3689 "system before loading the new FW to the "
3692 if (__cyz_fpga_loaded(ctl_addr))
3693 plx_init(pdev, irq, ctl_addr);
3698 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3701 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3703 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3704 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3705 base_addr + readl(&fid->zfwctrl_addr));
3707 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3708 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3709 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3712 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3713 "check the connection between the Z host card and the "
3714 "serial expanders.\n");
3716 if (__cyz_fpga_loaded(ctl_addr))
3717 plx_init(pdev, irq, ctl_addr);
3719 dev_info(&pdev->dev, "Null number of ports detected. Board "
3725 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3726 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3729 Early firmware failed to start looking for commands.
3730 This enables firmware interrupts for those commands.
3732 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3734 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3739 release_firmware(fw);
3744 static int __devinit cy_pci_probe(struct pci_dev *pdev,
3745 const struct pci_device_id *ent)
3747 void __iomem *addr0 = NULL, *addr2 = NULL;
3748 char *card_name = NULL;
3749 u32 uninitialized_var(mailbox);
3750 unsigned int device_id, nchan = 0, card_no, i;
3751 unsigned char plx_ver;
3754 retval = pci_enable_device(pdev);
3756 dev_err(&pdev->dev, "cannot enable device\n");
3760 /* read PCI configuration area */
3762 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3764 #if defined(__alpha__)
3765 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
3766 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3767 "addresses on Alpha systems.\n");
3772 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3773 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3779 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3780 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3782 pdev->resource[2].flags &= ~IORESOURCE_IO;
3785 retval = pci_request_regions(pdev, "cyclades");
3787 dev_err(&pdev->dev, "failed to reserve resources\n");
3792 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3793 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3794 card_name = "Cyclom-Y";
3796 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3798 if (addr0 == NULL) {
3799 dev_err(&pdev->dev, "can't remap ctl region\n");
3802 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3804 if (addr2 == NULL) {
3805 dev_err(&pdev->dev, "can't remap base region\n");
3809 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3811 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3812 "Serial-Modules\n");
3815 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3816 struct RUNTIME_9060 __iomem *ctl_addr;
3818 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3820 if (addr0 == NULL) {
3821 dev_err(&pdev->dev, "can't remap ctl region\n");
3825 /* Disable interrupts on the PLX before resetting it */
3826 cy_writew(&ctl_addr->intr_ctrl_stat,
3827 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3829 plx_init(pdev, irq, addr0);
3831 mailbox = readl(&ctl_addr->mail_box_0);
3833 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3834 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3835 if (addr2 == NULL) {
3836 dev_err(&pdev->dev, "can't remap base region\n");
3840 if (mailbox == ZE_V1) {
3841 card_name = "Cyclades-Ze";
3843 card_name = "Cyclades-8Zo";
3845 if (mailbox == ZO_V1) {
3846 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3847 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3848 "id %lx, ver %lx\n", (ulong)(0xff &
3849 readl(&((struct CUSTOM_REG *)addr2)->
3850 fpga_id)), (ulong)(0xff &
3851 readl(&((struct CUSTOM_REG *)addr2)->
3853 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3855 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3856 "Cyclades-Z board. FPGA not loaded\n");
3859 /* The following clears the firmware id word. This
3860 ensures that the driver will not attempt to talk to
3861 the board until it has been properly initialized.
3863 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3864 cy_writel(addr2 + ID_ADDRESS, 0L);
3867 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3873 if ((cy_next_channel + nchan) > NR_PORTS) {
3874 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3875 "channels are available. Change NR_PORTS in "
3876 "cyclades.c and recompile kernel.\n");
3879 /* fill the next cy_card structure available */
3880 for (card_no = 0; card_no < NR_CARDS; card_no++) {
3881 if (cy_card[card_no].base_addr == NULL)
3884 if (card_no == NR_CARDS) { /* no more cy_cards available */
3885 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3886 "more cards can be used. Change NR_CARDS in "
3887 "cyclades.c and recompile kernel.\n");
3891 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3892 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3894 retval = request_irq(irq, cyy_interrupt,
3895 IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
3897 dev_err(&pdev->dev, "could not allocate IRQ\n");
3900 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
3902 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3903 struct ZFW_CTRL __iomem *zfw_ctrl;
3905 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3907 cy_card[card_no].hw_ver = mailbox;
3908 cy_card[card_no].num_chips = (unsigned int)-1;
3909 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
3910 #ifdef CONFIG_CYZ_INTR
3911 /* allocate IRQ only if board has an IRQ */
3912 if (irq != 0 && irq != 255) {
3913 retval = request_irq(irq, cyz_interrupt,
3914 IRQF_SHARED, "Cyclades-Z",
3917 dev_err(&pdev->dev, "could not allocate IRQ\n");
3921 #endif /* CONFIG_CYZ_INTR */
3925 cy_card[card_no].base_addr = addr2;
3926 cy_card[card_no].ctl_addr.p9050 = addr0;
3927 cy_card[card_no].irq = irq;
3928 cy_card[card_no].bus_index = 1;
3929 cy_card[card_no].first_line = cy_next_channel;
3930 cy_card[card_no].nports = nchan;
3931 retval = cy_init_card(&cy_card[card_no]);
3935 pci_set_drvdata(pdev, &cy_card[card_no]);
3937 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3938 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3939 /* enable interrupts in the PCI interface */
3940 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3943 cy_writeb(addr0 + 0x4c, 0x43);
3948 default: /* Old boards, use PLX_9060 */
3950 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3951 plx_init(pdev, irq, ctl_addr);
3952 cy_writew(&ctl_addr->intr_ctrl_stat,
3953 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3959 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3960 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3961 for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
3962 tty_register_device(cy_serial_driver, i, &pdev->dev);
3963 cy_next_channel += nchan;
3967 cy_card[card_no].base_addr = NULL;
3968 free_irq(irq, &cy_card[card_no]);
3974 pci_release_regions(pdev);
3976 pci_disable_device(pdev);
3981 static void __devexit cy_pci_remove(struct pci_dev *pdev)
3983 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3986 /* non-Z with old PLX */
3987 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3989 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3991 #ifndef CONFIG_CYZ_INTR
3992 if (!cy_is_Z(cinfo))
3994 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3995 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3998 iounmap(cinfo->base_addr);
3999 if (cinfo->ctl_addr.p9050)
4000 iounmap(cinfo->ctl_addr.p9050);
4002 #ifndef CONFIG_CYZ_INTR
4004 #endif /* CONFIG_CYZ_INTR */
4006 free_irq(cinfo->irq, cinfo);
4007 pci_release_regions(pdev);
4009 cinfo->base_addr = NULL;
4010 for (i = cinfo->first_line; i < cinfo->first_line +
4012 tty_unregister_device(cy_serial_driver, i);
4014 kfree(cinfo->ports);
4017 static struct pci_driver cy_pci_driver = {
4019 .id_table = cy_pci_dev_id,
4020 .probe = cy_pci_probe,
4021 .remove = __devexit_p(cy_pci_remove)
4025 static int cyclades_proc_show(struct seq_file *m, void *v)
4027 struct cyclades_port *info;
4029 __u32 cur_jifs = jiffies;
4031 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
4032 "IdleIn Overruns Ldisc\n");
4034 /* Output one line for each known port */
4035 for (i = 0; i < NR_CARDS; i++)
4036 for (j = 0; j < cy_card[i].nports; j++) {
4037 info = &cy_card[i].ports[j];
4039 if (info->port.count) {
4040 /* XXX is the ldisc num worth this? */
4041 struct tty_struct *tty;
4042 struct tty_ldisc *ld;
4044 tty = tty_port_tty_get(&info->port);
4046 ld = tty_ldisc_ref(tty);
4049 tty_ldisc_deref(ld);
4053 seq_printf(m, "%3d %8lu %10lu %8lu "
4054 "%10lu %8lu %9lu %6d\n", info->line,
4055 (cur_jifs - info->idle_stats.in_use) /
4056 HZ, info->idle_stats.xmit_bytes,
4057 (cur_jifs - info->idle_stats.xmit_idle)/
4058 HZ, info->idle_stats.recv_bytes,
4059 (cur_jifs - info->idle_stats.recv_idle)/
4060 HZ, info->idle_stats.overruns,
4063 seq_printf(m, "%3d %8lu %10lu %8lu "
4064 "%10lu %8lu %9lu %6ld\n",
4065 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4070 static int cyclades_proc_open(struct inode *inode, struct file *file)
4072 return single_open(file, cyclades_proc_show, NULL);
4075 static const struct file_operations cyclades_proc_fops = {
4076 .owner = THIS_MODULE,
4077 .open = cyclades_proc_open,
4079 .llseek = seq_lseek,
4080 .release = single_release,
4083 /* The serial driver boot-time initialization code!
4084 Hardware I/O ports are mapped to character special devices on a
4085 first found, first allocated manner. That is, this code searches
4086 for Cyclom cards in the system. As each is found, it is probed
4087 to discover how many chips (and thus how many ports) are present.
4088 These ports are mapped to the tty ports 32 and upward in monotonic
4089 fashion. If an 8-port card is replaced with a 16-port card, the
4090 port mapping on a following card will shift.
4092 This approach is different from what is used in the other serial
4093 device driver because the Cyclom is more properly a multiplexer,
4094 not just an aggregation of serial ports on one card.
4096 If there are more cards with more ports than have been
4097 statically allocated above, a warning is printed and the
4098 extra ports are ignored.
4101 static const struct tty_operations cy_ops = {
4105 .put_char = cy_put_char,
4106 .flush_chars = cy_flush_chars,
4107 .write_room = cy_write_room,
4108 .chars_in_buffer = cy_chars_in_buffer,
4109 .flush_buffer = cy_flush_buffer,
4111 .throttle = cy_throttle,
4112 .unthrottle = cy_unthrottle,
4113 .set_termios = cy_set_termios,
4116 .hangup = cy_hangup,
4117 .break_ctl = cy_break,
4118 .wait_until_sent = cy_wait_until_sent,
4119 .tiocmget = cy_tiocmget,
4120 .tiocmset = cy_tiocmset,
4121 .proc_fops = &cyclades_proc_fops,
4124 static int __init cy_init(void)
4126 unsigned int nboards;
4127 int retval = -ENOMEM;
4129 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4130 if (!cy_serial_driver)
4133 printk(KERN_INFO "Cyclades driver " CY_VERSION " (built %s %s)\n",
4134 __DATE__, __TIME__);
4136 /* Initialize the tty_driver structure */
4138 cy_serial_driver->owner = THIS_MODULE;
4139 cy_serial_driver->driver_name = "cyclades";
4140 cy_serial_driver->name = "ttyC";
4141 cy_serial_driver->major = CYCLADES_MAJOR;
4142 cy_serial_driver->minor_start = 0;
4143 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4144 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4145 cy_serial_driver->init_termios = tty_std_termios;
4146 cy_serial_driver->init_termios.c_cflag =
4147 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4148 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4149 tty_set_operations(cy_serial_driver, &cy_ops);
4151 retval = tty_register_driver(cy_serial_driver);
4153 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4157 /* the code below is responsible to find the boards. Each different
4158 type of board has its own detection routine. If a board is found,
4159 the next cy_card structure available is set by the detection
4160 routine. These functions are responsible for checking the
4161 availability of cy_card and cy_port data structures and updating
4162 the cy_next_channel. */
4164 /* look for isa boards */
4165 nboards = cy_detect_isa();
4168 /* look for pci boards */
4169 retval = pci_register_driver(&cy_pci_driver);
4170 if (retval && !nboards) {
4171 tty_unregister_driver(cy_serial_driver);
4178 put_tty_driver(cy_serial_driver);
4183 static void __exit cy_cleanup_module(void)
4185 struct cyclades_card *card;
4188 #ifndef CONFIG_CYZ_INTR
4189 del_timer_sync(&cyz_timerlist);
4190 #endif /* CONFIG_CYZ_INTR */
4192 e1 = tty_unregister_driver(cy_serial_driver);
4194 printk(KERN_ERR "failed to unregister Cyclades serial "
4195 "driver(%d)\n", e1);
4198 pci_unregister_driver(&cy_pci_driver);
4201 for (i = 0; i < NR_CARDS; i++) {
4203 if (card->base_addr) {
4204 /* clear interrupt */
4205 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4206 iounmap(card->base_addr);
4207 if (card->ctl_addr.p9050)
4208 iounmap(card->ctl_addr.p9050);
4210 #ifndef CONFIG_CYZ_INTR
4212 #endif /* CONFIG_CYZ_INTR */
4214 free_irq(card->irq, card);
4215 for (e1 = card->first_line; e1 < card->first_line +
4217 tty_unregister_device(cy_serial_driver, e1);
4222 put_tty_driver(cy_serial_driver);
4223 } /* cy_cleanup_module */
4225 module_init(cy_init);
4226 module_exit(cy_cleanup_module);
4228 MODULE_LICENSE("GPL");
4229 MODULE_VERSION(CY_VERSION);
4230 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);