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_struct
*tty
;
445 struct tty_port
*port
;
446 int len
, index
= cinfo
->bus_index
;
447 u8 ivr
, save_xir
, channel
, save_car
, data
, char_count
;
449 #ifdef CY_DEBUG_INTERRUPTS
450 printk(KERN_DEBUG
"cyy_interrupt: rcvd intr, chip %d\n", chip
);
452 /* determine the channel & change to that context */
453 save_xir
= readb(base_addr
+ (CyRIR
<< index
));
454 channel
= save_xir
& CyIRChannel
;
455 info
= &cinfo
->ports
[channel
+ chip
* 4];
457 save_car
= cyy_readb(info
, CyCAR
);
458 cyy_writeb(info
, CyCAR
, save_xir
);
459 ivr
= cyy_readb(info
, CyRIVR
) & CyIVRMask
;
461 tty
= tty_port_tty_get(port
);
462 /* if there is nowhere to put the data, discard it */
464 if (ivr
== CyIVRRxEx
) { /* exception */
465 data
= cyy_readb(info
, CyRDSR
);
466 } else { /* normal character reception */
467 char_count
= cyy_readb(info
, CyRDCR
);
469 data
= cyy_readb(info
, CyRDSR
);
473 /* there is an open port for this data */
474 if (ivr
== CyIVRRxEx
) { /* exception */
475 data
= cyy_readb(info
, CyRDSR
);
477 /* For statistics only */
480 else if (data
& CyFRAME
)
481 info
->icount
.frame
++;
482 else if (data
& CyPARITY
)
483 info
->icount
.parity
++;
484 else if (data
& CyOVERRUN
)
485 info
->icount
.overrun
++;
487 if (data
& info
->ignore_status_mask
) {
492 if (tty_buffer_request_room(port
, 1)) {
493 if (data
& info
->read_status_mask
) {
494 if (data
& CyBREAK
) {
495 tty_insert_flip_char(tty
,
496 cyy_readb(info
, CyRDSR
),
499 if (port
->flags
& ASYNC_SAK
)
501 } else if (data
& CyFRAME
) {
502 tty_insert_flip_char(tty
,
503 cyy_readb(info
, CyRDSR
),
506 info
->idle_stats
.frame_errs
++;
507 } else if (data
& CyPARITY
) {
508 /* Pieces of seven... */
509 tty_insert_flip_char(tty
,
510 cyy_readb(info
, CyRDSR
),
513 info
->idle_stats
.parity_errs
++;
514 } else if (data
& CyOVERRUN
) {
515 tty_insert_flip_char(tty
, 0,
518 /* If the flip buffer itself is
519 overflowing, we still lose
520 the next incoming character.
522 tty_insert_flip_char(tty
,
523 cyy_readb(info
, CyRDSR
),
526 info
->idle_stats
.overruns
++;
527 /* These two conditions may imply */
528 /* a normal read should be done. */
529 /* } else if(data & CyTIMEOUT) { */
530 /* } else if(data & CySPECHAR) { */
532 tty_insert_flip_char(tty
, 0,
537 tty_insert_flip_char(tty
, 0, TTY_NORMAL
);
541 /* there was a software buffer overrun and nothing
542 * could be done about it!!! */
543 info
->icount
.buf_overrun
++;
544 info
->idle_stats
.overruns
++;
546 } else { /* normal character reception */
547 /* load # chars available from the chip */
548 char_count
= cyy_readb(info
, CyRDCR
);
550 #ifdef CY_ENABLE_MONITORING
551 ++info
->mon
.int_count
;
552 info
->mon
.char_count
+= char_count
;
553 if (char_count
> info
->mon
.char_max
)
554 info
->mon
.char_max
= char_count
;
555 info
->mon
.char_last
= char_count
;
557 len
= tty_buffer_request_room(port
, char_count
);
559 data
= cyy_readb(info
, CyRDSR
);
560 tty_insert_flip_char(tty
, data
, TTY_NORMAL
);
561 info
->idle_stats
.recv_bytes
++;
567 info
->idle_stats
.recv_idle
= jiffies
;
569 tty_schedule_flip(tty
);
573 cyy_writeb(info
, CyRIR
, save_xir
& 0x3f);
574 cyy_writeb(info
, CyCAR
, save_car
);
577 static void cyy_chip_tx(struct cyclades_card
*cinfo
, unsigned int chip
,
578 void __iomem
*base_addr
)
580 struct cyclades_port
*info
;
581 struct tty_struct
*tty
;
582 int char_count
, index
= cinfo
->bus_index
;
583 u8 save_xir
, channel
, save_car
, outch
;
585 /* Since we only get here when the transmit buffer
586 is empty, we know we can always stuff a dozen
588 #ifdef CY_DEBUG_INTERRUPTS
589 printk(KERN_DEBUG
"cyy_interrupt: xmit intr, chip %d\n", chip
);
592 /* determine the channel & change to that context */
593 save_xir
= readb(base_addr
+ (CyTIR
<< index
));
594 channel
= save_xir
& CyIRChannel
;
595 save_car
= readb(base_addr
+ (CyCAR
<< index
));
596 cy_writeb(base_addr
+ (CyCAR
<< index
), save_xir
);
598 info
= &cinfo
->ports
[channel
+ chip
* 4];
599 tty
= tty_port_tty_get(&info
->port
);
601 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) & ~CyTxRdy
);
605 /* load the on-chip space for outbound data */
606 char_count
= info
->xmit_fifo_size
;
608 if (info
->x_char
) { /* send special char */
609 outch
= info
->x_char
;
610 cyy_writeb(info
, CyTDR
, outch
);
616 if (info
->breakon
|| info
->breakoff
) {
618 cyy_writeb(info
, CyTDR
, 0);
619 cyy_writeb(info
, CyTDR
, 0x81);
623 if (info
->breakoff
) {
624 cyy_writeb(info
, CyTDR
, 0);
625 cyy_writeb(info
, CyTDR
, 0x83);
631 while (char_count
-- > 0) {
632 if (!info
->xmit_cnt
) {
633 if (cyy_readb(info
, CySRER
) & CyTxMpty
) {
634 cyy_writeb(info
, CySRER
,
635 cyy_readb(info
, CySRER
) & ~CyTxMpty
);
637 cyy_writeb(info
, CySRER
, CyTxMpty
|
638 (cyy_readb(info
, CySRER
) & ~CyTxRdy
));
642 if (info
->port
.xmit_buf
== NULL
) {
643 cyy_writeb(info
, CySRER
,
644 cyy_readb(info
, CySRER
) & ~CyTxRdy
);
647 if (tty
->stopped
|| tty
->hw_stopped
) {
648 cyy_writeb(info
, CySRER
,
649 cyy_readb(info
, CySRER
) & ~CyTxRdy
);
652 /* Because the Embedded Transmit Commands have been enabled,
653 * we must check to see if the escape character, NULL, is being
654 * sent. If it is, we must ensure that there is room for it to
655 * be doubled in the output stream. Therefore we no longer
656 * advance the pointer when the character is fetched, but
657 * rather wait until after the check for a NULL output
658 * character. This is necessary because there may not be room
659 * for the two chars needed to send a NULL.)
661 outch
= info
->port
.xmit_buf
[info
->xmit_tail
];
664 info
->xmit_tail
= (info
->xmit_tail
+ 1) &
665 (SERIAL_XMIT_SIZE
- 1);
666 cyy_writeb(info
, CyTDR
, outch
);
669 if (char_count
> 1) {
671 info
->xmit_tail
= (info
->xmit_tail
+ 1) &
672 (SERIAL_XMIT_SIZE
- 1);
673 cyy_writeb(info
, CyTDR
, outch
);
674 cyy_writeb(info
, CyTDR
, 0);
686 cyy_writeb(info
, CyTIR
, save_xir
& 0x3f);
687 cyy_writeb(info
, CyCAR
, save_car
);
690 static void cyy_chip_modem(struct cyclades_card
*cinfo
, int chip
,
691 void __iomem
*base_addr
)
693 struct cyclades_port
*info
;
694 struct tty_struct
*tty
;
695 int index
= cinfo
->bus_index
;
696 u8 save_xir
, channel
, save_car
, mdm_change
, mdm_status
;
698 /* determine the channel & change to that context */
699 save_xir
= readb(base_addr
+ (CyMIR
<< index
));
700 channel
= save_xir
& CyIRChannel
;
701 info
= &cinfo
->ports
[channel
+ chip
* 4];
702 save_car
= cyy_readb(info
, CyCAR
);
703 cyy_writeb(info
, CyCAR
, save_xir
);
705 mdm_change
= cyy_readb(info
, CyMISR
);
706 mdm_status
= cyy_readb(info
, CyMSVR1
);
708 tty
= tty_port_tty_get(&info
->port
);
712 if (mdm_change
& CyANY_DELTA
) {
713 /* For statistics only */
714 if (mdm_change
& CyDCD
)
716 if (mdm_change
& CyCTS
)
718 if (mdm_change
& CyDSR
)
720 if (mdm_change
& CyRI
)
723 wake_up_interruptible(&info
->port
.delta_msr_wait
);
726 if ((mdm_change
& CyDCD
) && (info
->port
.flags
& ASYNC_CHECK_CD
)) {
727 if (mdm_status
& CyDCD
)
728 wake_up_interruptible(&info
->port
.open_wait
);
732 if ((mdm_change
& CyCTS
) && tty_port_cts_enabled(&info
->port
)) {
733 if (tty
->hw_stopped
) {
734 if (mdm_status
& CyCTS
) {
735 /* cy_start isn't used
738 cyy_writeb(info
, CySRER
,
739 cyy_readb(info
, CySRER
) | CyTxRdy
);
743 if (!(mdm_status
& CyCTS
)) {
744 /* cy_stop isn't used
747 cyy_writeb(info
, CySRER
,
748 cyy_readb(info
, CySRER
) & ~CyTxRdy
);
752 /* if (mdm_change & CyDSR) {
754 if (mdm_change & CyRI) {
759 cyy_writeb(info
, CyMIR
, save_xir
& 0x3f);
760 cyy_writeb(info
, CyCAR
, save_car
);
763 /* The real interrupt service routine is called
764 whenever the card wants its hand held--chars
765 received, out buffer empty, modem change, etc.
767 static irqreturn_t
cyy_interrupt(int irq
, void *dev_id
)
770 struct cyclades_card
*cinfo
= dev_id
;
771 void __iomem
*base_addr
, *card_base_addr
;
772 unsigned int chip
, too_many
, had_work
;
775 if (unlikely(cinfo
== NULL
)) {
776 #ifdef CY_DEBUG_INTERRUPTS
777 printk(KERN_DEBUG
"cyy_interrupt: spurious interrupt %d\n",
780 return IRQ_NONE
; /* spurious interrupt */
783 card_base_addr
= cinfo
->base_addr
;
784 index
= cinfo
->bus_index
;
786 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
787 if (unlikely(card_base_addr
== NULL
))
790 /* This loop checks all chips in the card. Make a note whenever
791 _any_ chip had some work to do, as this is considered an
792 indication that there will be more to do. Only when no chip
793 has any work does this outermost loop exit.
797 for (chip
= 0; chip
< cinfo
->num_chips
; chip
++) {
798 base_addr
= cinfo
->base_addr
+
799 (cy_chip_offset
[chip
] << index
);
801 while ((status
= readb(base_addr
+
802 (CySVRR
<< index
))) != 0x00) {
804 /* The purpose of the following test is to ensure that
805 no chip can monopolize the driver. This forces the
806 chips to be checked in a round-robin fashion (after
807 draining each of a bunch (1000) of characters).
809 if (1000 < too_many
++)
811 spin_lock(&cinfo
->card_lock
);
812 if (status
& CySRReceive
) /* rx intr */
813 cyy_chip_rx(cinfo
, chip
, base_addr
);
814 if (status
& CySRTransmit
) /* tx intr */
815 cyy_chip_tx(cinfo
, chip
, base_addr
);
816 if (status
& CySRModem
) /* modem intr */
817 cyy_chip_modem(cinfo
, chip
, base_addr
);
818 spin_unlock(&cinfo
->card_lock
);
823 /* clear interrupts */
824 spin_lock(&cinfo
->card_lock
);
825 cy_writeb(card_base_addr
+ (Cy_ClrIntr
<< index
), 0);
826 /* Cy_ClrIntr is 0x1800 */
827 spin_unlock(&cinfo
->card_lock
);
829 } /* cyy_interrupt */
831 static void cyy_change_rts_dtr(struct cyclades_port
*info
, unsigned int set
,
834 struct cyclades_card
*card
= info
->card
;
835 int channel
= info
->line
- card
->first_line
;
836 u32 rts
, dtr
, msvrr
, msvrd
;
840 if (info
->rtsdtr_inv
) {
851 if (set
& TIOCM_RTS
) {
852 cyy_writeb(info
, CyCAR
, channel
);
853 cyy_writeb(info
, msvrr
, rts
);
855 if (clear
& TIOCM_RTS
) {
856 cyy_writeb(info
, CyCAR
, channel
);
857 cyy_writeb(info
, msvrr
, ~rts
);
859 if (set
& TIOCM_DTR
) {
860 cyy_writeb(info
, CyCAR
, channel
);
861 cyy_writeb(info
, msvrd
, dtr
);
863 printk(KERN_DEBUG
"cyc:set_modem_info raising DTR\n");
864 printk(KERN_DEBUG
" status: 0x%x, 0x%x\n",
865 cyy_readb(info
, CyMSVR1
),
866 cyy_readb(info
, CyMSVR2
));
869 if (clear
& TIOCM_DTR
) {
870 cyy_writeb(info
, CyCAR
, channel
);
871 cyy_writeb(info
, msvrd
, ~dtr
);
873 printk(KERN_DEBUG
"cyc:set_modem_info dropping DTR\n");
874 printk(KERN_DEBUG
" status: 0x%x, 0x%x\n",
875 cyy_readb(info
, CyMSVR1
),
876 cyy_readb(info
, CyMSVR2
));
881 /***********************************************************/
882 /********* End of block of Cyclom-Y specific code **********/
883 /******** Start of block of Cyclades-Z specific code *******/
884 /***********************************************************/
887 cyz_fetch_msg(struct cyclades_card
*cinfo
,
888 __u32
*channel
, __u8
*cmd
, __u32
*param
)
890 struct BOARD_CTRL __iomem
*board_ctrl
= cinfo
->board_ctrl
;
891 unsigned long loc_doorbell
;
893 loc_doorbell
= readl(&cinfo
->ctl_addr
.p9060
->loc_doorbell
);
895 *cmd
= (char)(0xff & loc_doorbell
);
896 *channel
= readl(&board_ctrl
->fwcmd_channel
);
897 *param
= (__u32
) readl(&board_ctrl
->fwcmd_param
);
898 cy_writel(&cinfo
->ctl_addr
.p9060
->loc_doorbell
, 0xffffffff);
902 } /* cyz_fetch_msg */
905 cyz_issue_cmd(struct cyclades_card
*cinfo
,
906 __u32 channel
, __u8 cmd
, __u32 param
)
908 struct BOARD_CTRL __iomem
*board_ctrl
= cinfo
->board_ctrl
;
909 __u32 __iomem
*pci_doorbell
;
912 if (!cyz_is_loaded(cinfo
))
916 pci_doorbell
= &cinfo
->ctl_addr
.p9060
->pci_doorbell
;
917 while ((readl(pci_doorbell
) & 0xff) != 0) {
919 return (int)(readl(pci_doorbell
) & 0xff);
922 cy_writel(&board_ctrl
->hcmd_channel
, channel
);
923 cy_writel(&board_ctrl
->hcmd_param
, param
);
924 cy_writel(pci_doorbell
, (long)cmd
);
927 } /* cyz_issue_cmd */
929 static void cyz_handle_rx(struct cyclades_port
*info
, struct tty_struct
*tty
)
931 struct BUF_CTRL __iomem
*buf_ctrl
= info
->u
.cyz
.buf_ctrl
;
932 struct cyclades_card
*cinfo
= info
->card
;
933 struct tty_port
*port
= &info
->port
;
934 unsigned int char_count
;
941 __u32 rx_put
, rx_get
, new_rx_get
, rx_bufsize
, rx_bufaddr
;
943 rx_get
= new_rx_get
= readl(&buf_ctrl
->rx_get
);
944 rx_put
= readl(&buf_ctrl
->rx_put
);
945 rx_bufsize
= readl(&buf_ctrl
->rx_bufsize
);
946 rx_bufaddr
= readl(&buf_ctrl
->rx_bufaddr
);
947 if (rx_put
>= rx_get
)
948 char_count
= rx_put
- rx_get
;
950 char_count
= rx_put
- rx_get
+ rx_bufsize
;
953 #ifdef CY_ENABLE_MONITORING
954 info
->mon
.int_count
++;
955 info
->mon
.char_count
+= char_count
;
956 if (char_count
> info
->mon
.char_max
)
957 info
->mon
.char_max
= char_count
;
958 info
->mon
.char_last
= char_count
;
961 /* flush received characters */
962 new_rx_get
= (new_rx_get
+ char_count
) &
964 info
->rflush_count
++;
967 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
968 for performance, but because of buffer boundaries, there
969 may be several steps to the operation */
971 len
= tty_prepare_flip_string(tty
, &buf
,
976 len
= min_t(unsigned int, min(len
, char_count
),
977 rx_bufsize
- new_rx_get
);
979 memcpy_fromio(buf
, cinfo
->base_addr
+
980 rx_bufaddr
+ new_rx_get
, len
);
982 new_rx_get
= (new_rx_get
+ len
) &
985 info
->icount
.rx
+= len
;
986 info
->idle_stats
.recv_bytes
+= len
;
989 len
= tty_buffer_request_room(port
, char_count
);
991 data
= readb(cinfo
->base_addr
+ rx_bufaddr
+
993 new_rx_get
= (new_rx_get
+ 1) &
995 tty_insert_flip_char(tty
, data
, TTY_NORMAL
);
996 info
->idle_stats
.recv_bytes
++;
1000 #ifdef CONFIG_CYZ_INTR
1001 /* Recalculate the number of chars in the RX buffer and issue
1002 a cmd in case it's higher than the RX high water mark */
1003 rx_put
= readl(&buf_ctrl
->rx_put
);
1004 if (rx_put
>= rx_get
)
1005 char_count
= rx_put
- rx_get
;
1007 char_count
= rx_put
- rx_get
+ rx_bufsize
;
1008 if (char_count
>= readl(&buf_ctrl
->rx_threshold
) &&
1009 !timer_pending(&cyz_rx_full_timer
[
1011 mod_timer(&cyz_rx_full_timer
[info
->line
],
1014 info
->idle_stats
.recv_idle
= jiffies
;
1015 tty_schedule_flip(tty
);
1018 cy_writel(&buf_ctrl
->rx_get
, new_rx_get
);
1022 static void cyz_handle_tx(struct cyclades_port
*info
, struct tty_struct
*tty
)
1024 struct BUF_CTRL __iomem
*buf_ctrl
= info
->u
.cyz
.buf_ctrl
;
1025 struct cyclades_card
*cinfo
= info
->card
;
1027 unsigned int char_count
;
1031 __u32 tx_put
, tx_get
, tx_bufsize
, tx_bufaddr
;
1033 if (info
->xmit_cnt
<= 0) /* Nothing to transmit */
1036 tx_get
= readl(&buf_ctrl
->tx_get
);
1037 tx_put
= readl(&buf_ctrl
->tx_put
);
1038 tx_bufsize
= readl(&buf_ctrl
->tx_bufsize
);
1039 tx_bufaddr
= readl(&buf_ctrl
->tx_bufaddr
);
1040 if (tx_put
>= tx_get
)
1041 char_count
= tx_get
- tx_put
- 1 + tx_bufsize
;
1043 char_count
= tx_get
- tx_put
- 1;
1050 if (info
->x_char
) { /* send special char */
1051 data
= info
->x_char
;
1053 cy_writeb(cinfo
->base_addr
+ tx_bufaddr
+ tx_put
, data
);
1054 tx_put
= (tx_put
+ 1) & (tx_bufsize
- 1);
1060 while (0 < (small_count
= min_t(unsigned int,
1061 tx_bufsize
- tx_put
, min_t(unsigned int,
1062 (SERIAL_XMIT_SIZE
- info
->xmit_tail
),
1063 min_t(unsigned int, info
->xmit_cnt
,
1066 memcpy_toio((char *)(cinfo
->base_addr
+ tx_bufaddr
+
1068 &info
->port
.xmit_buf
[info
->xmit_tail
],
1071 tx_put
= (tx_put
+ small_count
) & (tx_bufsize
- 1);
1072 char_count
-= small_count
;
1073 info
->icount
.tx
+= small_count
;
1074 info
->xmit_cnt
-= small_count
;
1075 info
->xmit_tail
= (info
->xmit_tail
+ small_count
) &
1076 (SERIAL_XMIT_SIZE
- 1);
1079 while (info
->xmit_cnt
&& char_count
) {
1080 data
= info
->port
.xmit_buf
[info
->xmit_tail
];
1082 info
->xmit_tail
= (info
->xmit_tail
+ 1) &
1083 (SERIAL_XMIT_SIZE
- 1);
1085 cy_writeb(cinfo
->base_addr
+ tx_bufaddr
+ tx_put
, data
);
1086 tx_put
= (tx_put
+ 1) & (tx_bufsize
- 1);
1094 cy_writel(&buf_ctrl
->tx_put
, tx_put
);
1098 static void cyz_handle_cmd(struct cyclades_card
*cinfo
)
1100 struct BOARD_CTRL __iomem
*board_ctrl
= cinfo
->board_ctrl
;
1101 struct tty_struct
*tty
;
1102 struct cyclades_port
*info
;
1103 __u32 channel
, param
, fw_ver
;
1108 fw_ver
= readl(&board_ctrl
->fw_version
);
1110 while (cyz_fetch_msg(cinfo
, &channel
, &cmd
, ¶m
) == 1) {
1113 info
= &cinfo
->ports
[channel
];
1114 tty
= tty_port_tty_get(&info
->port
);
1120 tty_insert_flip_char(tty
, 0, TTY_PARITY
);
1125 tty_insert_flip_char(tty
, 0, TTY_FRAME
);
1130 tty_insert_flip_char(tty
, 0, TTY_BREAK
);
1137 if (info
->port
.flags
& ASYNC_CHECK_CD
) {
1138 u32 dcd
= fw_ver
> 241 ? param
:
1139 readl(&info
->u
.cyz
.ch_ctrl
->rs_status
);
1141 wake_up_interruptible(&info
->port
.open_wait
);
1160 complete(&info
->shutdown_wait
);
1163 #ifdef CONFIG_CYZ_INTR
1167 /* Reception Interrupt */
1168 #ifdef CY_DEBUG_INTERRUPTS
1169 printk(KERN_DEBUG
"cyz_interrupt: rcvd intr, card %d, "
1170 "port %ld\n", info
->card
, channel
);
1172 cyz_handle_rx(info
, tty
);
1177 /* Transmission Interrupt */
1178 #ifdef CY_DEBUG_INTERRUPTS
1179 printk(KERN_DEBUG
"cyz_interrupt: xmit intr, card %d, "
1180 "port %ld\n", info
->card
, channel
);
1182 cyz_handle_tx(info
, tty
);
1184 #endif /* CONFIG_CYZ_INTR */
1186 /* should do something with this !!! */
1192 wake_up_interruptible(&info
->port
.delta_msr_wait
);
1194 tty_schedule_flip(tty
);
1199 #ifdef CONFIG_CYZ_INTR
1200 static irqreturn_t
cyz_interrupt(int irq
, void *dev_id
)
1202 struct cyclades_card
*cinfo
= dev_id
;
1204 if (unlikely(!cyz_is_loaded(cinfo
))) {
1205 #ifdef CY_DEBUG_INTERRUPTS
1206 printk(KERN_DEBUG
"cyz_interrupt: board not yet loaded "
1212 /* Handle the interrupts */
1213 cyz_handle_cmd(cinfo
);
1216 } /* cyz_interrupt */
1218 static void cyz_rx_restart(unsigned long arg
)
1220 struct cyclades_port
*info
= (struct cyclades_port
*)arg
;
1221 struct cyclades_card
*card
= info
->card
;
1223 __u32 channel
= info
->line
- card
->first_line
;
1224 unsigned long flags
;
1226 spin_lock_irqsave(&card
->card_lock
, flags
);
1227 retval
= cyz_issue_cmd(card
, channel
, C_CM_INTBACK2
, 0L);
1229 printk(KERN_ERR
"cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1230 info
->line
, retval
);
1232 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1235 #else /* CONFIG_CYZ_INTR */
1237 static void cyz_poll(unsigned long arg
)
1239 struct cyclades_card
*cinfo
;
1240 struct cyclades_port
*info
;
1241 unsigned long expires
= jiffies
+ HZ
;
1242 unsigned int port
, card
;
1244 for (card
= 0; card
< NR_CARDS
; card
++) {
1245 cinfo
= &cy_card
[card
];
1247 if (!cy_is_Z(cinfo
))
1249 if (!cyz_is_loaded(cinfo
))
1252 /* Skip first polling cycle to avoid racing conditions with the FW */
1253 if (!cinfo
->intr_enabled
) {
1254 cinfo
->intr_enabled
= 1;
1258 cyz_handle_cmd(cinfo
);
1260 for (port
= 0; port
< cinfo
->nports
; port
++) {
1261 struct tty_struct
*tty
;
1263 info
= &cinfo
->ports
[port
];
1264 tty
= tty_port_tty_get(&info
->port
);
1265 /* OK to pass NULL to the handle functions below.
1266 They need to drop the data in that case. */
1268 if (!info
->throttle
)
1269 cyz_handle_rx(info
, tty
);
1270 cyz_handle_tx(info
, tty
);
1273 /* poll every 'cyz_polling_cycle' period */
1274 expires
= jiffies
+ cyz_polling_cycle
;
1276 mod_timer(&cyz_timerlist
, expires
);
1279 #endif /* CONFIG_CYZ_INTR */
1281 /********** End of block of Cyclades-Z specific code *********/
1282 /***********************************************************/
1284 /* This is called whenever a port becomes active;
1285 interrupts are enabled and DTR & RTS are turned on.
1287 static int cy_startup(struct cyclades_port
*info
, struct tty_struct
*tty
)
1289 struct cyclades_card
*card
;
1290 unsigned long flags
;
1296 channel
= info
->line
- card
->first_line
;
1298 page
= get_zeroed_page(GFP_KERNEL
);
1302 spin_lock_irqsave(&card
->card_lock
, flags
);
1304 if (info
->port
.flags
& ASYNC_INITIALIZED
)
1308 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1312 if (info
->port
.xmit_buf
)
1315 info
->port
.xmit_buf
= (unsigned char *)page
;
1317 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1319 cy_set_line_char(info
, tty
);
1321 if (!cy_is_Z(card
)) {
1324 spin_lock_irqsave(&card
->card_lock
, flags
);
1326 cyy_writeb(info
, CyCAR
, channel
);
1328 cyy_writeb(info
, CyRTPR
,
1329 (info
->default_timeout
? info
->default_timeout
: 0x02));
1330 /* 10ms rx timeout */
1332 cyy_issue_cmd(info
, CyCHAN_CTL
| CyENB_RCVR
| CyENB_XMTR
);
1334 cyy_change_rts_dtr(info
, TIOCM_RTS
| TIOCM_DTR
, 0);
1336 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) | CyRxData
);
1338 struct CH_CTRL __iomem
*ch_ctrl
= info
->u
.cyz
.ch_ctrl
;
1340 if (!cyz_is_loaded(card
))
1343 #ifdef CY_DEBUG_OPEN
1344 printk(KERN_DEBUG
"cyc startup Z card %d, channel %d, "
1345 "base_addr %p\n", card
, channel
, card
->base_addr
);
1347 spin_lock_irqsave(&card
->card_lock
, flags
);
1349 cy_writel(&ch_ctrl
->op_mode
, C_CH_ENABLE
);
1351 #ifdef CONFIG_CYZ_INTR
1352 cy_writel(&ch_ctrl
->intr_enable
,
1353 C_IN_TXBEMPTY
| C_IN_TXLOWWM
| C_IN_RXHIWM
|
1354 C_IN_RXNNDT
| C_IN_IOCTLW
| C_IN_MDCD
);
1356 cy_writel(&ch_ctrl
->intr_enable
,
1357 C_IN_IOCTLW
| C_IN_MDCD
);
1358 #endif /* CONFIG_CYZ_INTR */
1360 #ifdef CONFIG_CYZ_INTR
1361 cy_writel(&ch_ctrl
->intr_enable
,
1362 C_IN_TXBEMPTY
| C_IN_TXLOWWM
| C_IN_RXHIWM
|
1363 C_IN_RXNNDT
| C_IN_MDCD
);
1365 cy_writel(&ch_ctrl
->intr_enable
, C_IN_MDCD
);
1366 #endif /* CONFIG_CYZ_INTR */
1369 retval
= cyz_issue_cmd(card
, channel
, C_CM_IOCTL
, 0L);
1371 printk(KERN_ERR
"cyc:startup(1) retval on ttyC%d was "
1372 "%x\n", info
->line
, retval
);
1375 /* Flush RX buffers before raising DTR and RTS */
1376 retval
= cyz_issue_cmd(card
, channel
, C_CM_FLUSH_RX
, 0L);
1378 printk(KERN_ERR
"cyc:startup(2) retval on ttyC%d was "
1379 "%x\n", info
->line
, retval
);
1382 /* set timeout !!! */
1383 /* set RTS and DTR !!! */
1384 tty_port_raise_dtr_rts(&info
->port
);
1386 /* enable send, recv, modem !!! */
1389 info
->port
.flags
|= ASYNC_INITIALIZED
;
1391 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
1392 info
->xmit_cnt
= info
->xmit_head
= info
->xmit_tail
= 0;
1393 info
->breakon
= info
->breakoff
= 0;
1394 memset((char *)&info
->idle_stats
, 0, sizeof(info
->idle_stats
));
1395 info
->idle_stats
.in_use
=
1396 info
->idle_stats
.recv_idle
=
1397 info
->idle_stats
.xmit_idle
= jiffies
;
1399 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1401 #ifdef CY_DEBUG_OPEN
1402 printk(KERN_DEBUG
"cyc startup done\n");
1407 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1412 static void start_xmit(struct cyclades_port
*info
)
1414 struct cyclades_card
*card
= info
->card
;
1415 unsigned long flags
;
1416 int channel
= info
->line
- card
->first_line
;
1418 if (!cy_is_Z(card
)) {
1419 spin_lock_irqsave(&card
->card_lock
, flags
);
1420 cyy_writeb(info
, CyCAR
, channel
& 0x03);
1421 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) | CyTxRdy
);
1422 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1424 #ifdef CONFIG_CYZ_INTR
1427 spin_lock_irqsave(&card
->card_lock
, flags
);
1428 retval
= cyz_issue_cmd(card
, channel
, C_CM_INTBACK
, 0L);
1430 printk(KERN_ERR
"cyc:start_xmit retval on ttyC%d was "
1431 "%x\n", info
->line
, retval
);
1433 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1434 #else /* CONFIG_CYZ_INTR */
1435 /* Don't have to do anything at this time */
1436 #endif /* CONFIG_CYZ_INTR */
1441 * This routine shuts down a serial port; interrupts are disabled,
1442 * and DTR is dropped if the hangup on close termio flag is on.
1444 static void cy_shutdown(struct cyclades_port
*info
, struct tty_struct
*tty
)
1446 struct cyclades_card
*card
;
1447 unsigned long flags
;
1449 if (!(info
->port
.flags
& ASYNC_INITIALIZED
))
1453 if (!cy_is_Z(card
)) {
1454 spin_lock_irqsave(&card
->card_lock
, flags
);
1456 /* Clear delta_msr_wait queue to avoid mem leaks. */
1457 wake_up_interruptible(&info
->port
.delta_msr_wait
);
1459 if (info
->port
.xmit_buf
) {
1460 unsigned char *temp
;
1461 temp
= info
->port
.xmit_buf
;
1462 info
->port
.xmit_buf
= NULL
;
1463 free_page((unsigned long)temp
);
1465 if (tty
->termios
.c_cflag
& HUPCL
)
1466 cyy_change_rts_dtr(info
, 0, TIOCM_RTS
| TIOCM_DTR
);
1468 cyy_issue_cmd(info
, CyCHAN_CTL
| CyDIS_RCVR
);
1469 /* it may be appropriate to clear _XMIT at
1470 some later date (after testing)!!! */
1472 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1473 info
->port
.flags
&= ~ASYNC_INITIALIZED
;
1474 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1476 #ifdef CY_DEBUG_OPEN
1477 int channel
= info
->line
- card
->first_line
;
1478 printk(KERN_DEBUG
"cyc shutdown Z card %d, channel %d, "
1479 "base_addr %p\n", card
, channel
, card
->base_addr
);
1482 if (!cyz_is_loaded(card
))
1485 spin_lock_irqsave(&card
->card_lock
, flags
);
1487 if (info
->port
.xmit_buf
) {
1488 unsigned char *temp
;
1489 temp
= info
->port
.xmit_buf
;
1490 info
->port
.xmit_buf
= NULL
;
1491 free_page((unsigned long)temp
);
1494 if (tty
->termios
.c_cflag
& HUPCL
)
1495 tty_port_lower_dtr_rts(&info
->port
);
1497 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1498 info
->port
.flags
&= ~ASYNC_INITIALIZED
;
1500 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1503 #ifdef CY_DEBUG_OPEN
1504 printk(KERN_DEBUG
"cyc shutdown done\n");
1509 * ------------------------------------------------------------
1510 * cy_open() and friends
1511 * ------------------------------------------------------------
1515 * This routine is called whenever a serial port is opened. It
1516 * performs the serial-specific initialization for the tty structure.
1518 static int cy_open(struct tty_struct
*tty
, struct file
*filp
)
1520 struct cyclades_port
*info
;
1521 unsigned int i
, line
= tty
->index
;
1524 for (i
= 0; i
< NR_CARDS
; i
++)
1525 if (line
< cy_card
[i
].first_line
+ cy_card
[i
].nports
&&
1526 line
>= cy_card
[i
].first_line
)
1530 info
= &cy_card
[i
].ports
[line
- cy_card
[i
].first_line
];
1534 /* If the card's firmware hasn't been loaded,
1535 treat it as absent from the system. This
1536 will make the user pay attention.
1538 if (cy_is_Z(info
->card
)) {
1539 struct cyclades_card
*cinfo
= info
->card
;
1540 struct FIRM_ID __iomem
*firm_id
= cinfo
->base_addr
+ ID_ADDRESS
;
1542 if (!cyz_is_loaded(cinfo
)) {
1543 if (cinfo
->hw_ver
== ZE_V1
&& cyz_fpga_loaded(cinfo
) &&
1544 readl(&firm_id
->signature
) ==
1546 printk(KERN_ERR
"cyc:Cyclades-Z Error: you "
1547 "need an external power supply for "
1548 "this number of ports.\nFirmware "
1551 printk(KERN_ERR
"cyc:Cyclades-Z firmware not "
1556 #ifdef CONFIG_CYZ_INTR
1558 /* In case this Z board is operating in interrupt mode, its
1559 interrupts should be enabled as soon as the first open
1560 happens to one of its ports. */
1561 if (!cinfo
->intr_enabled
) {
1564 /* Enable interrupts on the PLX chip */
1565 intr
= readw(&cinfo
->ctl_addr
.p9060
->
1566 intr_ctrl_stat
) | 0x0900;
1567 cy_writew(&cinfo
->ctl_addr
.p9060
->
1568 intr_ctrl_stat
, intr
);
1569 /* Enable interrupts on the FW */
1570 retval
= cyz_issue_cmd(cinfo
, 0,
1573 printk(KERN_ERR
"cyc:IRQ enable retval "
1574 "was %x\n", retval
);
1576 cinfo
->intr_enabled
= 1;
1579 #endif /* CONFIG_CYZ_INTR */
1580 /* Make sure this Z port really exists in hardware */
1581 if (info
->line
> (cinfo
->first_line
+ cinfo
->nports
- 1))
1584 #ifdef CY_DEBUG_OTHER
1585 printk(KERN_DEBUG
"cyc:cy_open ttyC%d\n", info
->line
);
1587 tty
->driver_data
= info
;
1588 if (serial_paranoia_check(info
, tty
->name
, "cy_open"))
1591 #ifdef CY_DEBUG_OPEN
1592 printk(KERN_DEBUG
"cyc:cy_open ttyC%d, count = %d\n", info
->line
,
1596 #ifdef CY_DEBUG_COUNT
1597 printk(KERN_DEBUG
"cyc:cy_open (%d): incrementing count to %d\n",
1598 current
->pid
, info
->port
.count
);
1602 * If the port is the middle of closing, bail out now
1604 if (tty_hung_up_p(filp
) || (info
->port
.flags
& ASYNC_CLOSING
)) {
1605 wait_event_interruptible_tty(tty
, info
->port
.close_wait
,
1606 !(info
->port
.flags
& ASYNC_CLOSING
));
1607 return (info
->port
.flags
& ASYNC_HUP_NOTIFY
) ? -EAGAIN
: -ERESTARTSYS
;
1611 * Start up serial port
1613 retval
= cy_startup(info
, tty
);
1617 retval
= tty_port_block_til_ready(&info
->port
, tty
, filp
);
1619 #ifdef CY_DEBUG_OPEN
1620 printk(KERN_DEBUG
"cyc:cy_open returning after block_til_ready "
1621 "with %d\n", retval
);
1627 tty_port_tty_set(&info
->port
, tty
);
1629 #ifdef CY_DEBUG_OPEN
1630 printk(KERN_DEBUG
"cyc:cy_open done\n");
1636 * cy_wait_until_sent() --- wait until the transmitter is empty
1638 static void cy_wait_until_sent(struct tty_struct
*tty
, int timeout
)
1640 struct cyclades_card
*card
;
1641 struct cyclades_port
*info
= tty
->driver_data
;
1642 unsigned long orig_jiffies
;
1645 if (serial_paranoia_check(info
, tty
->name
, "cy_wait_until_sent"))
1648 if (info
->xmit_fifo_size
== 0)
1649 return; /* Just in case.... */
1651 orig_jiffies
= jiffies
;
1653 * Set the check interval to be 1/5 of the estimated time to
1654 * send a single character, and make it at least 1. The check
1655 * interval should also be less than the timeout.
1657 * Note: we have to use pretty tight timings here to satisfy
1660 char_time
= (info
->timeout
- HZ
/ 50) / info
->xmit_fifo_size
;
1661 char_time
= char_time
/ 5;
1667 char_time
= min(char_time
, timeout
);
1669 * If the transmitter hasn't cleared in twice the approximate
1670 * amount of time to send the entire FIFO, it probably won't
1671 * ever clear. This assumes the UART isn't doing flow
1672 * control, which is currently the case. Hence, if it ever
1673 * takes longer than info->timeout, this is probably due to a
1674 * UART bug of some kind. So, we clamp the timeout parameter at
1677 if (!timeout
|| timeout
> 2 * info
->timeout
)
1678 timeout
= 2 * info
->timeout
;
1681 if (!cy_is_Z(card
)) {
1682 while (cyy_readb(info
, CySRER
) & CyTxRdy
) {
1683 if (msleep_interruptible(jiffies_to_msecs(char_time
)))
1685 if (timeout
&& time_after(jiffies
, orig_jiffies
+
1690 /* Run one more char cycle */
1691 msleep_interruptible(jiffies_to_msecs(char_time
* 5));
1694 static void cy_flush_buffer(struct tty_struct
*tty
)
1696 struct cyclades_port
*info
= tty
->driver_data
;
1697 struct cyclades_card
*card
;
1698 int channel
, retval
;
1699 unsigned long flags
;
1702 printk(KERN_DEBUG
"cyc:cy_flush_buffer ttyC%d\n", info
->line
);
1705 if (serial_paranoia_check(info
, tty
->name
, "cy_flush_buffer"))
1709 channel
= info
->line
- card
->first_line
;
1711 spin_lock_irqsave(&card
->card_lock
, flags
);
1712 info
->xmit_cnt
= info
->xmit_head
= info
->xmit_tail
= 0;
1713 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1715 if (cy_is_Z(card
)) { /* If it is a Z card, flush the on-board
1717 spin_lock_irqsave(&card
->card_lock
, flags
);
1718 retval
= cyz_issue_cmd(card
, channel
, C_CM_FLUSH_TX
, 0L);
1720 printk(KERN_ERR
"cyc: flush_buffer retval on ttyC%d "
1721 "was %x\n", info
->line
, retval
);
1723 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1726 } /* cy_flush_buffer */
1729 static void cy_do_close(struct tty_port
*port
)
1731 struct cyclades_port
*info
= container_of(port
, struct cyclades_port
,
1733 struct cyclades_card
*card
;
1734 unsigned long flags
;
1738 channel
= info
->line
- card
->first_line
;
1739 spin_lock_irqsave(&card
->card_lock
, flags
);
1741 if (!cy_is_Z(card
)) {
1742 /* Stop accepting input */
1743 cyy_writeb(info
, CyCAR
, channel
& 0x03);
1744 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) & ~CyRxData
);
1745 if (info
->port
.flags
& ASYNC_INITIALIZED
) {
1746 /* Waiting for on-board buffers to be empty before
1748 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1749 cy_wait_until_sent(port
->tty
, info
->timeout
);
1750 spin_lock_irqsave(&card
->card_lock
, flags
);
1754 /* Waiting for on-board buffers to be empty before closing
1756 struct CH_CTRL __iomem
*ch_ctrl
= info
->u
.cyz
.ch_ctrl
;
1759 if (readl(&ch_ctrl
->flow_status
) != C_FS_TXIDLE
) {
1760 retval
= cyz_issue_cmd(card
, channel
, C_CM_IOCTLW
, 0L);
1762 printk(KERN_DEBUG
"cyc:cy_close retval on "
1763 "ttyC%d was %x\n", info
->line
, retval
);
1765 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1766 wait_for_completion_interruptible(&info
->shutdown_wait
);
1767 spin_lock_irqsave(&card
->card_lock
, flags
);
1771 spin_unlock_irqrestore(&card
->card_lock
, flags
);
1772 cy_shutdown(info
, port
->tty
);
1776 * This routine is called when a particular tty device is closed.
1778 static void cy_close(struct tty_struct
*tty
, struct file
*filp
)
1780 struct cyclades_port
*info
= tty
->driver_data
;
1781 if (!info
|| serial_paranoia_check(info
, tty
->name
, "cy_close"))
1783 tty_port_close(&info
->port
, tty
, filp
);
1786 /* This routine gets called when tty_write has put something into
1787 * the write_queue. The characters may come from user space or
1790 * This routine will return the number of characters actually
1791 * accepted for writing.
1793 * If the port is not already transmitting stuff, start it off by
1794 * enabling interrupts. The interrupt service routine will then
1795 * ensure that the characters are sent.
1796 * If the port is already active, there is no need to kick it.
1799 static int cy_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
1801 struct cyclades_port
*info
= tty
->driver_data
;
1802 unsigned long flags
;
1806 printk(KERN_DEBUG
"cyc:cy_write ttyC%d\n", info
->line
);
1809 if (serial_paranoia_check(info
, tty
->name
, "cy_write"))
1812 if (!info
->port
.xmit_buf
)
1815 spin_lock_irqsave(&info
->card
->card_lock
, flags
);
1817 c
= min(count
, (int)(SERIAL_XMIT_SIZE
- info
->xmit_cnt
- 1));
1818 c
= min(c
, (int)(SERIAL_XMIT_SIZE
- info
->xmit_head
));
1823 memcpy(info
->port
.xmit_buf
+ info
->xmit_head
, buf
, c
);
1824 info
->xmit_head
= (info
->xmit_head
+ c
) &
1825 (SERIAL_XMIT_SIZE
- 1);
1826 info
->xmit_cnt
+= c
;
1831 spin_unlock_irqrestore(&info
->card
->card_lock
, flags
);
1833 info
->idle_stats
.xmit_bytes
+= ret
;
1834 info
->idle_stats
.xmit_idle
= jiffies
;
1836 if (info
->xmit_cnt
&& !tty
->stopped
&& !tty
->hw_stopped
)
1843 * This routine is called by the kernel to write a single
1844 * character to the tty device. If the kernel uses this routine,
1845 * it must call the flush_chars() routine (if defined) when it is
1846 * done stuffing characters into the driver. If there is no room
1847 * in the queue, the character is ignored.
1849 static int cy_put_char(struct tty_struct
*tty
, unsigned char ch
)
1851 struct cyclades_port
*info
= tty
->driver_data
;
1852 unsigned long flags
;
1855 printk(KERN_DEBUG
"cyc:cy_put_char ttyC%d\n", info
->line
);
1858 if (serial_paranoia_check(info
, tty
->name
, "cy_put_char"))
1861 if (!info
->port
.xmit_buf
)
1864 spin_lock_irqsave(&info
->card
->card_lock
, flags
);
1865 if (info
->xmit_cnt
>= (int)(SERIAL_XMIT_SIZE
- 1)) {
1866 spin_unlock_irqrestore(&info
->card
->card_lock
, flags
);
1870 info
->port
.xmit_buf
[info
->xmit_head
++] = ch
;
1871 info
->xmit_head
&= SERIAL_XMIT_SIZE
- 1;
1873 info
->idle_stats
.xmit_bytes
++;
1874 info
->idle_stats
.xmit_idle
= jiffies
;
1875 spin_unlock_irqrestore(&info
->card
->card_lock
, flags
);
1880 * This routine is called by the kernel after it has written a
1881 * series of characters to the tty device using put_char().
1883 static void cy_flush_chars(struct tty_struct
*tty
)
1885 struct cyclades_port
*info
= tty
->driver_data
;
1888 printk(KERN_DEBUG
"cyc:cy_flush_chars ttyC%d\n", info
->line
);
1891 if (serial_paranoia_check(info
, tty
->name
, "cy_flush_chars"))
1894 if (info
->xmit_cnt
<= 0 || tty
->stopped
|| tty
->hw_stopped
||
1895 !info
->port
.xmit_buf
)
1899 } /* cy_flush_chars */
1902 * This routine returns the numbers of characters the tty driver
1903 * will accept for queuing to be written. This number is subject
1904 * to change as output buffers get emptied, or if the output flow
1905 * control is activated.
1907 static int cy_write_room(struct tty_struct
*tty
)
1909 struct cyclades_port
*info
= tty
->driver_data
;
1913 printk(KERN_DEBUG
"cyc:cy_write_room ttyC%d\n", info
->line
);
1916 if (serial_paranoia_check(info
, tty
->name
, "cy_write_room"))
1918 ret
= SERIAL_XMIT_SIZE
- info
->xmit_cnt
- 1;
1922 } /* cy_write_room */
1924 static int cy_chars_in_buffer(struct tty_struct
*tty
)
1926 struct cyclades_port
*info
= tty
->driver_data
;
1928 if (serial_paranoia_check(info
, tty
->name
, "cy_chars_in_buffer"))
1931 #ifdef Z_EXT_CHARS_IN_BUFFER
1932 if (!cy_is_Z(info
->card
)) {
1933 #endif /* Z_EXT_CHARS_IN_BUFFER */
1935 printk(KERN_DEBUG
"cyc:cy_chars_in_buffer ttyC%d %d\n",
1936 info
->line
, info
->xmit_cnt
);
1938 return info
->xmit_cnt
;
1939 #ifdef Z_EXT_CHARS_IN_BUFFER
1941 struct BUF_CTRL __iomem
*buf_ctrl
= info
->u
.cyz
.buf_ctrl
;
1943 __u32 tx_put
, tx_get
, tx_bufsize
;
1945 tx_get
= readl(&buf_ctrl
->tx_get
);
1946 tx_put
= readl(&buf_ctrl
->tx_put
);
1947 tx_bufsize
= readl(&buf_ctrl
->tx_bufsize
);
1948 if (tx_put
>= tx_get
)
1949 char_count
= tx_put
- tx_get
;
1951 char_count
= tx_put
- tx_get
+ tx_bufsize
;
1953 printk(KERN_DEBUG
"cyc:cy_chars_in_buffer ttyC%d %d\n",
1954 info
->line
, info
->xmit_cnt
+ char_count
);
1956 return info
->xmit_cnt
+ char_count
;
1958 #endif /* Z_EXT_CHARS_IN_BUFFER */
1959 } /* cy_chars_in_buffer */
1962 * ------------------------------------------------------------
1963 * cy_ioctl() and friends
1964 * ------------------------------------------------------------
1967 static void cyy_baud_calc(struct cyclades_port
*info
, __u32 baud
)
1969 int co
, co_val
, bpr
;
1970 __u32 cy_clock
= ((info
->chip_rev
>= CD1400_REV_J
) ? 60000000 :
1974 info
->tbpr
= info
->tco
= info
->rbpr
= info
->rco
= 0;
1978 /* determine which prescaler to use */
1979 for (co
= 4, co_val
= 2048; co
; co
--, co_val
>>= 2) {
1980 if (cy_clock
/ co_val
/ baud
> 63)
1984 bpr
= (cy_clock
/ co_val
* 2 / baud
+ 1) / 2;
1988 info
->tbpr
= info
->rbpr
= bpr
;
1989 info
->tco
= info
->rco
= co
;
1993 * This routine finds or computes the various line characteristics.
1994 * It used to be called config_setup
1996 static void cy_set_line_char(struct cyclades_port
*info
, struct tty_struct
*tty
)
1998 struct cyclades_card
*card
;
1999 unsigned long flags
;
2001 unsigned cflag
, iflag
;
2002 int baud
, baud_rate
= 0;
2005 if (info
->line
== -1)
2008 cflag
= tty
->termios
.c_cflag
;
2009 iflag
= tty
->termios
.c_iflag
;
2012 * Set up the tty->alt_speed kludge
2014 if ((info
->port
.flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
2015 tty
->alt_speed
= 57600;
2016 if ((info
->port
.flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
2017 tty
->alt_speed
= 115200;
2018 if ((info
->port
.flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
2019 tty
->alt_speed
= 230400;
2020 if ((info
->port
.flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
2021 tty
->alt_speed
= 460800;
2024 channel
= info
->line
- card
->first_line
;
2026 if (!cy_is_Z(card
)) {
2030 baud
= tty_get_baud_rate(tty
);
2031 if (baud
== 38400 && (info
->port
.flags
& ASYNC_SPD_MASK
) ==
2033 if (info
->custom_divisor
)
2034 baud_rate
= info
->baud
/ info
->custom_divisor
;
2036 baud_rate
= info
->baud
;
2037 } else if (baud
> CD1400_MAX_SPEED
) {
2038 baud
= CD1400_MAX_SPEED
;
2040 /* find the baud index */
2041 for (i
= 0; i
< 20; i
++) {
2042 if (baud
== baud_table
[i
])
2046 i
= 19; /* CD1400_MAX_SPEED */
2048 if (baud
== 38400 && (info
->port
.flags
& ASYNC_SPD_MASK
) ==
2050 cyy_baud_calc(info
, baud_rate
);
2052 if (info
->chip_rev
>= CD1400_REV_J
) {
2053 /* It is a CD1400 rev. J or later */
2054 info
->tbpr
= baud_bpr_60
[i
]; /* Tx BPR */
2055 info
->tco
= baud_co_60
[i
]; /* Tx CO */
2056 info
->rbpr
= baud_bpr_60
[i
]; /* Rx BPR */
2057 info
->rco
= baud_co_60
[i
]; /* Rx CO */
2059 info
->tbpr
= baud_bpr_25
[i
]; /* Tx BPR */
2060 info
->tco
= baud_co_25
[i
]; /* Tx CO */
2061 info
->rbpr
= baud_bpr_25
[i
]; /* Rx BPR */
2062 info
->rco
= baud_co_25
[i
]; /* Rx CO */
2065 if (baud_table
[i
] == 134) {
2066 /* get it right for 134.5 baud */
2067 info
->timeout
= (info
->xmit_fifo_size
* HZ
* 30 / 269) +
2069 } else if (baud
== 38400 && (info
->port
.flags
& ASYNC_SPD_MASK
) ==
2071 info
->timeout
= (info
->xmit_fifo_size
* HZ
* 15 /
2073 } else if (baud_table
[i
]) {
2074 info
->timeout
= (info
->xmit_fifo_size
* HZ
* 15 /
2076 /* this needs to be propagated into the card info */
2080 /* By tradition (is it a standard?) a baud rate of zero
2081 implies the line should be/has been closed. A bit
2082 later in this routine such a test is performed. */
2084 /* byte size and parity */
2087 /* receive threshold */
2088 info
->cor3
= (info
->default_threshold
?
2089 info
->default_threshold
: baud_cor3
[i
]);
2091 switch (cflag
& CSIZE
) {
2093 info
->cor1
= Cy_5_BITS
;
2096 info
->cor1
= Cy_6_BITS
;
2099 info
->cor1
= Cy_7_BITS
;
2102 info
->cor1
= Cy_8_BITS
;
2106 info
->cor1
|= Cy_2_STOP
;
2108 if (cflag
& PARENB
) {
2110 info
->cor1
|= CyPARITY_O
;
2112 info
->cor1
|= CyPARITY_E
;
2114 info
->cor1
|= CyPARITY_NONE
;
2116 /* CTS flow control flag */
2117 if (cflag
& CRTSCTS
) {
2118 info
->port
.flags
|= ASYNC_CTS_FLOW
;
2119 info
->cor2
|= CyCtsAE
;
2121 info
->port
.flags
&= ~ASYNC_CTS_FLOW
;
2122 info
->cor2
&= ~CyCtsAE
;
2125 info
->port
.flags
&= ~ASYNC_CHECK_CD
;
2127 info
->port
.flags
|= ASYNC_CHECK_CD
;
2129 /***********************************************
2130 The hardware option, CyRtsAO, presents RTS when
2131 the chip has characters to send. Since most modems
2132 use RTS as reverse (inbound) flow control, this
2133 option is not used. If inbound flow control is
2134 necessary, DTR can be programmed to provide the
2135 appropriate signals for use with a non-standard
2136 cable. Contact Marcio Saito for details.
2137 ***********************************************/
2141 spin_lock_irqsave(&card
->card_lock
, flags
);
2142 cyy_writeb(info
, CyCAR
, channel
);
2144 /* tx and rx baud rate */
2146 cyy_writeb(info
, CyTCOR
, info
->tco
);
2147 cyy_writeb(info
, CyTBPR
, info
->tbpr
);
2148 cyy_writeb(info
, CyRCOR
, info
->rco
);
2149 cyy_writeb(info
, CyRBPR
, info
->rbpr
);
2151 /* set line characteristics according configuration */
2153 cyy_writeb(info
, CySCHR1
, START_CHAR(tty
));
2154 cyy_writeb(info
, CySCHR2
, STOP_CHAR(tty
));
2155 cyy_writeb(info
, CyCOR1
, info
->cor1
);
2156 cyy_writeb(info
, CyCOR2
, info
->cor2
);
2157 cyy_writeb(info
, CyCOR3
, info
->cor3
);
2158 cyy_writeb(info
, CyCOR4
, info
->cor4
);
2159 cyy_writeb(info
, CyCOR5
, info
->cor5
);
2161 cyy_issue_cmd(info
, CyCOR_CHANGE
| CyCOR1ch
| CyCOR2ch
|
2164 /* !!! Is this needed? */
2165 cyy_writeb(info
, CyCAR
, channel
);
2166 cyy_writeb(info
, CyRTPR
,
2167 (info
->default_timeout
? info
->default_timeout
: 0x02));
2168 /* 10ms rx timeout */
2172 cflags
|= CyDSR
| CyRI
| CyDCD
;
2173 /* without modem intr */
2174 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) | CyMdmCh
);
2175 /* act on 1->0 modem transitions */
2176 if ((cflag
& CRTSCTS
) && info
->rflow
)
2177 cyy_writeb(info
, CyMCOR1
, cflags
| rflow_thr
[i
]);
2179 cyy_writeb(info
, CyMCOR1
, cflags
);
2180 /* act on 0->1 modem transitions */
2181 cyy_writeb(info
, CyMCOR2
, cflags
);
2183 if (i
== 0) /* baud rate is zero, turn off line */
2184 cyy_change_rts_dtr(info
, 0, TIOCM_DTR
);
2186 cyy_change_rts_dtr(info
, TIOCM_DTR
, 0);
2188 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
2189 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2192 struct CH_CTRL __iomem
*ch_ctrl
= info
->u
.cyz
.ch_ctrl
;
2196 if (!cyz_is_loaded(card
))
2200 baud
= tty_get_baud_rate(tty
);
2201 if (baud
== 38400 && (info
->port
.flags
& ASYNC_SPD_MASK
) ==
2203 if (info
->custom_divisor
)
2204 baud_rate
= info
->baud
/ info
->custom_divisor
;
2206 baud_rate
= info
->baud
;
2207 } else if (baud
> CYZ_MAX_SPEED
) {
2208 baud
= CYZ_MAX_SPEED
;
2210 cy_writel(&ch_ctrl
->comm_baud
, baud
);
2213 /* get it right for 134.5 baud */
2214 info
->timeout
= (info
->xmit_fifo_size
* HZ
* 30 / 269) +
2216 } else if (baud
== 38400 && (info
->port
.flags
& ASYNC_SPD_MASK
) ==
2218 info
->timeout
= (info
->xmit_fifo_size
* HZ
* 15 /
2221 info
->timeout
= (info
->xmit_fifo_size
* HZ
* 15 /
2223 /* this needs to be propagated into the card info */
2228 /* byte size and parity */
2229 switch (cflag
& CSIZE
) {
2231 cy_writel(&ch_ctrl
->comm_data_l
, C_DL_CS5
);
2234 cy_writel(&ch_ctrl
->comm_data_l
, C_DL_CS6
);
2237 cy_writel(&ch_ctrl
->comm_data_l
, C_DL_CS7
);
2240 cy_writel(&ch_ctrl
->comm_data_l
, C_DL_CS8
);
2243 if (cflag
& CSTOPB
) {
2244 cy_writel(&ch_ctrl
->comm_data_l
,
2245 readl(&ch_ctrl
->comm_data_l
) | C_DL_2STOP
);
2247 cy_writel(&ch_ctrl
->comm_data_l
,
2248 readl(&ch_ctrl
->comm_data_l
) | C_DL_1STOP
);
2250 if (cflag
& PARENB
) {
2252 cy_writel(&ch_ctrl
->comm_parity
, C_PR_ODD
);
2254 cy_writel(&ch_ctrl
->comm_parity
, C_PR_EVEN
);
2256 cy_writel(&ch_ctrl
->comm_parity
, C_PR_NONE
);
2258 /* CTS flow control flag */
2259 if (cflag
& CRTSCTS
) {
2260 cy_writel(&ch_ctrl
->hw_flow
,
2261 readl(&ch_ctrl
->hw_flow
) | C_RS_CTS
| C_RS_RTS
);
2263 cy_writel(&ch_ctrl
->hw_flow
, readl(&ch_ctrl
->hw_flow
) &
2264 ~(C_RS_CTS
| C_RS_RTS
));
2266 /* As the HW flow control is done in firmware, the driver
2267 doesn't need to care about it */
2268 info
->port
.flags
&= ~ASYNC_CTS_FLOW
;
2270 /* XON/XOFF/XANY flow control flags */
2273 sw_flow
|= C_FL_OXX
;
2275 sw_flow
|= C_FL_OIXANY
;
2277 cy_writel(&ch_ctrl
->sw_flow
, sw_flow
);
2279 retval
= cyz_issue_cmd(card
, channel
, C_CM_IOCTL
, 0L);
2281 printk(KERN_ERR
"cyc:set_line_char retval on ttyC%d "
2282 "was %x\n", info
->line
, retval
);
2285 /* CD sensitivity */
2287 info
->port
.flags
&= ~ASYNC_CHECK_CD
;
2289 info
->port
.flags
|= ASYNC_CHECK_CD
;
2291 if (baud
== 0) { /* baud rate is zero, turn off line */
2292 cy_writel(&ch_ctrl
->rs_control
,
2293 readl(&ch_ctrl
->rs_control
) & ~C_RS_DTR
);
2295 printk(KERN_DEBUG
"cyc:set_line_char dropping Z DTR\n");
2298 cy_writel(&ch_ctrl
->rs_control
,
2299 readl(&ch_ctrl
->rs_control
) | C_RS_DTR
);
2301 printk(KERN_DEBUG
"cyc:set_line_char raising Z DTR\n");
2305 retval
= cyz_issue_cmd(card
, channel
, C_CM_IOCTLM
, 0L);
2307 printk(KERN_ERR
"cyc:set_line_char(2) retval on ttyC%d "
2308 "was %x\n", info
->line
, retval
);
2311 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
2313 } /* set_line_char */
2315 static int cy_get_serial_info(struct cyclades_port
*info
,
2316 struct serial_struct __user
*retinfo
)
2318 struct cyclades_card
*cinfo
= info
->card
;
2319 struct serial_struct tmp
= {
2322 .port
= (info
->card
- cy_card
) * 0x100 + info
->line
-
2325 .flags
= info
->port
.flags
,
2326 .close_delay
= info
->port
.close_delay
,
2327 .closing_wait
= info
->port
.closing_wait
,
2328 .baud_base
= info
->baud
,
2329 .custom_divisor
= info
->custom_divisor
,
2332 return copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)) ? -EFAULT
: 0;
2336 cy_set_serial_info(struct cyclades_port
*info
, struct tty_struct
*tty
,
2337 struct serial_struct __user
*new_info
)
2339 struct serial_struct new_serial
;
2342 if (copy_from_user(&new_serial
, new_info
, sizeof(new_serial
)))
2345 mutex_lock(&info
->port
.mutex
);
2346 if (!capable(CAP_SYS_ADMIN
)) {
2347 if (new_serial
.close_delay
!= info
->port
.close_delay
||
2348 new_serial
.baud_base
!= info
->baud
||
2349 (new_serial
.flags
& ASYNC_FLAGS
&
2351 (info
->port
.flags
& ASYNC_FLAGS
& ~ASYNC_USR_MASK
))
2353 mutex_unlock(&info
->port
.mutex
);
2356 info
->port
.flags
= (info
->port
.flags
& ~ASYNC_USR_MASK
) |
2357 (new_serial
.flags
& ASYNC_USR_MASK
);
2358 info
->baud
= new_serial
.baud_base
;
2359 info
->custom_divisor
= new_serial
.custom_divisor
;
2360 goto check_and_exit
;
2364 * OK, past this point, all the error checking has been done.
2365 * At this point, we start making changes.....
2368 info
->baud
= new_serial
.baud_base
;
2369 info
->custom_divisor
= new_serial
.custom_divisor
;
2370 info
->port
.flags
= (info
->port
.flags
& ~ASYNC_FLAGS
) |
2371 (new_serial
.flags
& ASYNC_FLAGS
);
2372 info
->port
.close_delay
= new_serial
.close_delay
* HZ
/ 100;
2373 info
->port
.closing_wait
= new_serial
.closing_wait
* HZ
/ 100;
2376 if (info
->port
.flags
& ASYNC_INITIALIZED
) {
2377 cy_set_line_char(info
, tty
);
2380 ret
= cy_startup(info
, tty
);
2382 mutex_unlock(&info
->port
.mutex
);
2384 } /* set_serial_info */
2387 * get_lsr_info - get line status register info
2389 * Purpose: Let user call ioctl() to get info when the UART physically
2390 * is emptied. On bus types like RS485, the transmitter must
2391 * release the bus after transmitting. This must be done when
2392 * the transmit shift register is empty, not be done when the
2393 * transmit holding register is empty. This functionality
2394 * allows an RS485 driver to be written in user space.
2396 static int get_lsr_info(struct cyclades_port
*info
, unsigned int __user
*value
)
2398 struct cyclades_card
*card
= info
->card
;
2399 unsigned int result
;
2400 unsigned long flags
;
2403 if (!cy_is_Z(card
)) {
2404 spin_lock_irqsave(&card
->card_lock
, flags
);
2405 status
= cyy_readb(info
, CySRER
) & (CyTxRdy
| CyTxMpty
);
2406 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2407 result
= (status
? 0 : TIOCSER_TEMT
);
2409 /* Not supported yet */
2412 return put_user(result
, value
);
2415 static int cy_tiocmget(struct tty_struct
*tty
)
2417 struct cyclades_port
*info
= tty
->driver_data
;
2418 struct cyclades_card
*card
;
2421 if (serial_paranoia_check(info
, tty
->name
, __func__
))
2426 if (!cy_is_Z(card
)) {
2427 unsigned long flags
;
2428 int channel
= info
->line
- card
->first_line
;
2431 spin_lock_irqsave(&card
->card_lock
, flags
);
2432 cyy_writeb(info
, CyCAR
, channel
& 0x03);
2433 status
= cyy_readb(info
, CyMSVR1
);
2434 status
|= cyy_readb(info
, CyMSVR2
);
2435 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2437 if (info
->rtsdtr_inv
) {
2438 result
= ((status
& CyRTS
) ? TIOCM_DTR
: 0) |
2439 ((status
& CyDTR
) ? TIOCM_RTS
: 0);
2441 result
= ((status
& CyRTS
) ? TIOCM_RTS
: 0) |
2442 ((status
& CyDTR
) ? TIOCM_DTR
: 0);
2444 result
|= ((status
& CyDCD
) ? TIOCM_CAR
: 0) |
2445 ((status
& CyRI
) ? TIOCM_RNG
: 0) |
2446 ((status
& CyDSR
) ? TIOCM_DSR
: 0) |
2447 ((status
& CyCTS
) ? TIOCM_CTS
: 0);
2451 if (!cyz_is_loaded(card
)) {
2456 lstatus
= readl(&info
->u
.cyz
.ch_ctrl
->rs_status
);
2457 result
= ((lstatus
& C_RS_RTS
) ? TIOCM_RTS
: 0) |
2458 ((lstatus
& C_RS_DTR
) ? TIOCM_DTR
: 0) |
2459 ((lstatus
& C_RS_DCD
) ? TIOCM_CAR
: 0) |
2460 ((lstatus
& C_RS_RI
) ? TIOCM_RNG
: 0) |
2461 ((lstatus
& C_RS_DSR
) ? TIOCM_DSR
: 0) |
2462 ((lstatus
& C_RS_CTS
) ? TIOCM_CTS
: 0);
2469 cy_tiocmset(struct tty_struct
*tty
,
2470 unsigned int set
, unsigned int clear
)
2472 struct cyclades_port
*info
= tty
->driver_data
;
2473 struct cyclades_card
*card
;
2474 unsigned long flags
;
2476 if (serial_paranoia_check(info
, tty
->name
, __func__
))
2480 if (!cy_is_Z(card
)) {
2481 spin_lock_irqsave(&card
->card_lock
, flags
);
2482 cyy_change_rts_dtr(info
, set
, clear
);
2483 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2485 struct CH_CTRL __iomem
*ch_ctrl
= info
->u
.cyz
.ch_ctrl
;
2486 int retval
, channel
= info
->line
- card
->first_line
;
2489 if (!cyz_is_loaded(card
))
2492 spin_lock_irqsave(&card
->card_lock
, flags
);
2493 rs
= readl(&ch_ctrl
->rs_control
);
2494 if (set
& TIOCM_RTS
)
2496 if (clear
& TIOCM_RTS
)
2498 if (set
& TIOCM_DTR
) {
2501 printk(KERN_DEBUG
"cyc:set_modem_info raising Z DTR\n");
2504 if (clear
& TIOCM_DTR
) {
2507 printk(KERN_DEBUG
"cyc:set_modem_info clearing "
2511 cy_writel(&ch_ctrl
->rs_control
, rs
);
2512 retval
= cyz_issue_cmd(card
, channel
, C_CM_IOCTLM
, 0L);
2513 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2515 printk(KERN_ERR
"cyc:set_modem_info retval on ttyC%d "
2516 "was %x\n", info
->line
, retval
);
2523 * cy_break() --- routine which turns the break handling on or off
2525 static int cy_break(struct tty_struct
*tty
, int break_state
)
2527 struct cyclades_port
*info
= tty
->driver_data
;
2528 struct cyclades_card
*card
;
2529 unsigned long flags
;
2532 if (serial_paranoia_check(info
, tty
->name
, "cy_break"))
2537 spin_lock_irqsave(&card
->card_lock
, flags
);
2538 if (!cy_is_Z(card
)) {
2539 /* Let the transmit ISR take care of this (since it
2540 requires stuffing characters into the output stream).
2542 if (break_state
== -1) {
2543 if (!info
->breakon
) {
2545 if (!info
->xmit_cnt
) {
2546 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2548 spin_lock_irqsave(&card
->card_lock
, flags
);
2552 if (!info
->breakoff
) {
2554 if (!info
->xmit_cnt
) {
2555 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2557 spin_lock_irqsave(&card
->card_lock
, flags
);
2562 if (break_state
== -1) {
2563 retval
= cyz_issue_cmd(card
,
2564 info
->line
- card
->first_line
,
2565 C_CM_SET_BREAK
, 0L);
2567 printk(KERN_ERR
"cyc:cy_break (set) retval on "
2568 "ttyC%d was %x\n", info
->line
, retval
);
2571 retval
= cyz_issue_cmd(card
,
2572 info
->line
- card
->first_line
,
2573 C_CM_CLR_BREAK
, 0L);
2575 printk(KERN_DEBUG
"cyc:cy_break (clr) retval "
2576 "on ttyC%d was %x\n", info
->line
,
2581 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2585 static int set_threshold(struct cyclades_port
*info
, unsigned long value
)
2587 struct cyclades_card
*card
= info
->card
;
2588 unsigned long flags
;
2590 if (!cy_is_Z(card
)) {
2591 info
->cor3
&= ~CyREC_FIFO
;
2592 info
->cor3
|= value
& CyREC_FIFO
;
2594 spin_lock_irqsave(&card
->card_lock
, flags
);
2595 cyy_writeb(info
, CyCOR3
, info
->cor3
);
2596 cyy_issue_cmd(info
, CyCOR_CHANGE
| CyCOR3ch
);
2597 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2600 } /* set_threshold */
2602 static int get_threshold(struct cyclades_port
*info
,
2603 unsigned long __user
*value
)
2605 struct cyclades_card
*card
= info
->card
;
2607 if (!cy_is_Z(card
)) {
2608 u8 tmp
= cyy_readb(info
, CyCOR3
) & CyREC_FIFO
;
2609 return put_user(tmp
, value
);
2612 } /* get_threshold */
2614 static int set_timeout(struct cyclades_port
*info
, unsigned long value
)
2616 struct cyclades_card
*card
= info
->card
;
2617 unsigned long flags
;
2619 if (!cy_is_Z(card
)) {
2620 spin_lock_irqsave(&card
->card_lock
, flags
);
2621 cyy_writeb(info
, CyRTPR
, value
& 0xff);
2622 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2627 static int get_timeout(struct cyclades_port
*info
,
2628 unsigned long __user
*value
)
2630 struct cyclades_card
*card
= info
->card
;
2632 if (!cy_is_Z(card
)) {
2633 u8 tmp
= cyy_readb(info
, CyRTPR
);
2634 return put_user(tmp
, value
);
2639 static int cy_cflags_changed(struct cyclades_port
*info
, unsigned long arg
,
2640 struct cyclades_icount
*cprev
)
2642 struct cyclades_icount cnow
;
2643 unsigned long flags
;
2646 spin_lock_irqsave(&info
->card
->card_lock
, flags
);
2647 cnow
= info
->icount
; /* atomic copy */
2648 spin_unlock_irqrestore(&info
->card
->card_lock
, flags
);
2650 ret
= ((arg
& TIOCM_RNG
) && (cnow
.rng
!= cprev
->rng
)) ||
2651 ((arg
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
->dsr
)) ||
2652 ((arg
& TIOCM_CD
) && (cnow
.dcd
!= cprev
->dcd
)) ||
2653 ((arg
& TIOCM_CTS
) && (cnow
.cts
!= cprev
->cts
));
2661 * This routine allows the tty driver to implement device-
2662 * specific ioctl's. If the ioctl number passed in cmd is
2663 * not recognized by the driver, it should return ENOIOCTLCMD.
2666 cy_ioctl(struct tty_struct
*tty
,
2667 unsigned int cmd
, unsigned long arg
)
2669 struct cyclades_port
*info
= tty
->driver_data
;
2670 struct cyclades_icount cnow
; /* kernel counter temps */
2672 unsigned long flags
;
2673 void __user
*argp
= (void __user
*)arg
;
2675 if (serial_paranoia_check(info
, tty
->name
, "cy_ioctl"))
2678 #ifdef CY_DEBUG_OTHER
2679 printk(KERN_DEBUG
"cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
2680 info
->line
, cmd
, arg
);
2685 if (copy_to_user(argp
, &info
->mon
, sizeof(info
->mon
))) {
2689 memset(&info
->mon
, 0, sizeof(info
->mon
));
2692 ret_val
= get_threshold(info
, argp
);
2695 ret_val
= set_threshold(info
, arg
);
2697 case CYGETDEFTHRESH
:
2698 ret_val
= put_user(info
->default_threshold
,
2699 (unsigned long __user
*)argp
);
2701 case CYSETDEFTHRESH
:
2702 info
->default_threshold
= arg
& 0x0f;
2705 ret_val
= get_timeout(info
, argp
);
2708 ret_val
= set_timeout(info
, arg
);
2710 case CYGETDEFTIMEOUT
:
2711 ret_val
= put_user(info
->default_timeout
,
2712 (unsigned long __user
*)argp
);
2714 case CYSETDEFTIMEOUT
:
2715 info
->default_timeout
= arg
& 0xff;
2718 info
->rflow
= (int)arg
;
2721 ret_val
= info
->rflow
;
2723 case CYSETRTSDTR_INV
:
2724 info
->rtsdtr_inv
= (int)arg
;
2726 case CYGETRTSDTR_INV
:
2727 ret_val
= info
->rtsdtr_inv
;
2729 case CYGETCD1400VER
:
2730 ret_val
= info
->chip_rev
;
2732 #ifndef CONFIG_CYZ_INTR
2733 case CYZSETPOLLCYCLE
:
2734 cyz_polling_cycle
= (arg
* HZ
) / 1000;
2736 case CYZGETPOLLCYCLE
:
2737 ret_val
= (cyz_polling_cycle
* 1000) / HZ
;
2739 #endif /* CONFIG_CYZ_INTR */
2741 info
->port
.closing_wait
= (unsigned short)arg
* HZ
/ 100;
2744 ret_val
= info
->port
.closing_wait
/ (HZ
/ 100);
2747 ret_val
= cy_get_serial_info(info
, argp
);
2750 ret_val
= cy_set_serial_info(info
, tty
, argp
);
2752 case TIOCSERGETLSR
: /* Get line status register */
2753 ret_val
= get_lsr_info(info
, argp
);
2756 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2757 * - mask passed in arg for lines of interest
2758 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2759 * Caller should use TIOCGICOUNT to see which one it was
2762 spin_lock_irqsave(&info
->card
->card_lock
, flags
);
2763 /* note the counters on entry */
2764 cnow
= info
->icount
;
2765 spin_unlock_irqrestore(&info
->card
->card_lock
, flags
);
2766 ret_val
= wait_event_interruptible(info
->port
.delta_msr_wait
,
2767 cy_cflags_changed(info
, arg
, &cnow
));
2771 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
2772 * Return: write counters to the user passed counter struct
2773 * NB: both 1->0 and 0->1 transitions are counted except for
2774 * RI where only 0->1 is counted.
2777 ret_val
= -ENOIOCTLCMD
;
2780 #ifdef CY_DEBUG_OTHER
2781 printk(KERN_DEBUG
"cyc:cy_ioctl done\n");
2786 static int cy_get_icount(struct tty_struct
*tty
,
2787 struct serial_icounter_struct
*sic
)
2789 struct cyclades_port
*info
= tty
->driver_data
;
2790 struct cyclades_icount cnow
; /* Used to snapshot */
2791 unsigned long flags
;
2793 spin_lock_irqsave(&info
->card
->card_lock
, flags
);
2794 cnow
= info
->icount
;
2795 spin_unlock_irqrestore(&info
->card
->card_lock
, flags
);
2797 sic
->cts
= cnow
.cts
;
2798 sic
->dsr
= cnow
.dsr
;
2799 sic
->rng
= cnow
.rng
;
2800 sic
->dcd
= cnow
.dcd
;
2803 sic
->frame
= cnow
.frame
;
2804 sic
->overrun
= cnow
.overrun
;
2805 sic
->parity
= cnow
.parity
;
2806 sic
->brk
= cnow
.brk
;
2807 sic
->buf_overrun
= cnow
.buf_overrun
;
2812 * This routine allows the tty driver to be notified when
2813 * device's termios settings have changed. Note that a
2814 * well-designed tty driver should be prepared to accept the case
2815 * where old == NULL, and try to do something rational.
2817 static void cy_set_termios(struct tty_struct
*tty
, struct ktermios
*old_termios
)
2819 struct cyclades_port
*info
= tty
->driver_data
;
2821 #ifdef CY_DEBUG_OTHER
2822 printk(KERN_DEBUG
"cyc:cy_set_termios ttyC%d\n", info
->line
);
2825 cy_set_line_char(info
, tty
);
2827 if ((old_termios
->c_cflag
& CRTSCTS
) &&
2828 !(tty
->termios
.c_cflag
& CRTSCTS
)) {
2829 tty
->hw_stopped
= 0;
2834 * No need to wake up processes in open wait, since they
2835 * sample the CLOCAL flag once, and don't recheck it.
2836 * XXX It's not clear whether the current behavior is correct
2837 * or not. Hence, this may change.....
2839 if (!(old_termios
->c_cflag
& CLOCAL
) &&
2840 (tty
->termios
.c_cflag
& CLOCAL
))
2841 wake_up_interruptible(&info
->port
.open_wait
);
2843 } /* cy_set_termios */
2845 /* This function is used to send a high-priority XON/XOFF character to
2848 static void cy_send_xchar(struct tty_struct
*tty
, char ch
)
2850 struct cyclades_port
*info
= tty
->driver_data
;
2851 struct cyclades_card
*card
;
2854 if (serial_paranoia_check(info
, tty
->name
, "cy_send_xchar"))
2863 channel
= info
->line
- card
->first_line
;
2865 if (cy_is_Z(card
)) {
2866 if (ch
== STOP_CHAR(tty
))
2867 cyz_issue_cmd(card
, channel
, C_CM_SENDXOFF
, 0L);
2868 else if (ch
== START_CHAR(tty
))
2869 cyz_issue_cmd(card
, channel
, C_CM_SENDXON
, 0L);
2873 /* This routine is called by the upper-layer tty layer to signal
2874 that incoming characters should be throttled because the input
2875 buffers are close to full.
2877 static void cy_throttle(struct tty_struct
*tty
)
2879 struct cyclades_port
*info
= tty
->driver_data
;
2880 struct cyclades_card
*card
;
2881 unsigned long flags
;
2883 #ifdef CY_DEBUG_THROTTLE
2886 printk(KERN_DEBUG
"cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty
, buf
),
2887 tty
->ldisc
.chars_in_buffer(tty
), info
->line
);
2890 if (serial_paranoia_check(info
, tty
->name
, "cy_throttle"))
2897 cy_send_xchar(tty
, STOP_CHAR(tty
));
2902 if (tty
->termios
.c_cflag
& CRTSCTS
) {
2903 if (!cy_is_Z(card
)) {
2904 spin_lock_irqsave(&card
->card_lock
, flags
);
2905 cyy_change_rts_dtr(info
, 0, TIOCM_RTS
);
2906 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2914 * This routine notifies the tty driver that it should signal
2915 * that characters can now be sent to the tty without fear of
2916 * overrunning the input buffers of the line disciplines.
2918 static void cy_unthrottle(struct tty_struct
*tty
)
2920 struct cyclades_port
*info
= tty
->driver_data
;
2921 struct cyclades_card
*card
;
2922 unsigned long flags
;
2924 #ifdef CY_DEBUG_THROTTLE
2927 printk(KERN_DEBUG
"cyc:unthrottle %s: %ld...ttyC%d\n",
2928 tty_name(tty
, buf
), tty_chars_in_buffer(tty
), info
->line
);
2931 if (serial_paranoia_check(info
, tty
->name
, "cy_unthrottle"))
2938 cy_send_xchar(tty
, START_CHAR(tty
));
2941 if (tty
->termios
.c_cflag
& CRTSCTS
) {
2943 if (!cy_is_Z(card
)) {
2944 spin_lock_irqsave(&card
->card_lock
, flags
);
2945 cyy_change_rts_dtr(info
, TIOCM_RTS
, 0);
2946 spin_unlock_irqrestore(&card
->card_lock
, flags
);
2951 } /* cy_unthrottle */
2953 /* cy_start and cy_stop provide software output flow control as a
2954 function of XON/XOFF, software CTS, and other such stuff.
2956 static void cy_stop(struct tty_struct
*tty
)
2958 struct cyclades_card
*cinfo
;
2959 struct cyclades_port
*info
= tty
->driver_data
;
2961 unsigned long flags
;
2963 #ifdef CY_DEBUG_OTHER
2964 printk(KERN_DEBUG
"cyc:cy_stop ttyC%d\n", info
->line
);
2967 if (serial_paranoia_check(info
, tty
->name
, "cy_stop"))
2971 channel
= info
->line
- cinfo
->first_line
;
2972 if (!cy_is_Z(cinfo
)) {
2973 spin_lock_irqsave(&cinfo
->card_lock
, flags
);
2974 cyy_writeb(info
, CyCAR
, channel
& 0x03);
2975 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) & ~CyTxRdy
);
2976 spin_unlock_irqrestore(&cinfo
->card_lock
, flags
);
2980 static void cy_start(struct tty_struct
*tty
)
2982 struct cyclades_card
*cinfo
;
2983 struct cyclades_port
*info
= tty
->driver_data
;
2985 unsigned long flags
;
2987 #ifdef CY_DEBUG_OTHER
2988 printk(KERN_DEBUG
"cyc:cy_start ttyC%d\n", info
->line
);
2991 if (serial_paranoia_check(info
, tty
->name
, "cy_start"))
2995 channel
= info
->line
- cinfo
->first_line
;
2996 if (!cy_is_Z(cinfo
)) {
2997 spin_lock_irqsave(&cinfo
->card_lock
, flags
);
2998 cyy_writeb(info
, CyCAR
, channel
& 0x03);
2999 cyy_writeb(info
, CySRER
, cyy_readb(info
, CySRER
) | CyTxRdy
);
3000 spin_unlock_irqrestore(&cinfo
->card_lock
, flags
);
3005 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
3007 static void cy_hangup(struct tty_struct
*tty
)
3009 struct cyclades_port
*info
= tty
->driver_data
;
3011 #ifdef CY_DEBUG_OTHER
3012 printk(KERN_DEBUG
"cyc:cy_hangup ttyC%d\n", info
->line
);
3015 if (serial_paranoia_check(info
, tty
->name
, "cy_hangup"))
3018 cy_flush_buffer(tty
);
3019 cy_shutdown(info
, tty
);
3020 tty_port_hangup(&info
->port
);
3023 static int cyy_carrier_raised(struct tty_port
*port
)
3025 struct cyclades_port
*info
= container_of(port
, struct cyclades_port
,
3027 struct cyclades_card
*cinfo
= info
->card
;
3028 unsigned long flags
;
3029 int channel
= info
->line
- cinfo
->first_line
;
3032 spin_lock_irqsave(&cinfo
->card_lock
, flags
);
3033 cyy_writeb(info
, CyCAR
, channel
& 0x03);
3034 cd
= cyy_readb(info
, CyMSVR1
) & CyDCD
;
3035 spin_unlock_irqrestore(&cinfo
->card_lock
, flags
);
3040 static void cyy_dtr_rts(struct tty_port
*port
, int raise
)
3042 struct cyclades_port
*info
= container_of(port
, struct cyclades_port
,
3044 struct cyclades_card
*cinfo
= info
->card
;
3045 unsigned long flags
;
3047 spin_lock_irqsave(&cinfo
->card_lock
, flags
);
3048 cyy_change_rts_dtr(info
, raise
? TIOCM_RTS
| TIOCM_DTR
: 0,
3049 raise
? 0 : TIOCM_RTS
| TIOCM_DTR
);
3050 spin_unlock_irqrestore(&cinfo
->card_lock
, flags
);
3053 static int cyz_carrier_raised(struct tty_port
*port
)
3055 struct cyclades_port
*info
= container_of(port
, struct cyclades_port
,
3058 return readl(&info
->u
.cyz
.ch_ctrl
->rs_status
) & C_RS_DCD
;
3061 static void cyz_dtr_rts(struct tty_port
*port
, int raise
)
3063 struct cyclades_port
*info
= container_of(port
, struct cyclades_port
,
3065 struct cyclades_card
*cinfo
= info
->card
;
3066 struct CH_CTRL __iomem
*ch_ctrl
= info
->u
.cyz
.ch_ctrl
;
3067 int ret
, channel
= info
->line
- cinfo
->first_line
;
3070 rs
= readl(&ch_ctrl
->rs_control
);
3072 rs
|= C_RS_RTS
| C_RS_DTR
;
3074 rs
&= ~(C_RS_RTS
| C_RS_DTR
);
3075 cy_writel(&ch_ctrl
->rs_control
, rs
);
3076 ret
= cyz_issue_cmd(cinfo
, channel
, C_CM_IOCTLM
, 0L);
3078 printk(KERN_ERR
"%s: retval on ttyC%d was %x\n",
3079 __func__
, info
->line
, ret
);
3081 printk(KERN_DEBUG
"%s: raising Z DTR\n", __func__
);
3085 static const struct tty_port_operations cyy_port_ops
= {
3086 .carrier_raised
= cyy_carrier_raised
,
3087 .dtr_rts
= cyy_dtr_rts
,
3088 .shutdown
= cy_do_close
,
3091 static const struct tty_port_operations cyz_port_ops
= {
3092 .carrier_raised
= cyz_carrier_raised
,
3093 .dtr_rts
= cyz_dtr_rts
,
3094 .shutdown
= cy_do_close
,
3098 * ---------------------------------------------------------------------
3099 * cy_init() and friends
3101 * cy_init() is called at boot-time to initialize the serial driver.
3102 * ---------------------------------------------------------------------
3105 static int cy_init_card(struct cyclades_card
*cinfo
)
3107 struct cyclades_port
*info
;
3108 unsigned int channel
, port
;
3110 spin_lock_init(&cinfo
->card_lock
);
3111 cinfo
->intr_enabled
= 0;
3113 cinfo
->ports
= kcalloc(cinfo
->nports
, sizeof(*cinfo
->ports
),
3115 if (cinfo
->ports
== NULL
) {
3116 printk(KERN_ERR
"Cyclades: cannot allocate ports\n");
3120 for (channel
= 0, port
= cinfo
->first_line
; channel
< cinfo
->nports
;
3121 channel
++, port
++) {
3122 info
= &cinfo
->ports
[channel
];
3123 tty_port_init(&info
->port
);
3124 info
->magic
= CYCLADES_MAGIC
;
3128 info
->port
.closing_wait
= CLOSING_WAIT_DELAY
;
3129 info
->port
.close_delay
= 5 * HZ
/ 10;
3130 info
->port
.flags
= STD_COM_FLAGS
;
3131 init_completion(&info
->shutdown_wait
);
3133 if (cy_is_Z(cinfo
)) {
3134 struct FIRM_ID
*firm_id
= cinfo
->base_addr
+ ID_ADDRESS
;
3135 struct ZFW_CTRL
*zfw_ctrl
;
3137 info
->port
.ops
= &cyz_port_ops
;
3138 info
->type
= PORT_STARTECH
;
3140 zfw_ctrl
= cinfo
->base_addr
+
3141 (readl(&firm_id
->zfwctrl_addr
) & 0xfffff);
3142 info
->u
.cyz
.ch_ctrl
= &zfw_ctrl
->ch_ctrl
[channel
];
3143 info
->u
.cyz
.buf_ctrl
= &zfw_ctrl
->buf_ctrl
[channel
];
3145 if (cinfo
->hw_ver
== ZO_V1
)
3146 info
->xmit_fifo_size
= CYZ_FIFO_SIZE
;
3148 info
->xmit_fifo_size
= 4 * CYZ_FIFO_SIZE
;
3149 #ifdef CONFIG_CYZ_INTR
3150 setup_timer(&cyz_rx_full_timer
[port
],
3151 cyz_rx_restart
, (unsigned long)info
);
3154 unsigned short chip_number
;
3155 int index
= cinfo
->bus_index
;
3157 info
->port
.ops
= &cyy_port_ops
;
3158 info
->type
= PORT_CIRRUS
;
3159 info
->xmit_fifo_size
= CyMAX_CHAR_FIFO
;
3160 info
->cor1
= CyPARITY_NONE
| Cy_1_STOP
| Cy_8_BITS
;
3162 info
->cor3
= 0x08; /* _very_ small rcv threshold */
3164 chip_number
= channel
/ CyPORTS_PER_CHIP
;
3165 info
->u
.cyy
.base_addr
= cinfo
->base_addr
+
3166 (cy_chip_offset
[chip_number
] << index
);
3167 info
->chip_rev
= cyy_readb(info
, CyGFRCR
);
3169 if (info
->chip_rev
>= CD1400_REV_J
) {
3170 /* It is a CD1400 rev. J or later */
3171 info
->tbpr
= baud_bpr_60
[13]; /* Tx BPR */
3172 info
->tco
= baud_co_60
[13]; /* Tx CO */
3173 info
->rbpr
= baud_bpr_60
[13]; /* Rx BPR */
3174 info
->rco
= baud_co_60
[13]; /* Rx CO */
3175 info
->rtsdtr_inv
= 1;
3177 info
->tbpr
= baud_bpr_25
[13]; /* Tx BPR */
3178 info
->tco
= baud_co_25
[13]; /* Tx CO */
3179 info
->rbpr
= baud_bpr_25
[13]; /* Rx BPR */
3180 info
->rco
= baud_co_25
[13]; /* Rx CO */
3181 info
->rtsdtr_inv
= 0;
3183 info
->read_status_mask
= CyTIMEOUT
| CySPECHAR
|
3184 CyBREAK
| CyPARITY
| CyFRAME
| CyOVERRUN
;
3189 #ifndef CONFIG_CYZ_INTR
3190 if (cy_is_Z(cinfo
) && !timer_pending(&cyz_timerlist
)) {
3191 mod_timer(&cyz_timerlist
, jiffies
+ 1);
3193 printk(KERN_DEBUG
"Cyclades-Z polling initialized\n");
3200 /* initialize chips on Cyclom-Y card -- return number of valid
3201 chips (which is number of ports/4) */
3202 static unsigned short cyy_init_card(void __iomem
*true_base_addr
,
3205 unsigned int chip_number
;
3206 void __iomem
*base_addr
;
3208 cy_writeb(true_base_addr
+ (Cy_HwReset
<< index
), 0);
3209 /* Cy_HwReset is 0x1400 */
3210 cy_writeb(true_base_addr
+ (Cy_ClrIntr
<< index
), 0);
3211 /* Cy_ClrIntr is 0x1800 */
3214 for (chip_number
= 0; chip_number
< CyMAX_CHIPS_PER_CARD
;
3217 true_base_addr
+ (cy_chip_offset
[chip_number
] << index
);
3219 if (readb(base_addr
+ (CyCCR
<< index
)) != 0x00) {
3221 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
3222 chip_number, (unsigned long)base_addr);
3227 cy_writeb(base_addr
+ (CyGFRCR
<< index
), 0);
3230 /* The Cyclom-16Y does not decode address bit 9 and therefore
3231 cannot distinguish between references to chip 0 and a non-
3232 existent chip 4. If the preceding clearing of the supposed
3233 chip 4 GFRCR register appears at chip 0, there is no chip 4
3234 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
3236 if (chip_number
== 4 && readb(true_base_addr
+
3237 (cy_chip_offset
[0] << index
) +
3238 (CyGFRCR
<< index
)) == 0) {
3242 cy_writeb(base_addr
+ (CyCCR
<< index
), CyCHIP_RESET
);
3245 if (readb(base_addr
+ (CyGFRCR
<< index
)) == 0x00) {
3247 printk(" chip #%d at %#6lx is not responding ",
3248 chip_number, (unsigned long)base_addr);
3249 printk("(GFRCR stayed 0)\n",
3253 if ((0xf0 & (readb(base_addr
+ (CyGFRCR
<< index
)))) !=
3256 printk(" chip #%d at %#6lx is not valid (GFRCR == "
3258 chip_number, (unsigned long)base_addr,
3259 base_addr[CyGFRCR<<index]);
3263 cy_writeb(base_addr
+ (CyGCR
<< index
), CyCH0_SERIAL
);
3264 if (readb(base_addr
+ (CyGFRCR
<< index
)) >= CD1400_REV_J
) {
3265 /* It is a CD1400 rev. J or later */
3266 /* Impossible to reach 5ms with this chip.
3267 Changed to 2ms instead (f = 500 Hz). */
3268 cy_writeb(base_addr
+ (CyPPR
<< index
), CyCLOCK_60_2MS
);
3271 cy_writeb(base_addr
+ (CyPPR
<< index
), CyCLOCK_25_5MS
);
3275 printk(" chip #%d at %#6lx is rev 0x%2x\n",
3276 chip_number, (unsigned long)base_addr,
3277 readb(base_addr+(CyGFRCR<<index)));
3281 } /* cyy_init_card */
3284 * ---------------------------------------------------------------------
3285 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
3286 * sets global variables and return the number of ISA boards found.
3287 * ---------------------------------------------------------------------
3289 static int __init
cy_detect_isa(void)
3292 struct cyclades_card
*card
;
3293 unsigned short cy_isa_irq
, nboard
;
3294 void __iomem
*cy_isa_address
;
3295 unsigned short i
, j
, k
, cy_isa_nchan
;
3300 /* Check for module parameters */
3301 for (i
= 0; i
< NR_CARDS
; i
++) {
3302 if (maddr
[i
] || i
) {
3304 cy_isa_addresses
[i
] = maddr
[i
];
3310 /* scan the address table probing for Cyclom-Y/ISA boards */
3311 for (i
= 0; i
< NR_ISA_ADDRS
; i
++) {
3312 unsigned int isa_address
= cy_isa_addresses
[i
];
3313 if (isa_address
== 0x0000)
3316 /* probe for CD1400... */
3317 cy_isa_address
= ioremap_nocache(isa_address
, CyISA_Ywin
);
3318 if (cy_isa_address
== NULL
) {
3319 printk(KERN_ERR
"Cyclom-Y/ISA: can't remap base "
3323 cy_isa_nchan
= CyPORTS_PER_CHIP
*
3324 cyy_init_card(cy_isa_address
, 0);
3325 if (cy_isa_nchan
== 0) {
3326 iounmap(cy_isa_address
);
3330 if (isparam
&& i
< NR_CARDS
&& irq
[i
])
3331 cy_isa_irq
= irq
[i
];
3333 /* find out the board's irq by probing */
3334 cy_isa_irq
= detect_isa_irq(cy_isa_address
);
3335 if (cy_isa_irq
== 0) {
3336 printk(KERN_ERR
"Cyclom-Y/ISA found at 0x%lx, but the "
3337 "IRQ could not be detected.\n",
3338 (unsigned long)cy_isa_address
);
3339 iounmap(cy_isa_address
);
3343 if ((cy_next_channel
+ cy_isa_nchan
) > NR_PORTS
) {
3344 printk(KERN_ERR
"Cyclom-Y/ISA found at 0x%lx, but no "
3345 "more channels are available. Change NR_PORTS "
3346 "in cyclades.c and recompile kernel.\n",
3347 (unsigned long)cy_isa_address
);
3348 iounmap(cy_isa_address
);
3351 /* fill the next cy_card structure available */
3352 for (j
= 0; j
< NR_CARDS
; j
++) {
3354 if (card
->base_addr
== NULL
)
3357 if (j
== NR_CARDS
) { /* no more cy_cards available */
3358 printk(KERN_ERR
"Cyclom-Y/ISA found at 0x%lx, but no "
3359 "more cards can be used. Change NR_CARDS in "
3360 "cyclades.c and recompile kernel.\n",
3361 (unsigned long)cy_isa_address
);
3362 iounmap(cy_isa_address
);
3367 if (request_irq(cy_isa_irq
, cyy_interrupt
,
3368 0, "Cyclom-Y", card
)) {
3369 printk(KERN_ERR
"Cyclom-Y/ISA found at 0x%lx, but "
3370 "could not allocate IRQ#%d.\n",
3371 (unsigned long)cy_isa_address
, cy_isa_irq
);
3372 iounmap(cy_isa_address
);
3377 card
->base_addr
= cy_isa_address
;
3378 card
->ctl_addr
.p9050
= NULL
;
3379 card
->irq
= (int)cy_isa_irq
;
3380 card
->bus_index
= 0;
3381 card
->first_line
= cy_next_channel
;
3382 card
->num_chips
= cy_isa_nchan
/ CyPORTS_PER_CHIP
;
3383 card
->nports
= cy_isa_nchan
;
3384 if (cy_init_card(card
)) {
3385 card
->base_addr
= NULL
;
3386 free_irq(cy_isa_irq
, card
);
3387 iounmap(cy_isa_address
);
3392 printk(KERN_INFO
"Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
3393 "%d channels starting from port %d\n",
3394 j
+ 1, (unsigned long)cy_isa_address
,
3395 (unsigned long)(cy_isa_address
+ (CyISA_Ywin
- 1)),
3396 cy_isa_irq
, cy_isa_nchan
, cy_next_channel
);
3398 for (k
= 0, j
= cy_next_channel
;
3399 j
< cy_next_channel
+ cy_isa_nchan
; j
++, k
++)
3400 tty_port_register_device(&card
->ports
[k
].port
,
3401 cy_serial_driver
, j
, NULL
);
3402 cy_next_channel
+= cy_isa_nchan
;
3407 #endif /* CONFIG_ISA */
3408 } /* cy_detect_isa */
3411 static inline int cyc_isfwstr(const char *str
, unsigned int size
)
3415 for (a
= 0; a
< size
&& *str
; a
++, str
++)
3419 for (; a
< size
; a
++, str
++)
3426 static inline void cyz_fpga_copy(void __iomem
*fpga
, const u8
*data
,
3429 for (; size
> 0; size
--) {
3430 cy_writel(fpga
, *data
++);
3435 static void plx_init(struct pci_dev
*pdev
, int irq
,
3436 struct RUNTIME_9060 __iomem
*addr
)
3439 cy_writel(&addr
->init_ctrl
, readl(&addr
->init_ctrl
) | 0x40000000);
3441 cy_writel(&addr
->init_ctrl
, readl(&addr
->init_ctrl
) & ~0x40000000);
3443 /* Reload Config. Registers from EEPROM */
3444 cy_writel(&addr
->init_ctrl
, readl(&addr
->init_ctrl
) | 0x20000000);
3446 cy_writel(&addr
->init_ctrl
, readl(&addr
->init_ctrl
) & ~0x20000000);
3448 /* For some yet unknown reason, once the PLX9060 reloads the EEPROM,
3449 * the IRQ is lost and, thus, we have to re-write it to the PCI config.
3450 * registers. This will remain here until we find a permanent fix.
3452 pci_write_config_byte(pdev
, PCI_INTERRUPT_LINE
, irq
);
3455 static int __cyz_load_fw(const struct firmware
*fw
,
3456 const char *name
, const u32 mailbox
, void __iomem
*base
,
3459 const void *ptr
= fw
->data
;
3460 const struct zfile_header
*h
= ptr
;
3461 const struct zfile_config
*c
, *cs
;
3462 const struct zfile_block
*b
, *bs
;
3463 unsigned int a
, tmp
, len
= fw
->size
;
3464 #define BAD_FW KERN_ERR "Bad firmware: "
3465 if (len
< sizeof(*h
)) {
3466 printk(BAD_FW
"too short: %u<%zu\n", len
, sizeof(*h
));
3470 cs
= ptr
+ h
->config_offset
;
3471 bs
= ptr
+ h
->block_offset
;
3473 if ((void *)(cs
+ h
->n_config
) > ptr
+ len
||
3474 (void *)(bs
+ h
->n_blocks
) > ptr
+ len
) {
3475 printk(BAD_FW
"too short");
3479 if (cyc_isfwstr(h
->name
, sizeof(h
->name
)) ||
3480 cyc_isfwstr(h
->date
, sizeof(h
->date
))) {
3481 printk(BAD_FW
"bad formatted header string\n");
3485 if (strncmp(name
, h
->name
, sizeof(h
->name
))) {
3486 printk(BAD_FW
"bad name '%s' (expected '%s')\n", h
->name
, name
);
3491 for (c
= cs
; c
< cs
+ h
->n_config
; c
++) {
3492 for (a
= 0; a
< c
->n_blocks
; a
++)
3493 if (c
->block_list
[a
] > h
->n_blocks
) {
3494 printk(BAD_FW
"bad block ref number in cfgs\n");
3497 if (c
->mailbox
== mailbox
&& c
->function
== 0) /* 0 is normal */
3501 printk(BAD_FW
"nothing appropriate\n");
3505 for (b
= bs
; b
< bs
+ h
->n_blocks
; b
++)
3506 if (b
->file_offset
+ b
->size
> len
) {
3507 printk(BAD_FW
"bad block data offset\n");
3511 /* everything is OK, let's seek'n'load it */
3512 for (c
= cs
; c
< cs
+ h
->n_config
; c
++)
3513 if (c
->mailbox
== mailbox
&& c
->function
== 0)
3516 for (a
= 0; a
< c
->n_blocks
; a
++) {
3517 b
= &bs
[c
->block_list
[a
]];
3518 if (b
->type
== ZBLOCK_FPGA
) {
3520 cyz_fpga_copy(fpga
, ptr
+ b
->file_offset
,
3524 memcpy_toio(base
+ b
->ram_offset
,
3525 ptr
+ b
->file_offset
, b
->size
);
3532 static int cyz_load_fw(struct pci_dev
*pdev
, void __iomem
*base_addr
,
3533 struct RUNTIME_9060 __iomem
*ctl_addr
, int irq
)
3535 const struct firmware
*fw
;
3536 struct FIRM_ID __iomem
*fid
= base_addr
+ ID_ADDRESS
;
3537 struct CUSTOM_REG __iomem
*cust
= base_addr
;
3538 struct ZFW_CTRL __iomem
*pt_zfwctrl
;
3540 u32 mailbox
, status
, nchan
;
3544 retval
= request_firmware(&fw
, "cyzfirm.bin", &pdev
->dev
);
3546 dev_err(&pdev
->dev
, "can't get firmware\n");
3550 /* Check whether the firmware is already loaded and running. If
3551 positive, skip this board */
3552 if (__cyz_fpga_loaded(ctl_addr
) && readl(&fid
->signature
) == ZFIRM_ID
) {
3553 u32 cntval
= readl(base_addr
+ 0x190);
3556 if (cntval
!= readl(base_addr
+ 0x190)) {
3557 /* FW counter is working, FW is running */
3558 dev_dbg(&pdev
->dev
, "Cyclades-Z FW already loaded. "
3559 "Skipping board.\n");
3566 cy_writel(&ctl_addr
->intr_ctrl_stat
, readl(&ctl_addr
->intr_ctrl_stat
) &
3569 mailbox
= readl(&ctl_addr
->mail_box_0
);
3571 if (mailbox
== 0 || __cyz_fpga_loaded(ctl_addr
)) {
3572 /* stops CPU and set window to beginning of RAM */
3573 cy_writel(&ctl_addr
->loc_addr_base
, WIN_CREG
);
3574 cy_writel(&cust
->cpu_stop
, 0);
3575 cy_writel(&ctl_addr
->loc_addr_base
, WIN_RAM
);
3579 plx_init(pdev
, irq
, ctl_addr
);
3583 retval
= __cyz_load_fw(fw
, "Cyclom-Z", mailbox
, NULL
,
3587 if (!__cyz_fpga_loaded(ctl_addr
)) {
3588 dev_err(&pdev
->dev
, "fw upload successful, but fw is "
3594 /* stops CPU and set window to beginning of RAM */
3595 cy_writel(&ctl_addr
->loc_addr_base
, WIN_CREG
);
3596 cy_writel(&cust
->cpu_stop
, 0);
3597 cy_writel(&ctl_addr
->loc_addr_base
, WIN_RAM
);
3601 for (tmp
= base_addr
; tmp
< base_addr
+ RAM_SIZE
; tmp
++)
3602 cy_writeb(tmp
, 255);
3604 /* set window to last 512K of RAM */
3605 cy_writel(&ctl_addr
->loc_addr_base
, WIN_RAM
+ RAM_SIZE
);
3606 for (tmp
= base_addr
; tmp
< base_addr
+ RAM_SIZE
; tmp
++)
3607 cy_writeb(tmp
, 255);
3608 /* set window to beginning of RAM */
3609 cy_writel(&ctl_addr
->loc_addr_base
, WIN_RAM
);
3612 retval
= __cyz_load_fw(fw
, "Cyclom-Z", mailbox
, base_addr
, NULL
);
3613 release_firmware(fw
);
3617 /* finish boot and start boards */
3618 cy_writel(&ctl_addr
->loc_addr_base
, WIN_CREG
);
3619 cy_writel(&cust
->cpu_start
, 0);
3620 cy_writel(&ctl_addr
->loc_addr_base
, WIN_RAM
);
3622 while ((status
= readl(&fid
->signature
)) != ZFIRM_ID
&& i
++ < 40)
3624 if (status
!= ZFIRM_ID
) {
3625 if (status
== ZFIRM_HLT
) {
3626 dev_err(&pdev
->dev
, "you need an external power supply "
3627 "for this number of ports. Firmware halted and "
3632 dev_warn(&pdev
->dev
, "fid->signature = 0x%x... Waiting "
3633 "some more time\n", status
);
3634 while ((status
= readl(&fid
->signature
)) != ZFIRM_ID
&&
3637 if (status
!= ZFIRM_ID
) {
3638 dev_err(&pdev
->dev
, "Board not started in 20 seconds! "
3639 "Giving up. (fid->signature = 0x%x)\n",
3641 dev_info(&pdev
->dev
, "*** Warning ***: if you are "
3642 "upgrading the FW, please power cycle the "
3643 "system before loading the new FW to the "
3646 if (__cyz_fpga_loaded(ctl_addr
))
3647 plx_init(pdev
, irq
, ctl_addr
);
3652 dev_dbg(&pdev
->dev
, "Firmware started after %d seconds.\n",
3655 pt_zfwctrl
= base_addr
+ readl(&fid
->zfwctrl_addr
);
3657 dev_dbg(&pdev
->dev
, "fid=> %p, zfwctrl_addr=> %x, npt_zfwctrl=> %p\n",
3658 base_addr
+ ID_ADDRESS
, readl(&fid
->zfwctrl_addr
),
3659 base_addr
+ readl(&fid
->zfwctrl_addr
));
3661 nchan
= readl(&pt_zfwctrl
->board_ctrl
.n_channel
);
3662 dev_info(&pdev
->dev
, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
3663 readl(&pt_zfwctrl
->board_ctrl
.fw_version
), nchan
);
3666 dev_warn(&pdev
->dev
, "no Cyclades-Z ports were found. Please "
3667 "check the connection between the Z host card and the "
3668 "serial expanders.\n");
3670 if (__cyz_fpga_loaded(ctl_addr
))
3671 plx_init(pdev
, irq
, ctl_addr
);
3673 dev_info(&pdev
->dev
, "Null number of ports detected. Board "
3679 cy_writel(&pt_zfwctrl
->board_ctrl
.op_system
, C_OS_LINUX
);
3680 cy_writel(&pt_zfwctrl
->board_ctrl
.dr_version
, DRIVER_VERSION
);
3683 Early firmware failed to start looking for commands.
3684 This enables firmware interrupts for those commands.
3686 cy_writel(&ctl_addr
->intr_ctrl_stat
, readl(&ctl_addr
->intr_ctrl_stat
) |
3688 cy_writel(&ctl_addr
->intr_ctrl_stat
, readl(&ctl_addr
->intr_ctrl_stat
) |
3693 release_firmware(fw
);
3698 static int cy_pci_probe(struct pci_dev
*pdev
,
3699 const struct pci_device_id
*ent
)
3701 struct cyclades_card
*card
;
3702 void __iomem
*addr0
= NULL
, *addr2
= NULL
;
3703 char *card_name
= NULL
;
3704 u32
uninitialized_var(mailbox
);
3705 unsigned int device_id
, nchan
= 0, card_no
, i
, j
;
3706 unsigned char plx_ver
;
3709 retval
= pci_enable_device(pdev
);
3711 dev_err(&pdev
->dev
, "cannot enable device\n");
3715 /* read PCI configuration area */
3717 device_id
= pdev
->device
& ~PCI_DEVICE_ID_MASK
;
3719 #if defined(__alpha__)
3720 if (device_id
== PCI_DEVICE_ID_CYCLOM_Y_Lo
) { /* below 1M? */
3721 dev_err(&pdev
->dev
, "Cyclom-Y/PCI not supported for low "
3722 "addresses on Alpha systems.\n");
3727 if (device_id
== PCI_DEVICE_ID_CYCLOM_Z_Lo
) {
3728 dev_err(&pdev
->dev
, "Cyclades-Z/PCI not supported for low "
3734 if (pci_resource_flags(pdev
, 2) & IORESOURCE_IO
) {
3735 dev_warn(&pdev
->dev
, "PCI I/O bit incorrectly set. Ignoring "
3737 pdev
->resource
[2].flags
&= ~IORESOURCE_IO
;
3740 retval
= pci_request_regions(pdev
, "cyclades");
3742 dev_err(&pdev
->dev
, "failed to reserve resources\n");
3747 if (device_id
== PCI_DEVICE_ID_CYCLOM_Y_Lo
||
3748 device_id
== PCI_DEVICE_ID_CYCLOM_Y_Hi
) {
3749 card_name
= "Cyclom-Y";
3751 addr0
= ioremap_nocache(pci_resource_start(pdev
, 0),
3753 if (addr0
== NULL
) {
3754 dev_err(&pdev
->dev
, "can't remap ctl region\n");
3757 addr2
= ioremap_nocache(pci_resource_start(pdev
, 2),
3759 if (addr2
== NULL
) {
3760 dev_err(&pdev
->dev
, "can't remap base region\n");
3764 nchan
= CyPORTS_PER_CHIP
* cyy_init_card(addr2
, 1);
3766 dev_err(&pdev
->dev
, "Cyclom-Y PCI host card with no "
3767 "Serial-Modules\n");
3770 } else if (device_id
== PCI_DEVICE_ID_CYCLOM_Z_Hi
) {
3771 struct RUNTIME_9060 __iomem
*ctl_addr
;
3773 ctl_addr
= addr0
= ioremap_nocache(pci_resource_start(pdev
, 0),
3775 if (addr0
== NULL
) {
3776 dev_err(&pdev
->dev
, "can't remap ctl region\n");
3780 /* Disable interrupts on the PLX before resetting it */
3781 cy_writew(&ctl_addr
->intr_ctrl_stat
,
3782 readw(&ctl_addr
->intr_ctrl_stat
) & ~0x0900);
3784 plx_init(pdev
, irq
, addr0
);
3786 mailbox
= readl(&ctl_addr
->mail_box_0
);
3788 addr2
= ioremap_nocache(pci_resource_start(pdev
, 2),
3789 mailbox
== ZE_V1
? CyPCI_Ze_win
: CyPCI_Zwin
);
3790 if (addr2
== NULL
) {
3791 dev_err(&pdev
->dev
, "can't remap base region\n");
3795 if (mailbox
== ZE_V1
) {
3796 card_name
= "Cyclades-Ze";
3798 card_name
= "Cyclades-8Zo";
3800 if (mailbox
== ZO_V1
) {
3801 cy_writel(&ctl_addr
->loc_addr_base
, WIN_CREG
);
3802 dev_info(&pdev
->dev
, "Cyclades-8Zo/PCI: FPGA "
3803 "id %lx, ver %lx\n", (ulong
)(0xff &
3804 readl(&((struct CUSTOM_REG
*)addr2
)->
3805 fpga_id
)), (ulong
)(0xff &
3806 readl(&((struct CUSTOM_REG
*)addr2
)->
3808 cy_writel(&ctl_addr
->loc_addr_base
, WIN_RAM
);
3810 dev_info(&pdev
->dev
, "Cyclades-Z/PCI: New "
3811 "Cyclades-Z board. FPGA not loaded\n");
3814 /* The following clears the firmware id word. This
3815 ensures that the driver will not attempt to talk to
3816 the board until it has been properly initialized.
3818 if ((mailbox
== ZO_V1
) || (mailbox
== ZO_V2
))
3819 cy_writel(addr2
+ ID_ADDRESS
, 0L);
3822 retval
= cyz_load_fw(pdev
, addr2
, addr0
, irq
);
3828 if ((cy_next_channel
+ nchan
) > NR_PORTS
) {
3829 dev_err(&pdev
->dev
, "Cyclades-8Zo/PCI found, but no "
3830 "channels are available. Change NR_PORTS in "
3831 "cyclades.c and recompile kernel.\n");
3834 /* fill the next cy_card structure available */
3835 for (card_no
= 0; card_no
< NR_CARDS
; card_no
++) {
3836 card
= &cy_card
[card_no
];
3837 if (card
->base_addr
== NULL
)
3840 if (card_no
== NR_CARDS
) { /* no more cy_cards available */
3841 dev_err(&pdev
->dev
, "Cyclades-8Zo/PCI found, but no "
3842 "more cards can be used. Change NR_CARDS in "
3843 "cyclades.c and recompile kernel.\n");
3847 if (device_id
== PCI_DEVICE_ID_CYCLOM_Y_Lo
||
3848 device_id
== PCI_DEVICE_ID_CYCLOM_Y_Hi
) {
3850 retval
= request_irq(irq
, cyy_interrupt
,
3851 IRQF_SHARED
, "Cyclom-Y", card
);
3853 dev_err(&pdev
->dev
, "could not allocate IRQ\n");
3856 card
->num_chips
= nchan
/ CyPORTS_PER_CHIP
;
3858 struct FIRM_ID __iomem
*firm_id
= addr2
+ ID_ADDRESS
;
3859 struct ZFW_CTRL __iomem
*zfw_ctrl
;
3861 zfw_ctrl
= addr2
+ (readl(&firm_id
->zfwctrl_addr
) & 0xfffff);
3863 card
->hw_ver
= mailbox
;
3864 card
->num_chips
= (unsigned int)-1;
3865 card
->board_ctrl
= &zfw_ctrl
->board_ctrl
;
3866 #ifdef CONFIG_CYZ_INTR
3867 /* allocate IRQ only if board has an IRQ */
3868 if (irq
!= 0 && irq
!= 255) {
3869 retval
= request_irq(irq
, cyz_interrupt
,
3870 IRQF_SHARED
, "Cyclades-Z", card
);
3872 dev_err(&pdev
->dev
, "could not allocate IRQ\n");
3876 #endif /* CONFIG_CYZ_INTR */
3880 card
->base_addr
= addr2
;
3881 card
->ctl_addr
.p9050
= addr0
;
3883 card
->bus_index
= 1;
3884 card
->first_line
= cy_next_channel
;
3885 card
->nports
= nchan
;
3886 retval
= cy_init_card(card
);
3890 pci_set_drvdata(pdev
, card
);
3892 if (device_id
== PCI_DEVICE_ID_CYCLOM_Y_Lo
||
3893 device_id
== PCI_DEVICE_ID_CYCLOM_Y_Hi
) {
3894 /* enable interrupts in the PCI interface */
3895 plx_ver
= readb(addr2
+ CyPLX_VER
) & 0x0f;
3898 cy_writeb(addr0
+ 0x4c, 0x43);
3903 default: /* Old boards, use PLX_9060 */
3905 struct RUNTIME_9060 __iomem
*ctl_addr
= addr0
;
3906 plx_init(pdev
, irq
, ctl_addr
);
3907 cy_writew(&ctl_addr
->intr_ctrl_stat
,
3908 readw(&ctl_addr
->intr_ctrl_stat
) | 0x0900);
3914 dev_info(&pdev
->dev
, "%s/PCI #%d found: %d channels starting from "
3915 "port %d.\n", card_name
, card_no
+ 1, nchan
, cy_next_channel
);
3916 for (j
= 0, i
= cy_next_channel
; i
< cy_next_channel
+ nchan
; i
++, j
++)
3917 tty_port_register_device(&card
->ports
[j
].port
,
3918 cy_serial_driver
, i
, &pdev
->dev
);
3919 cy_next_channel
+= nchan
;
3923 card
->base_addr
= NULL
;
3924 free_irq(irq
, card
);
3930 pci_release_regions(pdev
);
3932 pci_disable_device(pdev
);
3937 static void cy_pci_remove(struct pci_dev
*pdev
)
3939 struct cyclades_card
*cinfo
= pci_get_drvdata(pdev
);
3940 unsigned int i
, channel
;
3942 /* non-Z with old PLX */
3943 if (!cy_is_Z(cinfo
) && (readb(cinfo
->base_addr
+ CyPLX_VER
) & 0x0f) ==
3945 cy_writeb(cinfo
->ctl_addr
.p9050
+ 0x4c, 0);
3947 #ifndef CONFIG_CYZ_INTR
3948 if (!cy_is_Z(cinfo
))
3950 cy_writew(&cinfo
->ctl_addr
.p9060
->intr_ctrl_stat
,
3951 readw(&cinfo
->ctl_addr
.p9060
->intr_ctrl_stat
) &
3954 iounmap(cinfo
->base_addr
);
3955 if (cinfo
->ctl_addr
.p9050
)
3956 iounmap(cinfo
->ctl_addr
.p9050
);
3958 #ifndef CONFIG_CYZ_INTR
3960 #endif /* CONFIG_CYZ_INTR */
3962 free_irq(cinfo
->irq
, cinfo
);
3963 pci_release_regions(pdev
);
3965 cinfo
->base_addr
= NULL
;
3966 for (channel
= 0, i
= cinfo
->first_line
; i
< cinfo
->first_line
+
3967 cinfo
->nports
; i
++, channel
++) {
3968 tty_unregister_device(cy_serial_driver
, i
);
3969 tty_port_destroy(&cinfo
->ports
[channel
].port
);
3972 kfree(cinfo
->ports
);
3975 static struct pci_driver cy_pci_driver
= {
3977 .id_table
= cy_pci_dev_id
,
3978 .probe
= cy_pci_probe
,
3979 .remove
= cy_pci_remove
3983 static int cyclades_proc_show(struct seq_file
*m
, void *v
)
3985 struct cyclades_port
*info
;
3987 __u32 cur_jifs
= jiffies
;
3989 seq_puts(m
, "Dev TimeOpen BytesOut IdleOut BytesIn "
3990 "IdleIn Overruns Ldisc\n");
3992 /* Output one line for each known port */
3993 for (i
= 0; i
< NR_CARDS
; i
++)
3994 for (j
= 0; j
< cy_card
[i
].nports
; j
++) {
3995 info
= &cy_card
[i
].ports
[j
];
3997 if (info
->port
.count
) {
3998 /* XXX is the ldisc num worth this? */
3999 struct tty_struct
*tty
;
4000 struct tty_ldisc
*ld
;
4002 tty
= tty_port_tty_get(&info
->port
);
4004 ld
= tty_ldisc_ref(tty
);
4007 tty_ldisc_deref(ld
);
4011 seq_printf(m
, "%3d %8lu %10lu %8lu "
4012 "%10lu %8lu %9lu %6d\n", info
->line
,
4013 (cur_jifs
- info
->idle_stats
.in_use
) /
4014 HZ
, info
->idle_stats
.xmit_bytes
,
4015 (cur_jifs
- info
->idle_stats
.xmit_idle
)/
4016 HZ
, info
->idle_stats
.recv_bytes
,
4017 (cur_jifs
- info
->idle_stats
.recv_idle
)/
4018 HZ
, info
->idle_stats
.overruns
,
4021 seq_printf(m
, "%3d %8lu %10lu %8lu "
4022 "%10lu %8lu %9lu %6ld\n",
4023 info
->line
, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
4028 static int cyclades_proc_open(struct inode
*inode
, struct file
*file
)
4030 return single_open(file
, cyclades_proc_show
, NULL
);
4033 static const struct file_operations cyclades_proc_fops
= {
4034 .owner
= THIS_MODULE
,
4035 .open
= cyclades_proc_open
,
4037 .llseek
= seq_lseek
,
4038 .release
= single_release
,
4041 /* The serial driver boot-time initialization code!
4042 Hardware I/O ports are mapped to character special devices on a
4043 first found, first allocated manner. That is, this code searches
4044 for Cyclom cards in the system. As each is found, it is probed
4045 to discover how many chips (and thus how many ports) are present.
4046 These ports are mapped to the tty ports 32 and upward in monotonic
4047 fashion. If an 8-port card is replaced with a 16-port card, the
4048 port mapping on a following card will shift.
4050 This approach is different from what is used in the other serial
4051 device driver because the Cyclom is more properly a multiplexer,
4052 not just an aggregation of serial ports on one card.
4054 If there are more cards with more ports than have been
4055 statically allocated above, a warning is printed and the
4056 extra ports are ignored.
4059 static const struct tty_operations cy_ops
= {
4063 .put_char
= cy_put_char
,
4064 .flush_chars
= cy_flush_chars
,
4065 .write_room
= cy_write_room
,
4066 .chars_in_buffer
= cy_chars_in_buffer
,
4067 .flush_buffer
= cy_flush_buffer
,
4069 .throttle
= cy_throttle
,
4070 .unthrottle
= cy_unthrottle
,
4071 .set_termios
= cy_set_termios
,
4074 .hangup
= cy_hangup
,
4075 .break_ctl
= cy_break
,
4076 .wait_until_sent
= cy_wait_until_sent
,
4077 .tiocmget
= cy_tiocmget
,
4078 .tiocmset
= cy_tiocmset
,
4079 .get_icount
= cy_get_icount
,
4080 .proc_fops
= &cyclades_proc_fops
,
4083 static int __init
cy_init(void)
4085 unsigned int nboards
;
4086 int retval
= -ENOMEM
;
4088 cy_serial_driver
= alloc_tty_driver(NR_PORTS
);
4089 if (!cy_serial_driver
)
4092 printk(KERN_INFO
"Cyclades driver " CY_VERSION
"\n");
4094 /* Initialize the tty_driver structure */
4096 cy_serial_driver
->driver_name
= "cyclades";
4097 cy_serial_driver
->name
= "ttyC";
4098 cy_serial_driver
->major
= CYCLADES_MAJOR
;
4099 cy_serial_driver
->minor_start
= 0;
4100 cy_serial_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
4101 cy_serial_driver
->subtype
= SERIAL_TYPE_NORMAL
;
4102 cy_serial_driver
->init_termios
= tty_std_termios
;
4103 cy_serial_driver
->init_termios
.c_cflag
=
4104 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
4105 cy_serial_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
4106 tty_set_operations(cy_serial_driver
, &cy_ops
);
4108 retval
= tty_register_driver(cy_serial_driver
);
4110 printk(KERN_ERR
"Couldn't register Cyclades serial driver\n");
4114 /* the code below is responsible to find the boards. Each different
4115 type of board has its own detection routine. If a board is found,
4116 the next cy_card structure available is set by the detection
4117 routine. These functions are responsible for checking the
4118 availability of cy_card and cy_port data structures and updating
4119 the cy_next_channel. */
4121 /* look for isa boards */
4122 nboards
= cy_detect_isa();
4125 /* look for pci boards */
4126 retval
= pci_register_driver(&cy_pci_driver
);
4127 if (retval
&& !nboards
) {
4128 tty_unregister_driver(cy_serial_driver
);
4135 put_tty_driver(cy_serial_driver
);
4140 static void __exit
cy_cleanup_module(void)
4142 struct cyclades_card
*card
;
4145 #ifndef CONFIG_CYZ_INTR
4146 del_timer_sync(&cyz_timerlist
);
4147 #endif /* CONFIG_CYZ_INTR */
4149 e1
= tty_unregister_driver(cy_serial_driver
);
4151 printk(KERN_ERR
"failed to unregister Cyclades serial "
4152 "driver(%d)\n", e1
);
4155 pci_unregister_driver(&cy_pci_driver
);
4158 for (i
= 0; i
< NR_CARDS
; i
++) {
4160 if (card
->base_addr
) {
4161 /* clear interrupt */
4162 cy_writeb(card
->base_addr
+ Cy_ClrIntr
, 0);
4163 iounmap(card
->base_addr
);
4164 if (card
->ctl_addr
.p9050
)
4165 iounmap(card
->ctl_addr
.p9050
);
4167 #ifndef CONFIG_CYZ_INTR
4169 #endif /* CONFIG_CYZ_INTR */
4171 free_irq(card
->irq
, card
);
4172 for (e1
= card
->first_line
; e1
< card
->first_line
+
4174 tty_unregister_device(cy_serial_driver
, e1
);
4179 put_tty_driver(cy_serial_driver
);
4180 } /* cy_cleanup_module */
4182 module_init(cy_init
);
4183 module_exit(cy_cleanup_module
);
4185 MODULE_LICENSE("GPL");
4186 MODULE_VERSION(CY_VERSION
);
4187 MODULE_ALIAS_CHARDEV_MAJOR(CYCLADES_MAJOR
);
4188 MODULE_FIRMWARE("cyzfirm.bin");