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>
67 #include <linux/gfp.h>
69 #include <asm/system.h>
71 #include <asm/mvme16xhw.h>
72 #include <asm/bootinfo.h>
73 #include <asm/setup.h>
75 #include <linux/types.h>
76 #include <linux/kernel.h>
78 #include <asm/uaccess.h>
79 #include <linux/init.h>
81 #define SERIAL_PARANOIA_CHECK
82 #undef SERIAL_DEBUG_OPEN
83 #undef SERIAL_DEBUG_THROTTLE
84 #undef SERIAL_DEBUG_OTHER
85 #undef SERIAL_DEBUG_IO
86 #undef SERIAL_DEBUG_COUNT
87 #undef SERIAL_DEBUG_DTR
88 #undef CYCLOM_16Y_HACK
89 #define CYCLOM_ENABLE_MONITORING
91 #define WAKEUP_CHARS 256
93 #define STD_COM_FLAGS (0)
95 static struct tty_driver *cy_serial_driver;
96 extern int serial_console;
97 static struct cyclades_port *serial_console_info = NULL;
98 static unsigned int serial_console_cflag = 0;
99 u_char initial_console_speed;
101 /* Base address of cd2401 chip on mvme166/7 */
103 #define BASE_ADDR (0xfff45000)
104 #define pcc2chip ((volatile u_char *)0xfff42000)
105 #define PccSCCMICR 0x1d
106 #define PccSCCTICR 0x1e
107 #define PccSCCRICR 0x1f
108 #define PccTPIACKR 0x25
109 #define PccRPIACKR 0x27
112 /* This is the per-port data structure */
113 struct cyclades_port cy_port[] = {
121 #define NR_PORTS ARRAY_SIZE(cy_port)
124 * This is used to look up the divisor speeds and the timeouts
125 * We're normally limited to 15 distinct baud rates. The extra
126 * are accessed via settings in info->flags.
127 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
128 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
131 static int baud_table[] = {
132 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
133 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
138 static char baud_co[] = { /* 25 MHz clock option table */
139 /* value => 00 01 02 03 04 */
140 /* divide by 8 32 128 512 2048 */
141 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
142 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
145 static char baud_bpr[] = { /* 25 MHz baud rate period table */
146 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
147 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
151 /* I think 166 brd clocks 2401 at 20MHz.... */
153 /* These values are written directly to tcor, and >> 5 for writing to rcor */
154 static u_char baud_co[] = { /* 20 MHz clock option table */
155 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
156 0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
159 /* These values written directly to tbpr/rbpr */
160 static u_char baud_bpr[] = { /* 20 MHz baud rate period table */
161 0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
162 0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
165 static u_char baud_cor4[] = { /* receive threshold */
166 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
167 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
170 static void shutdown(struct cyclades_port *);
171 static int startup(struct cyclades_port *);
172 static void cy_throttle(struct tty_struct *);
173 static void cy_unthrottle(struct tty_struct *);
174 static void config_setup(struct cyclades_port *);
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 (info < &cy_port[0] || info >= &cy_port[NR_PORTS]) {
225 printk("Warning: cyclades_port out of range for (%s) in %s\n",
230 if (info->magic != CYCLADES_MAGIC) {
231 printk("Warning: bad magic number for serial struct (%s) in "
232 "%s\n", name, routine);
237 } /* serial_paranoia_check */
240 /* The following diagnostic routines allow the driver to spew
241 information on the screen, even (especially!) during interrupts.
246 local_irq_save(flags);
247 printk(KERN_EMERG "%s", data);
248 local_irq_restore(flags);
255 local_irq_save(flags);
257 printk(KERN_EMERG "%c", scrn);
258 local_irq_restore(flags);
263 (data < 10) ? CP(data + '0') : CP(data + 'A' - 10);
267 CP1((data >> 4) & 0x0f);
272 CP2((data >> 8) & 0xff);
277 CP4((data >> 16) & 0xffff);
282 /* This routine waits up to 1000 micro-seconds for the previous
283 command to the Cirrus chip to complete and then issues the
284 new command. An error is returned if the previous command
285 didn't finish within the time limit.
287 u_short write_cy_cmd(volatile u_char * base_addr, u_char cmd)
292 local_irq_save(flags);
293 /* Check to see that the previous command has completed */
294 for (i = 0; i < 100; i++) {
295 if (base_addr[CyCCR] == 0) {
300 /* if the CCR never cleared, the previous command
301 didn't finish within the "reasonable time" */
303 local_irq_restore(flags);
307 /* Issue the new command */
308 base_addr[CyCCR] = cmd;
309 local_irq_restore(flags);
313 /* cy_start and cy_stop provide software output flow control as a
314 function of XON/XOFF, software CTS, and other such stuff. */
316 static void cy_stop(struct tty_struct *tty)
318 struct cyclades_port *info = tty->driver_data;
319 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
323 #ifdef SERIAL_DEBUG_OTHER
324 printk("cy_stop %s\n", tty->name); /* */
327 if (serial_paranoia_check(info, tty->name, "cy_stop"))
330 channel = info->line;
332 local_irq_save(flags);
333 base_addr[CyCAR] = (u_char) (channel); /* index channel */
334 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
335 local_irq_restore(flags);
338 static void cy_start(struct tty_struct *tty)
340 struct cyclades_port *info = tty->driver_data;
341 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
345 #ifdef SERIAL_DEBUG_OTHER
346 printk("cy_start %s\n", tty->name); /* */
349 if (serial_paranoia_check(info, tty->name, "cy_start"))
352 channel = info->line;
354 local_irq_save(flags);
355 base_addr[CyCAR] = (u_char) (channel);
356 base_addr[CyIER] |= CyTxMpty;
357 local_irq_restore(flags);
360 /* The real interrupt service routines are called
361 whenever the card wants its hand held--chars
362 received, out buffer empty, modem change, etc.
364 static irqreturn_t cd2401_rxerr_interrupt(int irq, void *dev_id)
366 struct tty_struct *tty;
367 struct cyclades_port *info;
368 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
369 unsigned char err, rfoc;
373 /* determine the channel and change to that context */
374 channel = (u_short) (base_addr[CyLICR] >> 2);
375 info = &cy_port[channel];
376 info->last_active = jiffies;
378 if ((err = base_addr[CyRISR]) & CyTIMEOUT) {
379 /* This is a receive timeout interrupt, ignore it */
380 base_addr[CyREOIR] = CyNOTRANS;
384 /* Read a byte of data if there is any - assume the error
385 * is associated with this character */
387 if ((rfoc = base_addr[CyRFOC]) != 0)
388 data = base_addr[CyRDR];
392 /* if there is nowhere to put the data, discard it */
393 if (info->tty == 0) {
394 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
396 } else { /* there is an open port for this data */
398 if (err & info->ignore_status_mask) {
399 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
402 if (tty_buffer_request_room(tty, 1) != 0) {
403 if (err & info->read_status_mask) {
405 tty_insert_flip_char(tty, data,
407 if (info->flags & ASYNC_SAK) {
410 } else if (err & CyFRAME) {
411 tty_insert_flip_char(tty, data,
413 } else if (err & CyPARITY) {
414 tty_insert_flip_char(tty, data,
416 } else if (err & CyOVERRUN) {
417 tty_insert_flip_char(tty, 0,
420 If the flip buffer itself is
421 overflowing, we still lose
422 the next incoming character.
424 if (tty_buffer_request_room(tty, 1) !=
426 tty_insert_flip_char(tty, data,
429 /* These two conditions may imply */
430 /* a normal read should be done. */
431 /* else if(data & CyTIMEOUT) */
432 /* else if(data & CySPECHAR) */
434 tty_insert_flip_char(tty, 0,
438 tty_insert_flip_char(tty, data, TTY_NORMAL);
441 /* there was a software buffer overrun
442 and nothing could be done about it!!! */
445 tty_schedule_flip(tty);
447 base_addr[CyREOIR] = rfoc ? 0 : CyNOTRANS;
449 } /* cy_rxerr_interrupt */
451 static irqreturn_t cd2401_modem_interrupt(int irq, void *dev_id)
453 struct cyclades_port *info;
454 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
459 /* determine the channel and change to that context */
460 channel = (u_short) (base_addr[CyLICR] >> 2);
461 info = &cy_port[channel];
462 info->last_active = jiffies;
464 mdm_change = base_addr[CyMISR];
465 mdm_status = base_addr[CyMSVR1];
467 if (info->tty == 0) { /* nowhere to put the data, ignore it */
470 if ((mdm_change & CyDCD)
471 && (info->flags & ASYNC_CHECK_CD)) {
472 if (mdm_status & CyDCD) {
474 wake_up_interruptible(&info->open_wait);
477 tty_hangup(info->tty);
478 wake_up_interruptible(&info->open_wait);
479 info->flags &= ~ASYNC_NORMAL_ACTIVE;
482 if ((mdm_change & CyCTS)
483 && (info->flags & ASYNC_CTS_FLOW)) {
484 if (info->tty->stopped) {
485 if (mdm_status & CyCTS) {
486 /* !!! cy_start isn't used because... */
487 info->tty->stopped = 0;
488 base_addr[CyIER] |= CyTxMpty;
489 tty_wakeup(info->tty);
492 if (!(mdm_status & CyCTS)) {
493 /* !!! cy_stop isn't used because... */
494 info->tty->stopped = 1;
496 ~(CyTxMpty | CyTxRdy);
500 if (mdm_status & CyDSR) {
503 base_addr[CyMEOIR] = 0;
505 } /* cy_modem_interrupt */
507 static irqreturn_t cd2401_tx_interrupt(int irq, void *dev_id)
509 struct cyclades_port *info;
510 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
512 int char_count, saved_cnt;
515 /* determine the channel and change to that context */
516 channel = (u_short) (base_addr[CyLICR] >> 2);
518 #ifdef CONFIG_REMOTE_DEBUG
519 if (channel == DEBUG_PORT) {
520 panic("TxInt on debug port!!!");
523 /* validate the port number (as configured and open) */
524 if ((channel < 0) || (NR_PORTS <= channel)) {
525 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
526 base_addr[CyTEOIR] = CyNOTRANS;
529 info = &cy_port[channel];
530 info->last_active = jiffies;
531 if (info->tty == 0) {
532 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
533 base_addr[CyTEOIR] = CyNOTRANS;
537 /* load the on-chip space available for outbound data */
538 saved_cnt = char_count = base_addr[CyTFTC];
540 if (info->x_char) { /* send special char */
541 outch = info->x_char;
542 base_addr[CyTDR] = outch;
548 /* The Cirrus chip requires the "Embedded Transmit
549 Commands" of start break, delay, and end break
550 sequences to be sent. The duration of the
551 break is given in TICs, which runs at HZ
552 (typically 100) and the PPR runs at 200 Hz,
553 so the delay is duration * 200/HZ, and thus a
554 break can run from 1/100 sec to about 5/4 sec.
555 Need to check these values - RGH 141095.
557 base_addr[CyTDR] = 0; /* start break */
558 base_addr[CyTDR] = 0x81;
559 base_addr[CyTDR] = 0; /* delay a bit */
560 base_addr[CyTDR] = 0x82;
561 base_addr[CyTDR] = info->x_break * 200 / HZ;
562 base_addr[CyTDR] = 0; /* terminate break */
563 base_addr[CyTDR] = 0x83;
568 while (char_count > 0) {
569 if (!info->xmit_cnt) {
570 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
573 if (info->xmit_buf == 0) {
574 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
577 if (info->tty->stopped || info->tty->hw_stopped) {
578 base_addr[CyIER] &= ~(CyTxMpty | CyTxRdy);
581 /* Because the Embedded Transmit Commands have been
582 enabled, we must check to see if the escape
583 character, NULL, is being sent. If it is, we
584 must ensure that there is room for it to be
585 doubled in the output stream. Therefore we
586 no longer advance the pointer when the character
587 is fetched, but rather wait until after the check
588 for a NULL output character. (This is necessary
589 because there may not be room for the two chars
590 needed to send a NULL.
592 outch = info->xmit_buf[info->xmit_tail];
595 info->xmit_tail = (info->xmit_tail + 1)
597 base_addr[CyTDR] = outch;
600 if (char_count > 1) {
602 info->xmit_tail = (info->xmit_tail + 1)
604 base_addr[CyTDR] = outch;
605 base_addr[CyTDR] = 0;
614 if (info->xmit_cnt < WAKEUP_CHARS)
615 tty_wakeup(info->tty);
617 base_addr[CyTEOIR] = (char_count != saved_cnt) ? 0 : CyNOTRANS;
619 } /* cy_tx_interrupt */
621 static irqreturn_t cd2401_rx_interrupt(int irq, void *dev_id)
623 struct tty_struct *tty;
624 struct cyclades_port *info;
625 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
631 /* determine the channel and change to that context */
632 channel = (u_short) (base_addr[CyLICR] >> 2);
633 info = &cy_port[channel];
634 info->last_active = jiffies;
635 save_cnt = char_count = base_addr[CyRFOC];
637 #ifdef CONFIG_REMOTE_DEBUG
638 if (channel == DEBUG_PORT) {
639 while (char_count--) {
640 data = base_addr[CyRDR];
641 queueDebugChar(data);
645 /* if there is nowhere to put the data, discard it */
646 if (info->tty == 0) {
647 while (char_count--) {
648 data = base_addr[CyRDR];
650 } else { /* there is an open port for this data */
652 /* load # characters available from the chip */
654 #ifdef CYCLOM_ENABLE_MONITORING
655 ++info->mon.int_count;
656 info->mon.char_count += char_count;
657 if (char_count > info->mon.char_max)
658 info->mon.char_max = char_count;
659 info->mon.char_last = char_count;
661 while (char_count--) {
662 data = base_addr[CyRDR];
663 tty_insert_flip_char(tty, data, TTY_NORMAL);
664 #ifdef CYCLOM_16Y_HACK
668 tty_schedule_flip(tty);
671 base_addr[CyREOIR] = save_cnt ? 0 : CyNOTRANS;
673 } /* cy_rx_interrupt */
675 /* This is called whenever a port becomes active;
676 interrupts are enabled and DTR & RTS are turned on.
678 static int startup(struct cyclades_port *info)
681 volatile unsigned char *base_addr = (unsigned char *)BASE_ADDR;
684 if (info->flags & ASYNC_INITIALIZED) {
690 set_bit(TTY_IO_ERROR, &info->tty->flags);
694 if (!info->xmit_buf) {
695 info->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
696 if (!info->xmit_buf) {
703 channel = info->line;
705 #ifdef SERIAL_DEBUG_OPEN
706 printk("startup channel %d\n", channel);
709 local_irq_save(flags);
710 base_addr[CyCAR] = (u_char) channel;
711 write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
713 base_addr[CyCAR] = (u_char) channel; /* !!! Is this needed? */
714 base_addr[CyMSVR1] = CyRTS;
715 /* CP('S');CP('1'); */
716 base_addr[CyMSVR2] = CyDTR;
718 #ifdef SERIAL_DEBUG_DTR
719 printk("cyc: %d: raising DTR\n", __LINE__);
720 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
724 base_addr[CyIER] |= CyRxData;
725 info->flags |= ASYNC_INITIALIZED;
728 clear_bit(TTY_IO_ERROR, &info->tty->flags);
730 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
732 local_irq_restore(flags);
734 #ifdef SERIAL_DEBUG_OPEN
740 void start_xmit(struct cyclades_port *info)
743 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
746 channel = info->line;
747 local_irq_save(flags);
748 base_addr[CyCAR] = channel;
749 base_addr[CyIER] |= CyTxMpty;
750 local_irq_restore(flags);
754 * This routine shuts down a serial port; interrupts are disabled,
755 * and DTR is dropped if the hangup on close termio flag is on.
757 static void shutdown(struct cyclades_port *info)
760 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
763 if (!(info->flags & ASYNC_INITIALIZED)) {
768 channel = info->line;
770 #ifdef SERIAL_DEBUG_OPEN
771 printk("shutdown channel %d\n", channel);
774 /* !!! REALLY MUST WAIT FOR LAST CHARACTER TO BE
775 SENT BEFORE DROPPING THE LINE !!! (Perhaps
776 set some flag that is read when XMTY happens.)
777 Other choices are to delay some fixed interval
778 or schedule some later processing.
780 local_irq_save(flags);
781 if (info->xmit_buf) {
782 free_page((unsigned long)info->xmit_buf);
783 info->xmit_buf = NULL;
786 base_addr[CyCAR] = (u_char) channel;
787 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
788 base_addr[CyMSVR1] = 0;
789 /* CP('C');CP('1'); */
790 base_addr[CyMSVR2] = 0;
791 #ifdef SERIAL_DEBUG_DTR
792 printk("cyc: %d: dropping DTR\n", __LINE__);
793 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
797 write_cy_cmd(base_addr, CyDIS_RCVR);
798 /* it may be appropriate to clear _XMIT at
799 some later date (after testing)!!! */
802 set_bit(TTY_IO_ERROR, &info->tty->flags);
804 info->flags &= ~ASYNC_INITIALIZED;
805 local_irq_restore(flags);
807 #ifdef SERIAL_DEBUG_OPEN
813 * This routine finds or computes the various line characteristics.
815 static void config_setup(struct cyclades_port *info)
818 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
822 unsigned char ti, need_init_chan = 0;
824 if (!info->tty || !info->tty->termios) {
827 if (info->line == -1) {
830 cflag = info->tty->termios->c_cflag;
835 /* Starting with kernel 1.1.65, there is direct support for
836 higher baud rates. The following code supports those
837 changes. The conditional aspect allows this driver to be
838 used for earlier as well as later kernel versions. (The
839 mapping is slightly different from serial.c because there
840 is still the possibility of supporting 75 kbit/sec with
846 else if (i == B115200)
849 else if (i == B78600)
853 info->tty->termios->c_cflag &= ~CBAUDEX;
857 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
859 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
862 /* Don't ever change the speed of the console port. It will
863 * run at the speed specified in bootinfo, or at 19.2K */
864 /* Actually, it should run at whatever speed 166Bug was using */
865 /* Note info->timeout isn't used at present */
866 if (info != serial_console_info) {
867 info->tbpr = baud_bpr[i]; /* Tx BPR */
868 info->tco = baud_co[i]; /* Tx CO */
869 info->rbpr = baud_bpr[i]; /* Rx BPR */
870 info->rco = baud_co[i] >> 5; /* Rx CO */
871 if (baud_table[i] == 134) {
873 (info->xmit_fifo_size * HZ * 30 / 269) + 2;
874 /* get it right for 134.5 baud */
875 } else if (baud_table[i]) {
877 (info->xmit_fifo_size * HZ * 15 / baud_table[i]) +
879 /* this needs to be propagated into the card info */
884 /* By tradition (is it a standard?) a baud rate of zero
885 implies the line should be/has been closed. A bit
886 later in this routine such a test is performed. */
888 /* byte size and parity */
892 info->cor4 = (info->default_threshold ? info->default_threshold : baud_cor4[i]); /* receive threshold */
893 /* Following two lines added 101295, RGH. */
894 /* It is obviously wrong to access CyCORx, and not info->corx here,
895 * try and remember to fix it later! */
896 channel = info->line;
897 base_addr[CyCAR] = (u_char) channel;
898 if (C_CLOCAL(info->tty)) {
899 if (base_addr[CyIER] & CyMdmCh)
900 base_addr[CyIER] &= ~CyMdmCh; /* without modem intr */
901 /* ignore 1->0 modem transitions */
902 if (base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD))
903 base_addr[CyCOR4] &= ~(CyDSR | CyCTS | CyDCD);
904 /* ignore 0->1 modem transitions */
905 if (base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD))
906 base_addr[CyCOR5] &= ~(CyDSR | CyCTS | CyDCD);
908 if ((base_addr[CyIER] & CyMdmCh) != CyMdmCh)
909 base_addr[CyIER] |= CyMdmCh; /* with modem intr */
910 /* act on 1->0 modem transitions */
911 if ((base_addr[CyCOR4] & (CyDSR | CyCTS | CyDCD)) !=
912 (CyDSR | CyCTS | CyDCD))
913 base_addr[CyCOR4] |= CyDSR | CyCTS | CyDCD;
914 /* act on 0->1 modem transitions */
915 if ((base_addr[CyCOR5] & (CyDSR | CyCTS | CyDCD)) !=
916 (CyDSR | CyCTS | CyDCD))
917 base_addr[CyCOR5] |= CyDSR | CyCTS | CyDCD;
919 info->cor3 = (cflag & CSTOPB) ? Cy_2_STOP : Cy_1_STOP;
921 switch (cflag & CSIZE) {
923 info->cor1 = Cy_5_BITS;
926 info->cor1 = Cy_6_BITS;
929 info->cor1 = Cy_7_BITS;
932 info->cor1 = Cy_8_BITS;
935 if (cflag & PARENB) {
936 if (cflag & PARODD) {
937 info->cor1 |= CyPARITY_O;
939 info->cor1 |= CyPARITY_E;
942 info->cor1 |= CyPARITY_NONE;
945 /* CTS flow control flag */
947 /* Don't complcate matters for now! RGH 141095 */
948 if (cflag & CRTSCTS) {
949 info->flags |= ASYNC_CTS_FLOW;
950 info->cor2 |= CyCtsAE;
952 info->flags &= ~ASYNC_CTS_FLOW;
953 info->cor2 &= ~CyCtsAE;
957 info->flags &= ~ASYNC_CHECK_CD;
959 info->flags |= ASYNC_CHECK_CD;
961 /***********************************************
962 The hardware option, CyRtsAO, presents RTS when
963 the chip has characters to send. Since most modems
964 use RTS as reverse (inbound) flow control, this
965 option is not used. If inbound flow control is
966 necessary, DTR can be programmed to provide the
967 appropriate signals for use with a non-standard
968 cable. Contact Marcio Saito for details.
969 ***********************************************/
971 channel = info->line;
973 local_irq_save(flags);
974 base_addr[CyCAR] = (u_char) channel;
976 /* CyCMR set once only in mvme167_init_serial() */
977 if (base_addr[CyLICR] != channel << 2)
978 base_addr[CyLICR] = channel << 2;
979 if (base_addr[CyLIVR] != 0x5c)
980 base_addr[CyLIVR] = 0x5c;
982 /* tx and rx baud rate */
984 if (base_addr[CyCOR1] != info->cor1)
986 if (base_addr[CyTCOR] != info->tco)
987 base_addr[CyTCOR] = info->tco;
988 if (base_addr[CyTBPR] != info->tbpr)
989 base_addr[CyTBPR] = info->tbpr;
990 if (base_addr[CyRCOR] != info->rco)
991 base_addr[CyRCOR] = info->rco;
992 if (base_addr[CyRBPR] != info->rbpr)
993 base_addr[CyRBPR] = info->rbpr;
995 /* set line characteristics according configuration */
997 if (base_addr[CySCHR1] != START_CHAR(info->tty))
998 base_addr[CySCHR1] = START_CHAR(info->tty);
999 if (base_addr[CySCHR2] != STOP_CHAR(info->tty))
1000 base_addr[CySCHR2] = STOP_CHAR(info->tty);
1001 if (base_addr[CySCRL] != START_CHAR(info->tty))
1002 base_addr[CySCRL] = START_CHAR(info->tty);
1003 if (base_addr[CySCRH] != START_CHAR(info->tty))
1004 base_addr[CySCRH] = START_CHAR(info->tty);
1005 if (base_addr[CyCOR1] != info->cor1)
1006 base_addr[CyCOR1] = info->cor1;
1007 if (base_addr[CyCOR2] != info->cor2)
1008 base_addr[CyCOR2] = info->cor2;
1009 if (base_addr[CyCOR3] != info->cor3)
1010 base_addr[CyCOR3] = info->cor3;
1011 if (base_addr[CyCOR4] != info->cor4)
1012 base_addr[CyCOR4] = info->cor4;
1013 if (base_addr[CyCOR5] != info->cor5)
1014 base_addr[CyCOR5] = info->cor5;
1015 if (base_addr[CyCOR6] != info->cor6)
1016 base_addr[CyCOR6] = info->cor6;
1017 if (base_addr[CyCOR7] != info->cor7)
1018 base_addr[CyCOR7] = info->cor7;
1021 write_cy_cmd(base_addr, CyINIT_CHAN);
1023 base_addr[CyCAR] = (u_char) channel; /* !!! Is this needed? */
1025 /* 2ms default rx timeout */
1026 ti = info->default_timeout ? info->default_timeout : 0x02;
1027 if (base_addr[CyRTPRL] != ti)
1028 base_addr[CyRTPRL] = ti;
1029 if (base_addr[CyRTPRH] != 0)
1030 base_addr[CyRTPRH] = 0;
1032 /* Set up RTS here also ????? RGH 141095 */
1033 if (i == 0) { /* baud rate is zero, turn off line */
1034 if ((base_addr[CyMSVR2] & CyDTR) == CyDTR)
1035 base_addr[CyMSVR2] = 0;
1036 #ifdef SERIAL_DEBUG_DTR
1037 printk("cyc: %d: dropping DTR\n", __LINE__);
1038 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1039 base_addr[CyMSVR2]);
1042 if ((base_addr[CyMSVR2] & CyDTR) != CyDTR)
1043 base_addr[CyMSVR2] = CyDTR;
1044 #ifdef SERIAL_DEBUG_DTR
1045 printk("cyc: %d: raising DTR\n", __LINE__);
1046 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1047 base_addr[CyMSVR2]);
1052 clear_bit(TTY_IO_ERROR, &info->tty->flags);
1055 local_irq_restore(flags);
1057 } /* config_setup */
1059 static int cy_put_char(struct tty_struct *tty, unsigned char ch)
1061 struct cyclades_port *info = tty->driver_data;
1062 unsigned long flags;
1064 #ifdef SERIAL_DEBUG_IO
1065 printk("cy_put_char %s(0x%02x)\n", tty->name, ch);
1068 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
1071 if (!info->xmit_buf)
1074 local_irq_save(flags);
1075 if (info->xmit_cnt >= PAGE_SIZE - 1) {
1076 local_irq_restore(flags);
1080 info->xmit_buf[info->xmit_head++] = ch;
1081 info->xmit_head &= PAGE_SIZE - 1;
1083 local_irq_restore(flags);
1087 static void cy_flush_chars(struct tty_struct *tty)
1089 struct cyclades_port *info = tty->driver_data;
1090 unsigned long flags;
1091 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1094 #ifdef SERIAL_DEBUG_IO
1095 printk("cy_flush_chars %s\n", tty->name); /* */
1098 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
1101 if (info->xmit_cnt <= 0 || tty->stopped
1102 || tty->hw_stopped || !info->xmit_buf)
1105 channel = info->line;
1107 local_irq_save(flags);
1108 base_addr[CyCAR] = channel;
1109 base_addr[CyIER] |= CyTxMpty;
1110 local_irq_restore(flags);
1111 } /* cy_flush_chars */
1113 /* This routine gets called when tty_write has put something into
1114 the write_queue. If the port is not already transmitting stuff,
1115 start it off by enabling interrupts. The interrupt service
1116 routine will then ensure that the characters are sent. If the
1117 port is already active, there is no need to kick it.
1119 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1121 struct cyclades_port *info = tty->driver_data;
1122 unsigned long flags;
1125 #ifdef SERIAL_DEBUG_IO
1126 printk("cy_write %s\n", tty->name); /* */
1129 if (serial_paranoia_check(info, tty->name, "cy_write")) {
1133 if (!info->xmit_buf) {
1138 local_irq_save(flags);
1139 c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
1140 SERIAL_XMIT_SIZE - info->xmit_head));
1142 local_irq_restore(flags);
1146 memcpy(info->xmit_buf + info->xmit_head, buf, c);
1148 (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
1149 info->xmit_cnt += c;
1150 local_irq_restore(flags);
1157 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
1163 static int cy_write_room(struct tty_struct *tty)
1165 struct cyclades_port *info = tty->driver_data;
1168 #ifdef SERIAL_DEBUG_IO
1169 printk("cy_write_room %s\n", tty->name); /* */
1172 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
1174 ret = PAGE_SIZE - info->xmit_cnt - 1;
1178 } /* cy_write_room */
1180 static int cy_chars_in_buffer(struct tty_struct *tty)
1182 struct cyclades_port *info = tty->driver_data;
1184 #ifdef SERIAL_DEBUG_IO
1185 printk("cy_chars_in_buffer %s %d\n", tty->name, info->xmit_cnt); /* */
1188 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
1191 return info->xmit_cnt;
1192 } /* cy_chars_in_buffer */
1194 static void cy_flush_buffer(struct tty_struct *tty)
1196 struct cyclades_port *info = tty->driver_data;
1197 unsigned long flags;
1199 #ifdef SERIAL_DEBUG_IO
1200 printk("cy_flush_buffer %s\n", tty->name); /* */
1203 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
1205 local_irq_save(flags);
1206 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1207 local_irq_restore(flags);
1209 } /* cy_flush_buffer */
1211 /* This routine is called by the upper-layer tty layer to signal
1212 that incoming characters should be throttled or that the
1213 throttle should be released.
1215 static void cy_throttle(struct tty_struct *tty)
1217 struct cyclades_port *info = tty->driver_data;
1218 unsigned long flags;
1219 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1222 #ifdef SERIAL_DEBUG_THROTTLE
1225 printk("throttle %s: %d....\n", tty_name(tty, buf),
1226 tty->ldisc.chars_in_buffer(tty));
1227 printk("cy_throttle %s\n", tty->name);
1230 if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1235 info->x_char = STOP_CHAR(tty);
1236 /* Should use the "Send Special Character" feature!!! */
1239 channel = info->line;
1241 local_irq_save(flags);
1242 base_addr[CyCAR] = (u_char) channel;
1243 base_addr[CyMSVR1] = 0;
1244 local_irq_restore(flags);
1247 static void cy_unthrottle(struct tty_struct *tty)
1249 struct cyclades_port *info = tty->driver_data;
1250 unsigned long flags;
1251 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1254 #ifdef SERIAL_DEBUG_THROTTLE
1257 printk("throttle %s: %d....\n", tty_name(tty, buf),
1258 tty->ldisc.chars_in_buffer(tty));
1259 printk("cy_unthrottle %s\n", tty->name);
1262 if (serial_paranoia_check(info, tty->name, "cy_nthrottle")) {
1267 info->x_char = START_CHAR(tty);
1268 /* Should use the "Send Special Character" feature!!! */
1271 channel = info->line;
1273 local_irq_save(flags);
1274 base_addr[CyCAR] = (u_char) channel;
1275 base_addr[CyMSVR1] = CyRTS;
1276 local_irq_restore(flags);
1277 } /* cy_unthrottle */
1280 get_serial_info(struct cyclades_port *info,
1281 struct serial_struct __user * retinfo)
1283 struct serial_struct tmp;
1288 memset(&tmp, 0, sizeof(tmp));
1289 tmp.type = info->type;
1290 tmp.line = info->line;
1291 tmp.port = info->line;
1293 tmp.flags = info->flags;
1294 tmp.baud_base = 0; /*!!! */
1295 tmp.close_delay = info->close_delay;
1296 tmp.custom_divisor = 0; /*!!! */
1297 tmp.hub6 = 0; /*!!! */
1298 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
1299 } /* get_serial_info */
1302 set_serial_info(struct cyclades_port *info,
1303 struct serial_struct __user * new_info)
1305 struct serial_struct new_serial;
1306 struct cyclades_port old_info;
1311 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
1315 if (!capable(CAP_SYS_ADMIN)) {
1316 if ((new_serial.close_delay != info->close_delay) ||
1317 ((new_serial.flags & ASYNC_FLAGS & ~ASYNC_USR_MASK) !=
1318 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK)))
1320 info->flags = ((info->flags & ~ASYNC_USR_MASK) |
1321 (new_serial.flags & ASYNC_USR_MASK));
1322 goto check_and_exit;
1326 * OK, past this point, all the error checking has been done.
1327 * At this point, we start making changes.....
1330 info->flags = ((info->flags & ~ASYNC_FLAGS) |
1331 (new_serial.flags & ASYNC_FLAGS));
1332 info->close_delay = new_serial.close_delay;
1335 if (info->flags & ASYNC_INITIALIZED) {
1339 return startup(info);
1340 } /* set_serial_info */
1342 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
1344 struct cyclades_port *info = tty->driver_data;
1346 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1347 unsigned long flags;
1348 unsigned char status;
1350 channel = info->line;
1352 local_irq_save(flags);
1353 base_addr[CyCAR] = (u_char) channel;
1354 status = base_addr[CyMSVR1] | base_addr[CyMSVR2];
1355 local_irq_restore(flags);
1357 return ((status & CyRTS) ? TIOCM_RTS : 0)
1358 | ((status & CyDTR) ? TIOCM_DTR : 0)
1359 | ((status & CyDCD) ? TIOCM_CAR : 0)
1360 | ((status & CyDSR) ? TIOCM_DSR : 0)
1361 | ((status & CyCTS) ? TIOCM_CTS : 0);
1365 cy_tiocmset(struct tty_struct *tty, struct file *file,
1366 unsigned int set, unsigned int clear)
1368 struct cyclades_port *info = tty->driver_data;
1370 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1371 unsigned long flags;
1373 channel = info->line;
1375 if (set & TIOCM_RTS) {
1376 local_irq_save(flags);
1377 base_addr[CyCAR] = (u_char) channel;
1378 base_addr[CyMSVR1] = CyRTS;
1379 local_irq_restore(flags);
1381 if (set & TIOCM_DTR) {
1382 local_irq_save(flags);
1383 base_addr[CyCAR] = (u_char) channel;
1384 /* CP('S');CP('2'); */
1385 base_addr[CyMSVR2] = CyDTR;
1386 #ifdef SERIAL_DEBUG_DTR
1387 printk("cyc: %d: raising DTR\n", __LINE__);
1388 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1389 base_addr[CyMSVR2]);
1391 local_irq_restore(flags);
1394 if (clear & TIOCM_RTS) {
1395 local_irq_save(flags);
1396 base_addr[CyCAR] = (u_char) channel;
1397 base_addr[CyMSVR1] = 0;
1398 local_irq_restore(flags);
1400 if (clear & TIOCM_DTR) {
1401 local_irq_save(flags);
1402 base_addr[CyCAR] = (u_char) channel;
1403 /* CP('C');CP('2'); */
1404 base_addr[CyMSVR2] = 0;
1405 #ifdef SERIAL_DEBUG_DTR
1406 printk("cyc: %d: dropping DTR\n", __LINE__);
1407 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1408 base_addr[CyMSVR2]);
1410 local_irq_restore(flags);
1414 } /* set_modem_info */
1416 static void send_break(struct cyclades_port *info, int duration)
1417 { /* Let the transmit ISR take care of this (since it
1418 requires stuffing characters into the output stream).
1420 info->x_break = duration;
1421 if (!info->xmit_cnt) {
1427 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
1430 if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
1432 info->mon.int_count = 0;
1433 info->mon.char_count = 0;
1434 info->mon.char_max = 0;
1435 info->mon.char_last = 0;
1439 static int set_threshold(struct cyclades_port *info, unsigned long __user * arg)
1441 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1442 unsigned long value;
1445 if (get_user(value, arg))
1448 channel = info->line;
1449 info->cor4 &= ~CyREC_FIFO;
1450 info->cor4 |= value & CyREC_FIFO;
1451 base_addr[CyCOR4] = info->cor4;
1456 get_threshold(struct cyclades_port *info, unsigned long __user * value)
1458 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1462 channel = info->line;
1464 tmp = base_addr[CyCOR4] & CyREC_FIFO;
1465 return put_user(tmp, value);
1469 set_default_threshold(struct cyclades_port *info, unsigned long __user * arg)
1471 unsigned long value;
1473 if (get_user(value, arg))
1476 info->default_threshold = value & 0x0f;
1481 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
1483 return put_user(info->default_threshold, value);
1486 static int set_timeout(struct cyclades_port *info, unsigned long __user * arg)
1488 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1490 unsigned long value;
1492 if (get_user(value, arg))
1495 channel = info->line;
1497 base_addr[CyRTPRL] = value & 0xff;
1498 base_addr[CyRTPRH] = (value >> 8) & 0xff;
1502 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
1504 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1508 channel = info->line;
1510 tmp = base_addr[CyRTPRL];
1511 return put_user(tmp, value);
1514 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
1516 info->default_timeout = value & 0xff;
1521 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
1523 return put_user(info->default_timeout, value);
1527 cy_ioctl(struct tty_struct *tty, struct file *file,
1528 unsigned int cmd, unsigned long arg)
1530 struct cyclades_port *info = tty->driver_data;
1532 void __user *argp = (void __user *)arg;
1534 #ifdef SERIAL_DEBUG_OTHER
1535 printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty->name, cmd, arg); /* */
1542 ret_val = get_mon_info(info, argp);
1545 ret_val = get_threshold(info, argp);
1548 ret_val = set_threshold(info, argp);
1550 case CYGETDEFTHRESH:
1551 ret_val = get_default_threshold(info, argp);
1553 case CYSETDEFTHRESH:
1554 ret_val = set_default_threshold(info, argp);
1557 ret_val = get_timeout(info, argp);
1560 ret_val = set_timeout(info, argp);
1562 case CYGETDEFTIMEOUT:
1563 ret_val = get_default_timeout(info, argp);
1565 case CYSETDEFTIMEOUT:
1566 ret_val = set_default_timeout(info, (unsigned long)arg);
1568 case TCSBRK: /* SVID version: non-zero arg --> no break */
1569 ret_val = tty_check_change(tty);
1572 tty_wait_until_sent(tty, 0);
1574 send_break(info, HZ / 4); /* 1/4 second */
1576 case TCSBRKP: /* support for POSIX tcsendbreak() */
1577 ret_val = tty_check_change(tty);
1580 tty_wait_until_sent(tty, 0);
1581 send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
1584 /* The following commands are incompletely implemented!!! */
1586 ret_val = get_serial_info(info, argp);
1589 ret_val = set_serial_info(info, argp);
1592 ret_val = -ENOIOCTLCMD;
1596 #ifdef SERIAL_DEBUG_OTHER
1597 printk("cy_ioctl done\n");
1603 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1605 struct cyclades_port *info = tty->driver_data;
1607 #ifdef SERIAL_DEBUG_OTHER
1608 printk("cy_set_termios %s\n", tty->name);
1611 if (tty->termios->c_cflag == old_termios->c_cflag)
1615 if ((old_termios->c_cflag & CRTSCTS) &&
1616 !(tty->termios->c_cflag & CRTSCTS)) {
1620 #ifdef tytso_patch_94Nov25_1726
1621 if (!(old_termios->c_cflag & CLOCAL) &&
1622 (tty->termios->c_cflag & CLOCAL))
1623 wake_up_interruptible(&info->open_wait);
1625 } /* cy_set_termios */
1627 static void cy_close(struct tty_struct *tty, struct file *filp)
1629 struct cyclades_port *info = tty->driver_data;
1632 #ifdef SERIAL_DEBUG_OTHER
1633 printk("cy_close %s\n", tty->name);
1636 if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
1639 #ifdef SERIAL_DEBUG_OPEN
1640 printk("cy_close %s, count = %d\n", tty->name, info->count);
1643 if ((tty->count == 1) && (info->count != 1)) {
1645 * Uh, oh. tty->count is 1, which means that the tty
1646 * structure will be freed. Info->count should always
1647 * be one in these conditions. If it's greater than
1648 * one, we've got real problems, since it means the
1649 * serial port won't be shutdown.
1651 printk("cy_close: bad serial port count; tty->count is 1, "
1652 "info->count is %d\n", info->count);
1655 #ifdef SERIAL_DEBUG_COUNT
1656 printk("cyc: %d: decrementing count to %d\n", __LINE__,
1659 if (--info->count < 0) {
1660 printk("cy_close: bad serial port count for ttys%d: %d\n",
1661 info->line, info->count);
1662 #ifdef SERIAL_DEBUG_COUNT
1663 printk("cyc: %d: setting count to 0\n", __LINE__);
1669 info->flags |= ASYNC_CLOSING;
1670 if (info->flags & ASYNC_INITIALIZED)
1671 tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
1673 cy_flush_buffer(tty);
1674 tty_ldisc_flush(tty);
1676 if (info->blocked_open) {
1677 if (info->close_delay) {
1678 msleep_interruptible(jiffies_to_msecs
1679 (info->close_delay));
1681 wake_up_interruptible(&info->open_wait);
1683 info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
1684 wake_up_interruptible(&info->close_wait);
1686 #ifdef SERIAL_DEBUG_OTHER
1687 printk("cy_close done\n");
1692 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
1694 void cy_hangup(struct tty_struct *tty)
1696 struct cyclades_port *info = tty->driver_data;
1698 #ifdef SERIAL_DEBUG_OTHER
1699 printk("cy_hangup %s\n", tty->name); /* */
1702 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
1709 #ifdef SERIAL_DEBUG_COUNT
1710 printk("cyc: %d: setting count to 0\n", __LINE__);
1714 info->flags &= ~ASYNC_NORMAL_ACTIVE;
1715 wake_up_interruptible(&info->open_wait);
1719 * ------------------------------------------------------------
1720 * cy_open() and friends
1721 * ------------------------------------------------------------
1725 block_til_ready(struct tty_struct *tty, struct file *filp,
1726 struct cyclades_port *info)
1728 DECLARE_WAITQUEUE(wait, current);
1729 unsigned long flags;
1732 volatile u_char *base_addr = (u_char *) BASE_ADDR;
1735 * If the device is in the middle of being closed, then block
1736 * until it's done, and then try again.
1738 if (info->flags & ASYNC_CLOSING) {
1739 interruptible_sleep_on(&info->close_wait);
1740 if (info->flags & ASYNC_HUP_NOTIFY) {
1743 return -ERESTARTSYS;
1748 * If non-blocking mode is set, then make the check up front
1751 if (filp->f_flags & O_NONBLOCK) {
1752 info->flags |= ASYNC_NORMAL_ACTIVE;
1757 * Block waiting for the carrier detect and the line to become
1758 * free (i.e., not in use by the callout). While we are in
1759 * this loop, info->count is dropped by one, so that
1760 * cy_close() knows when to free things. We restore it upon
1761 * exit, either normal or abnormal.
1764 add_wait_queue(&info->open_wait, &wait);
1765 #ifdef SERIAL_DEBUG_OPEN
1766 printk("block_til_ready before block: %s, count = %d\n",
1767 tty->name, info->count);
1771 #ifdef SERIAL_DEBUG_COUNT
1772 printk("cyc: %d: decrementing count to %d\n", __LINE__, info->count);
1774 info->blocked_open++;
1776 channel = info->line;
1779 local_irq_save(flags);
1780 base_addr[CyCAR] = (u_char) channel;
1781 base_addr[CyMSVR1] = CyRTS;
1782 /* CP('S');CP('4'); */
1783 base_addr[CyMSVR2] = CyDTR;
1784 #ifdef SERIAL_DEBUG_DTR
1785 printk("cyc: %d: raising DTR\n", __LINE__);
1786 printk(" status: 0x%x, 0x%x\n", base_addr[CyMSVR1],
1787 base_addr[CyMSVR2]);
1789 local_irq_restore(flags);
1790 set_current_state(TASK_INTERRUPTIBLE);
1791 if (tty_hung_up_p(filp)
1792 || !(info->flags & ASYNC_INITIALIZED)) {
1793 if (info->flags & ASYNC_HUP_NOTIFY) {
1796 retval = -ERESTARTSYS;
1800 local_irq_save(flags);
1801 base_addr[CyCAR] = (u_char) channel;
1802 /* CP('L');CP1(1 && C_CLOCAL(tty)); CP1(1 && (base_addr[CyMSVR1] & CyDCD) ); */
1803 if (!(info->flags & ASYNC_CLOSING)
1805 || (base_addr[CyMSVR1] & CyDCD))) {
1806 local_irq_restore(flags);
1809 local_irq_restore(flags);
1810 if (signal_pending(current)) {
1811 retval = -ERESTARTSYS;
1814 #ifdef SERIAL_DEBUG_OPEN
1815 printk("block_til_ready blocking: %s, count = %d\n",
1816 tty->name, info->count);
1821 __set_current_state(TASK_RUNNING);
1822 remove_wait_queue(&info->open_wait, &wait);
1823 if (!tty_hung_up_p(filp)) {
1825 #ifdef SERIAL_DEBUG_COUNT
1826 printk("cyc: %d: incrementing count to %d\n", __LINE__,
1830 info->blocked_open--;
1831 #ifdef SERIAL_DEBUG_OPEN
1832 printk("block_til_ready after blocking: %s, count = %d\n",
1833 tty->name, info->count);
1838 info->flags |= ASYNC_NORMAL_ACTIVE;
1840 } /* block_til_ready */
1843 * This routine is called whenever a serial port is opened. It
1844 * performs the serial-specific initialization for the tty structure.
1846 int cy_open(struct tty_struct *tty, struct file *filp)
1848 struct cyclades_port *info;
1853 if ((line < 0) || (NR_PORTS <= line)) {
1856 info = &cy_port[line];
1857 if (info->line < 0) {
1860 #ifdef SERIAL_DEBUG_OTHER
1861 printk("cy_open %s\n", tty->name); /* */
1863 if (serial_paranoia_check(info, tty->name, "cy_open")) {
1866 #ifdef SERIAL_DEBUG_OPEN
1867 printk("cy_open %s, count = %d\n", tty->name, info->count);
1871 #ifdef SERIAL_DEBUG_COUNT
1872 printk("cyc: %d: incrementing count to %d\n", __LINE__, info->count);
1874 tty->driver_data = info;
1878 * Start up serial port
1880 retval = startup(info);
1885 retval = block_til_ready(tty, filp, info);
1887 #ifdef SERIAL_DEBUG_OPEN
1888 printk("cy_open returning after block_til_ready with %d\n",
1893 #ifdef SERIAL_DEBUG_OPEN
1894 printk("cy_open done\n");
1901 * ---------------------------------------------------------------------
1902 * serial167_init() and friends
1904 * serial167_init() is called at boot-time to initialize the serial driver.
1905 * ---------------------------------------------------------------------
1909 * This routine prints out the appropriate serial driver version
1910 * number, and identifies which options were configured into this
1913 static void show_version(void)
1915 printk("MVME166/167 cd2401 driver\n");
1916 } /* show_version */
1918 /* initialize chips on card -- return number of valid
1919 chips (which is number of ports/4) */
1922 * This initialises the hardware to a reasonable state. It should
1923 * probe the chip first so as to copy 166-Bug setup as a default for
1924 * port 0. It initialises CMR to CyASYNC; that is never done again, so
1925 * as to limit the number of CyINIT_CHAN commands in normal running.
1927 * ... I wonder what I should do if this fails ...
1930 void mvme167_serial_console_setup(int cflag)
1932 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
1935 u_char rcor, rbpr, badspeed = 0;
1936 unsigned long flags;
1938 local_irq_save(flags);
1941 * First probe channel zero of the chip, to see what speed has
1945 base_addr[CyCAR] = 0;
1947 rcor = base_addr[CyRCOR] << 5;
1948 rbpr = base_addr[CyRBPR];
1950 for (spd = 0; spd < sizeof(baud_bpr); spd++)
1951 if (rbpr == baud_bpr[spd] && rcor == baud_co[spd])
1953 if (spd >= sizeof(baud_bpr)) {
1954 spd = 14; /* 19200 */
1955 badspeed = 1; /* Failed to identify speed */
1957 initial_console_speed = spd;
1959 /* OK, we have chosen a speed, now reset and reinitialise */
1961 my_udelay(20000L); /* Allow time for any active o/p to complete */
1962 if (base_addr[CyCCR] != 0x00) {
1963 local_irq_restore(flags);
1964 /* printk(" chip is never idle (CCR != 0)\n"); */
1968 base_addr[CyCCR] = CyCHIP_RESET; /* Reset the chip */
1971 if (base_addr[CyGFRCR] == 0x00) {
1972 local_irq_restore(flags);
1973 /* printk(" chip is not responding (GFRCR stayed 0)\n"); */
1978 * System clock is 20Mhz, divided by 2048, so divide by 10 for a 1.0ms
1982 base_addr[CyTPR] = 10;
1984 base_addr[CyPILR1] = 0x01; /* Interrupt level for modem change */
1985 base_addr[CyPILR2] = 0x02; /* Interrupt level for tx ints */
1986 base_addr[CyPILR3] = 0x03; /* Interrupt level for rx ints */
1989 * Attempt to set up all channels to something reasonable, and
1990 * bang out a INIT_CHAN command. We should then be able to limit
1991 * the amount of fiddling we have to do in normal running.
1994 for (ch = 3; ch >= 0; ch--) {
1995 base_addr[CyCAR] = (u_char) ch;
1996 base_addr[CyIER] = 0;
1997 base_addr[CyCMR] = CyASYNC;
1998 base_addr[CyLICR] = (u_char) ch << 2;
1999 base_addr[CyLIVR] = 0x5c;
2000 base_addr[CyTCOR] = baud_co[spd];
2001 base_addr[CyTBPR] = baud_bpr[spd];
2002 base_addr[CyRCOR] = baud_co[spd] >> 5;
2003 base_addr[CyRBPR] = baud_bpr[spd];
2004 base_addr[CySCHR1] = 'Q' & 0x1f;
2005 base_addr[CySCHR2] = 'X' & 0x1f;
2006 base_addr[CySCRL] = 0;
2007 base_addr[CySCRH] = 0;
2008 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
2009 base_addr[CyCOR2] = 0;
2010 base_addr[CyCOR3] = Cy_1_STOP;
2011 base_addr[CyCOR4] = baud_cor4[spd];
2012 base_addr[CyCOR5] = 0;
2013 base_addr[CyCOR6] = 0;
2014 base_addr[CyCOR7] = 0;
2015 base_addr[CyRTPRL] = 2;
2016 base_addr[CyRTPRH] = 0;
2017 base_addr[CyMSVR1] = 0;
2018 base_addr[CyMSVR2] = 0;
2019 write_cy_cmd(base_addr, CyINIT_CHAN | CyDIS_RCVR | CyDIS_XMTR);
2023 * Now do specials for channel zero....
2026 base_addr[CyMSVR1] = CyRTS;
2027 base_addr[CyMSVR2] = CyDTR;
2028 base_addr[CyIER] = CyRxData;
2029 write_cy_cmd(base_addr, CyENB_RCVR | CyENB_XMTR);
2031 local_irq_restore(flags);
2033 my_udelay(20000L); /* Let it all settle down */
2035 printk("CD2401 initialised, chip is rev 0x%02x\n", base_addr[CyGFRCR]);
2038 (" WARNING: Failed to identify line speed, rcor=%02x,rbpr=%02x\n",
2040 } /* serial_console_init */
2042 static const struct tty_operations cy_ops = {
2046 .put_char = cy_put_char,
2047 .flush_chars = cy_flush_chars,
2048 .write_room = cy_write_room,
2049 .chars_in_buffer = cy_chars_in_buffer,
2050 .flush_buffer = cy_flush_buffer,
2052 .throttle = cy_throttle,
2053 .unthrottle = cy_unthrottle,
2054 .set_termios = cy_set_termios,
2057 .hangup = cy_hangup,
2058 .tiocmget = cy_tiocmget,
2059 .tiocmset = cy_tiocmset,
2062 /* The serial driver boot-time initialization code!
2063 Hardware I/O ports are mapped to character special devices on a
2064 first found, first allocated manner. That is, this code searches
2065 for Cyclom cards in the system. As each is found, it is probed
2066 to discover how many chips (and thus how many ports) are present.
2067 These ports are mapped to the tty ports 64 and upward in monotonic
2068 fashion. If an 8-port card is replaced with a 16-port card, the
2069 port mapping on a following card will shift.
2071 This approach is different from what is used in the other serial
2072 device driver because the Cyclom is more properly a multiplexer,
2073 not just an aggregation of serial ports on one card.
2075 If there are more cards with more ports than have been statically
2076 allocated above, a warning is printed and the extra ports are ignored.
2078 static int __init serial167_init(void)
2080 struct cyclades_port *info;
2087 struct sigaction sa;
2090 if (!(mvme16x_config & MVME16x_CONFIG_GOT_CD2401))
2093 cy_serial_driver = alloc_tty_driver(NR_PORTS);
2094 if (!cy_serial_driver)
2103 /* Has "console=0,9600n8" been used in bootinfo to change speed? */
2104 if (serial_console_cflag)
2105 DefSpeed = serial_console_cflag & 0017;
2107 DefSpeed = initial_console_speed;
2108 serial_console_info = &cy_port[0];
2109 serial_console_cflag = DefSpeed | CS8;
2111 serial_console = 64; /*callout_driver.minor_start */
2115 /* Initialize the tty_driver structure */
2117 cy_serial_driver->owner = THIS_MODULE;
2118 cy_serial_driver->name = "ttyS";
2119 cy_serial_driver->major = TTY_MAJOR;
2120 cy_serial_driver->minor_start = 64;
2121 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
2122 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
2123 cy_serial_driver->init_termios = tty_std_termios;
2124 cy_serial_driver->init_termios.c_cflag =
2125 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2126 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
2127 tty_set_operations(cy_serial_driver, &cy_ops);
2129 ret = tty_register_driver(cy_serial_driver);
2131 printk(KERN_ERR "Couldn't register MVME166/7 serial driver\n");
2132 put_tty_driver(cy_serial_driver);
2138 for (index = 0; index < 1; index++) {
2142 if (port_num < NR_PORTS) {
2143 while (good_ports-- && port_num < NR_PORTS) {
2144 /*** initialize port ***/
2145 info->magic = CYCLADES_MAGIC;
2146 info->type = PORT_CIRRUS;
2148 info->line = port_num;
2149 info->flags = STD_COM_FLAGS;
2151 info->xmit_fifo_size = 12;
2152 info->cor1 = CyPARITY_NONE | Cy_8_BITS;
2154 info->cor3 = Cy_1_STOP;
2155 info->cor4 = 0x08; /* _very_ small receive threshold */
2159 info->tbpr = baud_bpr[DefSpeed]; /* Tx BPR */
2160 info->tco = baud_co[DefSpeed]; /* Tx CO */
2161 info->rbpr = baud_bpr[DefSpeed]; /* Rx BPR */
2162 info->rco = baud_co[DefSpeed] >> 5; /* Rx CO */
2163 info->close_delay = 0;
2166 #ifdef SERIAL_DEBUG_COUNT
2167 printk("cyc: %d: setting count to 0\n",
2170 info->blocked_open = 0;
2171 info->default_threshold = 0;
2172 info->default_timeout = 0;
2173 init_waitqueue_head(&info->open_wait);
2174 init_waitqueue_head(&info->close_wait);
2177 /*** !!!!!!!! this may expose new bugs !!!!!!!!! *********/
2178 info->read_status_mask =
2179 CyTIMEOUT | CySPECHAR | CyBREAK | CyPARITY |
2180 CyFRAME | CyOVERRUN;
2183 printk("ttyS%d ", info->line);
2186 if (!(port_num & 7)) {
2193 while (port_num < NR_PORTS) {
2198 #ifdef CONFIG_REMOTE_DEBUG
2201 ret = request_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt, 0,
2202 "cd2401_errors", cd2401_rxerr_interrupt);
2204 printk(KERN_ERR "Could't get cd2401_errors IRQ");
2205 goto cleanup_serial_driver;
2208 ret = request_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt, 0,
2209 "cd2401_modem", cd2401_modem_interrupt);
2211 printk(KERN_ERR "Could't get cd2401_modem IRQ");
2212 goto cleanup_irq_cd2401_errors;
2215 ret = request_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt, 0,
2216 "cd2401_txints", cd2401_tx_interrupt);
2218 printk(KERN_ERR "Could't get cd2401_txints IRQ");
2219 goto cleanup_irq_cd2401_modem;
2222 ret = request_irq(MVME167_IRQ_SER_RX, cd2401_rx_interrupt, 0,
2223 "cd2401_rxints", cd2401_rx_interrupt);
2225 printk(KERN_ERR "Could't get cd2401_rxints IRQ");
2226 goto cleanup_irq_cd2401_txints;
2229 /* Now we have registered the interrupt handlers, allow the interrupts */
2231 pcc2chip[PccSCCMICR] = 0x15; /* Serial ints are level 5 */
2232 pcc2chip[PccSCCTICR] = 0x15;
2233 pcc2chip[PccSCCRICR] = 0x15;
2235 pcc2chip[PccIMLR] = 3; /* Allow PCC2 ints above 3!? */
2238 cleanup_irq_cd2401_txints:
2239 free_irq(MVME167_IRQ_SER_TX, cd2401_tx_interrupt);
2240 cleanup_irq_cd2401_modem:
2241 free_irq(MVME167_IRQ_SER_MODEM, cd2401_modem_interrupt);
2242 cleanup_irq_cd2401_errors:
2243 free_irq(MVME167_IRQ_SER_ERR, cd2401_rxerr_interrupt);
2244 cleanup_serial_driver:
2245 if (tty_unregister_driver(cy_serial_driver))
2247 "Couldn't unregister MVME166/7 serial driver\n");
2248 put_tty_driver(cy_serial_driver);
2250 } /* serial167_init */
2252 module_init(serial167_init);
2254 #ifdef CYCLOM_SHOW_STATUS
2255 static void show_status(int line_num)
2257 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2259 struct cyclades_port *info;
2260 unsigned long flags;
2262 info = &cy_port[line_num];
2263 channel = info->line;
2264 printk(" channel %d\n", channel);
2265 /**/ printk(" cy_port\n");
2266 printk(" card line flags = %d %d %x\n",
2267 info->card, info->line, info->flags);
2269 (" *tty read_status_mask timeout xmit_fifo_size = %lx %x %x %x\n",
2270 (long)info->tty, info->read_status_mask, info->timeout,
2271 info->xmit_fifo_size);
2272 printk(" cor1,cor2,cor3,cor4,cor5,cor6,cor7 = %x %x %x %x %x %x %x\n",
2273 info->cor1, info->cor2, info->cor3, info->cor4, info->cor5,
2274 info->cor6, info->cor7);
2275 printk(" tbpr,tco,rbpr,rco = %d %d %d %d\n", info->tbpr, info->tco,
2276 info->rbpr, info->rco);
2277 printk(" close_delay event count = %d %d %d\n", info->close_delay,
2278 info->event, info->count);
2279 printk(" x_char blocked_open = %x %x\n", info->x_char,
2280 info->blocked_open);
2281 printk(" open_wait = %lx %lx %lx\n", (long)info->open_wait);
2283 local_irq_save(flags);
2285 /* Global Registers */
2287 printk(" CyGFRCR %x\n", base_addr[CyGFRCR]);
2288 printk(" CyCAR %x\n", base_addr[CyCAR]);
2289 printk(" CyRISR %x\n", base_addr[CyRISR]);
2290 printk(" CyTISR %x\n", base_addr[CyTISR]);
2291 printk(" CyMISR %x\n", base_addr[CyMISR]);
2292 printk(" CyRIR %x\n", base_addr[CyRIR]);
2293 printk(" CyTIR %x\n", base_addr[CyTIR]);
2294 printk(" CyMIR %x\n", base_addr[CyMIR]);
2295 printk(" CyTPR %x\n", base_addr[CyTPR]);
2297 base_addr[CyCAR] = (u_char) channel;
2299 /* Virtual Registers */
2302 printk(" CyRIVR %x\n", base_addr[CyRIVR]);
2303 printk(" CyTIVR %x\n", base_addr[CyTIVR]);
2304 printk(" CyMIVR %x\n", base_addr[CyMIVR]);
2305 printk(" CyMISR %x\n", base_addr[CyMISR]);
2308 /* Channel Registers */
2310 printk(" CyCCR %x\n", base_addr[CyCCR]);
2311 printk(" CyIER %x\n", base_addr[CyIER]);
2312 printk(" CyCOR1 %x\n", base_addr[CyCOR1]);
2313 printk(" CyCOR2 %x\n", base_addr[CyCOR2]);
2314 printk(" CyCOR3 %x\n", base_addr[CyCOR3]);
2315 printk(" CyCOR4 %x\n", base_addr[CyCOR4]);
2316 printk(" CyCOR5 %x\n", base_addr[CyCOR5]);
2318 printk(" CyCCSR %x\n", base_addr[CyCCSR]);
2319 printk(" CyRDCR %x\n", base_addr[CyRDCR]);
2321 printk(" CySCHR1 %x\n", base_addr[CySCHR1]);
2322 printk(" CySCHR2 %x\n", base_addr[CySCHR2]);
2324 printk(" CySCHR3 %x\n", base_addr[CySCHR3]);
2325 printk(" CySCHR4 %x\n", base_addr[CySCHR4]);
2326 printk(" CySCRL %x\n", base_addr[CySCRL]);
2327 printk(" CySCRH %x\n", base_addr[CySCRH]);
2328 printk(" CyLNC %x\n", base_addr[CyLNC]);
2329 printk(" CyMCOR1 %x\n", base_addr[CyMCOR1]);
2330 printk(" CyMCOR2 %x\n", base_addr[CyMCOR2]);
2332 printk(" CyRTPRL %x\n", base_addr[CyRTPRL]);
2333 printk(" CyRTPRH %x\n", base_addr[CyRTPRH]);
2334 printk(" CyMSVR1 %x\n", base_addr[CyMSVR1]);
2335 printk(" CyMSVR2 %x\n", base_addr[CyMSVR2]);
2336 printk(" CyRBPR %x\n", base_addr[CyRBPR]);
2337 printk(" CyRCOR %x\n", base_addr[CyRCOR]);
2338 printk(" CyTBPR %x\n", base_addr[CyTBPR]);
2339 printk(" CyTCOR %x\n", base_addr[CyTCOR]);
2341 local_irq_restore(flags);
2346 /* Dummy routine in mvme16x/config.c for now */
2348 /* Serial console setup. Called from linux/init/main.c */
2350 void console_setup(char *str, int *ints)
2353 int baud, bits, parity;
2357 if (ints[0] > 3 || ints[1] > 3)
2360 /* Get baud, bits and parity */
2366 if ((s = strchr(str, ','))) {
2369 } while (*s >= '0' && *s <= '9');
2376 /* Now construct a cflag setting. */
2415 serial_console_info = &cy_port[ints[1]];
2416 serial_console_cflag = cflag;
2417 serial_console = ints[1] + 64; /*callout_driver.minor_start */
2422 * The following is probably out of date for 2.1.x serial console stuff.
2424 * The console is registered early on from arch/m68k/kernel/setup.c, and
2425 * it therefore relies on the chip being setup correctly by 166-Bug. This
2426 * seems reasonable, as the serial port has been used to invoke the system
2427 * boot. It also means that this function must not rely on any data
2428 * initialisation performed by serial167_init() etc.
2430 * Of course, once the console has been registered, we had better ensure
2431 * that serial167_init() doesn't leave the chip non-functional.
2433 * The console must be locked when we get here.
2436 void serial167_console_write(struct console *co, const char *str,
2439 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2440 unsigned long flags;
2441 volatile u_char sink;
2447 local_irq_save(flags);
2449 /* Ensure transmitter is enabled! */
2452 base_addr[CyCAR] = (u_char) port;
2453 while (base_addr[CyCCR])
2455 base_addr[CyCCR] = CyENB_XMTR;
2457 ier = base_addr[CyIER];
2458 base_addr[CyIER] = CyTxMpty;
2461 if (pcc2chip[PccSCCTICR] & 0x20) {
2462 /* We have a Tx int. Acknowledge it */
2463 sink = pcc2chip[PccTPIACKR];
2464 if ((base_addr[CyLICR] >> 2) == port) {
2466 /* Last char of string is now output */
2467 base_addr[CyTEOIR] = CyNOTRANS;
2471 base_addr[CyTDR] = '\n';
2475 } else if (*str == '\n') {
2476 base_addr[CyTDR] = '\r';
2479 base_addr[CyTDR] = *str++;
2482 base_addr[CyTEOIR] = 0;
2484 base_addr[CyTEOIR] = CyNOTRANS;
2488 base_addr[CyIER] = ier;
2490 local_irq_restore(flags);
2493 static struct tty_driver *serial167_console_device(struct console *c,
2497 return cy_serial_driver;
2500 static struct console sercons = {
2502 .write = serial167_console_write,
2503 .device = serial167_console_device,
2504 .flags = CON_PRINTBUFFER,
2508 static int __init serial167_console_init(void)
2510 if (vme_brdtype == VME_TYPE_MVME166 ||
2511 vme_brdtype == VME_TYPE_MVME167 ||
2512 vme_brdtype == VME_TYPE_MVME177) {
2513 mvme167_serial_console_setup(0);
2514 register_console(&sercons);
2519 console_initcall(serial167_console_init);
2521 #ifdef CONFIG_REMOTE_DEBUG
2522 void putDebugChar(int c)
2524 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2525 unsigned long flags;
2526 volatile u_char sink;
2530 local_irq_save(flags);
2532 /* Ensure transmitter is enabled! */
2535 base_addr[CyCAR] = (u_char) port;
2536 while (base_addr[CyCCR])
2538 base_addr[CyCCR] = CyENB_XMTR;
2540 ier = base_addr[CyIER];
2541 base_addr[CyIER] = CyTxMpty;
2544 if (pcc2chip[PccSCCTICR] & 0x20) {
2545 /* We have a Tx int. Acknowledge it */
2546 sink = pcc2chip[PccTPIACKR];
2547 if ((base_addr[CyLICR] >> 2) == port) {
2548 base_addr[CyTDR] = c;
2549 base_addr[CyTEOIR] = 0;
2552 base_addr[CyTEOIR] = CyNOTRANS;
2556 base_addr[CyIER] = ier;
2558 local_irq_restore(flags);
2563 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2564 unsigned long flags;
2565 volatile u_char sink;
2571 if (i != debugiq.in) {
2573 if (++i == DEBUG_LEN)
2578 /* OK, nothing in queue, wait in poll loop */
2580 local_irq_save(flags);
2582 /* Ensure receiver is enabled! */
2585 base_addr[CyCAR] = (u_char) port;
2587 while (base_addr[CyCCR])
2589 base_addr[CyCCR] = CyENB_RCVR;
2591 ier = base_addr[CyIER];
2592 base_addr[CyIER] = CyRxData;
2595 if (pcc2chip[PccSCCRICR] & 0x20) {
2596 /* We have a Rx int. Acknowledge it */
2597 sink = pcc2chip[PccRPIACKR];
2598 if ((base_addr[CyLICR] >> 2) == port) {
2599 int cnt = base_addr[CyRFOC];
2601 c = base_addr[CyRDR];
2604 ("!! debug char is null (cnt=%d) !!",
2609 base_addr[CyREOIR] = 0;
2611 if (i == debugiq.in)
2612 panic("Debug input queue empty!");
2614 if (++i == DEBUG_LEN)
2619 base_addr[CyREOIR] = CyNOTRANS;
2623 base_addr[CyIER] = ier;
2625 local_irq_restore(flags);
2630 void queueDebugChar(int c)
2636 if (++i == DEBUG_LEN)
2638 if (i != debugiq.out)
2642 static void debug_setup()
2644 unsigned long flags;
2645 volatile unsigned char *base_addr = (u_char *) BASE_ADDR;
2650 local_irq_save(flags);
2652 for (i = 0; i < 4; i++) {
2653 base_addr[CyCAR] = i;
2654 base_addr[CyLICR] = i << 2;
2657 debugiq.in = debugiq.out = 0;
2659 base_addr[CyCAR] = DEBUG_PORT;
2664 base_addr[CyIER] = 0;
2666 base_addr[CyCMR] = CyASYNC;
2667 base_addr[CyLICR] = DEBUG_PORT << 2;
2668 base_addr[CyLIVR] = 0x5c;
2670 /* tx and rx baud rate */
2672 base_addr[CyTCOR] = baud_co[i];
2673 base_addr[CyTBPR] = baud_bpr[i];
2674 base_addr[CyRCOR] = baud_co[i] >> 5;
2675 base_addr[CyRBPR] = baud_bpr[i];
2677 /* set line characteristics according configuration */
2679 base_addr[CySCHR1] = 0;
2680 base_addr[CySCHR2] = 0;
2681 base_addr[CySCRL] = 0;
2682 base_addr[CySCRH] = 0;
2683 base_addr[CyCOR1] = Cy_8_BITS | CyPARITY_NONE;
2684 base_addr[CyCOR2] = 0;
2685 base_addr[CyCOR3] = Cy_1_STOP;
2686 base_addr[CyCOR4] = baud_cor4[i];
2687 base_addr[CyCOR5] = 0;
2688 base_addr[CyCOR6] = 0;
2689 base_addr[CyCOR7] = 0;
2691 write_cy_cmd(base_addr, CyINIT_CHAN);
2692 write_cy_cmd(base_addr, CyENB_RCVR);
2694 base_addr[CyCAR] = DEBUG_PORT; /* !!! Is this needed? */
2696 base_addr[CyRTPRL] = 2;
2697 base_addr[CyRTPRH] = 0;
2699 base_addr[CyMSVR1] = CyRTS;
2700 base_addr[CyMSVR2] = CyDTR;
2702 base_addr[CyIER] = CyRxData;
2704 local_irq_restore(flags);
2710 MODULE_LICENSE("GPL");