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 info = &cinfo->ports[channel + chip * 4];
602 tty = tty_port_tty_get(&info->port);
604 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
608 /* load the on-chip space for outbound data */
609 char_count = info->xmit_fifo_size;
611 if (info->x_char) { /* send special char */
612 outch = info->x_char;
613 cyy_writeb(info, CyTDR, outch);
619 if (info->breakon || info->breakoff) {
621 cyy_writeb(info, CyTDR, 0);
622 cyy_writeb(info, CyTDR, 0x81);
626 if (info->breakoff) {
627 cyy_writeb(info, CyTDR, 0);
628 cyy_writeb(info, CyTDR, 0x83);
634 while (char_count-- > 0) {
635 if (!info->xmit_cnt) {
636 if (cyy_readb(info, CySRER) & CyTxMpty) {
637 cyy_writeb(info, CySRER,
638 cyy_readb(info, CySRER) & ~CyTxMpty);
640 cyy_writeb(info, CySRER, CyTxMpty |
641 (cyy_readb(info, CySRER) & ~CyTxRdy));
645 if (info->port.xmit_buf == NULL) {
646 cyy_writeb(info, CySRER,
647 cyy_readb(info, CySRER) & ~CyTxRdy);
650 if (tty->stopped || tty->hw_stopped) {
651 cyy_writeb(info, CySRER,
652 cyy_readb(info, CySRER) & ~CyTxRdy);
655 /* Because the Embedded Transmit Commands have been enabled,
656 * we must check to see if the escape character, NULL, is being
657 * sent. If it is, we must ensure that there is room for it to
658 * be doubled in the output stream. Therefore we no longer
659 * advance the pointer when the character is fetched, but
660 * rather wait until after the check for a NULL output
661 * character. This is necessary because there may not be room
662 * for the two chars needed to send a NULL.)
664 outch = info->port.xmit_buf[info->xmit_tail];
667 info->xmit_tail = (info->xmit_tail + 1) &
668 (SERIAL_XMIT_SIZE - 1);
669 cyy_writeb(info, CyTDR, outch);
672 if (char_count > 1) {
674 info->xmit_tail = (info->xmit_tail + 1) &
675 (SERIAL_XMIT_SIZE - 1);
676 cyy_writeb(info, CyTDR, outch);
677 cyy_writeb(info, CyTDR, 0);
689 cyy_writeb(info, CyTIR, save_xir & 0x3f);
690 cyy_writeb(info, CyCAR, save_car);
693 static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
694 void __iomem *base_addr)
696 struct cyclades_port *info;
697 struct tty_struct *tty;
698 int index = cinfo->bus_index;
699 u8 save_xir, channel, save_car, mdm_change, mdm_status;
701 /* determine the channel & change to that context */
702 save_xir = readb(base_addr + (CyMIR << index));
703 channel = save_xir & CyIRChannel;
704 info = &cinfo->ports[channel + chip * 4];
705 save_car = cyy_readb(info, CyCAR);
706 cyy_writeb(info, CyCAR, save_xir);
708 mdm_change = cyy_readb(info, CyMISR);
709 mdm_status = cyy_readb(info, CyMSVR1);
711 tty = tty_port_tty_get(&info->port);
715 if (mdm_change & CyANY_DELTA) {
716 /* For statistics only */
717 if (mdm_change & CyDCD)
719 if (mdm_change & CyCTS)
721 if (mdm_change & CyDSR)
723 if (mdm_change & CyRI)
726 wake_up_interruptible(&info->port.delta_msr_wait);
729 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
730 if (mdm_status & CyDCD)
731 wake_up_interruptible(&info->port.open_wait);
735 if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
736 if (tty->hw_stopped) {
737 if (mdm_status & CyCTS) {
738 /* cy_start isn't used
741 cyy_writeb(info, CySRER,
742 cyy_readb(info, CySRER) | CyTxRdy);
746 if (!(mdm_status & CyCTS)) {
747 /* cy_stop isn't used
750 cyy_writeb(info, CySRER,
751 cyy_readb(info, CySRER) & ~CyTxRdy);
755 /* if (mdm_change & CyDSR) {
757 if (mdm_change & CyRI) {
762 cyy_writeb(info, CyMIR, save_xir & 0x3f);
763 cyy_writeb(info, CyCAR, save_car);
766 /* The real interrupt service routine is called
767 whenever the card wants its hand held--chars
768 received, out buffer empty, modem change, etc.
770 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
773 struct cyclades_card *cinfo = dev_id;
774 void __iomem *base_addr, *card_base_addr;
775 unsigned int chip, too_many, had_work;
778 if (unlikely(cinfo == NULL)) {
779 #ifdef CY_DEBUG_INTERRUPTS
780 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
783 return IRQ_NONE; /* spurious interrupt */
786 card_base_addr = cinfo->base_addr;
787 index = cinfo->bus_index;
789 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
790 if (unlikely(card_base_addr == NULL))
793 /* This loop checks all chips in the card. Make a note whenever
794 _any_ chip had some work to do, as this is considered an
795 indication that there will be more to do. Only when no chip
796 has any work does this outermost loop exit.
800 for (chip = 0; chip < cinfo->num_chips; chip++) {
801 base_addr = cinfo->base_addr +
802 (cy_chip_offset[chip] << index);
804 while ((status = readb(base_addr +
805 (CySVRR << index))) != 0x00) {
807 /* The purpose of the following test is to ensure that
808 no chip can monopolize the driver. This forces the
809 chips to be checked in a round-robin fashion (after
810 draining each of a bunch (1000) of characters).
812 if (1000 < too_many++)
814 spin_lock(&cinfo->card_lock);
815 if (status & CySRReceive) /* rx intr */
816 cyy_chip_rx(cinfo, chip, base_addr);
817 if (status & CySRTransmit) /* tx intr */
818 cyy_chip_tx(cinfo, chip, base_addr);
819 if (status & CySRModem) /* modem intr */
820 cyy_chip_modem(cinfo, chip, base_addr);
821 spin_unlock(&cinfo->card_lock);
826 /* clear interrupts */
827 spin_lock(&cinfo->card_lock);
828 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
829 /* Cy_ClrIntr is 0x1800 */
830 spin_unlock(&cinfo->card_lock);
832 } /* cyy_interrupt */
834 static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
837 struct cyclades_card *card = info->card;
838 int channel = info->line - card->first_line;
839 u32 rts, dtr, msvrr, msvrd;
843 if (info->rtsdtr_inv) {
854 if (set & TIOCM_RTS) {
855 cyy_writeb(info, CyCAR, channel);
856 cyy_writeb(info, msvrr, rts);
858 if (clear & TIOCM_RTS) {
859 cyy_writeb(info, CyCAR, channel);
860 cyy_writeb(info, msvrr, ~rts);
862 if (set & TIOCM_DTR) {
863 cyy_writeb(info, CyCAR, channel);
864 cyy_writeb(info, msvrd, dtr);
866 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
867 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
868 cyy_readb(info, CyMSVR1),
869 cyy_readb(info, CyMSVR2));
872 if (clear & TIOCM_DTR) {
873 cyy_writeb(info, CyCAR, channel);
874 cyy_writeb(info, msvrd, ~dtr);
876 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
877 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
878 cyy_readb(info, CyMSVR1),
879 cyy_readb(info, CyMSVR2));
884 /***********************************************************/
885 /********* End of block of Cyclom-Y specific code **********/
886 /******** Start of block of Cyclades-Z specific code *******/
887 /***********************************************************/
890 cyz_fetch_msg(struct cyclades_card *cinfo,
891 __u32 *channel, __u8 *cmd, __u32 *param)
893 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
894 unsigned long loc_doorbell;
896 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
898 *cmd = (char)(0xff & loc_doorbell);
899 *channel = readl(&board_ctrl->fwcmd_channel);
900 *param = (__u32) readl(&board_ctrl->fwcmd_param);
901 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
905 } /* cyz_fetch_msg */
908 cyz_issue_cmd(struct cyclades_card *cinfo,
909 __u32 channel, __u8 cmd, __u32 param)
911 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
912 __u32 __iomem *pci_doorbell;
915 if (!cyz_is_loaded(cinfo))
919 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
920 while ((readl(pci_doorbell) & 0xff) != 0) {
922 return (int)(readl(pci_doorbell) & 0xff);
925 cy_writel(&board_ctrl->hcmd_channel, channel);
926 cy_writel(&board_ctrl->hcmd_param, param);
927 cy_writel(pci_doorbell, (long)cmd);
930 } /* cyz_issue_cmd */
932 static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
934 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
935 struct cyclades_card *cinfo = info->card;
936 unsigned int char_count;
943 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
945 rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
946 rx_put = readl(&buf_ctrl->rx_put);
947 rx_bufsize = readl(&buf_ctrl->rx_bufsize);
948 rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
949 if (rx_put >= rx_get)
950 char_count = rx_put - rx_get;
952 char_count = rx_put - rx_get + rx_bufsize;
955 #ifdef CY_ENABLE_MONITORING
956 info->mon.int_count++;
957 info->mon.char_count += char_count;
958 if (char_count > info->mon.char_max)
959 info->mon.char_max = char_count;
960 info->mon.char_last = char_count;
963 /* flush received characters */
964 new_rx_get = (new_rx_get + char_count) &
966 info->rflush_count++;
969 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
970 for performance, but because of buffer boundaries, there
971 may be several steps to the operation */
973 len = tty_prepare_flip_string(tty, &buf,
978 len = min_t(unsigned int, min(len, char_count),
979 rx_bufsize - new_rx_get);
981 memcpy_fromio(buf, cinfo->base_addr +
982 rx_bufaddr + new_rx_get, len);
984 new_rx_get = (new_rx_get + len) &
987 info->icount.rx += len;
988 info->idle_stats.recv_bytes += len;
991 len = tty_buffer_request_room(tty, char_count);
993 data = readb(cinfo->base_addr + rx_bufaddr +
995 new_rx_get = (new_rx_get + 1) &
997 tty_insert_flip_char(tty, data, TTY_NORMAL);
998 info->idle_stats.recv_bytes++;
1002 #ifdef CONFIG_CYZ_INTR
1003 /* Recalculate the number of chars in the RX buffer and issue
1004 a cmd in case it's higher than the RX high water mark */
1005 rx_put = readl(&buf_ctrl->rx_put);
1006 if (rx_put >= rx_get)
1007 char_count = rx_put - rx_get;
1009 char_count = rx_put - rx_get + rx_bufsize;
1010 if (char_count >= readl(&buf_ctrl->rx_threshold) &&
1011 !timer_pending(&cyz_rx_full_timer[
1013 mod_timer(&cyz_rx_full_timer[info->line],
1016 info->idle_stats.recv_idle = jiffies;
1017 tty_schedule_flip(tty);
1020 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1024 static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
1026 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1027 struct cyclades_card *cinfo = info->card;
1029 unsigned int char_count;
1033 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1035 if (info->xmit_cnt <= 0) /* Nothing to transmit */
1038 tx_get = readl(&buf_ctrl->tx_get);
1039 tx_put = readl(&buf_ctrl->tx_put);
1040 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1041 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1042 if (tx_put >= tx_get)
1043 char_count = tx_get - tx_put - 1 + tx_bufsize;
1045 char_count = tx_get - tx_put - 1;
1052 if (info->x_char) { /* send special char */
1053 data = info->x_char;
1055 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1056 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1062 while (0 < (small_count = min_t(unsigned int,
1063 tx_bufsize - tx_put, min_t(unsigned int,
1064 (SERIAL_XMIT_SIZE - info->xmit_tail),
1065 min_t(unsigned int, info->xmit_cnt,
1068 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1070 &info->port.xmit_buf[info->xmit_tail],
1073 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1074 char_count -= small_count;
1075 info->icount.tx += small_count;
1076 info->xmit_cnt -= small_count;
1077 info->xmit_tail = (info->xmit_tail + small_count) &
1078 (SERIAL_XMIT_SIZE - 1);
1081 while (info->xmit_cnt && char_count) {
1082 data = info->port.xmit_buf[info->xmit_tail];
1084 info->xmit_tail = (info->xmit_tail + 1) &
1085 (SERIAL_XMIT_SIZE - 1);
1087 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1088 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1096 cy_writel(&buf_ctrl->tx_put, tx_put);
1100 static void cyz_handle_cmd(struct cyclades_card *cinfo)
1102 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1103 struct tty_struct *tty;
1104 struct cyclades_port *info;
1105 __u32 channel, param, fw_ver;
1110 fw_ver = readl(&board_ctrl->fw_version);
1112 while (cyz_fetch_msg(cinfo, &channel, &cmd, ¶m) == 1) {
1115 info = &cinfo->ports[channel];
1116 tty = tty_port_tty_get(&info->port);
1122 tty_insert_flip_char(tty, 0, TTY_PARITY);
1127 tty_insert_flip_char(tty, 0, TTY_FRAME);
1132 tty_insert_flip_char(tty, 0, TTY_BREAK);
1139 if (info->port.flags & ASYNC_CHECK_CD) {
1140 u32 dcd = fw_ver > 241 ? param :
1141 readl(&info->u.cyz.ch_ctrl->rs_status);
1143 wake_up_interruptible(&info->port.open_wait);
1162 complete(&info->shutdown_wait);
1165 #ifdef CONFIG_CYZ_INTR
1169 /* Reception Interrupt */
1170 #ifdef CY_DEBUG_INTERRUPTS
1171 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1172 "port %ld\n", info->card, channel);
1174 cyz_handle_rx(info, tty);
1179 /* Transmission Interrupt */
1180 #ifdef CY_DEBUG_INTERRUPTS
1181 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1182 "port %ld\n", info->card, channel);
1184 cyz_handle_tx(info, tty);
1186 #endif /* CONFIG_CYZ_INTR */
1188 /* should do something with this !!! */
1194 wake_up_interruptible(&info->port.delta_msr_wait);
1196 tty_schedule_flip(tty);
1201 #ifdef CONFIG_CYZ_INTR
1202 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1204 struct cyclades_card *cinfo = dev_id;
1206 if (unlikely(!cyz_is_loaded(cinfo))) {
1207 #ifdef CY_DEBUG_INTERRUPTS
1208 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1214 /* Handle the interrupts */
1215 cyz_handle_cmd(cinfo);
1218 } /* cyz_interrupt */
1220 static void cyz_rx_restart(unsigned long arg)
1222 struct cyclades_port *info = (struct cyclades_port *)arg;
1223 struct cyclades_card *card = info->card;
1225 __u32 channel = info->line - card->first_line;
1226 unsigned long flags;
1228 spin_lock_irqsave(&card->card_lock, flags);
1229 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1231 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1232 info->line, retval);
1234 spin_unlock_irqrestore(&card->card_lock, flags);
1237 #else /* CONFIG_CYZ_INTR */
1239 static void cyz_poll(unsigned long arg)
1241 struct cyclades_card *cinfo;
1242 struct cyclades_port *info;
1243 unsigned long expires = jiffies + HZ;
1244 unsigned int port, card;
1246 for (card = 0; card < NR_CARDS; card++) {
1247 cinfo = &cy_card[card];
1249 if (!cy_is_Z(cinfo))
1251 if (!cyz_is_loaded(cinfo))
1254 /* Skip first polling cycle to avoid racing conditions with the FW */
1255 if (!cinfo->intr_enabled) {
1256 cinfo->intr_enabled = 1;
1260 cyz_handle_cmd(cinfo);
1262 for (port = 0; port < cinfo->nports; port++) {
1263 struct tty_struct *tty;
1265 info = &cinfo->ports[port];
1266 tty = tty_port_tty_get(&info->port);
1267 /* OK to pass NULL to the handle functions below.
1268 They need to drop the data in that case. */
1270 if (!info->throttle)
1271 cyz_handle_rx(info, tty);
1272 cyz_handle_tx(info, tty);
1275 /* poll every 'cyz_polling_cycle' period */
1276 expires = jiffies + cyz_polling_cycle;
1278 mod_timer(&cyz_timerlist, expires);
1281 #endif /* CONFIG_CYZ_INTR */
1283 /********** End of block of Cyclades-Z specific code *********/
1284 /***********************************************************/
1286 /* This is called whenever a port becomes active;
1287 interrupts are enabled and DTR & RTS are turned on.
1289 static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1291 struct cyclades_card *card;
1292 unsigned long flags;
1298 channel = info->line - card->first_line;
1300 page = get_zeroed_page(GFP_KERNEL);
1304 spin_lock_irqsave(&card->card_lock, flags);
1306 if (info->port.flags & ASYNC_INITIALIZED)
1310 set_bit(TTY_IO_ERROR, &tty->flags);
1314 if (info->port.xmit_buf)
1317 info->port.xmit_buf = (unsigned char *)page;
1319 spin_unlock_irqrestore(&card->card_lock, flags);
1321 cy_set_line_char(info, tty);
1323 if (!cy_is_Z(card)) {
1326 spin_lock_irqsave(&card->card_lock, flags);
1328 cyy_writeb(info, CyCAR, channel);
1330 cyy_writeb(info, CyRTPR,
1331 (info->default_timeout ? info->default_timeout : 0x02));
1332 /* 10ms rx timeout */
1334 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1336 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1338 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1340 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1342 if (!cyz_is_loaded(card))
1345 #ifdef CY_DEBUG_OPEN
1346 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1347 "base_addr %p\n", card, channel, card->base_addr);
1349 spin_lock_irqsave(&card->card_lock, flags);
1351 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1353 #ifdef CONFIG_CYZ_INTR
1354 cy_writel(&ch_ctrl->intr_enable,
1355 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1356 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1358 cy_writel(&ch_ctrl->intr_enable,
1359 C_IN_IOCTLW | C_IN_MDCD);
1360 #endif /* CONFIG_CYZ_INTR */
1362 #ifdef CONFIG_CYZ_INTR
1363 cy_writel(&ch_ctrl->intr_enable,
1364 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1365 C_IN_RXNNDT | C_IN_MDCD);
1367 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1368 #endif /* CONFIG_CYZ_INTR */
1371 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1373 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1374 "%x\n", info->line, retval);
1377 /* Flush RX buffers before raising DTR and RTS */
1378 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1380 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1381 "%x\n", info->line, retval);
1384 /* set timeout !!! */
1385 /* set RTS and DTR !!! */
1386 tty_port_raise_dtr_rts(&info->port);
1388 /* enable send, recv, modem !!! */
1391 info->port.flags |= ASYNC_INITIALIZED;
1393 clear_bit(TTY_IO_ERROR, &tty->flags);
1394 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1395 info->breakon = info->breakoff = 0;
1396 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1397 info->idle_stats.in_use =
1398 info->idle_stats.recv_idle =
1399 info->idle_stats.xmit_idle = jiffies;
1401 spin_unlock_irqrestore(&card->card_lock, flags);
1403 #ifdef CY_DEBUG_OPEN
1404 printk(KERN_DEBUG "cyc startup done\n");
1409 spin_unlock_irqrestore(&card->card_lock, flags);
1414 static void start_xmit(struct cyclades_port *info)
1416 struct cyclades_card *card = info->card;
1417 unsigned long flags;
1418 int channel = info->line - card->first_line;
1420 if (!cy_is_Z(card)) {
1421 spin_lock_irqsave(&card->card_lock, flags);
1422 cyy_writeb(info, CyCAR, channel & 0x03);
1423 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1424 spin_unlock_irqrestore(&card->card_lock, flags);
1426 #ifdef CONFIG_CYZ_INTR
1429 spin_lock_irqsave(&card->card_lock, flags);
1430 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1432 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1433 "%x\n", info->line, retval);
1435 spin_unlock_irqrestore(&card->card_lock, flags);
1436 #else /* CONFIG_CYZ_INTR */
1437 /* Don't have to do anything at this time */
1438 #endif /* CONFIG_CYZ_INTR */
1443 * This routine shuts down a serial port; interrupts are disabled,
1444 * and DTR is dropped if the hangup on close termio flag is on.
1446 static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1448 struct cyclades_card *card;
1449 unsigned long flags;
1452 if (!(info->port.flags & ASYNC_INITIALIZED))
1456 channel = info->line - card->first_line;
1457 if (!cy_is_Z(card)) {
1458 spin_lock_irqsave(&card->card_lock, flags);
1460 /* Clear delta_msr_wait queue to avoid mem leaks. */
1461 wake_up_interruptible(&info->port.delta_msr_wait);
1463 if (info->port.xmit_buf) {
1464 unsigned char *temp;
1465 temp = info->port.xmit_buf;
1466 info->port.xmit_buf = NULL;
1467 free_page((unsigned long)temp);
1469 if (tty->termios->c_cflag & HUPCL)
1470 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1472 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1473 /* it may be appropriate to clear _XMIT at
1474 some later date (after testing)!!! */
1476 set_bit(TTY_IO_ERROR, &tty->flags);
1477 info->port.flags &= ~ASYNC_INITIALIZED;
1478 spin_unlock_irqrestore(&card->card_lock, flags);
1480 #ifdef CY_DEBUG_OPEN
1481 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1482 "base_addr %p\n", card, channel, card->base_addr);
1485 if (!cyz_is_loaded(card))
1488 spin_lock_irqsave(&card->card_lock, flags);
1490 if (info->port.xmit_buf) {
1491 unsigned char *temp;
1492 temp = info->port.xmit_buf;
1493 info->port.xmit_buf = NULL;
1494 free_page((unsigned long)temp);
1497 if (tty->termios->c_cflag & HUPCL)
1498 tty_port_lower_dtr_rts(&info->port);
1500 set_bit(TTY_IO_ERROR, &tty->flags);
1501 info->port.flags &= ~ASYNC_INITIALIZED;
1503 spin_unlock_irqrestore(&card->card_lock, flags);
1506 #ifdef CY_DEBUG_OPEN
1507 printk(KERN_DEBUG "cyc shutdown done\n");
1512 * ------------------------------------------------------------
1513 * cy_open() and friends
1514 * ------------------------------------------------------------
1518 * This routine is called whenever a serial port is opened. It
1519 * performs the serial-specific initialization for the tty structure.
1521 static int cy_open(struct tty_struct *tty, struct file *filp)
1523 struct cyclades_port *info;
1524 unsigned int i, line;
1528 if (tty->index < 0 || NR_PORTS <= line)
1531 for (i = 0; i < NR_CARDS; i++)
1532 if (line < cy_card[i].first_line + cy_card[i].nports &&
1533 line >= cy_card[i].first_line)
1537 info = &cy_card[i].ports[line - cy_card[i].first_line];
1541 /* If the card's firmware hasn't been loaded,
1542 treat it as absent from the system. This
1543 will make the user pay attention.
1545 if (cy_is_Z(info->card)) {
1546 struct cyclades_card *cinfo = info->card;
1547 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1549 if (!cyz_is_loaded(cinfo)) {
1550 if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1551 readl(&firm_id->signature) ==
1553 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1554 "need an external power supply for "
1555 "this number of ports.\nFirmware "
1558 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1563 #ifdef CONFIG_CYZ_INTR
1565 /* In case this Z board is operating in interrupt mode, its
1566 interrupts should be enabled as soon as the first open
1567 happens to one of its ports. */
1568 if (!cinfo->intr_enabled) {
1571 /* Enable interrupts on the PLX chip */
1572 intr = readw(&cinfo->ctl_addr.p9060->
1573 intr_ctrl_stat) | 0x0900;
1574 cy_writew(&cinfo->ctl_addr.p9060->
1575 intr_ctrl_stat, intr);
1576 /* Enable interrupts on the FW */
1577 retval = cyz_issue_cmd(cinfo, 0,
1580 printk(KERN_ERR "cyc:IRQ enable retval "
1581 "was %x\n", retval);
1583 cinfo->intr_enabled = 1;
1586 #endif /* CONFIG_CYZ_INTR */
1587 /* Make sure this Z port really exists in hardware */
1588 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1591 #ifdef CY_DEBUG_OTHER
1592 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1594 tty->driver_data = info;
1595 if (serial_paranoia_check(info, tty->name, "cy_open"))
1598 #ifdef CY_DEBUG_OPEN
1599 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1603 #ifdef CY_DEBUG_COUNT
1604 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1605 current->pid, info->port.count);
1609 * If the port is the middle of closing, bail out now
1611 if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1612 wait_event_interruptible(info->port.close_wait,
1613 !(info->port.flags & ASYNC_CLOSING));
1614 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1618 * Start up serial port
1620 retval = cy_startup(info, tty);
1624 retval = tty_port_block_til_ready(&info->port, tty, filp);
1626 #ifdef CY_DEBUG_OPEN
1627 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1628 "with %d\n", retval);
1634 tty_port_tty_set(&info->port, tty);
1636 #ifdef CY_DEBUG_OPEN
1637 printk(KERN_DEBUG "cyc:cy_open done\n");
1643 * cy_wait_until_sent() --- wait until the transmitter is empty
1645 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1647 struct cyclades_card *card;
1648 struct cyclades_port *info = tty->driver_data;
1649 unsigned long orig_jiffies;
1652 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1655 if (info->xmit_fifo_size == 0)
1656 return; /* Just in case.... */
1658 orig_jiffies = jiffies;
1661 * Set the check interval to be 1/5 of the estimated time to
1662 * send a single character, and make it at least 1. The check
1663 * interval should also be less than the timeout.
1665 * Note: we have to use pretty tight timings here to satisfy
1668 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1669 char_time = char_time / 5;
1675 char_time = min(char_time, timeout);
1677 * If the transmitter hasn't cleared in twice the approximate
1678 * amount of time to send the entire FIFO, it probably won't
1679 * ever clear. This assumes the UART isn't doing flow
1680 * control, which is currently the case. Hence, if it ever
1681 * takes longer than info->timeout, this is probably due to a
1682 * UART bug of some kind. So, we clamp the timeout parameter at
1685 if (!timeout || timeout > 2 * info->timeout)
1686 timeout = 2 * info->timeout;
1687 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1688 printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
1689 timeout, char_time, jiffies);
1692 if (!cy_is_Z(card)) {
1693 while (cyy_readb(info, CySRER) & CyTxRdy) {
1694 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1695 printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
1697 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1699 if (timeout && time_after(jiffies, orig_jiffies +
1704 /* Run one more char cycle */
1705 msleep_interruptible(jiffies_to_msecs(char_time * 5));
1707 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
1708 printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
1712 static void cy_flush_buffer(struct tty_struct *tty)
1714 struct cyclades_port *info = tty->driver_data;
1715 struct cyclades_card *card;
1716 int channel, retval;
1717 unsigned long flags;
1720 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1723 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1727 channel = info->line - card->first_line;
1729 spin_lock_irqsave(&card->card_lock, flags);
1730 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1731 spin_unlock_irqrestore(&card->card_lock, flags);
1733 if (cy_is_Z(card)) { /* If it is a Z card, flush the on-board
1735 spin_lock_irqsave(&card->card_lock, flags);
1736 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1738 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1739 "was %x\n", info->line, retval);
1741 spin_unlock_irqrestore(&card->card_lock, flags);
1744 } /* cy_flush_buffer */
1747 static void cy_do_close(struct tty_port *port)
1749 struct cyclades_port *info = container_of(port, struct cyclades_port,
1751 struct cyclades_card *card;
1752 unsigned long flags;
1756 channel = info->line - card->first_line;
1757 spin_lock_irqsave(&card->card_lock, flags);
1759 if (!cy_is_Z(card)) {
1760 /* Stop accepting input */
1761 cyy_writeb(info, CyCAR, channel & 0x03);
1762 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1763 if (info->port.flags & ASYNC_INITIALIZED) {
1764 /* Waiting for on-board buffers to be empty before
1766 spin_unlock_irqrestore(&card->card_lock, flags);
1767 cy_wait_until_sent(port->tty, info->timeout);
1768 spin_lock_irqsave(&card->card_lock, flags);
1772 /* Waiting for on-board buffers to be empty before closing
1774 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1777 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1778 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1780 printk(KERN_DEBUG "cyc:cy_close retval on "
1781 "ttyC%d was %x\n", info->line, retval);
1783 spin_unlock_irqrestore(&card->card_lock, flags);
1784 wait_for_completion_interruptible(&info->shutdown_wait);
1785 spin_lock_irqsave(&card->card_lock, flags);
1789 spin_unlock_irqrestore(&card->card_lock, flags);
1790 cy_shutdown(info, port->tty);
1794 * This routine is called when a particular tty device is closed.
1796 static void cy_close(struct tty_struct *tty, struct file *filp)
1798 struct cyclades_port *info = tty->driver_data;
1799 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1801 tty_port_close(&info->port, tty, filp);
1804 /* This routine gets called when tty_write has put something into
1805 * the write_queue. The characters may come from user space or
1808 * This routine will return the number of characters actually
1809 * accepted for writing.
1811 * If the port is not already transmitting stuff, start it off by
1812 * enabling interrupts. The interrupt service routine will then
1813 * ensure that the characters are sent.
1814 * If the port is already active, there is no need to kick it.
1817 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1819 struct cyclades_port *info = tty->driver_data;
1820 unsigned long flags;
1824 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1827 if (serial_paranoia_check(info, tty->name, "cy_write"))
1830 if (!info->port.xmit_buf)
1833 spin_lock_irqsave(&info->card->card_lock, flags);
1835 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1836 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1841 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1842 info->xmit_head = (info->xmit_head + c) &
1843 (SERIAL_XMIT_SIZE - 1);
1844 info->xmit_cnt += c;
1849 spin_unlock_irqrestore(&info->card->card_lock, flags);
1851 info->idle_stats.xmit_bytes += ret;
1852 info->idle_stats.xmit_idle = jiffies;
1854 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1861 * This routine is called by the kernel to write a single
1862 * character to the tty device. If the kernel uses this routine,
1863 * it must call the flush_chars() routine (if defined) when it is
1864 * done stuffing characters into the driver. If there is no room
1865 * in the queue, the character is ignored.
1867 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1869 struct cyclades_port *info = tty->driver_data;
1870 unsigned long flags;
1873 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1876 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1879 if (!info->port.xmit_buf)
1882 spin_lock_irqsave(&info->card->card_lock, flags);
1883 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1884 spin_unlock_irqrestore(&info->card->card_lock, flags);
1888 info->port.xmit_buf[info->xmit_head++] = ch;
1889 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1891 info->idle_stats.xmit_bytes++;
1892 info->idle_stats.xmit_idle = jiffies;
1893 spin_unlock_irqrestore(&info->card->card_lock, flags);
1898 * This routine is called by the kernel after it has written a
1899 * series of characters to the tty device using put_char().
1901 static void cy_flush_chars(struct tty_struct *tty)
1903 struct cyclades_port *info = tty->driver_data;
1906 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1909 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1912 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1913 !info->port.xmit_buf)
1917 } /* cy_flush_chars */
1920 * This routine returns the numbers of characters the tty driver
1921 * will accept for queuing to be written. This number is subject
1922 * to change as output buffers get emptied, or if the output flow
1923 * control is activated.
1925 static int cy_write_room(struct tty_struct *tty)
1927 struct cyclades_port *info = tty->driver_data;
1931 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1934 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1936 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1940 } /* cy_write_room */
1942 static int cy_chars_in_buffer(struct tty_struct *tty)
1944 struct cyclades_port *info = tty->driver_data;
1946 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1949 #ifdef Z_EXT_CHARS_IN_BUFFER
1950 if (!cy_is_Z(info->card)) {
1951 #endif /* Z_EXT_CHARS_IN_BUFFER */
1953 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1954 info->line, info->xmit_cnt);
1956 return info->xmit_cnt;
1957 #ifdef Z_EXT_CHARS_IN_BUFFER
1959 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1961 __u32 tx_put, tx_get, tx_bufsize;
1964 tx_get = readl(&buf_ctrl->tx_get);
1965 tx_put = readl(&buf_ctrl->tx_put);
1966 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1967 if (tx_put >= tx_get)
1968 char_count = tx_put - tx_get;
1970 char_count = tx_put - tx_get + tx_bufsize;
1972 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1973 info->line, info->xmit_cnt + char_count);
1976 return info->xmit_cnt + char_count;
1978 #endif /* Z_EXT_CHARS_IN_BUFFER */
1979 } /* cy_chars_in_buffer */
1982 * ------------------------------------------------------------
1983 * cy_ioctl() and friends
1984 * ------------------------------------------------------------
1987 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1989 int co, co_val, bpr;
1990 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
1994 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1998 /* determine which prescaler to use */
1999 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
2000 if (cy_clock / co_val / baud > 63)
2004 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
2008 info->tbpr = info->rbpr = bpr;
2009 info->tco = info->rco = co;
2013 * This routine finds or computes the various line characteristics.
2014 * It used to be called config_setup
2016 static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
2018 struct cyclades_card *card;
2019 unsigned long flags;
2021 unsigned cflag, iflag;
2022 int baud, baud_rate = 0;
2025 if (!tty->termios) /* XXX can this happen at all? */
2028 if (info->line == -1)
2031 cflag = tty->termios->c_cflag;
2032 iflag = tty->termios->c_iflag;
2035 * Set up the tty->alt_speed kludge
2037 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2038 tty->alt_speed = 57600;
2039 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2040 tty->alt_speed = 115200;
2041 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2042 tty->alt_speed = 230400;
2043 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2044 tty->alt_speed = 460800;
2047 channel = info->line - card->first_line;
2049 if (!cy_is_Z(card)) {
2053 baud = tty_get_baud_rate(tty);
2054 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2056 if (info->custom_divisor)
2057 baud_rate = info->baud / info->custom_divisor;
2059 baud_rate = info->baud;
2060 } else if (baud > CD1400_MAX_SPEED) {
2061 baud = CD1400_MAX_SPEED;
2063 /* find the baud index */
2064 for (i = 0; i < 20; i++) {
2065 if (baud == baud_table[i])
2069 i = 19; /* CD1400_MAX_SPEED */
2071 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2073 cyy_baud_calc(info, baud_rate);
2075 if (info->chip_rev >= CD1400_REV_J) {
2076 /* It is a CD1400 rev. J or later */
2077 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
2078 info->tco = baud_co_60[i]; /* Tx CO */
2079 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
2080 info->rco = baud_co_60[i]; /* Rx CO */
2082 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
2083 info->tco = baud_co_25[i]; /* Tx CO */
2084 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
2085 info->rco = baud_co_25[i]; /* Rx CO */
2088 if (baud_table[i] == 134) {
2089 /* get it right for 134.5 baud */
2090 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2092 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2094 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2096 } else if (baud_table[i]) {
2097 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2099 /* this needs to be propagated into the card info */
2103 /* By tradition (is it a standard?) a baud rate of zero
2104 implies the line should be/has been closed. A bit
2105 later in this routine such a test is performed. */
2107 /* byte size and parity */
2110 /* receive threshold */
2111 info->cor3 = (info->default_threshold ?
2112 info->default_threshold : baud_cor3[i]);
2114 switch (cflag & CSIZE) {
2116 info->cor1 = Cy_5_BITS;
2119 info->cor1 = Cy_6_BITS;
2122 info->cor1 = Cy_7_BITS;
2125 info->cor1 = Cy_8_BITS;
2129 info->cor1 |= Cy_2_STOP;
2131 if (cflag & PARENB) {
2133 info->cor1 |= CyPARITY_O;
2135 info->cor1 |= CyPARITY_E;
2137 info->cor1 |= CyPARITY_NONE;
2139 /* CTS flow control flag */
2140 if (cflag & CRTSCTS) {
2141 info->port.flags |= ASYNC_CTS_FLOW;
2142 info->cor2 |= CyCtsAE;
2144 info->port.flags &= ~ASYNC_CTS_FLOW;
2145 info->cor2 &= ~CyCtsAE;
2148 info->port.flags &= ~ASYNC_CHECK_CD;
2150 info->port.flags |= ASYNC_CHECK_CD;
2152 /***********************************************
2153 The hardware option, CyRtsAO, presents RTS when
2154 the chip has characters to send. Since most modems
2155 use RTS as reverse (inbound) flow control, this
2156 option is not used. If inbound flow control is
2157 necessary, DTR can be programmed to provide the
2158 appropriate signals for use with a non-standard
2159 cable. Contact Marcio Saito for details.
2160 ***********************************************/
2164 spin_lock_irqsave(&card->card_lock, flags);
2165 cyy_writeb(info, CyCAR, channel);
2167 /* tx and rx baud rate */
2169 cyy_writeb(info, CyTCOR, info->tco);
2170 cyy_writeb(info, CyTBPR, info->tbpr);
2171 cyy_writeb(info, CyRCOR, info->rco);
2172 cyy_writeb(info, CyRBPR, info->rbpr);
2174 /* set line characteristics according configuration */
2176 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2177 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2178 cyy_writeb(info, CyCOR1, info->cor1);
2179 cyy_writeb(info, CyCOR2, info->cor2);
2180 cyy_writeb(info, CyCOR3, info->cor3);
2181 cyy_writeb(info, CyCOR4, info->cor4);
2182 cyy_writeb(info, CyCOR5, info->cor5);
2184 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2187 /* !!! Is this needed? */
2188 cyy_writeb(info, CyCAR, channel);
2189 cyy_writeb(info, CyRTPR,
2190 (info->default_timeout ? info->default_timeout : 0x02));
2191 /* 10ms rx timeout */
2195 cflags |= CyDSR | CyRI | CyDCD;
2196 /* without modem intr */
2197 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2198 /* act on 1->0 modem transitions */
2199 if ((cflag & CRTSCTS) && info->rflow)
2200 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2202 cyy_writeb(info, CyMCOR1, cflags);
2203 /* act on 0->1 modem transitions */
2204 cyy_writeb(info, CyMCOR2, cflags);
2206 if (i == 0) /* baud rate is zero, turn off line */
2207 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2209 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2211 clear_bit(TTY_IO_ERROR, &tty->flags);
2212 spin_unlock_irqrestore(&card->card_lock, flags);
2215 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2219 if (!cyz_is_loaded(card))
2223 baud = tty_get_baud_rate(tty);
2224 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2226 if (info->custom_divisor)
2227 baud_rate = info->baud / info->custom_divisor;
2229 baud_rate = info->baud;
2230 } else if (baud > CYZ_MAX_SPEED) {
2231 baud = CYZ_MAX_SPEED;
2233 cy_writel(&ch_ctrl->comm_baud, baud);
2236 /* get it right for 134.5 baud */
2237 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2239 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2241 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2244 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2246 /* this needs to be propagated into the card info */
2251 /* byte size and parity */
2252 switch (cflag & CSIZE) {
2254 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2257 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2260 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2263 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2266 if (cflag & CSTOPB) {
2267 cy_writel(&ch_ctrl->comm_data_l,
2268 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2270 cy_writel(&ch_ctrl->comm_data_l,
2271 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2273 if (cflag & PARENB) {
2275 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2277 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2279 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2281 /* CTS flow control flag */
2282 if (cflag & CRTSCTS) {
2283 cy_writel(&ch_ctrl->hw_flow,
2284 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2286 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2287 ~(C_RS_CTS | C_RS_RTS));
2289 /* As the HW flow control is done in firmware, the driver
2290 doesn't need to care about it */
2291 info->port.flags &= ~ASYNC_CTS_FLOW;
2293 /* XON/XOFF/XANY flow control flags */
2296 sw_flow |= C_FL_OXX;
2298 sw_flow |= C_FL_OIXANY;
2300 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2302 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2304 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2305 "was %x\n", info->line, retval);
2308 /* CD sensitivity */
2310 info->port.flags &= ~ASYNC_CHECK_CD;
2312 info->port.flags |= ASYNC_CHECK_CD;
2314 if (baud == 0) { /* baud rate is zero, turn off line */
2315 cy_writel(&ch_ctrl->rs_control,
2316 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2318 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2321 cy_writel(&ch_ctrl->rs_control,
2322 readl(&ch_ctrl->rs_control) | C_RS_DTR);
2324 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2328 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2330 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2331 "was %x\n", info->line, retval);
2334 clear_bit(TTY_IO_ERROR, &tty->flags);
2336 } /* set_line_char */
2338 static int cy_get_serial_info(struct cyclades_port *info,
2339 struct serial_struct __user *retinfo)
2341 struct cyclades_card *cinfo = info->card;
2342 struct serial_struct tmp = {
2345 .port = (info->card - cy_card) * 0x100 + info->line -
2348 .flags = info->port.flags,
2349 .close_delay = info->port.close_delay,
2350 .closing_wait = info->port.closing_wait,
2351 .baud_base = info->baud,
2352 .custom_divisor = info->custom_divisor,
2355 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2359 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2360 struct serial_struct __user *new_info)
2362 struct serial_struct new_serial;
2364 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2367 if (!capable(CAP_SYS_ADMIN)) {
2368 if (new_serial.close_delay != info->port.close_delay ||
2369 new_serial.baud_base != info->baud ||
2370 (new_serial.flags & ASYNC_FLAGS &
2372 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2374 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2375 (new_serial.flags & ASYNC_USR_MASK);
2376 info->baud = new_serial.baud_base;
2377 info->custom_divisor = new_serial.custom_divisor;
2378 goto check_and_exit;
2382 * OK, past this point, all the error checking has been done.
2383 * At this point, we start making changes.....
2386 info->baud = new_serial.baud_base;
2387 info->custom_divisor = new_serial.custom_divisor;
2388 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2389 (new_serial.flags & ASYNC_FLAGS);
2390 info->port.close_delay = new_serial.close_delay * HZ / 100;
2391 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2394 if (info->port.flags & ASYNC_INITIALIZED) {
2395 cy_set_line_char(info, tty);
2398 return cy_startup(info, tty);
2400 } /* set_serial_info */
2403 * get_lsr_info - get line status register info
2405 * Purpose: Let user call ioctl() to get info when the UART physically
2406 * is emptied. On bus types like RS485, the transmitter must
2407 * release the bus after transmitting. This must be done when
2408 * the transmit shift register is empty, not be done when the
2409 * transmit holding register is empty. This functionality
2410 * allows an RS485 driver to be written in user space.
2412 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2414 struct cyclades_card *card = info->card;
2415 unsigned int result;
2416 unsigned long flags;
2419 if (!cy_is_Z(card)) {
2420 spin_lock_irqsave(&card->card_lock, flags);
2421 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2422 spin_unlock_irqrestore(&card->card_lock, flags);
2423 result = (status ? 0 : TIOCSER_TEMT);
2425 /* Not supported yet */
2428 return put_user(result, (unsigned long __user *)value);
2431 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
2433 struct cyclades_port *info = tty->driver_data;
2434 struct cyclades_card *card;
2437 if (serial_paranoia_check(info, tty->name, __func__))
2443 if (!cy_is_Z(card)) {
2444 unsigned long flags;
2445 int channel = info->line - card->first_line;
2448 spin_lock_irqsave(&card->card_lock, flags);
2449 cyy_writeb(info, CyCAR, channel & 0x03);
2450 status = cyy_readb(info, CyMSVR1);
2451 status |= cyy_readb(info, CyMSVR2);
2452 spin_unlock_irqrestore(&card->card_lock, flags);
2454 if (info->rtsdtr_inv) {
2455 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2456 ((status & CyDTR) ? TIOCM_RTS : 0);
2458 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2459 ((status & CyDTR) ? TIOCM_DTR : 0);
2461 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2462 ((status & CyRI) ? TIOCM_RNG : 0) |
2463 ((status & CyDSR) ? TIOCM_DSR : 0) |
2464 ((status & CyCTS) ? TIOCM_CTS : 0);
2468 if (!cyz_is_loaded(card)) {
2473 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2474 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2475 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2476 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2477 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2478 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2479 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2487 cy_tiocmset(struct tty_struct *tty, struct file *file,
2488 unsigned int set, unsigned int clear)
2490 struct cyclades_port *info = tty->driver_data;
2491 struct cyclades_card *card;
2492 unsigned long flags;
2494 if (serial_paranoia_check(info, tty->name, __func__))
2498 if (!cy_is_Z(card)) {
2499 spin_lock_irqsave(&card->card_lock, flags);
2500 cyy_change_rts_dtr(info, set, clear);
2501 spin_unlock_irqrestore(&card->card_lock, flags);
2503 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2504 int retval, channel = info->line - card->first_line;
2507 if (!cyz_is_loaded(card))
2510 spin_lock_irqsave(&card->card_lock, flags);
2511 rs = readl(&ch_ctrl->rs_control);
2512 if (set & TIOCM_RTS)
2514 if (clear & TIOCM_RTS)
2516 if (set & TIOCM_DTR) {
2519 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2522 if (clear & TIOCM_DTR) {
2525 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2529 cy_writel(&ch_ctrl->rs_control, rs);
2530 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2531 spin_unlock_irqrestore(&card->card_lock, flags);
2533 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2534 "was %x\n", info->line, retval);
2541 * cy_break() --- routine which turns the break handling on or off
2543 static int cy_break(struct tty_struct *tty, int break_state)
2545 struct cyclades_port *info = tty->driver_data;
2546 struct cyclades_card *card;
2547 unsigned long flags;
2550 if (serial_paranoia_check(info, tty->name, "cy_break"))
2555 spin_lock_irqsave(&card->card_lock, flags);
2556 if (!cy_is_Z(card)) {
2557 /* Let the transmit ISR take care of this (since it
2558 requires stuffing characters into the output stream).
2560 if (break_state == -1) {
2561 if (!info->breakon) {
2563 if (!info->xmit_cnt) {
2564 spin_unlock_irqrestore(&card->card_lock, flags);
2566 spin_lock_irqsave(&card->card_lock, flags);
2570 if (!info->breakoff) {
2572 if (!info->xmit_cnt) {
2573 spin_unlock_irqrestore(&card->card_lock, flags);
2575 spin_lock_irqsave(&card->card_lock, flags);
2580 if (break_state == -1) {
2581 retval = cyz_issue_cmd(card,
2582 info->line - card->first_line,
2583 C_CM_SET_BREAK, 0L);
2585 printk(KERN_ERR "cyc:cy_break (set) retval on "
2586 "ttyC%d was %x\n", info->line, retval);
2589 retval = cyz_issue_cmd(card,
2590 info->line - card->first_line,
2591 C_CM_CLR_BREAK, 0L);
2593 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2594 "on ttyC%d was %x\n", info->line,
2599 spin_unlock_irqrestore(&card->card_lock, flags);
2603 static int set_threshold(struct cyclades_port *info, unsigned long value)
2605 struct cyclades_card *card = info->card;
2606 unsigned long flags;
2608 if (!cy_is_Z(card)) {
2609 info->cor3 &= ~CyREC_FIFO;
2610 info->cor3 |= value & CyREC_FIFO;
2612 spin_lock_irqsave(&card->card_lock, flags);
2613 cyy_writeb(info, CyCOR3, info->cor3);
2614 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2615 spin_unlock_irqrestore(&card->card_lock, flags);
2618 } /* set_threshold */
2620 static int get_threshold(struct cyclades_port *info,
2621 unsigned long __user *value)
2623 struct cyclades_card *card = info->card;
2625 if (!cy_is_Z(card)) {
2626 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2627 return put_user(tmp, value);
2630 } /* get_threshold */
2632 static int set_timeout(struct cyclades_port *info, unsigned long value)
2634 struct cyclades_card *card = info->card;
2635 unsigned long flags;
2637 if (!cy_is_Z(card)) {
2638 spin_lock_irqsave(&card->card_lock, flags);
2639 cyy_writeb(info, CyRTPR, value & 0xff);
2640 spin_unlock_irqrestore(&card->card_lock, flags);
2645 static int get_timeout(struct cyclades_port *info,
2646 unsigned long __user *value)
2648 struct cyclades_card *card = info->card;
2650 if (!cy_is_Z(card)) {
2651 u8 tmp = cyy_readb(info, CyRTPR);
2652 return put_user(tmp, value);
2657 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2658 struct cyclades_icount *cprev)
2660 struct cyclades_icount cnow;
2661 unsigned long flags;
2664 spin_lock_irqsave(&info->card->card_lock, flags);
2665 cnow = info->icount; /* atomic copy */
2666 spin_unlock_irqrestore(&info->card->card_lock, flags);
2668 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2669 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2670 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2671 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2679 * This routine allows the tty driver to implement device-
2680 * specific ioctl's. If the ioctl number passed in cmd is
2681 * not recognized by the driver, it should return ENOIOCTLCMD.
2684 cy_ioctl(struct tty_struct *tty, struct file *file,
2685 unsigned int cmd, unsigned long arg)
2687 struct cyclades_port *info = tty->driver_data;
2688 struct cyclades_icount cnow; /* kernel counter temps */
2690 unsigned long flags;
2691 void __user *argp = (void __user *)arg;
2693 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2696 #ifdef CY_DEBUG_OTHER
2697 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2698 info->line, cmd, arg);
2704 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2708 memset(&info->mon, 0, sizeof(info->mon));
2711 ret_val = get_threshold(info, argp);
2714 ret_val = set_threshold(info, arg);
2716 case CYGETDEFTHRESH:
2717 ret_val = put_user(info->default_threshold,
2718 (unsigned long __user *)argp);
2720 case CYSETDEFTHRESH:
2721 info->default_threshold = arg & 0x0f;
2724 ret_val = get_timeout(info, argp);
2727 ret_val = set_timeout(info, arg);
2729 case CYGETDEFTIMEOUT:
2730 ret_val = put_user(info->default_timeout,
2731 (unsigned long __user *)argp);
2733 case CYSETDEFTIMEOUT:
2734 info->default_timeout = arg & 0xff;
2737 info->rflow = (int)arg;
2740 ret_val = info->rflow;
2742 case CYSETRTSDTR_INV:
2743 info->rtsdtr_inv = (int)arg;
2745 case CYGETRTSDTR_INV:
2746 ret_val = info->rtsdtr_inv;
2748 case CYGETCD1400VER:
2749 ret_val = info->chip_rev;
2751 #ifndef CONFIG_CYZ_INTR
2752 case CYZSETPOLLCYCLE:
2753 cyz_polling_cycle = (arg * HZ) / 1000;
2755 case CYZGETPOLLCYCLE:
2756 ret_val = (cyz_polling_cycle * 1000) / HZ;
2758 #endif /* CONFIG_CYZ_INTR */
2760 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2763 ret_val = info->port.closing_wait / (HZ / 100);
2766 ret_val = cy_get_serial_info(info, argp);
2769 ret_val = cy_set_serial_info(info, tty, argp);
2771 case TIOCSERGETLSR: /* Get line status register */
2772 ret_val = get_lsr_info(info, argp);
2775 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2776 * - mask passed in arg for lines of interest
2777 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2778 * Caller should use TIOCGICOUNT to see which one it was
2781 spin_lock_irqsave(&info->card->card_lock, flags);
2782 /* note the counters on entry */
2783 cnow = info->icount;
2784 spin_unlock_irqrestore(&info->card->card_lock, flags);
2785 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2786 cy_cflags_changed(info, arg, &cnow));
2790 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2791 * Return: write counters to the user passed counter struct
2792 * NB: both 1->0 and 0->1 transitions are counted except for
2793 * RI where only 0->1 is counted.
2796 struct serial_icounter_struct sic = { };
2798 spin_lock_irqsave(&info->card->card_lock, flags);
2799 cnow = info->icount;
2800 spin_unlock_irqrestore(&info->card->card_lock, flags);
2808 sic.frame = cnow.frame;
2809 sic.overrun = cnow.overrun;
2810 sic.parity = cnow.parity;
2812 sic.buf_overrun = cnow.buf_overrun;
2814 if (copy_to_user(argp, &sic, sizeof(sic)))
2819 ret_val = -ENOIOCTLCMD;
2823 #ifdef CY_DEBUG_OTHER
2824 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2830 * This routine allows the tty driver to be notified when
2831 * device's termios settings have changed. Note that a
2832 * well-designed tty driver should be prepared to accept the case
2833 * where old == NULL, and try to do something rational.
2835 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2837 struct cyclades_port *info = tty->driver_data;
2839 #ifdef CY_DEBUG_OTHER
2840 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2843 cy_set_line_char(info, tty);
2845 if ((old_termios->c_cflag & CRTSCTS) &&
2846 !(tty->termios->c_cflag & CRTSCTS)) {
2847 tty->hw_stopped = 0;
2852 * No need to wake up processes in open wait, since they
2853 * sample the CLOCAL flag once, and don't recheck it.
2854 * XXX It's not clear whether the current behavior is correct
2855 * or not. Hence, this may change.....
2857 if (!(old_termios->c_cflag & CLOCAL) &&
2858 (tty->termios->c_cflag & CLOCAL))
2859 wake_up_interruptible(&info->port.open_wait);
2861 } /* cy_set_termios */
2863 /* This function is used to send a high-priority XON/XOFF character to
2866 static void cy_send_xchar(struct tty_struct *tty, char ch)
2868 struct cyclades_port *info = tty->driver_data;
2869 struct cyclades_card *card;
2872 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2881 channel = info->line - card->first_line;
2883 if (cy_is_Z(card)) {
2884 if (ch == STOP_CHAR(tty))
2885 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2886 else if (ch == START_CHAR(tty))
2887 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2891 /* This routine is called by the upper-layer tty layer to signal
2892 that incoming characters should be throttled because the input
2893 buffers are close to full.
2895 static void cy_throttle(struct tty_struct *tty)
2897 struct cyclades_port *info = tty->driver_data;
2898 struct cyclades_card *card;
2899 unsigned long flags;
2901 #ifdef CY_DEBUG_THROTTLE
2904 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2905 tty->ldisc.chars_in_buffer(tty), info->line);
2908 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2915 cy_send_xchar(tty, STOP_CHAR(tty));
2920 if (tty->termios->c_cflag & CRTSCTS) {
2921 if (!cy_is_Z(card)) {
2922 spin_lock_irqsave(&card->card_lock, flags);
2923 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2924 spin_unlock_irqrestore(&card->card_lock, flags);
2932 * This routine notifies the tty driver that it should signal
2933 * that characters can now be sent to the tty without fear of
2934 * overrunning the input buffers of the line disciplines.
2936 static void cy_unthrottle(struct tty_struct *tty)
2938 struct cyclades_port *info = tty->driver_data;
2939 struct cyclades_card *card;
2940 unsigned long flags;
2942 #ifdef CY_DEBUG_THROTTLE
2945 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2946 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2949 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2956 cy_send_xchar(tty, START_CHAR(tty));
2959 if (tty->termios->c_cflag & CRTSCTS) {
2961 if (!cy_is_Z(card)) {
2962 spin_lock_irqsave(&card->card_lock, flags);
2963 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2964 spin_unlock_irqrestore(&card->card_lock, flags);
2969 } /* cy_unthrottle */
2971 /* cy_start and cy_stop provide software output flow control as a
2972 function of XON/XOFF, software CTS, and other such stuff.
2974 static void cy_stop(struct tty_struct *tty)
2976 struct cyclades_card *cinfo;
2977 struct cyclades_port *info = tty->driver_data;
2979 unsigned long flags;
2981 #ifdef CY_DEBUG_OTHER
2982 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2985 if (serial_paranoia_check(info, tty->name, "cy_stop"))
2989 channel = info->line - cinfo->first_line;
2990 if (!cy_is_Z(cinfo)) {
2991 spin_lock_irqsave(&cinfo->card_lock, flags);
2992 cyy_writeb(info, CyCAR, channel & 0x03);
2993 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2994 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2998 static void cy_start(struct tty_struct *tty)
3000 struct cyclades_card *cinfo;
3001 struct cyclades_port *info = tty->driver_data;
3003 unsigned long flags;
3005 #ifdef CY_DEBUG_OTHER
3006 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
3009 if (serial_paranoia_check(info, tty->name, "cy_start"))
3013 channel = info->line - cinfo->first_line;
3014 if (!cy_is_Z(cinfo)) {
3015 spin_lock_irqsave(&cinfo->card_lock, flags);
3016 cyy_writeb(info, CyCAR, channel & 0x03);
3017 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
3018 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3023 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
3025 static void cy_hangup(struct tty_struct *tty)
3027 struct cyclades_port *info = tty->driver_data;
3029 #ifdef CY_DEBUG_OTHER
3030 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
3033 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3036 cy_flush_buffer(tty);
3037 cy_shutdown(info, tty);
3038 tty_port_hangup(&info->port);
3041 static int cyy_carrier_raised(struct tty_port *port)
3043 struct cyclades_port *info = container_of(port, struct cyclades_port,
3045 struct cyclades_card *cinfo = info->card;
3046 unsigned long flags;
3047 int channel = info->line - cinfo->first_line;
3050 spin_lock_irqsave(&cinfo->card_lock, flags);
3051 cyy_writeb(info, CyCAR, channel & 0x03);
3052 cd = cyy_readb(info, CyMSVR1) & CyDCD;
3053 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3058 static void cyy_dtr_rts(struct tty_port *port, int raise)
3060 struct cyclades_port *info = container_of(port, struct cyclades_port,
3062 struct cyclades_card *cinfo = info->card;
3063 unsigned long flags;
3065 spin_lock_irqsave(&cinfo->card_lock, flags);
3066 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3067 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3068 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3071 static int cyz_carrier_raised(struct tty_port *port)
3073 struct cyclades_port *info = container_of(port, struct cyclades_port,
3076 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3079 static void cyz_dtr_rts(struct tty_port *port, int raise)
3081 struct cyclades_port *info = container_of(port, struct cyclades_port,
3083 struct cyclades_card *cinfo = info->card;
3084 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3085 int ret, channel = info->line - cinfo->first_line;
3088 rs = readl(&ch_ctrl->rs_control);
3090 rs |= C_RS_RTS | C_RS_DTR;
3092 rs &= ~(C_RS_RTS | C_RS_DTR);
3093 cy_writel(&ch_ctrl->rs_control, rs);
3094 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3096 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3097 __func__, info->line, ret);
3099 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3103 static const struct tty_port_operations cyy_port_ops = {
3104 .carrier_raised = cyy_carrier_raised,
3105 .dtr_rts = cyy_dtr_rts,
3106 .shutdown = cy_do_close,
3109 static const struct tty_port_operations cyz_port_ops = {
3110 .carrier_raised = cyz_carrier_raised,
3111 .dtr_rts = cyz_dtr_rts,
3112 .shutdown = cy_do_close,
3116 * ---------------------------------------------------------------------
3117 * cy_init() and friends
3119 * cy_init() is called at boot-time to initialize the serial driver.
3120 * ---------------------------------------------------------------------
3123 static int __devinit cy_init_card(struct cyclades_card *cinfo)
3125 struct cyclades_port *info;
3126 unsigned int channel, port;
3128 spin_lock_init(&cinfo->card_lock);
3129 cinfo->intr_enabled = 0;
3131 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3133 if (cinfo->ports == NULL) {
3134 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3138 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3139 channel++, port++) {
3140 info = &cinfo->ports[channel];
3141 tty_port_init(&info->port);
3142 info->magic = CYCLADES_MAGIC;
3146 info->port.closing_wait = CLOSING_WAIT_DELAY;
3147 info->port.close_delay = 5 * HZ / 10;
3148 info->port.flags = STD_COM_FLAGS;
3149 init_completion(&info->shutdown_wait);
3151 if (cy_is_Z(cinfo)) {
3152 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3153 struct ZFW_CTRL *zfw_ctrl;
3155 info->port.ops = &cyz_port_ops;
3156 info->type = PORT_STARTECH;
3158 zfw_ctrl = cinfo->base_addr +
3159 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3160 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3161 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3163 if (cinfo->hw_ver == ZO_V1)
3164 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3166 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3167 #ifdef CONFIG_CYZ_INTR
3168 setup_timer(&cyz_rx_full_timer[port],
3169 cyz_rx_restart, (unsigned long)info);
3172 unsigned short chip_number;
3173 int index = cinfo->bus_index;
3175 info->port.ops = &cyy_port_ops;
3176 info->type = PORT_CIRRUS;
3177 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3178 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3180 info->cor3 = 0x08; /* _very_ small rcv threshold */
3182 chip_number = channel / CyPORTS_PER_CHIP;
3183 info->u.cyy.base_addr = cinfo->base_addr +
3184 (cy_chip_offset[chip_number] << index);
3185 info->chip_rev = cyy_readb(info, CyGFRCR);
3187 if (info->chip_rev >= CD1400_REV_J) {
3188 /* It is a CD1400 rev. J or later */
3189 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
3190 info->tco = baud_co_60[13]; /* Tx CO */
3191 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
3192 info->rco = baud_co_60[13]; /* Rx CO */
3193 info->rtsdtr_inv = 1;
3195 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
3196 info->tco = baud_co_25[13]; /* Tx CO */
3197 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
3198 info->rco = baud_co_25[13]; /* Rx CO */
3199 info->rtsdtr_inv = 0;
3201 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3202 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3207 #ifndef CONFIG_CYZ_INTR
3208 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3209 mod_timer(&cyz_timerlist, jiffies + 1);
3211 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3218 /* initialize chips on Cyclom-Y card -- return number of valid
3219 chips (which is number of ports/4) */
3220 static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
3223 unsigned int chip_number;
3224 void __iomem *base_addr;
3226 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3227 /* Cy_HwReset is 0x1400 */
3228 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3229 /* Cy_ClrIntr is 0x1800 */
3232 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3235 true_base_addr + (cy_chip_offset[chip_number] << index);
3237 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3239 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3240 chip_number, (unsigned long)base_addr);
3245 cy_writeb(base_addr + (CyGFRCR << index), 0);
3248 /* The Cyclom-16Y does not decode address bit 9 and therefore
3249 cannot distinguish between references to chip 0 and a non-
3250 existent chip 4. If the preceding clearing of the supposed
3251 chip 4 GFRCR register appears at chip 0, there is no chip 4
3252 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3254 if (chip_number == 4 && readb(true_base_addr +
3255 (cy_chip_offset[0] << index) +
3256 (CyGFRCR << index)) == 0) {
3260 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3263 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3265 printk(" chip #%d at %#6lx is not responding ",
3266 chip_number, (unsigned long)base_addr);
3267 printk("(GFRCR stayed 0)\n",
3271 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3274 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3276 chip_number, (unsigned long)base_addr,
3277 base_addr[CyGFRCR<<index]);
3281 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3282 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3283 /* It is a CD1400 rev. J or later */
3284 /* Impossible to reach 5ms with this chip.
3285 Changed to 2ms instead (f = 500 Hz). */
3286 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3289 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3293 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3294 chip_number, (unsigned long)base_addr,
3295 readb(base_addr+(CyGFRCR<<index)));
3299 } /* cyy_init_card */
3302 * ---------------------------------------------------------------------
3303 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3304 * sets global variables and return the number of ISA boards found.
3305 * ---------------------------------------------------------------------
3307 static int __init cy_detect_isa(void)
3310 unsigned short cy_isa_irq, nboard;
3311 void __iomem *cy_isa_address;
3312 unsigned short i, j, cy_isa_nchan;
3320 /* Check for module parameters */
3321 for (i = 0; i < NR_CARDS; i++) {
3322 if (maddr[i] || i) {
3324 cy_isa_addresses[i] = maddr[i];
3331 /* scan the address table probing for Cyclom-Y/ISA boards */
3332 for (i = 0; i < NR_ISA_ADDRS; i++) {
3333 unsigned int isa_address = cy_isa_addresses[i];
3334 if (isa_address == 0x0000)
3337 /* probe for CD1400... */
3338 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3339 if (cy_isa_address == NULL) {
3340 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3344 cy_isa_nchan = CyPORTS_PER_CHIP *
3345 cyy_init_card(cy_isa_address, 0);
3346 if (cy_isa_nchan == 0) {
3347 iounmap(cy_isa_address);
3351 if (isparam && i < NR_CARDS && irq[i])
3352 cy_isa_irq = irq[i];
3355 /* find out the board's irq by probing */
3356 cy_isa_irq = detect_isa_irq(cy_isa_address);
3357 if (cy_isa_irq == 0) {
3358 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3359 "IRQ could not be detected.\n",
3360 (unsigned long)cy_isa_address);
3361 iounmap(cy_isa_address);
3365 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3366 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3367 "more channels are available. Change NR_PORTS "
3368 "in cyclades.c and recompile kernel.\n",
3369 (unsigned long)cy_isa_address);
3370 iounmap(cy_isa_address);
3373 /* fill the next cy_card structure available */
3374 for (j = 0; j < NR_CARDS; j++) {
3375 if (cy_card[j].base_addr == NULL)
3378 if (j == NR_CARDS) { /* no more cy_cards available */
3379 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3380 "more cards can be used. Change NR_CARDS in "
3381 "cyclades.c and recompile kernel.\n",
3382 (unsigned long)cy_isa_address);
3383 iounmap(cy_isa_address);
3388 if (request_irq(cy_isa_irq, cyy_interrupt,
3389 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
3390 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3391 "could not allocate IRQ#%d.\n",
3392 (unsigned long)cy_isa_address, cy_isa_irq);
3393 iounmap(cy_isa_address);
3398 cy_card[j].base_addr = cy_isa_address;
3399 cy_card[j].ctl_addr.p9050 = NULL;
3400 cy_card[j].irq = (int)cy_isa_irq;
3401 cy_card[j].bus_index = 0;
3402 cy_card[j].first_line = cy_next_channel;
3403 cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3404 cy_card[j].nports = cy_isa_nchan;
3405 if (cy_init_card(&cy_card[j])) {
3406 cy_card[j].base_addr = NULL;
3407 free_irq(cy_isa_irq, &cy_card[j]);
3408 iounmap(cy_isa_address);
3413 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3414 "%d channels starting from port %d\n",
3415 j + 1, (unsigned long)cy_isa_address,
3416 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3417 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3419 for (j = cy_next_channel;
3420 j < cy_next_channel + cy_isa_nchan; j++)
3421 tty_register_device(cy_serial_driver, j, NULL);
3422 cy_next_channel += cy_isa_nchan;
3427 #endif /* CONFIG_ISA */
3428 } /* cy_detect_isa */
3431 static inline int __devinit cyc_isfwstr(const char *str, unsigned int size)
3435 for (a = 0; a < size && *str; a++, str++)
3439 for (; a < size; a++, str++)
3446 static inline void __devinit cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3449 for (; size > 0; size--) {
3450 cy_writel(fpga, *data++);
3455 static void __devinit plx_init(struct pci_dev *pdev, int irq,
3456 struct RUNTIME_9060 __iomem *addr)
3459 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3461 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3463 /* Reload Config. Registers from EEPROM */
3464 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3466 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3468 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3469 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3470 * registers. This will remain here until we find a permanent fix.
3472 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3475 static int __devinit __cyz_load_fw(const struct firmware *fw,
3476 const char *name, const u32 mailbox, void __iomem *base,
3479 const void *ptr = fw->data;
3480 const struct zfile_header *h = ptr;
3481 const struct zfile_config *c, *cs;
3482 const struct zfile_block *b, *bs;
3483 unsigned int a, tmp, len = fw->size;
3484 #define BAD_FW KERN_ERR "Bad firmware: "
3485 if (len < sizeof(*h)) {
3486 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3490 cs = ptr + h->config_offset;
3491 bs = ptr + h->block_offset;
3493 if ((void *)(cs + h->n_config) > ptr + len ||
3494 (void *)(bs + h->n_blocks) > ptr + len) {
3495 printk(BAD_FW "too short");
3499 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3500 cyc_isfwstr(h->date, sizeof(h->date))) {
3501 printk(BAD_FW "bad formatted header string\n");
3505 if (strncmp(name, h->name, sizeof(h->name))) {
3506 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3511 for (c = cs; c < cs + h->n_config; c++) {
3512 for (a = 0; a < c->n_blocks; a++)
3513 if (c->block_list[a] > h->n_blocks) {
3514 printk(BAD_FW "bad block ref number in cfgs\n");
3517 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3521 printk(BAD_FW "nothing appropriate\n");
3525 for (b = bs; b < bs + h->n_blocks; b++)
3526 if (b->file_offset + b->size > len) {
3527 printk(BAD_FW "bad block data offset\n");
3531 /* everything is OK, let's seek'n'load it */
3532 for (c = cs; c < cs + h->n_config; c++)
3533 if (c->mailbox == mailbox && c->function == 0)
3536 for (a = 0; a < c->n_blocks; a++) {
3537 b = &bs[c->block_list[a]];
3538 if (b->type == ZBLOCK_FPGA) {
3540 cyz_fpga_copy(fpga, ptr + b->file_offset,
3544 memcpy_toio(base + b->ram_offset,
3545 ptr + b->file_offset, b->size);
3552 static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3553 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3555 const struct firmware *fw;
3556 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3557 struct CUSTOM_REG __iomem *cust = base_addr;
3558 struct ZFW_CTRL __iomem *pt_zfwctrl;
3560 u32 mailbox, status, nchan;
3564 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3566 dev_err(&pdev->dev, "can't get firmware\n");
3570 /* Check whether the firmware is already loaded and running. If
3571 positive, skip this board */
3572 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3573 u32 cntval = readl(base_addr + 0x190);
3576 if (cntval != readl(base_addr + 0x190)) {
3577 /* FW counter is working, FW is running */
3578 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3579 "Skipping board.\n");
3586 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3589 mailbox = readl(&ctl_addr->mail_box_0);
3591 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3592 /* stops CPU and set window to beginning of RAM */
3593 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3594 cy_writel(&cust->cpu_stop, 0);
3595 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3599 plx_init(pdev, irq, ctl_addr);
3603 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3607 if (!__cyz_fpga_loaded(ctl_addr)) {
3608 dev_err(&pdev->dev, "fw upload successful, but fw is "
3614 /* stops CPU and set window to beginning of RAM */
3615 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3616 cy_writel(&cust->cpu_stop, 0);
3617 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3621 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3622 cy_writeb(tmp, 255);
3624 /* set window to last 512K of RAM */
3625 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3626 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3627 cy_writeb(tmp, 255);
3628 /* set window to beginning of RAM */
3629 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3632 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3633 release_firmware(fw);
3637 /* finish boot and start boards */
3638 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3639 cy_writel(&cust->cpu_start, 0);
3640 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3642 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3644 if (status != ZFIRM_ID) {
3645 if (status == ZFIRM_HLT) {
3646 dev_err(&pdev->dev, "you need an external power supply "
3647 "for this number of ports. Firmware halted and "
3652 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3653 "some more time\n", status);
3654 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3657 if (status != ZFIRM_ID) {
3658 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3659 "Giving up. (fid->signature = 0x%x)\n",
3661 dev_info(&pdev->dev, "*** Warning ***: if you are "
3662 "upgrading the FW, please power cycle the "
3663 "system before loading the new FW to the "
3666 if (__cyz_fpga_loaded(ctl_addr))
3667 plx_init(pdev, irq, ctl_addr);
3672 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3675 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3677 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3678 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3679 base_addr + readl(&fid->zfwctrl_addr));
3681 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3682 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3683 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3686 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3687 "check the connection between the Z host card and the "
3688 "serial expanders.\n");
3690 if (__cyz_fpga_loaded(ctl_addr))
3691 plx_init(pdev, irq, ctl_addr);
3693 dev_info(&pdev->dev, "Null number of ports detected. Board "
3699 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3700 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3703 Early firmware failed to start looking for commands.
3704 This enables firmware interrupts for those commands.
3706 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3708 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3713 release_firmware(fw);
3718 static int __devinit cy_pci_probe(struct pci_dev *pdev,
3719 const struct pci_device_id *ent)
3721 void __iomem *addr0 = NULL, *addr2 = NULL;
3722 char *card_name = NULL;
3723 u32 uninitialized_var(mailbox);
3724 unsigned int device_id, nchan = 0, card_no, i;
3725 unsigned char plx_ver;
3728 retval = pci_enable_device(pdev);
3730 dev_err(&pdev->dev, "cannot enable device\n");
3734 /* read PCI configuration area */
3736 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3738 #if defined(__alpha__)
3739 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
3740 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3741 "addresses on Alpha systems.\n");
3746 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3747 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3753 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3754 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3756 pdev->resource[2].flags &= ~IORESOURCE_IO;
3759 retval = pci_request_regions(pdev, "cyclades");
3761 dev_err(&pdev->dev, "failed to reserve resources\n");
3766 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3767 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3768 card_name = "Cyclom-Y";
3770 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3772 if (addr0 == NULL) {
3773 dev_err(&pdev->dev, "can't remap ctl region\n");
3776 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3778 if (addr2 == NULL) {
3779 dev_err(&pdev->dev, "can't remap base region\n");
3783 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3785 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3786 "Serial-Modules\n");
3789 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3790 struct RUNTIME_9060 __iomem *ctl_addr;
3792 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3794 if (addr0 == NULL) {
3795 dev_err(&pdev->dev, "can't remap ctl region\n");
3799 /* Disable interrupts on the PLX before resetting it */
3800 cy_writew(&ctl_addr->intr_ctrl_stat,
3801 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3803 plx_init(pdev, irq, addr0);
3805 mailbox = readl(&ctl_addr->mail_box_0);
3807 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3808 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3809 if (addr2 == NULL) {
3810 dev_err(&pdev->dev, "can't remap base region\n");
3814 if (mailbox == ZE_V1) {
3815 card_name = "Cyclades-Ze";
3817 card_name = "Cyclades-8Zo";
3819 if (mailbox == ZO_V1) {
3820 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3821 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3822 "id %lx, ver %lx\n", (ulong)(0xff &
3823 readl(&((struct CUSTOM_REG *)addr2)->
3824 fpga_id)), (ulong)(0xff &
3825 readl(&((struct CUSTOM_REG *)addr2)->
3827 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3829 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3830 "Cyclades-Z board. FPGA not loaded\n");
3833 /* The following clears the firmware id word. This
3834 ensures that the driver will not attempt to talk to
3835 the board until it has been properly initialized.
3837 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3838 cy_writel(addr2 + ID_ADDRESS, 0L);
3841 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3847 if ((cy_next_channel + nchan) > NR_PORTS) {
3848 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3849 "channels are available. Change NR_PORTS in "
3850 "cyclades.c and recompile kernel.\n");
3853 /* fill the next cy_card structure available */
3854 for (card_no = 0; card_no < NR_CARDS; card_no++) {
3855 if (cy_card[card_no].base_addr == NULL)
3858 if (card_no == NR_CARDS) { /* no more cy_cards available */
3859 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3860 "more cards can be used. Change NR_CARDS in "
3861 "cyclades.c and recompile kernel.\n");
3865 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3866 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3868 retval = request_irq(irq, cyy_interrupt,
3869 IRQF_SHARED, "Cyclom-Y", &cy_card[card_no]);
3871 dev_err(&pdev->dev, "could not allocate IRQ\n");
3874 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
3876 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3877 struct ZFW_CTRL __iomem *zfw_ctrl;
3879 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3881 cy_card[card_no].hw_ver = mailbox;
3882 cy_card[card_no].num_chips = (unsigned int)-1;
3883 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
3884 #ifdef CONFIG_CYZ_INTR
3885 /* allocate IRQ only if board has an IRQ */
3886 if (irq != 0 && irq != 255) {
3887 retval = request_irq(irq, cyz_interrupt,
3888 IRQF_SHARED, "Cyclades-Z",
3891 dev_err(&pdev->dev, "could not allocate IRQ\n");
3895 #endif /* CONFIG_CYZ_INTR */
3899 cy_card[card_no].base_addr = addr2;
3900 cy_card[card_no].ctl_addr.p9050 = addr0;
3901 cy_card[card_no].irq = irq;
3902 cy_card[card_no].bus_index = 1;
3903 cy_card[card_no].first_line = cy_next_channel;
3904 cy_card[card_no].nports = nchan;
3905 retval = cy_init_card(&cy_card[card_no]);
3909 pci_set_drvdata(pdev, &cy_card[card_no]);
3911 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3912 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3913 /* enable interrupts in the PCI interface */
3914 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3917 cy_writeb(addr0 + 0x4c, 0x43);
3922 default: /* Old boards, use PLX_9060 */
3924 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3925 plx_init(pdev, irq, ctl_addr);
3926 cy_writew(&ctl_addr->intr_ctrl_stat,
3927 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3933 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3934 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3935 for (i = cy_next_channel; i < cy_next_channel + nchan; i++)
3936 tty_register_device(cy_serial_driver, i, &pdev->dev);
3937 cy_next_channel += nchan;
3941 cy_card[card_no].base_addr = NULL;
3942 free_irq(irq, &cy_card[card_no]);
3948 pci_release_regions(pdev);
3950 pci_disable_device(pdev);
3955 static void __devexit cy_pci_remove(struct pci_dev *pdev)
3957 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3960 /* non-Z with old PLX */
3961 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3963 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3965 #ifndef CONFIG_CYZ_INTR
3966 if (!cy_is_Z(cinfo))
3968 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3969 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3972 iounmap(cinfo->base_addr);
3973 if (cinfo->ctl_addr.p9050)
3974 iounmap(cinfo->ctl_addr.p9050);
3976 #ifndef CONFIG_CYZ_INTR
3978 #endif /* CONFIG_CYZ_INTR */
3980 free_irq(cinfo->irq, cinfo);
3981 pci_release_regions(pdev);
3983 cinfo->base_addr = NULL;
3984 for (i = cinfo->first_line; i < cinfo->first_line +
3986 tty_unregister_device(cy_serial_driver, i);
3988 kfree(cinfo->ports);
3991 static struct pci_driver cy_pci_driver = {
3993 .id_table = cy_pci_dev_id,
3994 .probe = cy_pci_probe,
3995 .remove = __devexit_p(cy_pci_remove)
3999 static int cyclades_proc_show(struct seq_file *m, void *v)
4001 struct cyclades_port *info;
4003 __u32 cur_jifs = jiffies;
4005 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
4006 "IdleIn Overruns Ldisc\n");
4008 /* Output one line for each known port */
4009 for (i = 0; i < NR_CARDS; i++)
4010 for (j = 0; j < cy_card[i].nports; j++) {
4011 info = &cy_card[i].ports[j];
4013 if (info->port.count) {
4014 /* XXX is the ldisc num worth this? */
4015 struct tty_struct *tty;
4016 struct tty_ldisc *ld;
4018 tty = tty_port_tty_get(&info->port);
4020 ld = tty_ldisc_ref(tty);
4023 tty_ldisc_deref(ld);
4027 seq_printf(m, "%3d %8lu %10lu %8lu "
4028 "%10lu %8lu %9lu %6d\n", info->line,
4029 (cur_jifs - info->idle_stats.in_use) /
4030 HZ, info->idle_stats.xmit_bytes,
4031 (cur_jifs - info->idle_stats.xmit_idle)/
4032 HZ, info->idle_stats.recv_bytes,
4033 (cur_jifs - info->idle_stats.recv_idle)/
4034 HZ, info->idle_stats.overruns,
4037 seq_printf(m, "%3d %8lu %10lu %8lu "
4038 "%10lu %8lu %9lu %6ld\n",
4039 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4044 static int cyclades_proc_open(struct inode *inode, struct file *file)
4046 return single_open(file, cyclades_proc_show, NULL);
4049 static const struct file_operations cyclades_proc_fops = {
4050 .owner = THIS_MODULE,
4051 .open = cyclades_proc_open,
4053 .llseek = seq_lseek,
4054 .release = single_release,
4057 /* The serial driver boot-time initialization code!
4058 Hardware I/O ports are mapped to character special devices on a
4059 first found, first allocated manner. That is, this code searches
4060 for Cyclom cards in the system. As each is found, it is probed
4061 to discover how many chips (and thus how many ports) are present.
4062 These ports are mapped to the tty ports 32 and upward in monotonic
4063 fashion. If an 8-port card is replaced with a 16-port card, the
4064 port mapping on a following card will shift.
4066 This approach is different from what is used in the other serial
4067 device driver because the Cyclom is more properly a multiplexer,
4068 not just an aggregation of serial ports on one card.
4070 If there are more cards with more ports than have been
4071 statically allocated above, a warning is printed and the
4072 extra ports are ignored.
4075 static const struct tty_operations cy_ops = {
4079 .put_char = cy_put_char,
4080 .flush_chars = cy_flush_chars,
4081 .write_room = cy_write_room,
4082 .chars_in_buffer = cy_chars_in_buffer,
4083 .flush_buffer = cy_flush_buffer,
4085 .throttle = cy_throttle,
4086 .unthrottle = cy_unthrottle,
4087 .set_termios = cy_set_termios,
4090 .hangup = cy_hangup,
4091 .break_ctl = cy_break,
4092 .wait_until_sent = cy_wait_until_sent,
4093 .tiocmget = cy_tiocmget,
4094 .tiocmset = cy_tiocmset,
4095 .proc_fops = &cyclades_proc_fops,
4098 static int __init cy_init(void)
4100 unsigned int nboards;
4101 int retval = -ENOMEM;
4103 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4104 if (!cy_serial_driver)
4107 printk(KERN_INFO "Cyclades driver " CY_VERSION " (built %s %s)\n",
4108 __DATE__, __TIME__);
4110 /* Initialize the tty_driver structure */
4112 cy_serial_driver->owner = THIS_MODULE;
4113 cy_serial_driver->driver_name = "cyclades";
4114 cy_serial_driver->name = "ttyC";
4115 cy_serial_driver->major = CYCLADES_MAJOR;
4116 cy_serial_driver->minor_start = 0;
4117 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4118 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4119 cy_serial_driver->init_termios = tty_std_termios;
4120 cy_serial_driver->init_termios.c_cflag =
4121 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4122 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4123 tty_set_operations(cy_serial_driver, &cy_ops);
4125 retval = tty_register_driver(cy_serial_driver);
4127 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4131 /* the code below is responsible to find the boards. Each different
4132 type of board has its own detection routine. If a board is found,
4133 the next cy_card structure available is set by the detection
4134 routine. These functions are responsible for checking the
4135 availability of cy_card and cy_port data structures and updating
4136 the cy_next_channel. */
4138 /* look for isa boards */
4139 nboards = cy_detect_isa();
4142 /* look for pci boards */
4143 retval = pci_register_driver(&cy_pci_driver);
4144 if (retval && !nboards) {
4145 tty_unregister_driver(cy_serial_driver);
4152 put_tty_driver(cy_serial_driver);
4157 static void __exit cy_cleanup_module(void)
4159 struct cyclades_card *card;
4162 #ifndef CONFIG_CYZ_INTR
4163 del_timer_sync(&cyz_timerlist);
4164 #endif /* CONFIG_CYZ_INTR */
4166 e1 = tty_unregister_driver(cy_serial_driver);
4168 printk(KERN_ERR "failed to unregister Cyclades serial "
4169 "driver(%d)\n", e1);
4172 pci_unregister_driver(&cy_pci_driver);
4175 for (i = 0; i < NR_CARDS; i++) {
4177 if (card->base_addr) {
4178 /* clear interrupt */
4179 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4180 iounmap(card->base_addr);
4181 if (card->ctl_addr.p9050)
4182 iounmap(card->ctl_addr.p9050);
4184 #ifndef CONFIG_CYZ_INTR
4186 #endif /* CONFIG_CYZ_INTR */
4188 free_irq(card->irq, card);
4189 for (e1 = card->first_line; e1 < card->first_line +
4191 tty_unregister_device(cy_serial_driver, e1);
4196 put_tty_driver(cy_serial_driver);
4197 } /* cy_cleanup_module */
4199 module_init(cy_init);
4200 module_exit(cy_cleanup_module);
4202 MODULE_LICENSE("GPL");
4203 MODULE_VERSION(CY_VERSION);
4204 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);