2 * linux/drivers/char/serial167.c
4 * Driver for MVME166/7 board serial ports, which are via a CD2401.
5 * Based very much on cyclades.c.
7 * MVME166/7 work by Richard Hirst [richard@sleepie.demon.co.uk]
9 * ==============================================================
11 * static char rcsid[] =
12 * "$Revision: 1.36.1.4 $$Date: 1995/03/29 06:14:14 $";
14 * linux/kernel/cyclades.c
16 * Maintained by Marcio Saito (cyclades@netcom.com) and
17 * Randolph Bentson (bentson@grieg.seaslug.org)
19 * Much of the design and some of the code came from serial.c
20 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
21 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
22 * and then fixed as suggested by Michael K. Johnson 12/12/92.
24 * This version does not support shared irq's.
26 * $Log: cyclades.c,v $
27 * Revision 1.36.1.4 1995/03/29 06:14:14 bentson
28 * disambiguate between Cyclom-16Y and Cyclom-32Ye;
32 * 200 lines of changes record removed - RGH 11-10-95, starting work on
33 * converting this to drive serial ports on mvme166 (cd2401).
35 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 2000/08/25
36 * - get rid of verify_area
37 * - use get_user to access memory from userspace in set_threshold,
38 * set_default_threshold and set_timeout
39 * - don't use the panic function in serial167_init
40 * - do resource release on failure on serial167_init
41 * - include missing restore_flags in mvme167_serial_console_setup
43 * Kars de Jong <jongk@linux-m68k.org> - 2004/09/06
44 * - replace bottom half handler with task queue handler
47 #include <linux/errno.h>
48 #include <linux/signal.h>
49 #include <linux/sched.h>
50 #include <linux/timer.h>
51 #include <linux/tty.h>
52 #include <linux/interrupt.h>
53 #include <linux/serial.h>
54 #include <linux/serialP.h>
55 #include <linux/smp_lock.h>
56 #include <linux/string.h>
57 #include <linux/fcntl.h>
58 #include <linux/ptrace.h>
59 #include <linux/serial167.h>
60 #include <linux/delay.h>
61 #include <linux/major.h>
63 #include <linux/console.h>
64 #include <linux/module.h>
65 #include <linux/bitops.h>
66 #include <linux/tty_flip.h>
68 #include <asm/system.h>
70 #include <asm/mvme16xhw.h>
71 #include <asm/bootinfo.h>
72 #include <asm/setup.h>
74 #include <linux/types.h>
75 #include <linux/kernel.h>
77 #include <asm/uaccess.h>
78 #include <linux/init.h>
80 #define SERIAL_PARANOIA_CHECK
81 #undef SERIAL_DEBUG_OPEN
82 #undef SERIAL_DEBUG_THROTTLE
83 #undef SERIAL_DEBUG_OTHER
84 #undef SERIAL_DEBUG_IO
85 #undef SERIAL_DEBUG_COUNT
86 #undef SERIAL_DEBUG_DTR
87 #undef CYCLOM_16Y_HACK
88 #define CYCLOM_ENABLE_MONITORING
90 #define WAKEUP_CHARS 256
92 #define STD_COM_FLAGS (0)
94 static struct tty_driver *cy_serial_driver;
95 extern int serial_console;
96 static struct cyclades_port *serial_console_info = NULL;
97 static unsigned int serial_console_cflag = 0;
98 u_char initial_console_speed;
100 /* Base address of cd2401 chip on mvme166/7 */
102 #define BASE_ADDR (0xfff45000)
103 #define pcc2chip ((volatile u_char *)0xfff42000)
104 #define PccSCCMICR 0x1d
105 #define PccSCCTICR 0x1e
106 #define PccSCCRICR 0x1f
107 #define PccTPIACKR 0x25
108 #define PccRPIACKR 0x27
111 /* This is the per-port data structure */
112 struct cyclades_port cy_port[] = {
120 #define NR_PORTS ARRAY_SIZE(cy_port)
123 * This is used to look up the divisor speeds and the timeouts
124 * We're normally limited to 15 distinct baud rates. The extra
125 * are accessed via settings in info->flags.
126 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
127 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
130 static int baud_table[] = {
131 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
132 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
137 static char baud_co[] = { /* 25 MHz clock option table */
138 /* value => 00 01 02 03 04 */
139 /* divide by 8 32 128 512 2048 */
140 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
141 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
144 static char baud_bpr[] = { /* 25 MHz baud rate period table */
145 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
146 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
150 /* I think 166 brd clocks 2401 at 20MHz.... */
152 /* These values are written directly to tcor, and >> 5 for writing to rcor */
153 static u_char baud_co[] = { /* 20 MHz clock option table */
154 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
155 0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
158 /* These values written directly to tbpr/rbpr */
159 static u_char baud_bpr[] = { /* 20 MHz baud rate period table */
160 0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
161 0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
164 static u_char baud_cor4[] = { /* receive threshold */
165 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
166 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
169 static void shutdown(struct cyclades_port *);
170 static int startup(struct cyclades_port *);
171 static void cy_throttle(struct tty_struct *);
172 static void cy_unthrottle(struct tty_struct *);
173 static void config_setup(struct cyclades_port *);
174 extern void console_print(const char *);
175 #ifdef CYCLOM_SHOW_STATUS
176 static void show_status(int);
179 #ifdef CONFIG_REMOTE_DEBUG
180 static void debug_setup(void);
181 void queueDebugChar(int c);
182 int getDebugChar(void);
185 #define DEBUG_LEN 256
190 unsigned char buf[DEBUG_LEN];
197 * I have my own version of udelay(), as it is needed when initialising
198 * the chip, before the delay loop has been calibrated. Should probably
199 * reference one of the vmechip2 or pccchip2 counter for an accurate
200 * delay, but this wild guess will do for now.
203 void my_udelay(long us)
206 volatile u_char *p = &x;
210 for (i = 100; i; i--)
214 static inline int serial_paranoia_check(struct cyclades_port *info, char *name,
217 #ifdef SERIAL_PARANOIA_CHECK
219 printk("Warning: null cyclades_port for (%s) in %s\n", name,
224 if ((long)info < (long)(&cy_port[0])
225 || (long)(&cy_port[NR_PORTS]) < (long)info) {
226 printk("Warning: cyclades_port out of range for (%s) in %s\n",
231 if (info->magic != CYCLADES_MAGIC) {
232 printk("Warning: bad magic number for serial struct (%s) in "
233 "%s\n", name, routine);
238 } /* serial_paranoia_check */
241 /* The following diagnostic routines allow the driver to spew
242 information on the screen, even (especially!) during interrupts.
247 local_irq_save(flags);
249 local_irq_restore(flags);
256 local_irq_save(flags);
259 local_irq_restore(flags);
264 (data < 10) ? CP(data + '0') : CP(data + 'A' - 10);
268 CP1((data >> 4) & 0x0f);
273 CP2((data >> 8) & 0xff);
278 CP4((data >> 16) & 0xffff);
283 /* This routine waits up to 1000 micro-seconds for the previous
284 command to the Cirrus chip to complete and then issues the
285 new command. An error is returned if the previous command
286 didn't finish within the time limit.
288 u_short write_cy_cmd(volatile u_char * base_addr, u_char cmd)
293 local_irq_save(flags);
294 /* Check to see that the previous command has completed */
295 for (i = 0; i < 100; i++) {
296 if (base_addr[CyCCR] == 0) {
301 /* if the CCR never cleared, the previous command
302 didn't finish within the "reasonable time" */
304 local_irq_restore(flags);
308 /* Issue the new command */
309 base_addr[CyCCR] = cmd;
310 local_irq_restore(flags);
314 /* cy_start and cy_stop provide software output flow control as a
315 function of XON/XOFF, software CTS, and other such stuff. */
317 static void cy_stop(struct tty_struct *tty)
319 struct cyclades_port *info = tty->driver_data;
320 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
324 #ifdef SERIAL_DEBUG_OTHER
325 printk("cy_stop %s\n", tty->name); /* */
328 if (serial_paranoia_check(info, tty->name, "cy_stop"))
331 channel = info->line;
333 local_irq_save(flags);
334 base_addr[CyCAR] = (u_char) (channel); /* index channel */
335 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
336 local_irq_restore(flags);
339 static void cy_start(struct tty_struct *tty)
341 struct cyclades_port *info = tty->driver_data;
342 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
346 #ifdef SERIAL_DEBUG_OTHER
347 printk("cy_start %s\n", tty->name); /* */
350 if (serial_paranoia_check(info, tty->name, "cy_start"))
353 channel = info->line;
355 local_irq_save(flags);
356 base_addr[CyCAR] = (u_char) (channel);
357 base_addr[CyIER] |= CyTxMpty;
358 local_irq_restore(flags);
361 /* The real interrupt service routines are called
362 whenever the card wants its hand held--chars
363 received, out buffer empty, modem change, etc.
365 static irqreturn_t cd2401_rxerr_interrupt(int irq, void *dev_id)
367 struct tty_struct *tty;
368 struct cyclades_port *info;
369 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
370 unsigned char err, rfoc;
374 /* determine the channel and change to that context */
375 channel = (u_short) (base_addr[CyLICR] >> 2);
376 info = &cy_port[channel];
377 info->last_active = jiffies;
379 if ((err = base_addr[CyRISR]) & CyTIMEOUT) {
380 /* This is a receive timeout interrupt, ignore it */
381 base_addr[CyREOIR] = CyNOTRANS;
385 /* Read a byte of data if there is any - assume the error
386 * is associated with this character */
388 if ((rfoc = base_addr[CyRFOC]) != 0)
389 data = base_addr[CyRDR];
393 /* if there is nowhere to put the data, discard it */
394 if (info->tty == 0) {
395 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
397 } else { /* there is an open port for this data */
399 if (err & info->ignore_status_mask) {
400 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
403 if (tty_buffer_request_room(tty, 1) != 0) {
404 if (err & info->read_status_mask) {
406 tty_insert_flip_char(tty, data,
408 if (info->flags & ASYNC_SAK) {
411 } else if (err & CyFRAME) {
412 tty_insert_flip_char(tty, data,
414 } else if (err & CyPARITY) {
415 tty_insert_flip_char(tty, data,
417 } else if (err & CyOVERRUN) {
418 tty_insert_flip_char(tty, 0,
421 If the flip buffer itself is
422 overflowing, we still lose
423 the next incoming character.
425 if (tty_buffer_request_room(tty, 1) !=
427 tty_insert_flip_char(tty, data,
430 /* These two conditions may imply */
431 /* a normal read should be done. */
432 /* else if(data & CyTIMEOUT) */
433 /* else if(data & CySPECHAR) */
435 tty_insert_flip_char(tty, 0,
439 tty_insert_flip_char(tty, data, TTY_NORMAL);
442 /* there was a software buffer overrun
443 and nothing could be done about it!!! */
446 tty_schedule_flip(tty);
448 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
450 } /* cy_rxerr_interrupt */
452 static irqreturn_t cd2401_modem_interrupt(int irq, void *dev_id)
454 struct cyclades_port *info;
455 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
460 /* determine the channel and change to that context */
461 channel = (u_short) (base_addr[CyLICR] >> 2);
462 info = &cy_port[channel];
463 info->last_active = jiffies;
465 mdm_change = base_addr[CyMISR];
466 mdm_status = base_addr[CyMSVR1];
468 if (info->tty == 0) { /* nowhere to put the data, ignore it */
471 if ((mdm_change & CyDCD)
472 && (info->flags & ASYNC_CHECK_CD)) {
473 if (mdm_status & CyDCD) {
475 wake_up_interruptible(&info->open_wait);
478 tty_hangup(info->tty);
479 wake_up_interruptible(&info->open_wait);
480 info->flags &= ~ASYNC_NORMAL_ACTIVE;
483 if ((mdm_change & CyCTS)
484 && (info->flags & ASYNC_CTS_FLOW)) {
485 if (info->tty->stopped) {
486 if (mdm_status & CyCTS) {
487 /* !!! cy_start isn't used because... */
488 info->tty->stopped = 0;
489 base_addr[CyIER] |= CyTxMpty;
490 tty_wakeup(info->tty);
493 if (!(mdm_status & CyCTS)) {
494 /* !!! cy_stop isn't used because... */
495 info->tty->stopped = 1;
497 ~(CyTxMpty | CyTxRdy);
501 if (mdm_status & CyDSR) {
504 base_addr[CyMEOIR] = 0;
506 } /* cy_modem_interrupt */
508 static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
510 struct cyclades_port *info;
511 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
513 int char_count, saved_cnt;
516 /* determine the channel and change to that context */
517 channel = (u_short) (base_addr[CyLICR] >> 2);
519 #ifdef CONFIG_REMOTE_DEBUG
520 if (channel == DEBUG_PORT) {
521 panic("TxInt on debug port!!!");
525 info = &cy_port[channel];
527 /* validate the port number (as configured and open) */
528 if ((channel < 0) || (NR_PORTS <= channel)) {
529 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
530 base_addr[CyTEOIR] = CyNOTRANS;
533 info->last_active = jiffies;
534 if (info->tty == 0) {
535 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
536 base_addr[CyTEOIR] = CyNOTRANS;
540 /* load the on-chip space available for outbound data */
541 saved_cnt = char_count = base_addr[CyTFTC];
543 if (info->x_char) { /* send special char */
544 outch = info->x_char;
545 base_addr[CyTDR] = outch;
551 /* The Cirrus chip requires the "Embedded Transmit
552 Commands" of start break, delay, and end break
553 sequences to be sent. The duration of the
554 break is given in TICs, which runs at HZ
555 (typically 100) and the PPR runs at 200 Hz,
556 so the delay is duration * 200/HZ, and thus a
557 break can run from 1/100 sec to about 5/4 sec.
558 Need to check these values - RGH 141095.
560 base_addr[CyTDR] = 0; /* start break */
561 base_addr[CyTDR] = 0x81;
562 base_addr[CyTDR] = 0; /* delay a bit */
563 base_addr[CyTDR] = 0x82;
564 base_addr[CyTDR] = info->x_break * 200 / HZ;
565 base_addr[CyTDR] = 0; /* terminate break */
566 base_addr[CyTDR] = 0x83;
571 while (char_count > 0) {
572 if (!info->xmit_cnt) {
573 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
576 if (info->xmit_buf == 0) {
577 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
580 if (info->tty->stopped || info->tty->hw_stopped) {
581 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
584 /* Because the Embedded Transmit Commands have been
585 enabled, we must check to see if the escape
586 character, NULL, is being sent. If it is, we
587 must ensure that there is room for it to be
588 doubled in the output stream. Therefore we
589 no longer advance the pointer when the character
590 is fetched, but rather wait until after the check
591 for a NULL output character. (This is necessary
592 because there may not be room for the two chars
593 needed to send a NULL.
595 outch = info->xmit_buf[info->xmit_tail];
598 info->xmit_tail = (info->xmit_tail + 1)
600 base_addr[CyTDR] = outch;
603 if (char_count > 1) {
605 info->xmit_tail = (info->xmit_tail + 1)
607 base_addr[CyTDR] = outch;
608 base_addr[CyTDR] = 0;
617 if (info->xmit_cnt < WAKEUP_CHARS)
618 tty_wakeup(info->tty);
620 base_addr[CyTEOIR] = (char_count != saved_cnt) ? 0 : CyNOTRANS;
622 } /* cy_tx_interrupt */
624 static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
626 struct tty_struct *tty;
627 struct cyclades_port *info;
628 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
635 /* determine the channel and change to that context */
636 channel = (u_short) (base_addr[CyLICR] >> 2);
637 info = &cy_port[channel];
638 info->last_active = jiffies;
639 save_cnt = char_count = base_addr[CyRFOC];
641 #ifdef CONFIG_REMOTE_DEBUG
642 if (channel == DEBUG_PORT) {
643 while (char_count--) {
644 data = base_addr[CyRDR];
645 queueDebugChar(data);
649 /* if there is nowhere to put the data, discard it */
650 if (info->tty == 0) {
651 while (char_count--) {
652 data = base_addr[CyRDR];
654 } else { /* there is an open port for this data */
656 /* load # characters available from the chip */
658 #ifdef CYCLOM_ENABLE_MONITORING
659 ++info->mon.int_count;
660 info->mon.char_count += char_count;
661 if (char_count > info->mon.char_max)
662 info->mon.char_max = char_count;
663 info->mon.char_last = char_count;
665 len = tty_buffer_request_room(tty, char_count);
667 data = base_addr[CyRDR];
668 tty_insert_flip_char(tty, data, TTY_NORMAL);
669 #ifdef CYCLOM_16Y_HACK
673 tty_schedule_flip(tty);
676 base_addr[CyREOIR] = save_cnt ? 0 : CyNOTRANS;
678 } /* cy_rx_interrupt */
680 /* This is called whenever a port becomes active;
681 interrupts are enabled and DTR & RTS are turned on.
683 static int startup(struct cyclades_port *info)
686 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
689 if (info->flags & ASYNC_INITIALIZED) {
695 set_bit(TTY_IO_ERROR, &info->tty->flags);
699 if (!info->xmit_buf) {
700 info->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
701 if (!info->xmit_buf) {
708 channel = info->line;
710 #ifdef SERIAL_DEBUG_OPEN
711 printk("startup channel %d\n", channel);
714 local_irq_save(flags);
715 base_addr[CyCAR] = (u_char) channel;
716 write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
718 base_addr[CyCAR] = (u_char) channel; /* !!! Is this needed? */
719 base_addr[CyMSVR1] = CyRTS;
720 /* CP('S');CP('1'); */
721 base_addr[CyMSVR2] = CyDTR;
723 #ifdef SERIAL_DEBUG_DTR
724 printk("cyc: %d: raising DTR\n", __LINE__);
725 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
729 base_addr[CyIER] |= CyRxData;
730 info->flags |= ASYNC_INITIALIZED;
733 clear_bit(TTY_IO_ERROR, &info->tty->flags);
735 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
737 local_irq_restore(flags);
739 #ifdef SERIAL_DEBUG_OPEN
745 void start_xmit(struct cyclades_port *info)
748 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
751 channel = info->line;
752 local_irq_save(flags);
753 base_addr[CyCAR] = channel;
754 base_addr[CyIER] |= CyTxMpty;
755 local_irq_restore(flags);
759 * This routine shuts down a serial port; interrupts are disabled,
760 * and DTR is dropped if the hangup on close termio flag is on.
762 static void shutdown(struct cyclades_port *info)
765 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
768 if (!(info->flags & ASYNC_INITIALIZED)) {
773 channel = info->line;
775 #ifdef SERIAL_DEBUG_OPEN
776 printk("shutdown channel %d\n", channel);
779 /* !!! REALLY MUST WAIT FOR LAST CHARACTER TO BE
780 SENT BEFORE DROPPING THE LINE !!! (Perhaps
781 set some flag that is read when XMTY happens.)
782 Other choices are to delay some fixed interval
783 or schedule some later processing.
785 local_irq_save(flags);
786 if (info->xmit_buf) {
787 free_page((unsigned long)info->xmit_buf);
788 info->xmit_buf = NULL;
791 base_addr[CyCAR] = (u_char) channel;
792 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
793 base_addr[CyMSVR1] = 0;
794 /* CP('C');CP('1'); */
795 base_addr[CyMSVR2] = 0;
796 #ifdef SERIAL_DEBUG_DTR
797 printk("cyc: %d: dropping DTR\n", __LINE__);
798 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
802 write_cy_cmd(base_addr, CyDIS_RCVR);
803 /* it may be appropriate to clear _XMIT at
804 some later date (after testing)!!! */
807 set_bit(TTY_IO_ERROR, &info->tty->flags);
809 info->flags &= ~ASYNC_INITIALIZED;
810 local_irq_restore(flags);
812 #ifdef SERIAL_DEBUG_OPEN
818 * This routine finds or computes the various line characteristics.
820 static void config_setup(struct cyclades_port *info)
823 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
827 unsigned char ti, need_init_chan = 0;
829 if (!info->tty || !info->tty->termios) {
832 if (info->line == -1) {
835 cflag = info->tty->termios->c_cflag;
840 /* Starting with kernel 1.1.65, there is direct support for
841 higher baud rates. The following code supports those
842 changes. The conditional aspect allows this driver to be
843 used for earlier as well as later kernel versions. (The
844 mapping is slightly different from serial.c because there
845 is still the possibility of supporting 75 kbit/sec with
851 else if (i == B115200)
854 else if (i == B78600)
858 info->tty->termios->c_cflag &= ~CBAUDEX;
862 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
864 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
867 /* Don't ever change the speed of the console port. It will
868 * run at the speed specified in bootinfo, or at 19.2K */
869 /* Actually, it should run at whatever speed 166Bug was using */
870 /* Note info->timeout isn't used at present */
871 if (info != serial_console_info) {
872 info->tbpr = baud_bpr[i]; /* Tx BPR */
873 info->tco = baud_co[i]; /* Tx CO */
874 info->rbpr = baud_bpr[i]; /* Rx BPR */
875 info->rco = baud_co[i] >> 5; /* Rx CO */
876 if (baud_table[i] == 134) {
878 (info->xmit_fifo_size * HZ * 30 / 269) + 2;
879 /* get it right for 134.5 baud */
880 } else if (baud_table[i]) {
882 (info->xmit_fifo_size * HZ * 15 / baud_table[i]) +
884 /* this needs to be propagated into the card info */
889 /* By tradition (is it a standard?) a baud rate of zero
890 implies the line should be/has been closed. A bit
891 later in this routine such a test is performed. */
893 /* byte size and parity */
897 info->cor4 = (info->default_threshold ? info->default_threshold : baud_cor4[i]); /* receive threshold */
898 /* Following two lines added 101295, RGH. */
899 /* It is obviously wrong to access CyCORx, and not info->corx here,
900 * try and remember to fix it later! */
901 channel = info->line;
902 base_addr[CyCAR] = (u_char) channel;
903 if (C_CLOCAL(info->tty)) {
904 if (base_addr[CyIER] & CyMdmCh)
905 base_addr[CyIER] &= ~CyMdmCh; /* without modem intr */
906 /* ignore 1->0 modem transitions */
907 if (base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD))
908 base_addr[CyCOR4] &= ~(CyDSR | CyCTS | CyDCD);
909 /* ignore 0->1 modem transitions */
910 if (base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD))
911 base_addr[CyCOR5] &= ~(CyDSR | CyCTS | CyDCD);
913 if ((base_addr[CyIER] & CyMdmCh) != CyMdmCh)
914 base_addr[CyIER] |= CyMdmCh; /* with modem intr */
915 /* act on 1->0 modem transitions */
916 if ((base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD)) !=
917 (CyDSR | CyCTS | CyDCD))
918 base_addr[CyCOR4] |= CyDSR | CyCTS | CyDCD;
919 /* act on 0->1 modem transitions */
920 if ((base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD)) !=
921 (CyDSR | CyCTS | CyDCD))
922 base_addr[CyCOR5] |= CyDSR | CyCTS | CyDCD;
924 info->cor3 = (cflag & CSTOPB) ? Cy_2_STOP : Cy_1_STOP;
926 switch (cflag & CSIZE) {
928 info->cor1 = Cy_5_BITS;
931 info->cor1 = Cy_6_BITS;
934 info->cor1 = Cy_7_BITS;
937 info->cor1 = Cy_8_BITS;
940 if (cflag & PARENB) {
941 if (cflag & PARODD) {
942 info->cor1 |= CyPARITY_O;
944 info->cor1 |= CyPARITY_E;
947 info->cor1 |= CyPARITY_NONE;
950 /* CTS flow control flag */
952 /* Don't complcate matters for now! RGH 141095 */
953 if (cflag & CRTSCTS) {
954 info->flags |= ASYNC_CTS_FLOW;
955 info->cor2 |= CyCtsAE;
957 info->flags &= ~ASYNC_CTS_FLOW;
958 info->cor2 &= ~CyCtsAE;
962 info->flags &= ~ASYNC_CHECK_CD;
964 info->flags |= ASYNC_CHECK_CD;
966 /***********************************************
967 The hardware option, CyRtsAO, presents RTS when
968 the chip has characters to send. Since most modems
969 use RTS as reverse (inbound) flow control, this
970 option is not used. If inbound flow control is
971 necessary, DTR can be programmed to provide the
972 appropriate signals for use with a non-standard
973 cable. Contact Marcio Saito for details.
974 ***********************************************/
976 channel = info->line;
978 local_irq_save(flags);
979 base_addr[CyCAR] = (u_char) channel;
981 /* CyCMR set once only in mvme167_init_serial() */
982 if (base_addr[CyLICR] != channel << 2)
983 base_addr[CyLICR] = channel << 2;
984 if (base_addr[CyLIVR] != 0x5c)
985 base_addr[CyLIVR] = 0x5c;
987 /* tx and rx baud rate */
989 if (base_addr[CyCOR1] != info->cor1)
991 if (base_addr[CyTCOR] != info->tco)
992 base_addr[CyTCOR] = info->tco;
993 if (base_addr[CyTBPR] != info->tbpr)
994 base_addr[CyTBPR] = info->tbpr;
995 if (base_addr[CyRCOR] != info->rco)
996 base_addr[CyRCOR] = info->rco;
997 if (base_addr[CyRBPR] != info->rbpr)
998 base_addr[CyRBPR] = info->rbpr;
1000 /* set line characteristics according configuration */
1002 if (base_addr[CySCHR1] != START_CHAR(info->tty))
1003 base_addr[CySCHR1] = START_CHAR(info->tty);
1004 if (base_addr[CySCHR2] != STOP_CHAR(info->tty))
1005 base_addr[CySCHR2] = STOP_CHAR(info->tty);
1006 if (base_addr[CySCRL] != START_CHAR(info->tty))
1007 base_addr[CySCRL] = START_CHAR(info->tty);
1008 if (base_addr[CySCRH] != START_CHAR(info->tty))
1009 base_addr[CySCRH] = START_CHAR(info->tty);
1010 if (base_addr[CyCOR1] != info->cor1)
1011 base_addr[CyCOR1] = info->cor1;
1012 if (base_addr[CyCOR2] != info->cor2)
1013 base_addr[CyCOR2] = info->cor2;
1014 if (base_addr[CyCOR3] != info->cor3)
1015 base_addr[CyCOR3] = info->cor3;
1016 if (base_addr[CyCOR4] != info->cor4)
1017 base_addr[CyCOR4] = info->cor4;
1018 if (base_addr[CyCOR5] != info->cor5)
1019 base_addr[CyCOR5] = info->cor5;
1020 if (base_addr[CyCOR6] != info->cor6)
1021 base_addr[CyCOR6] = info->cor6;
1022 if (base_addr[CyCOR7] != info->cor7)
1023 base_addr[CyCOR7] = info->cor7;
1026 write_cy_cmd(base_addr, CyINIT_CHAN);
1028 base_addr[CyCAR] = (u_char) channel; /* !!! Is this needed? */
1030 /* 2ms default rx timeout */
1031 ti = info->default_timeout ? info->default_timeout : 0x02;
1032 if (base_addr[CyRTPRL] != ti)
1033 base_addr[CyRTPRL] = ti;
1034 if (base_addr[CyRTPRH] != 0)
1035 base_addr[CyRTPRH] = 0;
1037 /* Set up RTS here also ????? RGH 141095 */
1038 if (i == 0) { /* baud rate is zero, turn off line */
1039 if ((base_addr[CyMSVR2] & CyDTR) == CyDTR)
1040 base_addr[CyMSVR2] = 0;
1041 #ifdef SERIAL_DEBUG_DTR
1042 printk("cyc: %d: dropping DTR\n", __LINE__);
1043 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1044 base_addr[CyMSVR2]);
1047 if ((base_addr[CyMSVR2] & CyDTR) != CyDTR)
1048 base_addr[CyMSVR2] = CyDTR;
1049 #ifdef SERIAL_DEBUG_DTR
1050 printk("cyc: %d: raising DTR\n", __LINE__);
1051 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1052 base_addr[CyMSVR2]);
1057 clear_bit(TTY_IO_ERROR, &info->tty->flags);
1060 local_irq_restore(flags);
1062 } /* config_setup */
1064 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1066 struct cyclades_port *info = tty->driver_data;
1067 unsigned long flags;
1069 #ifdef SERIAL_DEBUG_IO
1070 printk("cy_put_char %s(0x%02x)\n", tty->name, ch);
1073 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1076 if (!info->xmit_buf)
1079 local_irq_save(flags);
1080 if (info->xmit_cnt >= PAGE_SIZE - 1) {
1081 local_irq_restore(flags);
1085 info->xmit_buf[info->xmit_head++] = ch;
1086 info->xmit_head &= PAGE_SIZE - 1;
1088 local_irq_restore(flags);
1092 static void cy_flush_chars(struct tty_struct *tty)
1094 struct cyclades_port *info = tty->driver_data;
1095 unsigned long flags;
1096 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1099 #ifdef SERIAL_DEBUG_IO
1100 printk("cy_flush_chars %s\n", tty->name); /* */
1103 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1106 if (info->xmit_cnt <= 0 || tty->stopped
1107 || tty->hw_stopped || !info->xmit_buf)
1110 channel = info->line;
1112 local_irq_save(flags);
1113 base_addr[CyCAR] = channel;
1114 base_addr[CyIER] |= CyTxMpty;
1115 local_irq_restore(flags);
1116 } /* cy_flush_chars */
1118 /* This routine gets called when tty_write has put something into
1119 the write_queue. If the port is not already transmitting stuff,
1120 start it off by enabling interrupts. The interrupt service
1121 routine will then ensure that the characters are sent. If the
1122 port is already active, there is no need to kick it.
1124 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1126 struct cyclades_port *info = tty->driver_data;
1127 unsigned long flags;
1130 #ifdef SERIAL_DEBUG_IO
1131 printk("cy_write %s\n", tty->name); /* */
1134 if (serial_paranoia_check(info, tty->name, "cy_write")) {
1138 if (!info->xmit_buf) {
1143 local_irq_save(flags);
1144 c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
1145 SERIAL_XMIT_SIZE - info->xmit_head));
1147 local_irq_restore(flags);
1151 memcpy(info->xmit_buf + info->xmit_head, buf, c);
1153 (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
1154 info->xmit_cnt += c;
1155 local_irq_restore(flags);
1162 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
1168 static int cy_write_room(struct tty_struct *tty)
1170 struct cyclades_port *info = tty->driver_data;
1173 #ifdef SERIAL_DEBUG_IO
1174 printk("cy_write_room %s\n", tty->name); /* */
1177 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1179 ret = PAGE_SIZE - info->xmit_cnt - 1;
1183 } /* cy_write_room */
1185 static int cy_chars_in_buffer(struct tty_struct *tty)
1187 struct cyclades_port *info = tty->driver_data;
1189 #ifdef SERIAL_DEBUG_IO
1190 printk("cy_chars_in_buffer %s %d\n", tty->name, info->xmit_cnt); /* */
1193 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1196 return info->xmit_cnt;
1197 } /* cy_chars_in_buffer */
1199 static void cy_flush_buffer(struct tty_struct *tty)
1201 struct cyclades_port *info = tty->driver_data;
1202 unsigned long flags;
1204 #ifdef SERIAL_DEBUG_IO
1205 printk("cy_flush_buffer %s\n", tty->name); /* */
1208 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1210 local_irq_save(flags);
1211 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1212 local_irq_restore(flags);
1214 } /* cy_flush_buffer */
1216 /* This routine is called by the upper-layer tty layer to signal
1217 that incoming characters should be throttled or that the
1218 throttle should be released.
1220 static void cy_throttle(struct tty_struct *tty)
1222 struct cyclades_port *info = tty->driver_data;
1223 unsigned long flags;
1224 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1227 #ifdef SERIAL_DEBUG_THROTTLE
1230 printk("throttle %s: %d....\n", tty_name(tty, buf),
1231 tty->ldisc.chars_in_buffer(tty));
1232 printk("cy_throttle %s\n", tty->name);
1235 if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1240 info->x_char = STOP_CHAR(tty);
1241 /* Should use the "Send Special Character" feature!!! */
1244 channel = info->line;
1246 local_irq_save(flags);
1247 base_addr[CyCAR] = (u_char) channel;
1248 base_addr[CyMSVR1] = 0;
1249 local_irq_restore(flags);
1252 static void cy_unthrottle(struct tty_struct *tty)
1254 struct cyclades_port *info = tty->driver_data;
1255 unsigned long flags;
1256 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1259 #ifdef SERIAL_DEBUG_THROTTLE
1262 printk("throttle %s: %d....\n", tty_name(tty, buf),
1263 tty->ldisc.chars_in_buffer(tty));
1264 printk("cy_unthrottle %s\n", tty->name);
1267 if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1272 info->x_char = START_CHAR(tty);
1273 /* Should use the "Send Special Character" feature!!! */
1276 channel = info->line;
1278 local_irq_save(flags);
1279 base_addr[CyCAR] = (u_char) channel;
1280 base_addr[CyMSVR1] = CyRTS;
1281 local_irq_restore(flags);
1282 } /* cy_unthrottle */
1285 get_serial_info(struct cyclades_port *info,
1286 struct serial_struct __user * retinfo)
1288 struct serial_struct tmp;
1293 memset(&tmp, 0, sizeof(tmp));
1294 tmp.type = info->type;
1295 tmp.line = info->line;
1296 tmp.port = info->line;
1298 tmp.flags = info->flags;
1299 tmp.baud_base = 0; /*!!! */
1300 tmp.close_delay = info->close_delay;
1301 tmp.custom_divisor = 0; /*!!! */
1302 tmp.hub6 = 0; /*!!! */
1303 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
1304 } /* get_serial_info */
1307 set_serial_info(struct cyclades_port *info,
1308 struct serial_struct __user * new_info)
1310 struct serial_struct new_serial;
1311 struct cyclades_port old_info;
1316 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
1320 if (!capable(CAP_SYS_ADMIN)) {
1321 if ((new_serial.close_delay != info->close_delay) ||
1322 ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
1323 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
1325 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1326 (new_serial.flags & ASYNC_USR_MASK));
1327 goto check_and_exit;
1331 * OK, past this point, all the error checking has been done.
1332 * At this point, we start making changes.....
1335 info->flags = ((info->flags & ~ASYNC_FLAGS) |
1336 (new_serial.flags & ASYNC_FLAGS));
1337 info->close_delay = new_serial.close_delay;
1340 if (info->flags & ASYNC_INITIALIZED) {
1344 return startup(info);
1345 } /* set_serial_info */
1347 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
1349 struct cyclades_port *info = tty->driver_data;
1351 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1352 unsigned long flags;
1353 unsigned char status;
1355 channel = info->line;
1357 local_irq_save(flags);
1358 base_addr[CyCAR] = (u_char) channel;
1359 status = base_addr[CyMSVR1] | base_addr[CyMSVR2];
1360 local_irq_restore(flags);
1362 return ((status & CyRTS) ? TIOCM_RTS : 0)
1363 | ((status & CyDTR) ? TIOCM_DTR : 0)
1364 | ((status & CyDCD) ? TIOCM_CAR : 0)
1365 | ((status & CyDSR) ? TIOCM_DSR : 0)
1366 | ((status & CyCTS) ? TIOCM_CTS : 0);
1370 cy_tiocmset(struct tty_struct *tty, struct file *file,
1371 unsigned int set, unsigned int clear)
1373 struct cyclades_port *info = tty->driver_data;
1375 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1376 unsigned long flags;
1378 channel = info->line;
1380 if (set & TIOCM_RTS) {
1381 local_irq_save(flags);
1382 base_addr[CyCAR] = (u_char) channel;
1383 base_addr[CyMSVR1] = CyRTS;
1384 local_irq_restore(flags);
1386 if (set & TIOCM_DTR) {
1387 local_irq_save(flags);
1388 base_addr[CyCAR] = (u_char) channel;
1389 /* CP('S');CP('2'); */
1390 base_addr[CyMSVR2] = CyDTR;
1391 #ifdef SERIAL_DEBUG_DTR
1392 printk("cyc: %d: raising DTR\n", __LINE__);
1393 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1394 base_addr[CyMSVR2]);
1396 local_irq_restore(flags);
1399 if (clear & TIOCM_RTS) {
1400 local_irq_save(flags);
1401 base_addr[CyCAR] = (u_char) channel;
1402 base_addr[CyMSVR1] = 0;
1403 local_irq_restore(flags);
1405 if (clear & TIOCM_DTR) {
1406 local_irq_save(flags);
1407 base_addr[CyCAR] = (u_char) channel;
1408 /* CP('C');CP('2'); */
1409 base_addr[CyMSVR2] = 0;
1410 #ifdef SERIAL_DEBUG_DTR
1411 printk("cyc: %d: dropping DTR\n", __LINE__);
1412 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1413 base_addr[CyMSVR2]);
1415 local_irq_restore(flags);
1419 } /* set_modem_info */
1421 static void send_break(struct cyclades_port *info, int duration)
1422 { /* Let the transmit ISR take care of this (since it
1423 requires stuffing characters into the output stream).
1425 info->x_break = duration;
1426 if (!info->xmit_cnt) {
1432 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
1435 if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
1437 info->mon.int_count = 0;
1438 info->mon.char_count = 0;
1439 info->mon.char_max = 0;
1440 info->mon.char_last = 0;
1444 static int set_threshold(struct cyclades_port *info, unsigned long __user * arg)
1446 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1447 unsigned long value;
1450 if (get_user(value, arg))
1453 channel = info->line;
1454 info->cor4 &= ~CyREC_FIFO;
1455 info->cor4 |= value & CyREC_FIFO;
1456 base_addr[CyCOR4] = info->cor4;
1461 get_threshold(struct cyclades_port *info, unsigned long __user * value)
1463 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1467 channel = info->line;
1469 tmp = base_addr[CyCOR4] & CyREC_FIFO;
1470 return put_user(tmp, value);
1474 set_default_threshold(struct cyclades_port *info, unsigned long __user * arg)
1476 unsigned long value;
1478 if (get_user(value, arg))
1481 info->default_threshold = value & 0x0f;
1486 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
1488 return put_user(info->default_threshold, value);
1491 static int set_timeout(struct cyclades_port *info, unsigned long __user * arg)
1493 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1495 unsigned long value;
1497 if (get_user(value, arg))
1500 channel = info->line;
1502 base_addr[CyRTPRL] = value & 0xff;
1503 base_addr[CyRTPRH] = (value >> 8) & 0xff;
1507 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
1509 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1513 channel = info->line;
1515 tmp = base_addr[CyRTPRL];
1516 return put_user(tmp, value);
1519 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
1521 info->default_timeout = value & 0xff;
1526 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
1528 return put_user(info->default_timeout, value);
1532 cy_ioctl(struct tty_struct *tty, struct file *file,
1533 unsigned int cmd, unsigned long arg)
1536 struct cyclades_port *info = tty->driver_data;
1538 void __user *argp = (void __user *)arg;
1540 #ifdef SERIAL_DEBUG_OTHER
1541 printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty->name, cmd, arg); /* */
1548 ret_val = get_mon_info(info, argp);
1551 ret_val = get_threshold(info, argp);
1554 ret_val = set_threshold(info, argp);
1556 case CYGETDEFTHRESH:
1557 ret_val = get_default_threshold(info, argp);
1559 case CYSETDEFTHRESH:
1560 ret_val = set_default_threshold(info, argp);
1563 ret_val = get_timeout(info, argp);
1566 ret_val = set_timeout(info, argp);
1568 case CYGETDEFTIMEOUT:
1569 ret_val = get_default_timeout(info, argp);
1571 case CYSETDEFTIMEOUT:
1572 ret_val = set_default_timeout(info, (unsigned long)arg);
1574 case TCSBRK: /* SVID version: non-zero arg --> no break */
1575 ret_val = tty_check_change(tty);
1578 tty_wait_until_sent(tty, 0);
1580 send_break(info, HZ / 4); /* 1/4 second */
1582 case TCSBRKP: /* support for POSIX tcsendbreak() */
1583 ret_val = tty_check_change(tty);
1586 tty_wait_until_sent(tty, 0);
1587 send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
1590 /* The following commands are incompletely implemented!!! */
1592 ret_val = get_serial_info(info, argp);
1595 ret_val = set_serial_info(info, argp);
1598 ret_val = -ENOIOCTLCMD;
1602 #ifdef SERIAL_DEBUG_OTHER
1603 printk("cy_ioctl done\n");
1609 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1611 struct cyclades_port *info = tty->driver_data;
1613 #ifdef SERIAL_DEBUG_OTHER
1614 printk("cy_set_termios %s\n", tty->name);
1617 if (tty->termios->c_cflag == old_termios->c_cflag)
1621 if ((old_termios->c_cflag & CRTSCTS) &&
1622 !(tty->termios->c_cflag & CRTSCTS)) {
1626 #ifdef tytso_patch_94Nov25_1726
1627 if (!(old_termios->c_cflag & CLOCAL) &&
1628 (tty->termios->c_cflag & CLOCAL))
1629 wake_up_interruptible(&info->open_wait);
1631 } /* cy_set_termios */
1633 static void cy_close(struct tty_struct *tty, struct file *filp)
1635 struct cyclades_port *info = tty->driver_data;
1638 #ifdef SERIAL_DEBUG_OTHER
1639 printk("cy_close %s\n", tty->name);
1642 if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
1645 #ifdef SERIAL_DEBUG_OPEN
1646 printk("cy_close %s, count = %d\n", tty->name, info->count);
1649 if ((tty->count == 1) && (info->count != 1)) {
1651 * Uh, oh. tty->count is 1, which means that the tty
1652 * structure will be freed. Info->count should always
1653 * be one in these conditions. If it's greater than
1654 * one, we've got real problems, since it means the
1655 * serial port won't be shutdown.
1657 printk("cy_close: bad serial port count; tty->count is 1, "
1658 "info->count is %d\n", info->count);
1661 #ifdef SERIAL_DEBUG_COUNT
1662 printk("cyc: %d: decrementing count to %d\n", __LINE__,
1665 if (--info->count < 0) {
1666 printk("cy_close: bad serial port count for ttys%d: %d\n",
1667 info->line, info->count);
1668 #ifdef SERIAL_DEBUG_COUNT
1669 printk("cyc: %d: setting count to 0\n", __LINE__);
1675 info->flags |= ASYNC_CLOSING;
1676 if (info->flags & ASYNC_INITIALIZED)
1677 tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
1679 cy_flush_buffer(tty);
1680 tty_ldisc_flush(tty);
1682 if (info->blocked_open) {
1683 if (info->close_delay) {
1684 msleep_interruptible(jiffies_to_msecs
1685 (info->close_delay));
1687 wake_up_interruptible(&info->open_wait);
1689 info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1690 wake_up_interruptible(&info->close_wait);
1692 #ifdef SERIAL_DEBUG_OTHER
1693 printk("cy_close done\n");
1698 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
1700 void cy_hangup(struct tty_struct *tty)
1702 struct cyclades_port *info = tty->driver_data;
1704 #ifdef SERIAL_DEBUG_OTHER
1705 printk("cy_hangup %s\n", tty->name); /* */
1708 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
1715 #ifdef SERIAL_DEBUG_COUNT
1716 printk("cyc: %d: setting count to 0\n", __LINE__);
1720 info->flags &= ~ASYNC_NORMAL_ACTIVE;
1721 wake_up_interruptible(&info->open_wait);
1725 * ------------------------------------------------------------
1726 * cy_open() and friends
1727 * ------------------------------------------------------------
1731 block_til_ready(struct tty_struct *tty, struct file *filp,
1732 struct cyclades_port *info)
1734 DECLARE_WAITQUEUE(wait, current);
1735 unsigned long flags;
1738 volatile u_char *base_addr = (u_char *) BASE_ADDR;
1741 * If the device is in the middle of being closed, then block
1742 * until it's done, and then try again.
1744 if (info->flags & ASYNC_CLOSING) {
1745 interruptible_sleep_on(&info->close_wait);
1746 if (info->flags & ASYNC_HUP_NOTIFY) {
1749 return -ERESTARTSYS;
1754 * If non-blocking mode is set, then make the check up front
1757 if (filp->f_flags & O_NONBLOCK) {
1758 info->flags |= ASYNC_NORMAL_ACTIVE;
1763 * Block waiting for the carrier detect and the line to become
1764 * free (i.e., not in use by the callout). While we are in
1765 * this loop, info->count is dropped by one, so that
1766 * cy_close() knows when to free things. We restore it upon
1767 * exit, either normal or abnormal.
1770 add_wait_queue(&info->open_wait, &wait);
1771 #ifdef SERIAL_DEBUG_OPEN
1772 printk("block_til_ready before block: %s, count = %d\n",
1773 tty->name, info->count);
1777 #ifdef SERIAL_DEBUG_COUNT
1778 printk("cyc: %d: decrementing count to %d\n", __LINE__, info->count);
1780 info->blocked_open++;
1782 channel = info->line;
1785 local_irq_save(flags);
1786 base_addr[CyCAR] = (u_char) channel;
1787 base_addr[CyMSVR1] = CyRTS;
1788 /* CP('S');CP('4'); */
1789 base_addr[CyMSVR2] = CyDTR;
1790 #ifdef SERIAL_DEBUG_DTR
1791 printk("cyc: %d: raising DTR\n", __LINE__);
1792 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1793 base_addr[CyMSVR2]);
1795 local_irq_restore(flags);
1796 set_current_state(TASK_INTERRUPTIBLE);
1797 if (tty_hung_up_p(filp)
1798 || !(info->flags & ASYNC_INITIALIZED)) {
1799 if (info->flags & ASYNC_HUP_NOTIFY) {
1802 retval = -ERESTARTSYS;
1806 local_irq_save(flags);
1807 base_addr[CyCAR] = (u_char) channel;
1808 /* CP('L');CP1(1 && C_CLOCAL(tty)); CP1(1 && (base_addr[CyMSVR1] & CyDCD) ); */
1809 if (!(info->flags & ASYNC_CLOSING)
1811 || (base_addr[CyMSVR1] & CyDCD))) {
1812 local_irq_restore(flags);
1815 local_irq_restore(flags);
1816 if (signal_pending(current)) {
1817 retval = -ERESTARTSYS;
1820 #ifdef SERIAL_DEBUG_OPEN
1821 printk("block_til_ready blocking: %s, count = %d\n",
1822 tty->name, info->count);
1827 __set_current_state(TASK_RUNNING);
1828 remove_wait_queue(&info->open_wait, &wait);
1829 if (!tty_hung_up_p(filp)) {
1831 #ifdef SERIAL_DEBUG_COUNT
1832 printk("cyc: %d: incrementing count to %d\n", __LINE__,
1836 info->blocked_open--;
1837 #ifdef SERIAL_DEBUG_OPEN
1838 printk("block_til_ready after blocking: %s, count = %d\n",
1839 tty->name, info->count);
1844 info->flags |= ASYNC_NORMAL_ACTIVE;
1846 } /* block_til_ready */
1849 * This routine is called whenever a serial port is opened. It
1850 * performs the serial-specific initialization for the tty structure.
1852 int cy_open(struct tty_struct *tty, struct file *filp)
1854 struct cyclades_port *info;
1859 if ((line < 0) || (NR_PORTS <= line)) {
1862 info = &cy_port[line];
1863 if (info->line < 0) {
1866 #ifdef SERIAL_DEBUG_OTHER
1867 printk("cy_open %s\n", tty->name); /* */
1869 if (serial_paranoia_check(info, tty->name, "cy_open")) {
1872 #ifdef SERIAL_DEBUG_OPEN
1873 printk("cy_open %s, count = %d\n", tty->name, info->count);
1877 #ifdef SERIAL_DEBUG_COUNT
1878 printk("cyc: %d: incrementing count to %d\n", __LINE__, info->count);
1880 tty->driver_data = info;
1884 * Start up serial port
1886 retval = startup(info);
1891 retval = block_til_ready(tty, filp, info);
1893 #ifdef SERIAL_DEBUG_OPEN
1894 printk("cy_open returning after block_til_ready with %d\n",
1899 #ifdef SERIAL_DEBUG_OPEN
1900 printk("cy_open done\n");
1907 * ---------------------------------------------------------------------
1908 * serial167_init() and friends
1910 * serial167_init() is called at boot-time to initialize the serial driver.
1911 * ---------------------------------------------------------------------
1915 * This routine prints out the appropriate serial driver version
1916 * number, and identifies which options were configured into this
1919 static void show_version(void)
1921 printk("MVME166/167 cd2401 driver\n");
1922 } /* show_version */
1924 /* initialize chips on card -- return number of valid
1925 chips (which is number of ports/4) */
1928 * This initialises the hardware to a reasonable state. It should
1929 * probe the chip first so as to copy 166-Bug setup as a default for
1930 * port 0. It initialises CMR to CyASYNC; that is never done again, so
1931 * as to limit the number of CyINIT_CHAN commands in normal running.
1933 * ... I wonder what I should do if this fails ...
1936 void mvme167_serial_console_setup(int cflag)
1938 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1941 u_char rcor, rbpr, badspeed = 0;
1942 unsigned long flags;
1944 local_irq_save(flags);
1947 * First probe channel zero of the chip, to see what speed has
1951 base_addr[CyCAR] = 0;
1953 rcor = base_addr[CyRCOR] << 5;
1954 rbpr = base_addr[CyRBPR];
1956 for (spd = 0; spd < sizeof(baud_bpr); spd++)
1957 if (rbpr == baud_bpr[spd] && rcor == baud_co[spd])
1959 if (spd >= sizeof(baud_bpr)) {
1960 spd = 14; /* 19200 */
1961 badspeed = 1; /* Failed to identify speed */
1963 initial_console_speed = spd;
1965 /* OK, we have chosen a speed, now reset and reinitialise */
1967 my_udelay(20000L); /* Allow time for any active o/p to complete */
1968 if (base_addr[CyCCR] != 0x00) {
1969 local_irq_restore(flags);
1970 /* printk(" chip is never idle (CCR != 0)\n"); */
1974 base_addr[CyCCR] = CyCHIP_RESET; /* Reset the chip */
1977 if (base_addr[CyGFRCR] == 0x00) {
1978 local_irq_restore(flags);
1979 /* printk(" chip is not responding (GFRCR stayed 0)\n"); */
1984 * System clock is 20Mhz, divided by 2048, so divide by 10 for a 1.0ms
1988 base_addr[CyTPR] = 10;
1990 base_addr[CyPILR1] = 0x01; /* Interrupt level for modem change */
1991 base_addr[CyPILR2] = 0x02; /* Interrupt level for tx ints */
1992 base_addr[CyPILR3] = 0x03; /* Interrupt level for rx ints */
1995 * Attempt to set up all channels to something reasonable, and
1996 * bang out a INIT_CHAN command. We should then be able to limit
1997 * the ammount of fiddling we have to do in normal running.
2000 for (ch = 3; ch >= 0; ch--) {
2001 base_addr[CyCAR] = (u_char) ch;
2002 base_addr[CyIER] = 0;
2003 base_addr[CyCMR] = CyASYNC;
2004 base_addr[CyLICR] = (u_char) ch << 2;
2005 base_addr[CyLIVR] = 0x5c;
2006 base_addr[CyTCOR] = baud_co[spd];
2007 base_addr[CyTBPR] = baud_bpr[spd];
2008 base_addr[CyRCOR] = baud_co[spd] >> 5;
2009 base_addr[CyRBPR] = baud_bpr[spd];
2010 base_addr[CySCHR1] = 'Q' & 0x1f;
2011 base_addr[CySCHR2] = 'X' & 0x1f;
2012 base_addr[CySCRL] = 0;
2013 base_addr[CySCRH] = 0;
2014 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
2015 base_addr[CyCOR2] = 0;
2016 base_addr[CyCOR3] = Cy_1_STOP;
2017 base_addr[CyCOR4] = baud_cor4[spd];
2018 base_addr[CyCOR5] = 0;
2019 base_addr[CyCOR6] = 0;
2020 base_addr[CyCOR7] = 0;
2021 base_addr[CyRTPRL] = 2;
2022 base_addr[CyRTPRH] = 0;
2023 base_addr[CyMSVR1] = 0;
2024 base_addr[CyMSVR2] = 0;
2025 write_cy_cmd(base_addr, CyINIT_CHAN | CyDIS_RCVR | CyDIS_XMTR);
2029 * Now do specials for channel zero....
2032 base_addr[CyMSVR1] = CyRTS;
2033 base_addr[CyMSVR2] = CyDTR;
2034 base_addr[CyIER] = CyRxData;
2035 write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
2037 local_irq_restore(flags);
2039 my_udelay(20000L); /* Let it all settle down */
2041 printk("CD2401 initialised, chip is rev 0x%02x\n", base_addr[CyGFRCR]);
2044 (" WARNING: Failed to identify line speed, rcor=%02x,rbpr=%02x\n",
2046 } /* serial_console_init */
2048 static const struct tty_operations cy_ops = {
2052 .put_char = cy_put_char,
2053 .flush_chars = cy_flush_chars,
2054 .write_room = cy_write_room,
2055 .chars_in_buffer = cy_chars_in_buffer,
2056 .flush_buffer = cy_flush_buffer,
2058 .throttle = cy_throttle,
2059 .unthrottle = cy_unthrottle,
2060 .set_termios = cy_set_termios,
2063 .hangup = cy_hangup,
2064 .tiocmget = cy_tiocmget,
2065 .tiocmset = cy_tiocmset,
2068 /* The serial driver boot-time initialization code!
2069 Hardware I/O ports are mapped to character special devices on a
2070 first found, first allocated manner. That is, this code searches
2071 for Cyclom cards in the system. As each is found, it is probed
2072 to discover how many chips (and thus how many ports) are present.
2073 These ports are mapped to the tty ports 64 and upward in monotonic
2074 fashion. If an 8-port card is replaced with a 16-port card, the
2075 port mapping on a following card will shift.
2077 This approach is different from what is used in the other serial
2078 device driver because the Cyclom is more properly a multiplexer,
2079 not just an aggregation of serial ports on one card.
2081 If there are more cards with more ports than have been statically
2082 allocated above, a warning is printed and the extra ports are ignored.
2084 static int __init serial167_init(void)
2086 struct cyclades_port *info;
2093 struct sigaction sa;
2096 if (!(mvme16x_config & MVME16x_CONFIG_GOT_CD2401))
2099 cy_serial_driver = alloc_tty_driver(NR_PORTS);
2100 if (!cy_serial_driver)
2109 /* Has "console=0,9600n8" been used in bootinfo to change speed? */
2110 if (serial_console_cflag)
2111 DefSpeed = serial_console_cflag & 0017;
2113 DefSpeed = initial_console_speed;
2114 serial_console_info = &cy_port[0];
2115 serial_console_cflag = DefSpeed | CS8;
2117 serial_console = 64; /*callout_driver.minor_start */
2121 /* Initialize the tty_driver structure */
2123 cy_serial_driver->owner = THIS_MODULE;
2124 cy_serial_driver->name = "ttyS";
2125 cy_serial_driver->major = TTY_MAJOR;
2126 cy_serial_driver->minor_start = 64;
2127 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
2128 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
2129 cy_serial_driver->init_termios = tty_std_termios;
2130 cy_serial_driver->init_termios.c_cflag =
2131 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2132 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
2133 tty_set_operations(cy_serial_driver, &cy_ops);
2135 ret = tty_register_driver(cy_serial_driver);
2137 printk(KERN_ERR "Couldn't register MVME166/7 serial driver\n");
2138 put_tty_driver(cy_serial_driver);
2144 for (index = 0; index < 1; index++) {
2148 if (port_num < NR_PORTS) {
2149 while (good_ports-- && port_num < NR_PORTS) {
2150 /*** initialize port ***/
2151 info->magic = CYCLADES_MAGIC;
2152 info->type = PORT_CIRRUS;
2154 info->line = port_num;
2155 info->flags = STD_COM_FLAGS;
2157 info->xmit_fifo_size = 12;
2158 info->cor1 = CyPARITY_NONE | Cy_8_BITS;
2160 info->cor3 = Cy_1_STOP;
2161 info->cor4 = 0x08; /* _very_ small receive threshold */
2165 info->tbpr = baud_bpr[DefSpeed]; /* Tx BPR */
2166 info->tco = baud_co[DefSpeed]; /* Tx CO */
2167 info->rbpr = baud_bpr[DefSpeed]; /* Rx BPR */
2168 info->rco = baud_co[DefSpeed] >> 5; /* Rx CO */
2169 info->close_delay = 0;
2172 #ifdef SERIAL_DEBUG_COUNT
2173 printk("cyc: %d: setting count to 0\n",
2176 info->blocked_open = 0;
2177 info->default_threshold = 0;
2178 info->default_timeout = 0;
2179 init_waitqueue_head(&info->open_wait);
2180 init_waitqueue_head(&info->close_wait);
2183 /*** !!!!!!!! this may expose new bugs !!!!!!!!! *********/
2184 info->read_status_mask =
2185 CyTIMEOUT | CySPECHAR | CyBREAK | CyPARITY |
2186 CyFRAME | CyOVERRUN;
2189 printk("ttyS%d ", info->line);
2192 if (!(port_num & 7)) {
2199 while (port_num < NR_PORTS) {
2204 #ifdef CONFIG_REMOTE_DEBUG
2207 ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0,
2208 "cd2401_errors", cd2401_rxerr_interrupt);
2210 printk(KERN_ERR "Could't get cd2401_errors IRQ");
2211 goto cleanup_serial_driver;
2214 ret = request_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt, 0,
2215 "cd2401_modem", cd2401_modem_interrupt);
2217 printk(KERN_ERR "Could't get cd2401_modem IRQ");
2218 goto cleanup_irq_cd2401_errors;
2221 ret = request_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt, 0,
2222 "cd2401_txints", cd2401_tx_interrupt);
2224 printk(KERN_ERR "Could't get cd2401_txints IRQ");
2225 goto cleanup_irq_cd2401_modem;
2228 ret = request_irq(MVME167_IRQ_SER_RX, cd2401_rx_interrupt, 0,
2229 "cd2401_rxints", cd2401_rx_interrupt);
2231 printk(KERN_ERR "Could't get cd2401_rxints IRQ");
2232 goto cleanup_irq_cd2401_txints;
2235 /* Now we have registered the interrupt handlers, allow the interrupts */
2237 pcc2chip[PccSCCMICR] = 0x15; /* Serial ints are level 5 */
2238 pcc2chip[PccSCCTICR] = 0x15;
2239 pcc2chip[PccSCCRICR] = 0x15;
2241 pcc2chip[PccIMLR] = 3; /* Allow PCC2 ints above 3!? */
2244 cleanup_irq_cd2401_txints:
2245 free_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt);
2246 cleanup_irq_cd2401_modem:
2247 free_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt);
2248 cleanup_irq_cd2401_errors:
2249 free_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt);
2250 cleanup_serial_driver:
2251 if (tty_unregister_driver(cy_serial_driver))
2253 "Couldn't unregister MVME166/7 serial driver\n");
2254 put_tty_driver(cy_serial_driver);
2256 } /* serial167_init */
2258 module_init(serial167_init);
2260 #ifdef CYCLOM_SHOW_STATUS
2261 static void show_status(int line_num)
2263 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2265 struct cyclades_port *info;
2266 unsigned long flags;
2268 info = &cy_port[line_num];
2269 channel = info->line;
2270 printk(" channel %d\n", channel);
2271 /**/ printk(" cy_port\n");
2272 printk(" card line flags = %d %d %x\n",
2273 info->card, info->line, info->flags);
2275 (" *tty read_status_mask timeout xmit_fifo_size = %lx %x %x %x\n",
2276 (long)info->tty, info->read_status_mask, info->timeout,
2277 info->xmit_fifo_size);
2278 printk(" cor1,cor2,cor3,cor4,cor5,cor6,cor7 = %x %x %x %x %x %x %x\n",
2279 info->cor1, info->cor2, info->cor3, info->cor4, info->cor5,
2280 info->cor6, info->cor7);
2281 printk(" tbpr,tco,rbpr,rco = %d %d %d %d\n", info->tbpr, info->tco,
2282 info->rbpr, info->rco);
2283 printk(" close_delay event count = %d %d %d\n", info->close_delay,
2284 info->event, info->count);
2285 printk(" x_char blocked_open = %x %x\n", info->x_char,
2286 info->blocked_open);
2287 printk(" open_wait = %lx %lx %lx\n", (long)info->open_wait);
2289 local_irq_save(flags);
2291 /* Global Registers */
2293 printk(" CyGFRCR %x\n", base_addr[CyGFRCR]);
2294 printk(" CyCAR %x\n", base_addr[CyCAR]);
2295 printk(" CyRISR %x\n", base_addr[CyRISR]);
2296 printk(" CyTISR %x\n", base_addr[CyTISR]);
2297 printk(" CyMISR %x\n", base_addr[CyMISR]);
2298 printk(" CyRIR %x\n", base_addr[CyRIR]);
2299 printk(" CyTIR %x\n", base_addr[CyTIR]);
2300 printk(" CyMIR %x\n", base_addr[CyMIR]);
2301 printk(" CyTPR %x\n", base_addr[CyTPR]);
2303 base_addr[CyCAR] = (u_char) channel;
2305 /* Virtual Registers */
2308 printk(" CyRIVR %x\n", base_addr[CyRIVR]);
2309 printk(" CyTIVR %x\n", base_addr[CyTIVR]);
2310 printk(" CyMIVR %x\n", base_addr[CyMIVR]);
2311 printk(" CyMISR %x\n", base_addr[CyMISR]);
2314 /* Channel Registers */
2316 printk(" CyCCR %x\n", base_addr[CyCCR]);
2317 printk(" CyIER %x\n", base_addr[CyIER]);
2318 printk(" CyCOR1 %x\n", base_addr[CyCOR1]);
2319 printk(" CyCOR2 %x\n", base_addr[CyCOR2]);
2320 printk(" CyCOR3 %x\n", base_addr[CyCOR3]);
2321 printk(" CyCOR4 %x\n", base_addr[CyCOR4]);
2322 printk(" CyCOR5 %x\n", base_addr[CyCOR5]);
2324 printk(" CyCCSR %x\n", base_addr[CyCCSR]);
2325 printk(" CyRDCR %x\n", base_addr[CyRDCR]);
2327 printk(" CySCHR1 %x\n", base_addr[CySCHR1]);
2328 printk(" CySCHR2 %x\n", base_addr[CySCHR2]);
2330 printk(" CySCHR3 %x\n", base_addr[CySCHR3]);
2331 printk(" CySCHR4 %x\n", base_addr[CySCHR4]);
2332 printk(" CySCRL %x\n", base_addr[CySCRL]);
2333 printk(" CySCRH %x\n", base_addr[CySCRH]);
2334 printk(" CyLNC %x\n", base_addr[CyLNC]);
2335 printk(" CyMCOR1 %x\n", base_addr[CyMCOR1]);
2336 printk(" CyMCOR2 %x\n", base_addr[CyMCOR2]);
2338 printk(" CyRTPRL %x\n", base_addr[CyRTPRL]);
2339 printk(" CyRTPRH %x\n", base_addr[CyRTPRH]);
2340 printk(" CyMSVR1 %x\n", base_addr[CyMSVR1]);
2341 printk(" CyMSVR2 %x\n", base_addr[CyMSVR2]);
2342 printk(" CyRBPR %x\n", base_addr[CyRBPR]);
2343 printk(" CyRCOR %x\n", base_addr[CyRCOR]);
2344 printk(" CyTBPR %x\n", base_addr[CyTBPR]);
2345 printk(" CyTCOR %x\n", base_addr[CyTCOR]);
2347 local_irq_restore(flags);
2352 /* Dummy routine in mvme16x/config.c for now */
2354 /* Serial console setup. Called from linux/init/main.c */
2356 void console_setup(char *str, int *ints)
2359 int baud, bits, parity;
2363 if (ints[0] > 3 || ints[1] > 3)
2366 /* Get baud, bits and parity */
2372 if ((s = strchr(str, ','))) {
2375 } while (*s >= '0' && *s <= '9');
2382 /* Now construct a cflag setting. */
2421 serial_console_info = &cy_port[ints[1]];
2422 serial_console_cflag = cflag;
2423 serial_console = ints[1] + 64; /*callout_driver.minor_start */
2428 * The following is probably out of date for 2.1.x serial console stuff.
2430 * The console is registered early on from arch/m68k/kernel/setup.c, and
2431 * it therefore relies on the chip being setup correctly by 166-Bug. This
2432 * seems reasonable, as the serial port has been used to invoke the system
2433 * boot. It also means that this function must not rely on any data
2434 * initialisation performed by serial167_init() etc.
2436 * Of course, once the console has been registered, we had better ensure
2437 * that serial167_init() doesn't leave the chip non-functional.
2439 * The console must be locked when we get here.
2442 void serial167_console_write(struct console *co, const char *str,
2445 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2446 unsigned long flags;
2447 volatile u_char sink;
2453 local_irq_save(flags);
2455 /* Ensure transmitter is enabled! */
2458 base_addr[CyCAR] = (u_char) port;
2459 while (base_addr[CyCCR])
2461 base_addr[CyCCR] = CyENB_XMTR;
2463 ier = base_addr[CyIER];
2464 base_addr[CyIER] = CyTxMpty;
2467 if (pcc2chip[PccSCCTICR] & 0x20) {
2468 /* We have a Tx int. Acknowledge it */
2469 sink = pcc2chip[PccTPIACKR];
2470 if ((base_addr[CyLICR] >> 2) == port) {
2472 /* Last char of string is now output */
2473 base_addr[CyTEOIR] = CyNOTRANS;
2477 base_addr[CyTDR] = '\n';
2481 } else if (*str == '\n') {
2482 base_addr[CyTDR] = '\r';
2485 base_addr[CyTDR] = *str++;
2488 base_addr[CyTEOIR] = 0;
2490 base_addr[CyTEOIR] = CyNOTRANS;
2494 base_addr[CyIER] = ier;
2496 local_irq_restore(flags);
2499 static struct tty_driver *serial167_console_device(struct console *c,
2503 return cy_serial_driver;
2506 static struct console sercons = {
2508 .write = serial167_console_write,
2509 .device = serial167_console_device,
2510 .flags = CON_PRINTBUFFER,
2514 static int __init serial167_console_init(void)
2516 if (vme_brdtype == VME_TYPE_MVME166 ||
2517 vme_brdtype == VME_TYPE_MVME167 ||
2518 vme_brdtype == VME_TYPE_MVME177) {
2519 mvme167_serial_console_setup(0);
2520 register_console(&sercons);
2525 console_initcall(serial167_console_init);
2527 #ifdef CONFIG_REMOTE_DEBUG
2528 void putDebugChar(int c)
2530 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2531 unsigned long flags;
2532 volatile u_char sink;
2536 local_irq_save(flags);
2538 /* Ensure transmitter is enabled! */
2541 base_addr[CyCAR] = (u_char) port;
2542 while (base_addr[CyCCR])
2544 base_addr[CyCCR] = CyENB_XMTR;
2546 ier = base_addr[CyIER];
2547 base_addr[CyIER] = CyTxMpty;
2550 if (pcc2chip[PccSCCTICR] & 0x20) {
2551 /* We have a Tx int. Acknowledge it */
2552 sink = pcc2chip[PccTPIACKR];
2553 if ((base_addr[CyLICR] >> 2) == port) {
2554 base_addr[CyTDR] = c;
2555 base_addr[CyTEOIR] = 0;
2558 base_addr[CyTEOIR] = CyNOTRANS;
2562 base_addr[CyIER] = ier;
2564 local_irq_restore(flags);
2569 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2570 unsigned long flags;
2571 volatile u_char sink;
2577 if (i != debugiq.in) {
2579 if (++i == DEBUG_LEN)
2584 /* OK, nothing in queue, wait in poll loop */
2586 local_irq_save(flags);
2588 /* Ensure receiver is enabled! */
2591 base_addr[CyCAR] = (u_char) port;
2593 while (base_addr[CyCCR])
2595 base_addr[CyCCR] = CyENB_RCVR;
2597 ier = base_addr[CyIER];
2598 base_addr[CyIER] = CyRxData;
2601 if (pcc2chip[PccSCCRICR] & 0x20) {
2602 /* We have a Rx int. Acknowledge it */
2603 sink = pcc2chip[PccRPIACKR];
2604 if ((base_addr[CyLICR] >> 2) == port) {
2605 int cnt = base_addr[CyRFOC];
2607 c = base_addr[CyRDR];
2610 ("!! debug char is null (cnt=%d) !!",
2615 base_addr[CyREOIR] = 0;
2617 if (i == debugiq.in)
2618 panic("Debug input queue empty!");
2620 if (++i == DEBUG_LEN)
2625 base_addr[CyREOIR] = CyNOTRANS;
2629 base_addr[CyIER] = ier;
2631 local_irq_restore(flags);
2636 void queueDebugChar(int c)
2642 if (++i == DEBUG_LEN)
2644 if (i != debugiq.out)
2648 static void debug_setup()
2650 unsigned long flags;
2651 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2656 local_irq_save(flags);
2658 for (i = 0; i < 4; i++) {
2659 base_addr[CyCAR] = i;
2660 base_addr[CyLICR] = i << 2;
2663 debugiq.in = debugiq.out = 0;
2665 base_addr[CyCAR] = DEBUG_PORT;
2670 base_addr[CyIER] = 0;
2672 base_addr[CyCMR] = CyASYNC;
2673 base_addr[CyLICR] = DEBUG_PORT << 2;
2674 base_addr[CyLIVR] = 0x5c;
2676 /* tx and rx baud rate */
2678 base_addr[CyTCOR] = baud_co[i];
2679 base_addr[CyTBPR] = baud_bpr[i];
2680 base_addr[CyRCOR] = baud_co[i] >> 5;
2681 base_addr[CyRBPR] = baud_bpr[i];
2683 /* set line characteristics according configuration */
2685 base_addr[CySCHR1] = 0;
2686 base_addr[CySCHR2] = 0;
2687 base_addr[CySCRL] = 0;
2688 base_addr[CySCRH] = 0;
2689 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
2690 base_addr[CyCOR2] = 0;
2691 base_addr[CyCOR3] = Cy_1_STOP;
2692 base_addr[CyCOR4] = baud_cor4[i];
2693 base_addr[CyCOR5] = 0;
2694 base_addr[CyCOR6] = 0;
2695 base_addr[CyCOR7] = 0;
2697 write_cy_cmd(base_addr, CyINIT_CHAN);
2698 write_cy_cmd(base_addr, CyENB_RCVR);
2700 base_addr[CyCAR] = DEBUG_PORT; /* !!! Is this needed? */
2702 base_addr[CyRTPRL] = 2;
2703 base_addr[CyRTPRH] = 0;
2705 base_addr[CyMSVR1] = CyRTS;
2706 base_addr[CyMSVR2] = CyDTR;
2708 base_addr[CyIER] = CyRxData;
2710 local_irq_restore(flags);
2716 MODULE_LICENSE("GPL");