3 #undef Z_EXT_CHARS_IN_BUFFER
6 * This file contains the driver for the Cyclades async multiport
9 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
10 * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
12 * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
14 * Much of the design and some of the code came from serial.c
15 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
16 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
17 * and then fixed as suggested by Michael K. Johnson 12/12/92.
18 * Converted to pci probing and cleaned up by Jiri Slaby.
22 #define CY_VERSION "2.6"
24 /* If you need to install more boards than NR_CARDS, change the constant
25 in the definition below. No other change is necessary to support up to
26 eight boards. Beyond that you'll have to extend cy_isa_addresses. */
31 If the total number of ports is larger than NR_PORTS, change this
32 constant in the definition below. No other change is necessary to
33 support more boards/ports. */
41 #define SERIAL_PARANOIA_CHECK
43 #undef CY_DEBUG_THROTTLE
48 #undef CY_DEBUG_INTERRUPTS
50 #undef CY_ENABLE_MONITORING
56 #include <linux/module.h>
57 #include <linux/errno.h>
58 #include <linux/signal.h>
59 #include <linux/sched.h>
60 #include <linux/timer.h>
61 #include <linux/interrupt.h>
62 #include <linux/tty.h>
63 #include <linux/tty_flip.h>
64 #include <linux/serial.h>
65 #include <linux/major.h>
66 #include <linux/string.h>
67 #include <linux/fcntl.h>
68 #include <linux/ptrace.h>
69 #include <linux/cyclades.h>
71 #include <linux/ioport.h>
72 #include <linux/init.h>
73 #include <linux/delay.h>
74 #include <linux/spinlock.h>
75 #include <linux/bitops.h>
76 #include <linux/firmware.h>
77 #include <linux/device.h>
78 #include <linux/slab.h>
81 #include <linux/uaccess.h>
83 #include <linux/kernel.h>
84 #include <linux/pci.h>
86 #include <linux/stat.h>
87 #include <linux/proc_fs.h>
88 #include <linux/seq_file.h>
90 static void cy_send_xchar(struct tty_struct *tty, char ch);
92 #ifndef SERIAL_XMIT_SIZE
93 #define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
96 #define STD_COM_FLAGS (0)
99 #define ZL_MAX_BLOCKS 16
100 #define DRIVER_VERSION 0x02010203
101 #define RAM_SIZE 0x80000
108 struct zfile_header {
117 } __attribute__ ((packed));
119 struct zfile_config {
124 u32 block_list[ZL_MAX_BLOCKS];
125 } __attribute__ ((packed));
132 } __attribute__ ((packed));
134 static struct tty_driver *cy_serial_driver;
137 /* This is the address lookup table. The driver will probe for
138 Cyclom-Y/ISA boards at all addresses in here. If you want the
139 driver to probe addresses at a different address, add it to
140 this table. If the driver is probing some other board and
141 causing problems, remove the offending address from this table.
144 static unsigned int cy_isa_addresses[] = {
153 0, 0, 0, 0, 0, 0, 0, 0
156 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
158 static long maddr[NR_CARDS];
159 static int irq[NR_CARDS];
161 module_param_array(maddr, long, NULL, 0);
162 module_param_array(irq, int, NULL, 0);
164 #endif /* CONFIG_ISA */
166 /* This is the per-card data structure containing address, irq, number of
167 channels, etc. This driver supports a maximum of NR_CARDS cards.
169 static struct cyclades_card cy_card[NR_CARDS];
171 static int cy_next_channel; /* next minor available */
174 * This is used to look up the divisor speeds and the timeouts
175 * We're normally limited to 15 distinct baud rates. The extra
176 * are accessed via settings in info->port.flags.
177 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
178 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
182 static const int baud_table[] = {
183 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
184 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
188 static const char baud_co_25[] = { /* 25 MHz clock option table */
189 /* value => 00 01 02 03 04 */
190 /* divide by 8 32 128 512 2048 */
191 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
192 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
195 static const char baud_bpr_25[] = { /* 25 MHz baud rate period table */
196 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
197 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
200 static const char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
201 /* value => 00 01 02 03 04 */
202 /* divide by 8 32 128 512 2048 */
203 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
204 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
208 static const char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
209 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
210 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
214 static const char baud_cor3[] = { /* receive threshold */
215 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
216 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
221 * The Cyclades driver implements HW flow control as any serial driver.
222 * The cyclades_port structure member rflow and the vector rflow_thr
223 * allows us to take advantage of a special feature in the CD1400 to avoid
224 * data loss even when the system interrupt latency is too high. These flags
225 * are to be used only with very special applications. Setting these flags
226 * requires the use of a special cable (DTR and RTS reversed). In the new
227 * CD1400-based boards (rev. 6.00 or later), there is no need for special
231 static const char rflow_thr[] = { /* rflow threshold */
232 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
237 /* The Cyclom-Ye has placed the sequential chips in non-sequential
238 * address order. This look-up table overcomes that problem.
240 static const unsigned int cy_chip_offset[] = { 0x0000,
250 /* PCI related definitions */
253 static const struct pci_device_id cy_pci_dev_id[] = {
255 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
257 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },
259 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },
261 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },
263 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },
265 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },
267 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },
269 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },
270 { } /* end of table */
272 MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
275 static void cy_start(struct tty_struct *);
276 static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
277 static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
279 static unsigned detect_isa_irq(void __iomem *);
280 #endif /* CONFIG_ISA */
282 #ifndef CONFIG_CYZ_INTR
283 static void cyz_poll(unsigned long);
285 /* The Cyclades-Z polling cycle is defined by this variable */
286 static long cyz_polling_cycle = CZ_DEF_POLL;
288 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
290 #else /* CONFIG_CYZ_INTR */
291 static void cyz_rx_restart(unsigned long);
292 static struct timer_list cyz_rx_full_timer[NR_PORTS];
293 #endif /* CONFIG_CYZ_INTR */
295 static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
297 struct cyclades_card *card = port->card;
299 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
302 static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
304 struct cyclades_card *card = port->card;
306 return readb(port->u.cyy.base_addr + (reg << card->bus_index));
309 static inline bool cy_is_Z(struct cyclades_card *card)
311 return card->num_chips == (unsigned int)-1;
314 static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
316 return readl(&ctl_addr->init_ctrl) & (1 << 17);
319 static inline bool cyz_fpga_loaded(struct cyclades_card *card)
321 return __cyz_fpga_loaded(card->ctl_addr.p9060);
324 static inline bool cyz_is_loaded(struct cyclades_card *card)
326 struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
328 return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
329 readl(&fw_id->signature) == ZFIRM_ID;
332 static inline int serial_paranoia_check(struct cyclades_port *info,
333 const char *name, const char *routine)
335 #ifdef SERIAL_PARANOIA_CHECK
337 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
338 "in %s\n", name, routine);
342 if (info->magic != CYCLADES_MAGIC) {
343 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
344 "struct (%s) in %s\n", name, routine);
351 /***********************************************************/
352 /********* Start of block of Cyclom-Y specific code ********/
354 /* This routine waits up to 1000 micro-seconds for the previous
355 command to the Cirrus chip to complete and then issues the
356 new command. An error is returned if the previous command
357 didn't finish within the time limit.
359 This function is only called from inside spinlock-protected code.
361 static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
363 void __iomem *ccr = base_addr + (CyCCR << index);
366 /* Check to see that the previous command has completed */
367 for (i = 0; i < 100; i++) {
372 /* if the CCR never cleared, the previous command
373 didn't finish within the "reasonable time" */
377 /* Issue the new command */
383 static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
385 return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
386 port->card->bus_index);
390 /* ISA interrupt detection code */
391 static unsigned detect_isa_irq(void __iomem *address)
394 unsigned long irqs, flags;
395 int save_xir, save_car;
396 int index = 0; /* IRQ probing is only for ISA */
398 /* forget possible initially masked and pending IRQ */
399 irq = probe_irq_off(probe_irq_on());
401 /* Clear interrupts on the board first */
402 cy_writeb(address + (Cy_ClrIntr << index), 0);
403 /* Cy_ClrIntr is 0x1800 */
405 irqs = probe_irq_on();
409 /* Enable the Tx interrupts on the CD1400 */
410 local_irq_save(flags);
411 cy_writeb(address + (CyCAR << index), 0);
412 __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
414 cy_writeb(address + (CyCAR << index), 0);
415 cy_writeb(address + (CySRER << index),
416 readb(address + (CySRER << index)) | CyTxRdy);
417 local_irq_restore(flags);
422 /* Check which interrupt is in use */
423 irq = probe_irq_off(irqs);
426 save_xir = (u_char) readb(address + (CyTIR << index));
427 save_car = readb(address + (CyCAR << index));
428 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
429 cy_writeb(address + (CySRER << index),
430 readb(address + (CySRER << index)) & ~CyTxRdy);
431 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
432 cy_writeb(address + (CyCAR << index), (save_car));
433 cy_writeb(address + (Cy_ClrIntr << index), 0);
434 /* Cy_ClrIntr is 0x1800 */
436 return (irq > 0) ? irq : 0;
438 #endif /* CONFIG_ISA */
440 static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
441 void __iomem *base_addr)
443 struct cyclades_port *info;
444 struct tty_port *port;
445 int len, index = cinfo->bus_index;
446 u8 ivr, save_xir, channel, save_car, data, char_count;
448 #ifdef CY_DEBUG_INTERRUPTS
449 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
451 /* determine the channel & change to that context */
452 save_xir = readb(base_addr + (CyRIR << index));
453 channel = save_xir & CyIRChannel;
454 info = &cinfo->ports[channel + chip * 4];
456 save_car = cyy_readb(info, CyCAR);
457 cyy_writeb(info, CyCAR, save_xir);
458 ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
460 /* there is an open port for this data */
461 if (ivr == CyIVRRxEx) { /* exception */
462 data = cyy_readb(info, CyRDSR);
464 /* For statistics only */
467 else if (data & CyFRAME)
468 info->icount.frame++;
469 else if (data & CyPARITY)
470 info->icount.parity++;
471 else if (data & CyOVERRUN)
472 info->icount.overrun++;
474 if (data & info->ignore_status_mask) {
478 if (tty_buffer_request_room(port, 1)) {
479 if (data & info->read_status_mask) {
480 if (data & CyBREAK) {
481 tty_insert_flip_char(port,
482 cyy_readb(info, CyRDSR),
485 if (port->flags & ASYNC_SAK) {
486 struct tty_struct *tty =
487 tty_port_tty_get(port);
493 } else if (data & CyFRAME) {
494 tty_insert_flip_char(port,
495 cyy_readb(info, CyRDSR),
498 info->idle_stats.frame_errs++;
499 } else if (data & CyPARITY) {
500 /* Pieces of seven... */
501 tty_insert_flip_char(port,
502 cyy_readb(info, CyRDSR),
505 info->idle_stats.parity_errs++;
506 } else if (data & CyOVERRUN) {
507 tty_insert_flip_char(port, 0,
510 /* If the flip buffer itself is
511 overflowing, we still lose
512 the next incoming character.
514 tty_insert_flip_char(port,
515 cyy_readb(info, CyRDSR),
518 info->idle_stats.overruns++;
519 /* These two conditions may imply */
520 /* a normal read should be done. */
521 /* } else if(data & CyTIMEOUT) { */
522 /* } else if(data & CySPECHAR) { */
524 tty_insert_flip_char(port, 0,
529 tty_insert_flip_char(port, 0, TTY_NORMAL);
533 /* there was a software buffer overrun and nothing
534 * could be done about it!!! */
535 info->icount.buf_overrun++;
536 info->idle_stats.overruns++;
538 } else { /* normal character reception */
539 /* load # chars available from the chip */
540 char_count = cyy_readb(info, CyRDCR);
542 #ifdef CY_ENABLE_MONITORING
543 ++info->mon.int_count;
544 info->mon.char_count += char_count;
545 if (char_count > info->mon.char_max)
546 info->mon.char_max = char_count;
547 info->mon.char_last = char_count;
549 len = tty_buffer_request_room(port, char_count);
551 data = cyy_readb(info, CyRDSR);
552 tty_insert_flip_char(port, data, TTY_NORMAL);
553 info->idle_stats.recv_bytes++;
559 info->idle_stats.recv_idle = jiffies;
561 tty_schedule_flip(port);
564 cyy_writeb(info, CyRIR, save_xir & 0x3f);
565 cyy_writeb(info, CyCAR, save_car);
568 static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
569 void __iomem *base_addr)
571 struct cyclades_port *info;
572 struct tty_struct *tty;
573 int char_count, index = cinfo->bus_index;
574 u8 save_xir, channel, save_car, outch;
576 /* Since we only get here when the transmit buffer
577 is empty, we know we can always stuff a dozen
579 #ifdef CY_DEBUG_INTERRUPTS
580 printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
583 /* determine the channel & change to that context */
584 save_xir = readb(base_addr + (CyTIR << index));
585 channel = save_xir & CyIRChannel;
586 save_car = readb(base_addr + (CyCAR << index));
587 cy_writeb(base_addr + (CyCAR << index), save_xir);
589 info = &cinfo->ports[channel + chip * 4];
590 tty = tty_port_tty_get(&info->port);
592 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
596 /* load the on-chip space for outbound data */
597 char_count = info->xmit_fifo_size;
599 if (info->x_char) { /* send special char */
600 outch = info->x_char;
601 cyy_writeb(info, CyTDR, outch);
607 if (info->breakon || info->breakoff) {
609 cyy_writeb(info, CyTDR, 0);
610 cyy_writeb(info, CyTDR, 0x81);
614 if (info->breakoff) {
615 cyy_writeb(info, CyTDR, 0);
616 cyy_writeb(info, CyTDR, 0x83);
622 while (char_count-- > 0) {
623 if (!info->xmit_cnt) {
624 if (cyy_readb(info, CySRER) & CyTxMpty) {
625 cyy_writeb(info, CySRER,
626 cyy_readb(info, CySRER) & ~CyTxMpty);
628 cyy_writeb(info, CySRER, CyTxMpty |
629 (cyy_readb(info, CySRER) & ~CyTxRdy));
633 if (info->port.xmit_buf == NULL) {
634 cyy_writeb(info, CySRER,
635 cyy_readb(info, CySRER) & ~CyTxRdy);
638 if (tty->stopped || tty->hw_stopped) {
639 cyy_writeb(info, CySRER,
640 cyy_readb(info, CySRER) & ~CyTxRdy);
643 /* Because the Embedded Transmit Commands have been enabled,
644 * we must check to see if the escape character, NULL, is being
645 * sent. If it is, we must ensure that there is room for it to
646 * be doubled in the output stream. Therefore we no longer
647 * advance the pointer when the character is fetched, but
648 * rather wait until after the check for a NULL output
649 * character. This is necessary because there may not be room
650 * for the two chars needed to send a NULL.)
652 outch = info->port.xmit_buf[info->xmit_tail];
655 info->xmit_tail = (info->xmit_tail + 1) &
656 (SERIAL_XMIT_SIZE - 1);
657 cyy_writeb(info, CyTDR, outch);
660 if (char_count > 1) {
662 info->xmit_tail = (info->xmit_tail + 1) &
663 (SERIAL_XMIT_SIZE - 1);
664 cyy_writeb(info, CyTDR, outch);
665 cyy_writeb(info, CyTDR, 0);
677 cyy_writeb(info, CyTIR, save_xir & 0x3f);
678 cyy_writeb(info, CyCAR, save_car);
681 static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
682 void __iomem *base_addr)
684 struct cyclades_port *info;
685 struct tty_struct *tty;
686 int index = cinfo->bus_index;
687 u8 save_xir, channel, save_car, mdm_change, mdm_status;
689 /* determine the channel & change to that context */
690 save_xir = readb(base_addr + (CyMIR << index));
691 channel = save_xir & CyIRChannel;
692 info = &cinfo->ports[channel + chip * 4];
693 save_car = cyy_readb(info, CyCAR);
694 cyy_writeb(info, CyCAR, save_xir);
696 mdm_change = cyy_readb(info, CyMISR);
697 mdm_status = cyy_readb(info, CyMSVR1);
699 tty = tty_port_tty_get(&info->port);
703 if (mdm_change & CyANY_DELTA) {
704 /* For statistics only */
705 if (mdm_change & CyDCD)
707 if (mdm_change & CyCTS)
709 if (mdm_change & CyDSR)
711 if (mdm_change & CyRI)
714 wake_up_interruptible(&info->port.delta_msr_wait);
717 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
718 if (mdm_status & CyDCD)
719 wake_up_interruptible(&info->port.open_wait);
723 if ((mdm_change & CyCTS) && tty_port_cts_enabled(&info->port)) {
724 if (tty->hw_stopped) {
725 if (mdm_status & CyCTS) {
726 /* cy_start isn't used
729 cyy_writeb(info, CySRER,
730 cyy_readb(info, CySRER) | CyTxRdy);
734 if (!(mdm_status & CyCTS)) {
735 /* cy_stop isn't used
738 cyy_writeb(info, CySRER,
739 cyy_readb(info, CySRER) & ~CyTxRdy);
743 /* if (mdm_change & CyDSR) {
745 if (mdm_change & CyRI) {
750 cyy_writeb(info, CyMIR, save_xir & 0x3f);
751 cyy_writeb(info, CyCAR, save_car);
754 /* The real interrupt service routine is called
755 whenever the card wants its hand held--chars
756 received, out buffer empty, modem change, etc.
758 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
761 struct cyclades_card *cinfo = dev_id;
762 void __iomem *base_addr, *card_base_addr;
763 unsigned int chip, too_many, had_work;
766 if (unlikely(cinfo == NULL)) {
767 #ifdef CY_DEBUG_INTERRUPTS
768 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",
771 return IRQ_NONE; /* spurious interrupt */
774 card_base_addr = cinfo->base_addr;
775 index = cinfo->bus_index;
777 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
778 if (unlikely(card_base_addr == NULL))
781 /* This loop checks all chips in the card. Make a note whenever
782 _any_ chip had some work to do, as this is considered an
783 indication that there will be more to do. Only when no chip
784 has any work does this outermost loop exit.
788 for (chip = 0; chip < cinfo->num_chips; chip++) {
789 base_addr = cinfo->base_addr +
790 (cy_chip_offset[chip] << index);
792 while ((status = readb(base_addr +
793 (CySVRR << index))) != 0x00) {
795 /* The purpose of the following test is to ensure that
796 no chip can monopolize the driver. This forces the
797 chips to be checked in a round-robin fashion (after
798 draining each of a bunch (1000) of characters).
800 if (1000 < too_many++)
802 spin_lock(&cinfo->card_lock);
803 if (status & CySRReceive) /* rx intr */
804 cyy_chip_rx(cinfo, chip, base_addr);
805 if (status & CySRTransmit) /* tx intr */
806 cyy_chip_tx(cinfo, chip, base_addr);
807 if (status & CySRModem) /* modem intr */
808 cyy_chip_modem(cinfo, chip, base_addr);
809 spin_unlock(&cinfo->card_lock);
814 /* clear interrupts */
815 spin_lock(&cinfo->card_lock);
816 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
817 /* Cy_ClrIntr is 0x1800 */
818 spin_unlock(&cinfo->card_lock);
820 } /* cyy_interrupt */
822 static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
825 struct cyclades_card *card = info->card;
826 int channel = info->line - card->first_line;
827 u32 rts, dtr, msvrr, msvrd;
831 if (info->rtsdtr_inv) {
842 if (set & TIOCM_RTS) {
843 cyy_writeb(info, CyCAR, channel);
844 cyy_writeb(info, msvrr, rts);
846 if (clear & TIOCM_RTS) {
847 cyy_writeb(info, CyCAR, channel);
848 cyy_writeb(info, msvrr, ~rts);
850 if (set & TIOCM_DTR) {
851 cyy_writeb(info, CyCAR, channel);
852 cyy_writeb(info, msvrd, dtr);
854 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
855 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
856 cyy_readb(info, CyMSVR1),
857 cyy_readb(info, CyMSVR2));
860 if (clear & TIOCM_DTR) {
861 cyy_writeb(info, CyCAR, channel);
862 cyy_writeb(info, msvrd, ~dtr);
864 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
865 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
866 cyy_readb(info, CyMSVR1),
867 cyy_readb(info, CyMSVR2));
872 /***********************************************************/
873 /********* End of block of Cyclom-Y specific code **********/
874 /******** Start of block of Cyclades-Z specific code *******/
875 /***********************************************************/
878 cyz_fetch_msg(struct cyclades_card *cinfo,
879 __u32 *channel, __u8 *cmd, __u32 *param)
881 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
882 unsigned long loc_doorbell;
884 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
886 *cmd = (char)(0xff & loc_doorbell);
887 *channel = readl(&board_ctrl->fwcmd_channel);
888 *param = (__u32) readl(&board_ctrl->fwcmd_param);
889 cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
893 } /* cyz_fetch_msg */
896 cyz_issue_cmd(struct cyclades_card *cinfo,
897 __u32 channel, __u8 cmd, __u32 param)
899 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
900 __u32 __iomem *pci_doorbell;
903 if (!cyz_is_loaded(cinfo))
907 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
908 while ((readl(pci_doorbell) & 0xff) != 0) {
910 return (int)(readl(pci_doorbell) & 0xff);
913 cy_writel(&board_ctrl->hcmd_channel, channel);
914 cy_writel(&board_ctrl->hcmd_param, param);
915 cy_writel(pci_doorbell, (long)cmd);
918 } /* cyz_issue_cmd */
920 static void cyz_handle_rx(struct cyclades_port *info)
922 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
923 struct cyclades_card *cinfo = info->card;
924 struct tty_port *port = &info->port;
925 unsigned int char_count;
932 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
934 rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
935 rx_put = readl(&buf_ctrl->rx_put);
936 rx_bufsize = readl(&buf_ctrl->rx_bufsize);
937 rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
938 if (rx_put >= rx_get)
939 char_count = rx_put - rx_get;
941 char_count = rx_put - rx_get + rx_bufsize;
946 #ifdef CY_ENABLE_MONITORING
947 info->mon.int_count++;
948 info->mon.char_count += char_count;
949 if (char_count > info->mon.char_max)
950 info->mon.char_max = char_count;
951 info->mon.char_last = char_count;
955 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
956 for performance, but because of buffer boundaries, there
957 may be several steps to the operation */
959 len = tty_prepare_flip_string(port, &buf,
964 len = min_t(unsigned int, min(len, char_count),
965 rx_bufsize - new_rx_get);
967 memcpy_fromio(buf, cinfo->base_addr +
968 rx_bufaddr + new_rx_get, len);
970 new_rx_get = (new_rx_get + len) &
973 info->icount.rx += len;
974 info->idle_stats.recv_bytes += len;
977 len = tty_buffer_request_room(port, char_count);
979 data = readb(cinfo->base_addr + rx_bufaddr +
981 new_rx_get = (new_rx_get + 1) &
983 tty_insert_flip_char(port, data, TTY_NORMAL);
984 info->idle_stats.recv_bytes++;
988 #ifdef CONFIG_CYZ_INTR
989 /* Recalculate the number of chars in the RX buffer and issue
990 a cmd in case it's higher than the RX high water mark */
991 rx_put = readl(&buf_ctrl->rx_put);
992 if (rx_put >= rx_get)
993 char_count = rx_put - rx_get;
995 char_count = rx_put - rx_get + rx_bufsize;
996 if (char_count >= readl(&buf_ctrl->rx_threshold) &&
997 !timer_pending(&cyz_rx_full_timer[
999 mod_timer(&cyz_rx_full_timer[info->line],
1002 info->idle_stats.recv_idle = jiffies;
1003 tty_schedule_flip(&info->port);
1006 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1009 static void cyz_handle_tx(struct cyclades_port *info)
1011 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1012 struct cyclades_card *cinfo = info->card;
1013 struct tty_struct *tty;
1015 unsigned int char_count;
1019 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1021 if (info->xmit_cnt <= 0) /* Nothing to transmit */
1024 tx_get = readl(&buf_ctrl->tx_get);
1025 tx_put = readl(&buf_ctrl->tx_put);
1026 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1027 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1028 if (tx_put >= tx_get)
1029 char_count = tx_get - tx_put - 1 + tx_bufsize;
1031 char_count = tx_get - tx_put - 1;
1036 tty = tty_port_tty_get(&info->port);
1040 if (info->x_char) { /* send special char */
1041 data = info->x_char;
1043 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1044 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1050 while (0 < (small_count = min_t(unsigned int,
1051 tx_bufsize - tx_put, min_t(unsigned int,
1052 (SERIAL_XMIT_SIZE - info->xmit_tail),
1053 min_t(unsigned int, info->xmit_cnt,
1056 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr + tx_put),
1057 &info->port.xmit_buf[info->xmit_tail],
1060 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1061 char_count -= small_count;
1062 info->icount.tx += small_count;
1063 info->xmit_cnt -= small_count;
1064 info->xmit_tail = (info->xmit_tail + small_count) &
1065 (SERIAL_XMIT_SIZE - 1);
1068 while (info->xmit_cnt && char_count) {
1069 data = info->port.xmit_buf[info->xmit_tail];
1071 info->xmit_tail = (info->xmit_tail + 1) &
1072 (SERIAL_XMIT_SIZE - 1);
1074 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1075 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1084 cy_writel(&buf_ctrl->tx_put, tx_put);
1087 static void cyz_handle_cmd(struct cyclades_card *cinfo)
1089 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1090 struct cyclades_port *info;
1091 __u32 channel, param, fw_ver;
1096 fw_ver = readl(&board_ctrl->fw_version);
1098 while (cyz_fetch_msg(cinfo, &channel, &cmd, ¶m) == 1) {
1101 info = &cinfo->ports[channel];
1105 tty_insert_flip_char(&info->port, 0, TTY_PARITY);
1110 tty_insert_flip_char(&info->port, 0, TTY_FRAME);
1115 tty_insert_flip_char(&info->port, 0, TTY_BREAK);
1122 if (info->port.flags & ASYNC_CHECK_CD) {
1123 u32 dcd = fw_ver > 241 ? param :
1124 readl(&info->u.cyz.ch_ctrl->rs_status);
1126 wake_up_interruptible(&info->port.open_wait);
1128 struct tty_struct *tty;
1129 tty = tty_port_tty_get(&info->port);
1151 complete(&info->shutdown_wait);
1154 #ifdef CONFIG_CYZ_INTR
1158 /* Reception Interrupt */
1159 #ifdef CY_DEBUG_INTERRUPTS
1160 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1161 "port %ld\n", info->card, channel);
1163 cyz_handle_rx(info);
1168 /* Transmission Interrupt */
1169 #ifdef CY_DEBUG_INTERRUPTS
1170 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1171 "port %ld\n", info->card, channel);
1173 cyz_handle_tx(info);
1175 #endif /* CONFIG_CYZ_INTR */
1177 /* should do something with this !!! */
1183 wake_up_interruptible(&info->port.delta_msr_wait);
1185 tty_schedule_flip(&info->port);
1189 #ifdef CONFIG_CYZ_INTR
1190 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1192 struct cyclades_card *cinfo = dev_id;
1194 if (unlikely(!cyz_is_loaded(cinfo))) {
1195 #ifdef CY_DEBUG_INTERRUPTS
1196 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1202 /* Handle the interrupts */
1203 cyz_handle_cmd(cinfo);
1206 } /* cyz_interrupt */
1208 static void cyz_rx_restart(unsigned long arg)
1210 struct cyclades_port *info = (struct cyclades_port *)arg;
1211 struct cyclades_card *card = info->card;
1213 __u32 channel = info->line - card->first_line;
1214 unsigned long flags;
1216 spin_lock_irqsave(&card->card_lock, flags);
1217 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1219 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1220 info->line, retval);
1222 spin_unlock_irqrestore(&card->card_lock, flags);
1225 #else /* CONFIG_CYZ_INTR */
1227 static void cyz_poll(unsigned long arg)
1229 struct cyclades_card *cinfo;
1230 struct cyclades_port *info;
1231 unsigned long expires = jiffies + HZ;
1232 unsigned int port, card;
1234 for (card = 0; card < NR_CARDS; card++) {
1235 cinfo = &cy_card[card];
1237 if (!cy_is_Z(cinfo))
1239 if (!cyz_is_loaded(cinfo))
1242 /* Skip first polling cycle to avoid racing conditions with the FW */
1243 if (!cinfo->intr_enabled) {
1244 cinfo->intr_enabled = 1;
1248 cyz_handle_cmd(cinfo);
1250 for (port = 0; port < cinfo->nports; port++) {
1251 info = &cinfo->ports[port];
1253 if (!info->throttle)
1254 cyz_handle_rx(info);
1255 cyz_handle_tx(info);
1257 /* poll every 'cyz_polling_cycle' period */
1258 expires = jiffies + cyz_polling_cycle;
1260 mod_timer(&cyz_timerlist, expires);
1263 #endif /* CONFIG_CYZ_INTR */
1265 /********** End of block of Cyclades-Z specific code *********/
1266 /***********************************************************/
1268 /* This is called whenever a port becomes active;
1269 interrupts are enabled and DTR & RTS are turned on.
1271 static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1273 struct cyclades_card *card;
1274 unsigned long flags;
1280 channel = info->line - card->first_line;
1282 page = get_zeroed_page(GFP_KERNEL);
1286 spin_lock_irqsave(&card->card_lock, flags);
1288 if (info->port.flags & ASYNC_INITIALIZED)
1292 set_bit(TTY_IO_ERROR, &tty->flags);
1296 if (info->port.xmit_buf)
1299 info->port.xmit_buf = (unsigned char *)page;
1301 spin_unlock_irqrestore(&card->card_lock, flags);
1303 cy_set_line_char(info, tty);
1305 if (!cy_is_Z(card)) {
1308 spin_lock_irqsave(&card->card_lock, flags);
1310 cyy_writeb(info, CyCAR, channel);
1312 cyy_writeb(info, CyRTPR,
1313 (info->default_timeout ? info->default_timeout : 0x02));
1314 /* 10ms rx timeout */
1316 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1318 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1320 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1322 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1324 if (!cyz_is_loaded(card))
1327 #ifdef CY_DEBUG_OPEN
1328 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1329 "base_addr %p\n", card, channel, card->base_addr);
1331 spin_lock_irqsave(&card->card_lock, flags);
1333 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1335 #ifdef CONFIG_CYZ_INTR
1336 cy_writel(&ch_ctrl->intr_enable,
1337 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1338 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1340 cy_writel(&ch_ctrl->intr_enable,
1341 C_IN_IOCTLW | C_IN_MDCD);
1342 #endif /* CONFIG_CYZ_INTR */
1344 #ifdef CONFIG_CYZ_INTR
1345 cy_writel(&ch_ctrl->intr_enable,
1346 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1347 C_IN_RXNNDT | C_IN_MDCD);
1349 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1350 #endif /* CONFIG_CYZ_INTR */
1353 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
1355 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
1356 "%x\n", info->line, retval);
1359 /* Flush RX buffers before raising DTR and RTS */
1360 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
1362 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
1363 "%x\n", info->line, retval);
1366 /* set timeout !!! */
1367 /* set RTS and DTR !!! */
1368 tty_port_raise_dtr_rts(&info->port);
1370 /* enable send, recv, modem !!! */
1373 info->port.flags |= ASYNC_INITIALIZED;
1375 clear_bit(TTY_IO_ERROR, &tty->flags);
1376 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1377 info->breakon = info->breakoff = 0;
1378 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1379 info->idle_stats.in_use =
1380 info->idle_stats.recv_idle =
1381 info->idle_stats.xmit_idle = jiffies;
1383 spin_unlock_irqrestore(&card->card_lock, flags);
1385 #ifdef CY_DEBUG_OPEN
1386 printk(KERN_DEBUG "cyc startup done\n");
1391 spin_unlock_irqrestore(&card->card_lock, flags);
1396 static void start_xmit(struct cyclades_port *info)
1398 struct cyclades_card *card = info->card;
1399 unsigned long flags;
1400 int channel = info->line - card->first_line;
1402 if (!cy_is_Z(card)) {
1403 spin_lock_irqsave(&card->card_lock, flags);
1404 cyy_writeb(info, CyCAR, channel & 0x03);
1405 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
1406 spin_unlock_irqrestore(&card->card_lock, flags);
1408 #ifdef CONFIG_CYZ_INTR
1411 spin_lock_irqsave(&card->card_lock, flags);
1412 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
1414 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
1415 "%x\n", info->line, retval);
1417 spin_unlock_irqrestore(&card->card_lock, flags);
1418 #else /* CONFIG_CYZ_INTR */
1419 /* Don't have to do anything at this time */
1420 #endif /* CONFIG_CYZ_INTR */
1425 * This routine shuts down a serial port; interrupts are disabled,
1426 * and DTR is dropped if the hangup on close termio flag is on.
1428 static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
1430 struct cyclades_card *card;
1431 unsigned long flags;
1433 if (!(info->port.flags & ASYNC_INITIALIZED))
1437 if (!cy_is_Z(card)) {
1438 spin_lock_irqsave(&card->card_lock, flags);
1440 /* Clear delta_msr_wait queue to avoid mem leaks. */
1441 wake_up_interruptible(&info->port.delta_msr_wait);
1443 if (info->port.xmit_buf) {
1444 unsigned char *temp;
1445 temp = info->port.xmit_buf;
1446 info->port.xmit_buf = NULL;
1447 free_page((unsigned long)temp);
1449 if (tty->termios.c_cflag & HUPCL)
1450 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
1452 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
1453 /* it may be appropriate to clear _XMIT at
1454 some later date (after testing)!!! */
1456 set_bit(TTY_IO_ERROR, &tty->flags);
1457 info->port.flags &= ~ASYNC_INITIALIZED;
1458 spin_unlock_irqrestore(&card->card_lock, flags);
1460 #ifdef CY_DEBUG_OPEN
1461 int channel = info->line - card->first_line;
1462 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
1463 "base_addr %p\n", card, channel, card->base_addr);
1466 if (!cyz_is_loaded(card))
1469 spin_lock_irqsave(&card->card_lock, flags);
1471 if (info->port.xmit_buf) {
1472 unsigned char *temp;
1473 temp = info->port.xmit_buf;
1474 info->port.xmit_buf = NULL;
1475 free_page((unsigned long)temp);
1478 if (tty->termios.c_cflag & HUPCL)
1479 tty_port_lower_dtr_rts(&info->port);
1481 set_bit(TTY_IO_ERROR, &tty->flags);
1482 info->port.flags &= ~ASYNC_INITIALIZED;
1484 spin_unlock_irqrestore(&card->card_lock, flags);
1487 #ifdef CY_DEBUG_OPEN
1488 printk(KERN_DEBUG "cyc shutdown done\n");
1493 * ------------------------------------------------------------
1494 * cy_open() and friends
1495 * ------------------------------------------------------------
1499 * This routine is called whenever a serial port is opened. It
1500 * performs the serial-specific initialization for the tty structure.
1502 static int cy_open(struct tty_struct *tty, struct file *filp)
1504 struct cyclades_port *info;
1505 unsigned int i, line = tty->index;
1508 for (i = 0; i < NR_CARDS; i++)
1509 if (line < cy_card[i].first_line + cy_card[i].nports &&
1510 line >= cy_card[i].first_line)
1514 info = &cy_card[i].ports[line - cy_card[i].first_line];
1518 /* If the card's firmware hasn't been loaded,
1519 treat it as absent from the system. This
1520 will make the user pay attention.
1522 if (cy_is_Z(info->card)) {
1523 struct cyclades_card *cinfo = info->card;
1524 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
1526 if (!cyz_is_loaded(cinfo)) {
1527 if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
1528 readl(&firm_id->signature) ==
1530 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
1531 "need an external power supply for "
1532 "this number of ports.\nFirmware "
1535 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
1540 #ifdef CONFIG_CYZ_INTR
1542 /* In case this Z board is operating in interrupt mode, its
1543 interrupts should be enabled as soon as the first open
1544 happens to one of its ports. */
1545 if (!cinfo->intr_enabled) {
1548 /* Enable interrupts on the PLX chip */
1549 intr = readw(&cinfo->ctl_addr.p9060->
1550 intr_ctrl_stat) | 0x0900;
1551 cy_writew(&cinfo->ctl_addr.p9060->
1552 intr_ctrl_stat, intr);
1553 /* Enable interrupts on the FW */
1554 retval = cyz_issue_cmd(cinfo, 0,
1557 printk(KERN_ERR "cyc:IRQ enable retval "
1558 "was %x\n", retval);
1560 cinfo->intr_enabled = 1;
1563 #endif /* CONFIG_CYZ_INTR */
1564 /* Make sure this Z port really exists in hardware */
1565 if (info->line > (cinfo->first_line + cinfo->nports - 1))
1568 #ifdef CY_DEBUG_OTHER
1569 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
1571 tty->driver_data = info;
1572 if (serial_paranoia_check(info, tty->name, "cy_open"))
1575 #ifdef CY_DEBUG_OPEN
1576 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
1580 #ifdef CY_DEBUG_COUNT
1581 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
1582 current->pid, info->port.count);
1586 * If the port is the middle of closing, bail out now
1588 if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
1589 wait_event_interruptible_tty(tty, info->port.close_wait,
1590 !(info->port.flags & ASYNC_CLOSING));
1591 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1595 * Start up serial port
1597 retval = cy_startup(info, tty);
1601 retval = tty_port_block_til_ready(&info->port, tty, filp);
1603 #ifdef CY_DEBUG_OPEN
1604 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
1605 "with %d\n", retval);
1611 tty_port_tty_set(&info->port, tty);
1613 #ifdef CY_DEBUG_OPEN
1614 printk(KERN_DEBUG "cyc:cy_open done\n");
1620 * cy_wait_until_sent() --- wait until the transmitter is empty
1622 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1624 struct cyclades_card *card;
1625 struct cyclades_port *info = tty->driver_data;
1626 unsigned long orig_jiffies;
1629 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
1632 if (info->xmit_fifo_size == 0)
1633 return; /* Just in case.... */
1635 orig_jiffies = jiffies;
1637 * Set the check interval to be 1/5 of the estimated time to
1638 * send a single character, and make it at least 1. The check
1639 * interval should also be less than the timeout.
1641 * Note: we have to use pretty tight timings here to satisfy
1644 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
1645 char_time = char_time / 5;
1651 char_time = min(char_time, timeout);
1653 * If the transmitter hasn't cleared in twice the approximate
1654 * amount of time to send the entire FIFO, it probably won't
1655 * ever clear. This assumes the UART isn't doing flow
1656 * control, which is currently the case. Hence, if it ever
1657 * takes longer than info->timeout, this is probably due to a
1658 * UART bug of some kind. So, we clamp the timeout parameter at
1661 if (!timeout || timeout > 2 * info->timeout)
1662 timeout = 2 * info->timeout;
1665 if (!cy_is_Z(card)) {
1666 while (cyy_readb(info, CySRER) & CyTxRdy) {
1667 if (msleep_interruptible(jiffies_to_msecs(char_time)))
1669 if (timeout && time_after(jiffies, orig_jiffies +
1674 /* Run one more char cycle */
1675 msleep_interruptible(jiffies_to_msecs(char_time * 5));
1678 static void cy_flush_buffer(struct tty_struct *tty)
1680 struct cyclades_port *info = tty->driver_data;
1681 struct cyclades_card *card;
1682 int channel, retval;
1683 unsigned long flags;
1686 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
1689 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1693 channel = info->line - card->first_line;
1695 spin_lock_irqsave(&card->card_lock, flags);
1696 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1697 spin_unlock_irqrestore(&card->card_lock, flags);
1699 if (cy_is_Z(card)) { /* If it is a Z card, flush the on-board
1701 spin_lock_irqsave(&card->card_lock, flags);
1702 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
1704 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
1705 "was %x\n", info->line, retval);
1707 spin_unlock_irqrestore(&card->card_lock, flags);
1710 } /* cy_flush_buffer */
1713 static void cy_do_close(struct tty_port *port)
1715 struct cyclades_port *info = container_of(port, struct cyclades_port,
1717 struct cyclades_card *card;
1718 unsigned long flags;
1722 channel = info->line - card->first_line;
1723 spin_lock_irqsave(&card->card_lock, flags);
1725 if (!cy_is_Z(card)) {
1726 /* Stop accepting input */
1727 cyy_writeb(info, CyCAR, channel & 0x03);
1728 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
1729 if (info->port.flags & ASYNC_INITIALIZED) {
1730 /* Waiting for on-board buffers to be empty before
1732 spin_unlock_irqrestore(&card->card_lock, flags);
1733 cy_wait_until_sent(port->tty, info->timeout);
1734 spin_lock_irqsave(&card->card_lock, flags);
1738 /* Waiting for on-board buffers to be empty before closing
1740 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1743 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
1744 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
1746 printk(KERN_DEBUG "cyc:cy_close retval on "
1747 "ttyC%d was %x\n", info->line, retval);
1749 spin_unlock_irqrestore(&card->card_lock, flags);
1750 wait_for_completion_interruptible(&info->shutdown_wait);
1751 spin_lock_irqsave(&card->card_lock, flags);
1755 spin_unlock_irqrestore(&card->card_lock, flags);
1756 cy_shutdown(info, port->tty);
1760 * This routine is called when a particular tty device is closed.
1762 static void cy_close(struct tty_struct *tty, struct file *filp)
1764 struct cyclades_port *info = tty->driver_data;
1765 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1767 tty_port_close(&info->port, tty, filp);
1770 /* This routine gets called when tty_write has put something into
1771 * the write_queue. The characters may come from user space or
1774 * This routine will return the number of characters actually
1775 * accepted for writing.
1777 * If the port is not already transmitting stuff, start it off by
1778 * enabling interrupts. The interrupt service routine will then
1779 * ensure that the characters are sent.
1780 * If the port is already active, there is no need to kick it.
1783 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1785 struct cyclades_port *info = tty->driver_data;
1786 unsigned long flags;
1790 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
1793 if (serial_paranoia_check(info, tty->name, "cy_write"))
1796 if (!info->port.xmit_buf)
1799 spin_lock_irqsave(&info->card->card_lock, flags);
1801 c = min(count, (int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1));
1802 c = min(c, (int)(SERIAL_XMIT_SIZE - info->xmit_head));
1807 memcpy(info->port.xmit_buf + info->xmit_head, buf, c);
1808 info->xmit_head = (info->xmit_head + c) &
1809 (SERIAL_XMIT_SIZE - 1);
1810 info->xmit_cnt += c;
1815 spin_unlock_irqrestore(&info->card->card_lock, flags);
1817 info->idle_stats.xmit_bytes += ret;
1818 info->idle_stats.xmit_idle = jiffies;
1820 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped)
1827 * This routine is called by the kernel to write a single
1828 * character to the tty device. If the kernel uses this routine,
1829 * it must call the flush_chars() routine (if defined) when it is
1830 * done stuffing characters into the driver. If there is no room
1831 * in the queue, the character is ignored.
1833 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1835 struct cyclades_port *info = tty->driver_data;
1836 unsigned long flags;
1839 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
1842 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1845 if (!info->port.xmit_buf)
1848 spin_lock_irqsave(&info->card->card_lock, flags);
1849 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
1850 spin_unlock_irqrestore(&info->card->card_lock, flags);
1854 info->port.xmit_buf[info->xmit_head++] = ch;
1855 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
1857 info->idle_stats.xmit_bytes++;
1858 info->idle_stats.xmit_idle = jiffies;
1859 spin_unlock_irqrestore(&info->card->card_lock, flags);
1864 * This routine is called by the kernel after it has written a
1865 * series of characters to the tty device using put_char().
1867 static void cy_flush_chars(struct tty_struct *tty)
1869 struct cyclades_port *info = tty->driver_data;
1872 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
1875 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1878 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1879 !info->port.xmit_buf)
1883 } /* cy_flush_chars */
1886 * This routine returns the numbers of characters the tty driver
1887 * will accept for queuing to be written. This number is subject
1888 * to change as output buffers get emptied, or if the output flow
1889 * control is activated.
1891 static int cy_write_room(struct tty_struct *tty)
1893 struct cyclades_port *info = tty->driver_data;
1897 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
1900 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1902 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
1906 } /* cy_write_room */
1908 static int cy_chars_in_buffer(struct tty_struct *tty)
1910 struct cyclades_port *info = tty->driver_data;
1912 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1915 #ifdef Z_EXT_CHARS_IN_BUFFER
1916 if (!cy_is_Z(info->card)) {
1917 #endif /* Z_EXT_CHARS_IN_BUFFER */
1919 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1920 info->line, info->xmit_cnt);
1922 return info->xmit_cnt;
1923 #ifdef Z_EXT_CHARS_IN_BUFFER
1925 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1927 __u32 tx_put, tx_get, tx_bufsize;
1929 tx_get = readl(&buf_ctrl->tx_get);
1930 tx_put = readl(&buf_ctrl->tx_put);
1931 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1932 if (tx_put >= tx_get)
1933 char_count = tx_put - tx_get;
1935 char_count = tx_put - tx_get + tx_bufsize;
1937 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
1938 info->line, info->xmit_cnt + char_count);
1940 return info->xmit_cnt + char_count;
1942 #endif /* Z_EXT_CHARS_IN_BUFFER */
1943 } /* cy_chars_in_buffer */
1946 * ------------------------------------------------------------
1947 * cy_ioctl() and friends
1948 * ------------------------------------------------------------
1951 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1953 int co, co_val, bpr;
1954 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
1958 info->tbpr = info->tco = info->rbpr = info->rco = 0;
1962 /* determine which prescaler to use */
1963 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
1964 if (cy_clock / co_val / baud > 63)
1968 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
1972 info->tbpr = info->rbpr = bpr;
1973 info->tco = info->rco = co;
1977 * This routine finds or computes the various line characteristics.
1978 * It used to be called config_setup
1980 static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
1982 struct cyclades_card *card;
1983 unsigned long flags;
1985 unsigned cflag, iflag;
1986 int baud, baud_rate = 0;
1989 if (info->line == -1)
1992 cflag = tty->termios.c_cflag;
1993 iflag = tty->termios.c_iflag;
1996 * Set up the tty->alt_speed kludge
1998 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1999 tty->alt_speed = 57600;
2000 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2001 tty->alt_speed = 115200;
2002 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2003 tty->alt_speed = 230400;
2004 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2005 tty->alt_speed = 460800;
2008 channel = info->line - card->first_line;
2010 if (!cy_is_Z(card)) {
2014 baud = tty_get_baud_rate(tty);
2015 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2017 if (info->custom_divisor)
2018 baud_rate = info->baud / info->custom_divisor;
2020 baud_rate = info->baud;
2021 } else if (baud > CD1400_MAX_SPEED) {
2022 baud = CD1400_MAX_SPEED;
2024 /* find the baud index */
2025 for (i = 0; i < 20; i++) {
2026 if (baud == baud_table[i])
2030 i = 19; /* CD1400_MAX_SPEED */
2032 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2034 cyy_baud_calc(info, baud_rate);
2036 if (info->chip_rev >= CD1400_REV_J) {
2037 /* It is a CD1400 rev. J or later */
2038 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
2039 info->tco = baud_co_60[i]; /* Tx CO */
2040 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
2041 info->rco = baud_co_60[i]; /* Rx CO */
2043 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
2044 info->tco = baud_co_25[i]; /* Tx CO */
2045 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
2046 info->rco = baud_co_25[i]; /* Rx CO */
2049 if (baud_table[i] == 134) {
2050 /* get it right for 134.5 baud */
2051 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2053 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2055 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2057 } else if (baud_table[i]) {
2058 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2060 /* this needs to be propagated into the card info */
2064 /* By tradition (is it a standard?) a baud rate of zero
2065 implies the line should be/has been closed. A bit
2066 later in this routine such a test is performed. */
2068 /* byte size and parity */
2071 /* receive threshold */
2072 info->cor3 = (info->default_threshold ?
2073 info->default_threshold : baud_cor3[i]);
2075 switch (cflag & CSIZE) {
2077 info->cor1 = Cy_5_BITS;
2080 info->cor1 = Cy_6_BITS;
2083 info->cor1 = Cy_7_BITS;
2086 info->cor1 = Cy_8_BITS;
2090 info->cor1 |= Cy_2_STOP;
2092 if (cflag & PARENB) {
2094 info->cor1 |= CyPARITY_O;
2096 info->cor1 |= CyPARITY_E;
2098 info->cor1 |= CyPARITY_NONE;
2100 /* CTS flow control flag */
2101 if (cflag & CRTSCTS) {
2102 info->port.flags |= ASYNC_CTS_FLOW;
2103 info->cor2 |= CyCtsAE;
2105 info->port.flags &= ~ASYNC_CTS_FLOW;
2106 info->cor2 &= ~CyCtsAE;
2109 info->port.flags &= ~ASYNC_CHECK_CD;
2111 info->port.flags |= ASYNC_CHECK_CD;
2113 /***********************************************
2114 The hardware option, CyRtsAO, presents RTS when
2115 the chip has characters to send. Since most modems
2116 use RTS as reverse (inbound) flow control, this
2117 option is not used. If inbound flow control is
2118 necessary, DTR can be programmed to provide the
2119 appropriate signals for use with a non-standard
2120 cable. Contact Marcio Saito for details.
2121 ***********************************************/
2125 spin_lock_irqsave(&card->card_lock, flags);
2126 cyy_writeb(info, CyCAR, channel);
2128 /* tx and rx baud rate */
2130 cyy_writeb(info, CyTCOR, info->tco);
2131 cyy_writeb(info, CyTBPR, info->tbpr);
2132 cyy_writeb(info, CyRCOR, info->rco);
2133 cyy_writeb(info, CyRBPR, info->rbpr);
2135 /* set line characteristics according configuration */
2137 cyy_writeb(info, CySCHR1, START_CHAR(tty));
2138 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
2139 cyy_writeb(info, CyCOR1, info->cor1);
2140 cyy_writeb(info, CyCOR2, info->cor2);
2141 cyy_writeb(info, CyCOR3, info->cor3);
2142 cyy_writeb(info, CyCOR4, info->cor4);
2143 cyy_writeb(info, CyCOR5, info->cor5);
2145 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
2148 /* !!! Is this needed? */
2149 cyy_writeb(info, CyCAR, channel);
2150 cyy_writeb(info, CyRTPR,
2151 (info->default_timeout ? info->default_timeout : 0x02));
2152 /* 10ms rx timeout */
2156 cflags |= CyDSR | CyRI | CyDCD;
2157 /* without modem intr */
2158 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
2159 /* act on 1->0 modem transitions */
2160 if ((cflag & CRTSCTS) && info->rflow)
2161 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
2163 cyy_writeb(info, CyMCOR1, cflags);
2164 /* act on 0->1 modem transitions */
2165 cyy_writeb(info, CyMCOR2, cflags);
2167 if (i == 0) /* baud rate is zero, turn off line */
2168 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
2170 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
2172 clear_bit(TTY_IO_ERROR, &tty->flags);
2173 spin_unlock_irqrestore(&card->card_lock, flags);
2176 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2180 if (!cyz_is_loaded(card))
2184 baud = tty_get_baud_rate(tty);
2185 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2187 if (info->custom_divisor)
2188 baud_rate = info->baud / info->custom_divisor;
2190 baud_rate = info->baud;
2191 } else if (baud > CYZ_MAX_SPEED) {
2192 baud = CYZ_MAX_SPEED;
2194 cy_writel(&ch_ctrl->comm_baud, baud);
2197 /* get it right for 134.5 baud */
2198 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
2200 } else if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
2202 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2205 info->timeout = (info->xmit_fifo_size * HZ * 15 /
2207 /* this needs to be propagated into the card info */
2212 /* byte size and parity */
2213 switch (cflag & CSIZE) {
2215 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
2218 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
2221 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
2224 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
2227 if (cflag & CSTOPB) {
2228 cy_writel(&ch_ctrl->comm_data_l,
2229 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
2231 cy_writel(&ch_ctrl->comm_data_l,
2232 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
2234 if (cflag & PARENB) {
2236 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
2238 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
2240 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
2242 /* CTS flow control flag */
2243 if (cflag & CRTSCTS) {
2244 cy_writel(&ch_ctrl->hw_flow,
2245 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
2247 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
2248 ~(C_RS_CTS | C_RS_RTS));
2250 /* As the HW flow control is done in firmware, the driver
2251 doesn't need to care about it */
2252 info->port.flags &= ~ASYNC_CTS_FLOW;
2254 /* XON/XOFF/XANY flow control flags */
2257 sw_flow |= C_FL_OXX;
2259 sw_flow |= C_FL_OIXANY;
2261 cy_writel(&ch_ctrl->sw_flow, sw_flow);
2263 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2265 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
2266 "was %x\n", info->line, retval);
2269 /* CD sensitivity */
2271 info->port.flags &= ~ASYNC_CHECK_CD;
2273 info->port.flags |= ASYNC_CHECK_CD;
2275 if (baud == 0) { /* baud rate is zero, turn off line */
2276 cy_writel(&ch_ctrl->rs_control,
2277 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
2279 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
2282 cy_writel(&ch_ctrl->rs_control,
2283 readl(&ch_ctrl->rs_control) | C_RS_DTR);
2285 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
2289 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2291 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
2292 "was %x\n", info->line, retval);
2295 clear_bit(TTY_IO_ERROR, &tty->flags);
2297 } /* set_line_char */
2299 static int cy_get_serial_info(struct cyclades_port *info,
2300 struct serial_struct __user *retinfo)
2302 struct cyclades_card *cinfo = info->card;
2303 struct serial_struct tmp = {
2306 .port = (info->card - cy_card) * 0x100 + info->line -
2309 .flags = info->port.flags,
2310 .close_delay = info->port.close_delay,
2311 .closing_wait = info->port.closing_wait,
2312 .baud_base = info->baud,
2313 .custom_divisor = info->custom_divisor,
2316 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
2320 cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
2321 struct serial_struct __user *new_info)
2323 struct serial_struct new_serial;
2326 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
2329 mutex_lock(&info->port.mutex);
2330 if (!capable(CAP_SYS_ADMIN)) {
2331 if (new_serial.close_delay != info->port.close_delay ||
2332 new_serial.baud_base != info->baud ||
2333 (new_serial.flags & ASYNC_FLAGS &
2335 (info->port.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
2337 mutex_unlock(&info->port.mutex);
2340 info->port.flags = (info->port.flags & ~ASYNC_USR_MASK) |
2341 (new_serial.flags & ASYNC_USR_MASK);
2342 info->baud = new_serial.baud_base;
2343 info->custom_divisor = new_serial.custom_divisor;
2344 goto check_and_exit;
2348 * OK, past this point, all the error checking has been done.
2349 * At this point, we start making changes.....
2352 info->baud = new_serial.baud_base;
2353 info->custom_divisor = new_serial.custom_divisor;
2354 info->port.flags = (info->port.flags & ~ASYNC_FLAGS) |
2355 (new_serial.flags & ASYNC_FLAGS);
2356 info->port.close_delay = new_serial.close_delay * HZ / 100;
2357 info->port.closing_wait = new_serial.closing_wait * HZ / 100;
2360 if (info->port.flags & ASYNC_INITIALIZED) {
2361 cy_set_line_char(info, tty);
2364 ret = cy_startup(info, tty);
2366 mutex_unlock(&info->port.mutex);
2368 } /* set_serial_info */
2371 * get_lsr_info - get line status register info
2373 * Purpose: Let user call ioctl() to get info when the UART physically
2374 * is emptied. On bus types like RS485, the transmitter must
2375 * release the bus after transmitting. This must be done when
2376 * the transmit shift register is empty, not be done when the
2377 * transmit holding register is empty. This functionality
2378 * allows an RS485 driver to be written in user space.
2380 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
2382 struct cyclades_card *card = info->card;
2383 unsigned int result;
2384 unsigned long flags;
2387 if (!cy_is_Z(card)) {
2388 spin_lock_irqsave(&card->card_lock, flags);
2389 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
2390 spin_unlock_irqrestore(&card->card_lock, flags);
2391 result = (status ? 0 : TIOCSER_TEMT);
2393 /* Not supported yet */
2396 return put_user(result, value);
2399 static int cy_tiocmget(struct tty_struct *tty)
2401 struct cyclades_port *info = tty->driver_data;
2402 struct cyclades_card *card;
2405 if (serial_paranoia_check(info, tty->name, __func__))
2410 if (!cy_is_Z(card)) {
2411 unsigned long flags;
2412 int channel = info->line - card->first_line;
2415 spin_lock_irqsave(&card->card_lock, flags);
2416 cyy_writeb(info, CyCAR, channel & 0x03);
2417 status = cyy_readb(info, CyMSVR1);
2418 status |= cyy_readb(info, CyMSVR2);
2419 spin_unlock_irqrestore(&card->card_lock, flags);
2421 if (info->rtsdtr_inv) {
2422 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
2423 ((status & CyDTR) ? TIOCM_RTS : 0);
2425 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
2426 ((status & CyDTR) ? TIOCM_DTR : 0);
2428 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
2429 ((status & CyRI) ? TIOCM_RNG : 0) |
2430 ((status & CyDSR) ? TIOCM_DSR : 0) |
2431 ((status & CyCTS) ? TIOCM_CTS : 0);
2435 if (!cyz_is_loaded(card)) {
2440 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2441 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2442 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2443 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2444 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2445 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2446 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
2453 cy_tiocmset(struct tty_struct *tty,
2454 unsigned int set, unsigned int clear)
2456 struct cyclades_port *info = tty->driver_data;
2457 struct cyclades_card *card;
2458 unsigned long flags;
2460 if (serial_paranoia_check(info, tty->name, __func__))
2464 if (!cy_is_Z(card)) {
2465 spin_lock_irqsave(&card->card_lock, flags);
2466 cyy_change_rts_dtr(info, set, clear);
2467 spin_unlock_irqrestore(&card->card_lock, flags);
2469 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2470 int retval, channel = info->line - card->first_line;
2473 if (!cyz_is_loaded(card))
2476 spin_lock_irqsave(&card->card_lock, flags);
2477 rs = readl(&ch_ctrl->rs_control);
2478 if (set & TIOCM_RTS)
2480 if (clear & TIOCM_RTS)
2482 if (set & TIOCM_DTR) {
2485 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
2488 if (clear & TIOCM_DTR) {
2491 printk(KERN_DEBUG "cyc:set_modem_info clearing "
2495 cy_writel(&ch_ctrl->rs_control, rs);
2496 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2497 spin_unlock_irqrestore(&card->card_lock, flags);
2499 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
2500 "was %x\n", info->line, retval);
2507 * cy_break() --- routine which turns the break handling on or off
2509 static int cy_break(struct tty_struct *tty, int break_state)
2511 struct cyclades_port *info = tty->driver_data;
2512 struct cyclades_card *card;
2513 unsigned long flags;
2516 if (serial_paranoia_check(info, tty->name, "cy_break"))
2521 spin_lock_irqsave(&card->card_lock, flags);
2522 if (!cy_is_Z(card)) {
2523 /* Let the transmit ISR take care of this (since it
2524 requires stuffing characters into the output stream).
2526 if (break_state == -1) {
2527 if (!info->breakon) {
2529 if (!info->xmit_cnt) {
2530 spin_unlock_irqrestore(&card->card_lock, flags);
2532 spin_lock_irqsave(&card->card_lock, flags);
2536 if (!info->breakoff) {
2538 if (!info->xmit_cnt) {
2539 spin_unlock_irqrestore(&card->card_lock, flags);
2541 spin_lock_irqsave(&card->card_lock, flags);
2546 if (break_state == -1) {
2547 retval = cyz_issue_cmd(card,
2548 info->line - card->first_line,
2549 C_CM_SET_BREAK, 0L);
2551 printk(KERN_ERR "cyc:cy_break (set) retval on "
2552 "ttyC%d was %x\n", info->line, retval);
2555 retval = cyz_issue_cmd(card,
2556 info->line - card->first_line,
2557 C_CM_CLR_BREAK, 0L);
2559 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
2560 "on ttyC%d was %x\n", info->line,
2565 spin_unlock_irqrestore(&card->card_lock, flags);
2569 static int set_threshold(struct cyclades_port *info, unsigned long value)
2571 struct cyclades_card *card = info->card;
2572 unsigned long flags;
2574 if (!cy_is_Z(card)) {
2575 info->cor3 &= ~CyREC_FIFO;
2576 info->cor3 |= value & CyREC_FIFO;
2578 spin_lock_irqsave(&card->card_lock, flags);
2579 cyy_writeb(info, CyCOR3, info->cor3);
2580 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
2581 spin_unlock_irqrestore(&card->card_lock, flags);
2584 } /* set_threshold */
2586 static int get_threshold(struct cyclades_port *info,
2587 unsigned long __user *value)
2589 struct cyclades_card *card = info->card;
2591 if (!cy_is_Z(card)) {
2592 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
2593 return put_user(tmp, value);
2596 } /* get_threshold */
2598 static int set_timeout(struct cyclades_port *info, unsigned long value)
2600 struct cyclades_card *card = info->card;
2601 unsigned long flags;
2603 if (!cy_is_Z(card)) {
2604 spin_lock_irqsave(&card->card_lock, flags);
2605 cyy_writeb(info, CyRTPR, value & 0xff);
2606 spin_unlock_irqrestore(&card->card_lock, flags);
2611 static int get_timeout(struct cyclades_port *info,
2612 unsigned long __user *value)
2614 struct cyclades_card *card = info->card;
2616 if (!cy_is_Z(card)) {
2617 u8 tmp = cyy_readb(info, CyRTPR);
2618 return put_user(tmp, value);
2623 static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2624 struct cyclades_icount *cprev)
2626 struct cyclades_icount cnow;
2627 unsigned long flags;
2630 spin_lock_irqsave(&info->card->card_lock, flags);
2631 cnow = info->icount; /* atomic copy */
2632 spin_unlock_irqrestore(&info->card->card_lock, flags);
2634 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2635 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2636 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2637 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2645 * This routine allows the tty driver to implement device-
2646 * specific ioctl's. If the ioctl number passed in cmd is
2647 * not recognized by the driver, it should return ENOIOCTLCMD.
2650 cy_ioctl(struct tty_struct *tty,
2651 unsigned int cmd, unsigned long arg)
2653 struct cyclades_port *info = tty->driver_data;
2654 struct cyclades_icount cnow; /* kernel counter temps */
2656 unsigned long flags;
2657 void __user *argp = (void __user *)arg;
2659 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
2662 #ifdef CY_DEBUG_OTHER
2663 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2664 info->line, cmd, arg);
2669 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2673 memset(&info->mon, 0, sizeof(info->mon));
2676 ret_val = get_threshold(info, argp);
2679 ret_val = set_threshold(info, arg);
2681 case CYGETDEFTHRESH:
2682 ret_val = put_user(info->default_threshold,
2683 (unsigned long __user *)argp);
2685 case CYSETDEFTHRESH:
2686 info->default_threshold = arg & 0x0f;
2689 ret_val = get_timeout(info, argp);
2692 ret_val = set_timeout(info, arg);
2694 case CYGETDEFTIMEOUT:
2695 ret_val = put_user(info->default_timeout,
2696 (unsigned long __user *)argp);
2698 case CYSETDEFTIMEOUT:
2699 info->default_timeout = arg & 0xff;
2702 info->rflow = (int)arg;
2705 ret_val = info->rflow;
2707 case CYSETRTSDTR_INV:
2708 info->rtsdtr_inv = (int)arg;
2710 case CYGETRTSDTR_INV:
2711 ret_val = info->rtsdtr_inv;
2713 case CYGETCD1400VER:
2714 ret_val = info->chip_rev;
2716 #ifndef CONFIG_CYZ_INTR
2717 case CYZSETPOLLCYCLE:
2718 cyz_polling_cycle = (arg * HZ) / 1000;
2720 case CYZGETPOLLCYCLE:
2721 ret_val = (cyz_polling_cycle * 1000) / HZ;
2723 #endif /* CONFIG_CYZ_INTR */
2725 info->port.closing_wait = (unsigned short)arg * HZ / 100;
2728 ret_val = info->port.closing_wait / (HZ / 100);
2731 ret_val = cy_get_serial_info(info, argp);
2734 ret_val = cy_set_serial_info(info, tty, argp);
2736 case TIOCSERGETLSR: /* Get line status register */
2737 ret_val = get_lsr_info(info, argp);
2740 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2741 * - mask passed in arg for lines of interest
2742 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2743 * Caller should use TIOCGICOUNT to see which one it was
2746 spin_lock_irqsave(&info->card->card_lock, flags);
2747 /* note the counters on entry */
2748 cnow = info->icount;
2749 spin_unlock_irqrestore(&info->card->card_lock, flags);
2750 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
2751 cy_cflags_changed(info, arg, &cnow));
2755 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2756 * Return: write counters to the user passed counter struct
2757 * NB: both 1->0 and 0->1 transitions are counted except for
2758 * RI where only 0->1 is counted.
2761 ret_val = -ENOIOCTLCMD;
2764 #ifdef CY_DEBUG_OTHER
2765 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
2770 static int cy_get_icount(struct tty_struct *tty,
2771 struct serial_icounter_struct *sic)
2773 struct cyclades_port *info = tty->driver_data;
2774 struct cyclades_icount cnow; /* Used to snapshot */
2775 unsigned long flags;
2777 spin_lock_irqsave(&info->card->card_lock, flags);
2778 cnow = info->icount;
2779 spin_unlock_irqrestore(&info->card->card_lock, flags);
2781 sic->cts = cnow.cts;
2782 sic->dsr = cnow.dsr;
2783 sic->rng = cnow.rng;
2784 sic->dcd = cnow.dcd;
2787 sic->frame = cnow.frame;
2788 sic->overrun = cnow.overrun;
2789 sic->parity = cnow.parity;
2790 sic->brk = cnow.brk;
2791 sic->buf_overrun = cnow.buf_overrun;
2796 * This routine allows the tty driver to be notified when
2797 * device's termios settings have changed. Note that a
2798 * well-designed tty driver should be prepared to accept the case
2799 * where old == NULL, and try to do something rational.
2801 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
2803 struct cyclades_port *info = tty->driver_data;
2805 #ifdef CY_DEBUG_OTHER
2806 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
2809 cy_set_line_char(info, tty);
2811 if ((old_termios->c_cflag & CRTSCTS) &&
2812 !(tty->termios.c_cflag & CRTSCTS)) {
2813 tty->hw_stopped = 0;
2818 * No need to wake up processes in open wait, since they
2819 * sample the CLOCAL flag once, and don't recheck it.
2820 * XXX It's not clear whether the current behavior is correct
2821 * or not. Hence, this may change.....
2823 if (!(old_termios->c_cflag & CLOCAL) &&
2824 (tty->termios.c_cflag & CLOCAL))
2825 wake_up_interruptible(&info->port.open_wait);
2827 } /* cy_set_termios */
2829 /* This function is used to send a high-priority XON/XOFF character to
2832 static void cy_send_xchar(struct tty_struct *tty, char ch)
2834 struct cyclades_port *info = tty->driver_data;
2835 struct cyclades_card *card;
2838 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
2847 channel = info->line - card->first_line;
2849 if (cy_is_Z(card)) {
2850 if (ch == STOP_CHAR(tty))
2851 cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
2852 else if (ch == START_CHAR(tty))
2853 cyz_issue_cmd(card, channel, C_CM_SENDXON, 0L);
2857 /* This routine is called by the upper-layer tty layer to signal
2858 that incoming characters should be throttled because the input
2859 buffers are close to full.
2861 static void cy_throttle(struct tty_struct *tty)
2863 struct cyclades_port *info = tty->driver_data;
2864 struct cyclades_card *card;
2865 unsigned long flags;
2867 #ifdef CY_DEBUG_THROTTLE
2870 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
2871 tty->ldisc.chars_in_buffer(tty), info->line);
2874 if (serial_paranoia_check(info, tty->name, "cy_throttle"))
2881 cy_send_xchar(tty, STOP_CHAR(tty));
2886 if (tty->termios.c_cflag & CRTSCTS) {
2887 if (!cy_is_Z(card)) {
2888 spin_lock_irqsave(&card->card_lock, flags);
2889 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
2890 spin_unlock_irqrestore(&card->card_lock, flags);
2898 * This routine notifies the tty driver that it should signal
2899 * that characters can now be sent to the tty without fear of
2900 * overrunning the input buffers of the line disciplines.
2902 static void cy_unthrottle(struct tty_struct *tty)
2904 struct cyclades_port *info = tty->driver_data;
2905 struct cyclades_card *card;
2906 unsigned long flags;
2908 #ifdef CY_DEBUG_THROTTLE
2911 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
2912 tty_name(tty, buf), tty_chars_in_buffer(tty), info->line);
2915 if (serial_paranoia_check(info, tty->name, "cy_unthrottle"))
2922 cy_send_xchar(tty, START_CHAR(tty));
2925 if (tty->termios.c_cflag & CRTSCTS) {
2927 if (!cy_is_Z(card)) {
2928 spin_lock_irqsave(&card->card_lock, flags);
2929 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
2930 spin_unlock_irqrestore(&card->card_lock, flags);
2935 } /* cy_unthrottle */
2937 /* cy_start and cy_stop provide software output flow control as a
2938 function of XON/XOFF, software CTS, and other such stuff.
2940 static void cy_stop(struct tty_struct *tty)
2942 struct cyclades_card *cinfo;
2943 struct cyclades_port *info = tty->driver_data;
2945 unsigned long flags;
2947 #ifdef CY_DEBUG_OTHER
2948 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
2951 if (serial_paranoia_check(info, tty->name, "cy_stop"))
2955 channel = info->line - cinfo->first_line;
2956 if (!cy_is_Z(cinfo)) {
2957 spin_lock_irqsave(&cinfo->card_lock, flags);
2958 cyy_writeb(info, CyCAR, channel & 0x03);
2959 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
2960 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2964 static void cy_start(struct tty_struct *tty)
2966 struct cyclades_card *cinfo;
2967 struct cyclades_port *info = tty->driver_data;
2969 unsigned long flags;
2971 #ifdef CY_DEBUG_OTHER
2972 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
2975 if (serial_paranoia_check(info, tty->name, "cy_start"))
2979 channel = info->line - cinfo->first_line;
2980 if (!cy_is_Z(cinfo)) {
2981 spin_lock_irqsave(&cinfo->card_lock, flags);
2982 cyy_writeb(info, CyCAR, channel & 0x03);
2983 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
2984 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2989 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
2991 static void cy_hangup(struct tty_struct *tty)
2993 struct cyclades_port *info = tty->driver_data;
2995 #ifdef CY_DEBUG_OTHER
2996 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
2999 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
3002 cy_flush_buffer(tty);
3003 cy_shutdown(info, tty);
3004 tty_port_hangup(&info->port);
3007 static int cyy_carrier_raised(struct tty_port *port)
3009 struct cyclades_port *info = container_of(port, struct cyclades_port,
3011 struct cyclades_card *cinfo = info->card;
3012 unsigned long flags;
3013 int channel = info->line - cinfo->first_line;
3016 spin_lock_irqsave(&cinfo->card_lock, flags);
3017 cyy_writeb(info, CyCAR, channel & 0x03);
3018 cd = cyy_readb(info, CyMSVR1) & CyDCD;
3019 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3024 static void cyy_dtr_rts(struct tty_port *port, int raise)
3026 struct cyclades_port *info = container_of(port, struct cyclades_port,
3028 struct cyclades_card *cinfo = info->card;
3029 unsigned long flags;
3031 spin_lock_irqsave(&cinfo->card_lock, flags);
3032 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3033 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3034 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3037 static int cyz_carrier_raised(struct tty_port *port)
3039 struct cyclades_port *info = container_of(port, struct cyclades_port,
3042 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3045 static void cyz_dtr_rts(struct tty_port *port, int raise)
3047 struct cyclades_port *info = container_of(port, struct cyclades_port,
3049 struct cyclades_card *cinfo = info->card;
3050 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3051 int ret, channel = info->line - cinfo->first_line;
3054 rs = readl(&ch_ctrl->rs_control);
3056 rs |= C_RS_RTS | C_RS_DTR;
3058 rs &= ~(C_RS_RTS | C_RS_DTR);
3059 cy_writel(&ch_ctrl->rs_control, rs);
3060 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3062 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3063 __func__, info->line, ret);
3065 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3069 static const struct tty_port_operations cyy_port_ops = {
3070 .carrier_raised = cyy_carrier_raised,
3071 .dtr_rts = cyy_dtr_rts,
3072 .shutdown = cy_do_close,
3075 static const struct tty_port_operations cyz_port_ops = {
3076 .carrier_raised = cyz_carrier_raised,
3077 .dtr_rts = cyz_dtr_rts,
3078 .shutdown = cy_do_close,
3082 * ---------------------------------------------------------------------
3083 * cy_init() and friends
3085 * cy_init() is called at boot-time to initialize the serial driver.
3086 * ---------------------------------------------------------------------
3089 static int cy_init_card(struct cyclades_card *cinfo)
3091 struct cyclades_port *info;
3092 unsigned int channel, port;
3094 spin_lock_init(&cinfo->card_lock);
3095 cinfo->intr_enabled = 0;
3097 cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
3099 if (cinfo->ports == NULL) {
3100 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
3104 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
3105 channel++, port++) {
3106 info = &cinfo->ports[channel];
3107 tty_port_init(&info->port);
3108 info->magic = CYCLADES_MAGIC;
3112 info->port.closing_wait = CLOSING_WAIT_DELAY;
3113 info->port.close_delay = 5 * HZ / 10;
3114 info->port.flags = STD_COM_FLAGS;
3115 init_completion(&info->shutdown_wait);
3117 if (cy_is_Z(cinfo)) {
3118 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3119 struct ZFW_CTRL *zfw_ctrl;
3121 info->port.ops = &cyz_port_ops;
3122 info->type = PORT_STARTECH;
3124 zfw_ctrl = cinfo->base_addr +
3125 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3126 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3127 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3129 if (cinfo->hw_ver == ZO_V1)
3130 info->xmit_fifo_size = CYZ_FIFO_SIZE;
3132 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
3133 #ifdef CONFIG_CYZ_INTR
3134 setup_timer(&cyz_rx_full_timer[port],
3135 cyz_rx_restart, (unsigned long)info);
3138 unsigned short chip_number;
3139 int index = cinfo->bus_index;
3141 info->port.ops = &cyy_port_ops;
3142 info->type = PORT_CIRRUS;
3143 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
3144 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
3146 info->cor3 = 0x08; /* _very_ small rcv threshold */
3148 chip_number = channel / CyPORTS_PER_CHIP;
3149 info->u.cyy.base_addr = cinfo->base_addr +
3150 (cy_chip_offset[chip_number] << index);
3151 info->chip_rev = cyy_readb(info, CyGFRCR);
3153 if (info->chip_rev >= CD1400_REV_J) {
3154 /* It is a CD1400 rev. J or later */
3155 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
3156 info->tco = baud_co_60[13]; /* Tx CO */
3157 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
3158 info->rco = baud_co_60[13]; /* Rx CO */
3159 info->rtsdtr_inv = 1;
3161 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
3162 info->tco = baud_co_25[13]; /* Tx CO */
3163 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
3164 info->rco = baud_co_25[13]; /* Rx CO */
3165 info->rtsdtr_inv = 0;
3167 info->read_status_mask = CyTIMEOUT | CySPECHAR |
3168 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
3173 #ifndef CONFIG_CYZ_INTR
3174 if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
3175 mod_timer(&cyz_timerlist, jiffies + 1);
3177 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
3184 /* initialize chips on Cyclom-Y card -- return number of valid
3185 chips (which is number of ports/4) */
3186 static unsigned short cyy_init_card(void __iomem *true_base_addr,
3189 unsigned int chip_number;
3190 void __iomem *base_addr;
3192 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
3193 /* Cy_HwReset is 0x1400 */
3194 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
3195 /* Cy_ClrIntr is 0x1800 */
3198 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD;
3201 true_base_addr + (cy_chip_offset[chip_number] << index);
3203 if (readb(base_addr + (CyCCR << index)) != 0x00) {
3205 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3206 chip_number, (unsigned long)base_addr);
3211 cy_writeb(base_addr + (CyGFRCR << index), 0);
3214 /* The Cyclom-16Y does not decode address bit 9 and therefore
3215 cannot distinguish between references to chip 0 and a non-
3216 existent chip 4. If the preceding clearing of the supposed
3217 chip 4 GFRCR register appears at chip 0, there is no chip 4
3218 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3220 if (chip_number == 4 && readb(true_base_addr +
3221 (cy_chip_offset[0] << index) +
3222 (CyGFRCR << index)) == 0) {
3226 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
3229 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
3231 printk(" chip #%d at %#6lx is not responding ",
3232 chip_number, (unsigned long)base_addr);
3233 printk("(GFRCR stayed 0)\n",
3237 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
3240 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3242 chip_number, (unsigned long)base_addr,
3243 base_addr[CyGFRCR<<index]);
3247 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
3248 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
3249 /* It is a CD1400 rev. J or later */
3250 /* Impossible to reach 5ms with this chip.
3251 Changed to 2ms instead (f = 500 Hz). */
3252 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
3255 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
3259 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3260 chip_number, (unsigned long)base_addr,
3261 readb(base_addr+(CyGFRCR<<index)));
3265 } /* cyy_init_card */
3268 * ---------------------------------------------------------------------
3269 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3270 * sets global variables and return the number of ISA boards found.
3271 * ---------------------------------------------------------------------
3273 static int __init cy_detect_isa(void)
3276 struct cyclades_card *card;
3277 unsigned short cy_isa_irq, nboard;
3278 void __iomem *cy_isa_address;
3279 unsigned short i, j, k, cy_isa_nchan;
3284 /* Check for module parameters */
3285 for (i = 0; i < NR_CARDS; i++) {
3286 if (maddr[i] || i) {
3288 cy_isa_addresses[i] = maddr[i];
3294 /* scan the address table probing for Cyclom-Y/ISA boards */
3295 for (i = 0; i < NR_ISA_ADDRS; i++) {
3296 unsigned int isa_address = cy_isa_addresses[i];
3297 if (isa_address == 0x0000)
3300 /* probe for CD1400... */
3301 cy_isa_address = ioremap_nocache(isa_address, CyISA_Ywin);
3302 if (cy_isa_address == NULL) {
3303 printk(KERN_ERR "Cyclom-Y/ISA: can't remap base "
3307 cy_isa_nchan = CyPORTS_PER_CHIP *
3308 cyy_init_card(cy_isa_address, 0);
3309 if (cy_isa_nchan == 0) {
3310 iounmap(cy_isa_address);
3314 if (isparam && i < NR_CARDS && irq[i])
3315 cy_isa_irq = irq[i];
3317 /* find out the board's irq by probing */
3318 cy_isa_irq = detect_isa_irq(cy_isa_address);
3319 if (cy_isa_irq == 0) {
3320 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
3321 "IRQ could not be detected.\n",
3322 (unsigned long)cy_isa_address);
3323 iounmap(cy_isa_address);
3327 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
3328 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3329 "more channels are available. Change NR_PORTS "
3330 "in cyclades.c and recompile kernel.\n",
3331 (unsigned long)cy_isa_address);
3332 iounmap(cy_isa_address);
3335 /* fill the next cy_card structure available */
3336 for (j = 0; j < NR_CARDS; j++) {
3338 if (card->base_addr == NULL)
3341 if (j == NR_CARDS) { /* no more cy_cards available */
3342 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
3343 "more cards can be used. Change NR_CARDS in "
3344 "cyclades.c and recompile kernel.\n",
3345 (unsigned long)cy_isa_address);
3346 iounmap(cy_isa_address);
3351 if (request_irq(cy_isa_irq, cyy_interrupt,
3352 0, "Cyclom-Y", card)) {
3353 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3354 "could not allocate IRQ#%d.\n",
3355 (unsigned long)cy_isa_address, cy_isa_irq);
3356 iounmap(cy_isa_address);
3361 card->base_addr = cy_isa_address;
3362 card->ctl_addr.p9050 = NULL;
3363 card->irq = (int)cy_isa_irq;
3364 card->bus_index = 0;
3365 card->first_line = cy_next_channel;
3366 card->num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
3367 card->nports = cy_isa_nchan;
3368 if (cy_init_card(card)) {
3369 card->base_addr = NULL;
3370 free_irq(cy_isa_irq, card);
3371 iounmap(cy_isa_address);
3376 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3377 "%d channels starting from port %d\n",
3378 j + 1, (unsigned long)cy_isa_address,
3379 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
3380 cy_isa_irq, cy_isa_nchan, cy_next_channel);
3382 for (k = 0, j = cy_next_channel;
3383 j < cy_next_channel + cy_isa_nchan; j++, k++)
3384 tty_port_register_device(&card->ports[k].port,
3385 cy_serial_driver, j, NULL);
3386 cy_next_channel += cy_isa_nchan;
3391 #endif /* CONFIG_ISA */
3392 } /* cy_detect_isa */
3395 static inline int cyc_isfwstr(const char *str, unsigned int size)
3399 for (a = 0; a < size && *str; a++, str++)
3403 for (; a < size; a++, str++)
3410 static inline void cyz_fpga_copy(void __iomem *fpga, const u8 *data,
3413 for (; size > 0; size--) {
3414 cy_writel(fpga, *data++);
3419 static void plx_init(struct pci_dev *pdev, int irq,
3420 struct RUNTIME_9060 __iomem *addr)
3423 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x40000000);
3425 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x40000000);
3427 /* Reload Config. Registers from EEPROM */
3428 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) | 0x20000000);
3430 cy_writel(&addr->init_ctrl, readl(&addr->init_ctrl) & ~0x20000000);
3432 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3433 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3434 * registers. This will remain here until we find a permanent fix.
3436 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, irq);
3439 static int __cyz_load_fw(const struct firmware *fw,
3440 const char *name, const u32 mailbox, void __iomem *base,
3443 const void *ptr = fw->data;
3444 const struct zfile_header *h = ptr;
3445 const struct zfile_config *c, *cs;
3446 const struct zfile_block *b, *bs;
3447 unsigned int a, tmp, len = fw->size;
3448 #define BAD_FW KERN_ERR "Bad firmware: "
3449 if (len < sizeof(*h)) {
3450 printk(BAD_FW "too short: %u<%zu\n", len, sizeof(*h));
3454 cs = ptr + h->config_offset;
3455 bs = ptr + h->block_offset;
3457 if ((void *)(cs + h->n_config) > ptr + len ||
3458 (void *)(bs + h->n_blocks) > ptr + len) {
3459 printk(BAD_FW "too short");
3463 if (cyc_isfwstr(h->name, sizeof(h->name)) ||
3464 cyc_isfwstr(h->date, sizeof(h->date))) {
3465 printk(BAD_FW "bad formatted header string\n");
3469 if (strncmp(name, h->name, sizeof(h->name))) {
3470 printk(BAD_FW "bad name '%s' (expected '%s')\n", h->name, name);
3475 for (c = cs; c < cs + h->n_config; c++) {
3476 for (a = 0; a < c->n_blocks; a++)
3477 if (c->block_list[a] > h->n_blocks) {
3478 printk(BAD_FW "bad block ref number in cfgs\n");
3481 if (c->mailbox == mailbox && c->function == 0) /* 0 is normal */
3485 printk(BAD_FW "nothing appropriate\n");
3489 for (b = bs; b < bs + h->n_blocks; b++)
3490 if (b->file_offset + b->size > len) {
3491 printk(BAD_FW "bad block data offset\n");
3495 /* everything is OK, let's seek'n'load it */
3496 for (c = cs; c < cs + h->n_config; c++)
3497 if (c->mailbox == mailbox && c->function == 0)
3500 for (a = 0; a < c->n_blocks; a++) {
3501 b = &bs[c->block_list[a]];
3502 if (b->type == ZBLOCK_FPGA) {
3504 cyz_fpga_copy(fpga, ptr + b->file_offset,
3508 memcpy_toio(base + b->ram_offset,
3509 ptr + b->file_offset, b->size);
3516 static int cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
3517 struct RUNTIME_9060 __iomem *ctl_addr, int irq)
3519 const struct firmware *fw;
3520 struct FIRM_ID __iomem *fid = base_addr + ID_ADDRESS;
3521 struct CUSTOM_REG __iomem *cust = base_addr;
3522 struct ZFW_CTRL __iomem *pt_zfwctrl;
3524 u32 mailbox, status, nchan;
3528 retval = request_firmware(&fw, "cyzfirm.bin", &pdev->dev);
3530 dev_err(&pdev->dev, "can't get firmware\n");
3534 /* Check whether the firmware is already loaded and running. If
3535 positive, skip this board */
3536 if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
3537 u32 cntval = readl(base_addr + 0x190);
3540 if (cntval != readl(base_addr + 0x190)) {
3541 /* FW counter is working, FW is running */
3542 dev_dbg(&pdev->dev, "Cyclades-Z FW already loaded. "
3543 "Skipping board.\n");
3550 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) &
3553 mailbox = readl(&ctl_addr->mail_box_0);
3555 if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
3556 /* stops CPU and set window to beginning of RAM */
3557 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3558 cy_writel(&cust->cpu_stop, 0);
3559 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3563 plx_init(pdev, irq, ctl_addr);
3567 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, NULL,
3571 if (!__cyz_fpga_loaded(ctl_addr)) {
3572 dev_err(&pdev->dev, "fw upload successful, but fw is "
3578 /* stops CPU and set window to beginning of RAM */
3579 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3580 cy_writel(&cust->cpu_stop, 0);
3581 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3585 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3586 cy_writeb(tmp, 255);
3588 /* set window to last 512K of RAM */
3589 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM + RAM_SIZE);
3590 for (tmp = base_addr; tmp < base_addr + RAM_SIZE; tmp++)
3591 cy_writeb(tmp, 255);
3592 /* set window to beginning of RAM */
3593 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3596 retval = __cyz_load_fw(fw, "Cyclom-Z", mailbox, base_addr, NULL);
3597 release_firmware(fw);
3601 /* finish boot and start boards */
3602 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3603 cy_writel(&cust->cpu_start, 0);
3604 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3606 while ((status = readl(&fid->signature)) != ZFIRM_ID && i++ < 40)
3608 if (status != ZFIRM_ID) {
3609 if (status == ZFIRM_HLT) {
3610 dev_err(&pdev->dev, "you need an external power supply "
3611 "for this number of ports. Firmware halted and "
3616 dev_warn(&pdev->dev, "fid->signature = 0x%x... Waiting "
3617 "some more time\n", status);
3618 while ((status = readl(&fid->signature)) != ZFIRM_ID &&
3621 if (status != ZFIRM_ID) {
3622 dev_err(&pdev->dev, "Board not started in 20 seconds! "
3623 "Giving up. (fid->signature = 0x%x)\n",
3625 dev_info(&pdev->dev, "*** Warning ***: if you are "
3626 "upgrading the FW, please power cycle the "
3627 "system before loading the new FW to the "
3630 if (__cyz_fpga_loaded(ctl_addr))
3631 plx_init(pdev, irq, ctl_addr);
3636 dev_dbg(&pdev->dev, "Firmware started after %d seconds.\n",
3639 pt_zfwctrl = base_addr + readl(&fid->zfwctrl_addr);
3641 dev_dbg(&pdev->dev, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3642 base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
3643 base_addr + readl(&fid->zfwctrl_addr));
3645 nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
3646 dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3647 readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
3650 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
3651 "check the connection between the Z host card and the "
3652 "serial expanders.\n");
3654 if (__cyz_fpga_loaded(ctl_addr))
3655 plx_init(pdev, irq, ctl_addr);
3657 dev_info(&pdev->dev, "Null number of ports detected. Board "
3663 cy_writel(&pt_zfwctrl->board_ctrl.op_system, C_OS_LINUX);
3664 cy_writel(&pt_zfwctrl->board_ctrl.dr_version, DRIVER_VERSION);
3667 Early firmware failed to start looking for commands.
3668 This enables firmware interrupts for those commands.
3670 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3672 cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
3677 release_firmware(fw);
3682 static int cy_pci_probe(struct pci_dev *pdev,
3683 const struct pci_device_id *ent)
3685 struct cyclades_card *card;
3686 void __iomem *addr0 = NULL, *addr2 = NULL;
3687 char *card_name = NULL;
3688 u32 uninitialized_var(mailbox);
3689 unsigned int device_id, nchan = 0, card_no, i, j;
3690 unsigned char plx_ver;
3693 retval = pci_enable_device(pdev);
3695 dev_err(&pdev->dev, "cannot enable device\n");
3699 /* read PCI configuration area */
3701 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
3703 #if defined(__alpha__)
3704 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
3705 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for low "
3706 "addresses on Alpha systems.\n");
3711 if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
3712 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for low "
3718 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
3719 dev_warn(&pdev->dev, "PCI I/O bit incorrectly set. Ignoring "
3721 pdev->resource[2].flags &= ~IORESOURCE_IO;
3724 retval = pci_request_regions(pdev, "cyclades");
3726 dev_err(&pdev->dev, "failed to reserve resources\n");
3731 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3732 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3733 card_name = "Cyclom-Y";
3735 addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3737 if (addr0 == NULL) {
3738 dev_err(&pdev->dev, "can't remap ctl region\n");
3741 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3743 if (addr2 == NULL) {
3744 dev_err(&pdev->dev, "can't remap base region\n");
3748 nchan = CyPORTS_PER_CHIP * cyy_init_card(addr2, 1);
3750 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
3751 "Serial-Modules\n");
3754 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
3755 struct RUNTIME_9060 __iomem *ctl_addr;
3757 ctl_addr = addr0 = ioremap_nocache(pci_resource_start(pdev, 0),
3759 if (addr0 == NULL) {
3760 dev_err(&pdev->dev, "can't remap ctl region\n");
3764 /* Disable interrupts on the PLX before resetting it */
3765 cy_writew(&ctl_addr->intr_ctrl_stat,
3766 readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
3768 plx_init(pdev, irq, addr0);
3770 mailbox = readl(&ctl_addr->mail_box_0);
3772 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
3773 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
3774 if (addr2 == NULL) {
3775 dev_err(&pdev->dev, "can't remap base region\n");
3779 if (mailbox == ZE_V1) {
3780 card_name = "Cyclades-Ze";
3782 card_name = "Cyclades-8Zo";
3784 if (mailbox == ZO_V1) {
3785 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
3786 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA "
3787 "id %lx, ver %lx\n", (ulong)(0xff &
3788 readl(&((struct CUSTOM_REG *)addr2)->
3789 fpga_id)), (ulong)(0xff &
3790 readl(&((struct CUSTOM_REG *)addr2)->
3792 cy_writel(&ctl_addr->loc_addr_base, WIN_RAM);
3794 dev_info(&pdev->dev, "Cyclades-Z/PCI: New "
3795 "Cyclades-Z board. FPGA not loaded\n");
3798 /* The following clears the firmware id word. This
3799 ensures that the driver will not attempt to talk to
3800 the board until it has been properly initialized.
3802 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
3803 cy_writel(addr2 + ID_ADDRESS, 0L);
3806 retval = cyz_load_fw(pdev, addr2, addr0, irq);
3812 if ((cy_next_channel + nchan) > NR_PORTS) {
3813 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3814 "channels are available. Change NR_PORTS in "
3815 "cyclades.c and recompile kernel.\n");
3818 /* fill the next cy_card structure available */
3819 for (card_no = 0; card_no < NR_CARDS; card_no++) {
3820 card = &cy_card[card_no];
3821 if (card->base_addr == NULL)
3824 if (card_no == NR_CARDS) { /* no more cy_cards available */
3825 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
3826 "more cards can be used. Change NR_CARDS in "
3827 "cyclades.c and recompile kernel.\n");
3831 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3832 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3834 retval = request_irq(irq, cyy_interrupt,
3835 IRQF_SHARED, "Cyclom-Y", card);
3837 dev_err(&pdev->dev, "could not allocate IRQ\n");
3840 card->num_chips = nchan / CyPORTS_PER_CHIP;
3842 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3843 struct ZFW_CTRL __iomem *zfw_ctrl;
3845 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3847 card->hw_ver = mailbox;
3848 card->num_chips = (unsigned int)-1;
3849 card->board_ctrl = &zfw_ctrl->board_ctrl;
3850 #ifdef CONFIG_CYZ_INTR
3851 /* allocate IRQ only if board has an IRQ */
3852 if (irq != 0 && irq != 255) {
3853 retval = request_irq(irq, cyz_interrupt,
3854 IRQF_SHARED, "Cyclades-Z", card);
3856 dev_err(&pdev->dev, "could not allocate IRQ\n");
3860 #endif /* CONFIG_CYZ_INTR */
3864 card->base_addr = addr2;
3865 card->ctl_addr.p9050 = addr0;
3867 card->bus_index = 1;
3868 card->first_line = cy_next_channel;
3869 card->nports = nchan;
3870 retval = cy_init_card(card);
3874 pci_set_drvdata(pdev, card);
3876 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
3877 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
3878 /* enable interrupts in the PCI interface */
3879 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
3882 cy_writeb(addr0 + 0x4c, 0x43);
3887 default: /* Old boards, use PLX_9060 */
3889 struct RUNTIME_9060 __iomem *ctl_addr = addr0;
3890 plx_init(pdev, irq, ctl_addr);
3891 cy_writew(&ctl_addr->intr_ctrl_stat,
3892 readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
3898 dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
3899 "port %d.\n", card_name, card_no + 1, nchan, cy_next_channel);
3900 for (j = 0, i = cy_next_channel; i < cy_next_channel + nchan; i++, j++)
3901 tty_port_register_device(&card->ports[j].port,
3902 cy_serial_driver, i, &pdev->dev);
3903 cy_next_channel += nchan;
3907 card->base_addr = NULL;
3908 free_irq(irq, card);
3914 pci_release_regions(pdev);
3916 pci_disable_device(pdev);
3921 static void cy_pci_remove(struct pci_dev *pdev)
3923 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
3924 unsigned int i, channel;
3926 /* non-Z with old PLX */
3927 if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
3929 cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
3931 #ifndef CONFIG_CYZ_INTR
3932 if (!cy_is_Z(cinfo))
3934 cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
3935 readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
3938 iounmap(cinfo->base_addr);
3939 if (cinfo->ctl_addr.p9050)
3940 iounmap(cinfo->ctl_addr.p9050);
3942 #ifndef CONFIG_CYZ_INTR
3944 #endif /* CONFIG_CYZ_INTR */
3946 free_irq(cinfo->irq, cinfo);
3947 pci_release_regions(pdev);
3949 cinfo->base_addr = NULL;
3950 for (channel = 0, i = cinfo->first_line; i < cinfo->first_line +
3951 cinfo->nports; i++, channel++) {
3952 tty_unregister_device(cy_serial_driver, i);
3953 tty_port_destroy(&cinfo->ports[channel].port);
3956 kfree(cinfo->ports);
3959 static struct pci_driver cy_pci_driver = {
3961 .id_table = cy_pci_dev_id,
3962 .probe = cy_pci_probe,
3963 .remove = cy_pci_remove
3967 static int cyclades_proc_show(struct seq_file *m, void *v)
3969 struct cyclades_port *info;
3971 __u32 cur_jifs = jiffies;
3973 seq_puts(m, "Dev TimeOpen BytesOut IdleOut BytesIn "
3974 "IdleIn Overruns Ldisc\n");
3976 /* Output one line for each known port */
3977 for (i = 0; i < NR_CARDS; i++)
3978 for (j = 0; j < cy_card[i].nports; j++) {
3979 info = &cy_card[i].ports[j];
3981 if (info->port.count) {
3982 /* XXX is the ldisc num worth this? */
3983 struct tty_struct *tty;
3984 struct tty_ldisc *ld;
3986 tty = tty_port_tty_get(&info->port);
3988 ld = tty_ldisc_ref(tty);
3991 tty_ldisc_deref(ld);
3995 seq_printf(m, "%3d %8lu %10lu %8lu "
3996 "%10lu %8lu %9lu %6d\n", info->line,
3997 (cur_jifs - info->idle_stats.in_use) /
3998 HZ, info->idle_stats.xmit_bytes,
3999 (cur_jifs - info->idle_stats.xmit_idle)/
4000 HZ, info->idle_stats.recv_bytes,
4001 (cur_jifs - info->idle_stats.recv_idle)/
4002 HZ, info->idle_stats.overruns,
4005 seq_printf(m, "%3d %8lu %10lu %8lu "
4006 "%10lu %8lu %9lu %6ld\n",
4007 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4012 static int cyclades_proc_open(struct inode *inode, struct file *file)
4014 return single_open(file, cyclades_proc_show, NULL);
4017 static const struct file_operations cyclades_proc_fops = {
4018 .owner = THIS_MODULE,
4019 .open = cyclades_proc_open,
4021 .llseek = seq_lseek,
4022 .release = single_release,
4025 /* The serial driver boot-time initialization code!
4026 Hardware I/O ports are mapped to character special devices on a
4027 first found, first allocated manner. That is, this code searches
4028 for Cyclom cards in the system. As each is found, it is probed
4029 to discover how many chips (and thus how many ports) are present.
4030 These ports are mapped to the tty ports 32 and upward in monotonic
4031 fashion. If an 8-port card is replaced with a 16-port card, the
4032 port mapping on a following card will shift.
4034 This approach is different from what is used in the other serial
4035 device driver because the Cyclom is more properly a multiplexer,
4036 not just an aggregation of serial ports on one card.
4038 If there are more cards with more ports than have been
4039 statically allocated above, a warning is printed and the
4040 extra ports are ignored.
4043 static const struct tty_operations cy_ops = {
4047 .put_char = cy_put_char,
4048 .flush_chars = cy_flush_chars,
4049 .write_room = cy_write_room,
4050 .chars_in_buffer = cy_chars_in_buffer,
4051 .flush_buffer = cy_flush_buffer,
4053 .throttle = cy_throttle,
4054 .unthrottle = cy_unthrottle,
4055 .set_termios = cy_set_termios,
4058 .hangup = cy_hangup,
4059 .break_ctl = cy_break,
4060 .wait_until_sent = cy_wait_until_sent,
4061 .tiocmget = cy_tiocmget,
4062 .tiocmset = cy_tiocmset,
4063 .get_icount = cy_get_icount,
4064 .proc_fops = &cyclades_proc_fops,
4067 static int __init cy_init(void)
4069 unsigned int nboards;
4070 int retval = -ENOMEM;
4072 cy_serial_driver = alloc_tty_driver(NR_PORTS);
4073 if (!cy_serial_driver)
4076 printk(KERN_INFO "Cyclades driver " CY_VERSION "\n");
4078 /* Initialize the tty_driver structure */
4080 cy_serial_driver->driver_name = "cyclades";
4081 cy_serial_driver->name = "ttyC";
4082 cy_serial_driver->major = CYCLADES_MAJOR;
4083 cy_serial_driver->minor_start = 0;
4084 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
4085 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
4086 cy_serial_driver->init_termios = tty_std_termios;
4087 cy_serial_driver->init_termios.c_cflag =
4088 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
4089 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4090 tty_set_operations(cy_serial_driver, &cy_ops);
4092 retval = tty_register_driver(cy_serial_driver);
4094 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
4098 /* the code below is responsible to find the boards. Each different
4099 type of board has its own detection routine. If a board is found,
4100 the next cy_card structure available is set by the detection
4101 routine. These functions are responsible for checking the
4102 availability of cy_card and cy_port data structures and updating
4103 the cy_next_channel. */
4105 /* look for isa boards */
4106 nboards = cy_detect_isa();
4109 /* look for pci boards */
4110 retval = pci_register_driver(&cy_pci_driver);
4111 if (retval && !nboards) {
4112 tty_unregister_driver(cy_serial_driver);
4119 put_tty_driver(cy_serial_driver);
4124 static void __exit cy_cleanup_module(void)
4126 struct cyclades_card *card;
4129 #ifndef CONFIG_CYZ_INTR
4130 del_timer_sync(&cyz_timerlist);
4131 #endif /* CONFIG_CYZ_INTR */
4133 e1 = tty_unregister_driver(cy_serial_driver);
4135 printk(KERN_ERR "failed to unregister Cyclades serial "
4136 "driver(%d)\n", e1);
4139 pci_unregister_driver(&cy_pci_driver);
4142 for (i = 0; i < NR_CARDS; i++) {
4144 if (card->base_addr) {
4145 /* clear interrupt */
4146 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
4147 iounmap(card->base_addr);
4148 if (card->ctl_addr.p9050)
4149 iounmap(card->ctl_addr.p9050);
4151 #ifndef CONFIG_CYZ_INTR
4153 #endif /* CONFIG_CYZ_INTR */
4155 free_irq(card->irq, card);
4156 for (e1 = card->first_line; e1 < card->first_line +
4158 tty_unregister_device(cy_serial_driver, e1);
4163 put_tty_driver(cy_serial_driver);
4164 } /* cy_cleanup_module */
4166 module_init(cy_init);
4167 module_exit(cy_cleanup_module);
4169 MODULE_LICENSE("GPL");
4170 MODULE_VERSION(CY_VERSION);
4171 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR);
4172 MODULE_FIRMWARE("cyzfirm.bin");