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/string.h>
56 #include <linux/fcntl.h>
57 #include <linux/ptrace.h>
58 #include <linux/serial167.h>
59 #include <linux/delay.h>
60 #include <linux/major.h>
62 #include <linux/console.h>
63 #include <linux/module.h>
64 #include <linux/bitops.h>
65 #include <linux/tty_flip.h>
67 #include <asm/system.h>
69 #include <asm/mvme16xhw.h>
70 #include <asm/bootinfo.h>
71 #include <asm/setup.h>
73 #include <linux/types.h>
74 #include <linux/kernel.h>
76 #include <asm/uaccess.h>
77 #include <linux/init.h>
79 #define SERIAL_PARANOIA_CHECK
80 #undef SERIAL_DEBUG_OPEN
81 #undef SERIAL_DEBUG_THROTTLE
82 #undef SERIAL_DEBUG_OTHER
83 #undef SERIAL_DEBUG_IO
84 #undef SERIAL_DEBUG_COUNT
85 #undef SERIAL_DEBUG_DTR
86 #undef CYCLOM_16Y_HACK
87 #define CYCLOM_ENABLE_MONITORING
89 #define WAKEUP_CHARS 256
91 #define STD_COM_FLAGS (0)
93 static struct tty_driver
*cy_serial_driver
;
94 extern int serial_console
;
95 static struct cyclades_port
*serial_console_info
= NULL
;
96 static unsigned int serial_console_cflag
= 0;
97 u_char initial_console_speed
;
99 /* Base address of cd2401 chip on mvme166/7 */
101 #define BASE_ADDR (0xfff45000)
102 #define pcc2chip ((volatile u_char *)0xfff42000)
103 #define PccSCCMICR 0x1d
104 #define PccSCCTICR 0x1e
105 #define PccSCCRICR 0x1f
106 #define PccTPIACKR 0x25
107 #define PccRPIACKR 0x27
110 /* This is the per-port data structure */
111 struct cyclades_port cy_port
[] = {
119 #define NR_PORTS ARRAY_SIZE(cy_port)
122 * This is used to look up the divisor speeds and the timeouts
123 * We're normally limited to 15 distinct baud rates. The extra
124 * are accessed via settings in info->flags.
125 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
126 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
129 static int baud_table
[] = {
130 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
131 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
136 static char baud_co
[] = { /* 25 MHz clock option table */
137 /* value => 00 01 02 03 04 */
138 /* divide by 8 32 128 512 2048 */
139 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
140 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
143 static char baud_bpr
[] = { /* 25 MHz baud rate period table */
144 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
145 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
149 /* I think 166 brd clocks 2401 at 20MHz.... */
151 /* These values are written directly to tcor, and >> 5 for writing to rcor */
152 static u_char baud_co
[] = { /* 20 MHz clock option table */
153 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x60, 0x40,
154 0x40, 0x40, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
157 /* These values written directly to tbpr/rbpr */
158 static u_char baud_bpr
[] = { /* 20 MHz baud rate period table */
159 0x00, 0xc0, 0x80, 0x58, 0x6c, 0x40, 0xc0, 0x81, 0x40, 0x81,
160 0x57, 0x40, 0x81, 0x40, 0x81, 0x40, 0x2b, 0x20, 0x15, 0x10
163 static u_char baud_cor4
[] = { /* receive threshold */
164 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
165 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07
168 static void shutdown(struct cyclades_port
*);
169 static int startup(struct cyclades_port
*);
170 static void cy_throttle(struct tty_struct
*);
171 static void cy_unthrottle(struct tty_struct
*);
172 static void config_setup(struct cyclades_port
*);
173 extern void console_print(const char *);
174 #ifdef CYCLOM_SHOW_STATUS
175 static void show_status(int);
178 #ifdef CONFIG_REMOTE_DEBUG
179 static void debug_setup(void);
180 void queueDebugChar(int c
);
181 int getDebugChar(void);
184 #define DEBUG_LEN 256
189 unsigned char buf
[DEBUG_LEN
];
196 * I have my own version of udelay(), as it is needed when initialising
197 * the chip, before the delay loop has been calibrated. Should probably
198 * reference one of the vmechip2 or pccchip2 counter for an accurate
199 * delay, but this wild guess will do for now.
202 void my_udelay(long us
)
205 volatile u_char
*p
= &x
;
209 for (i
= 100; i
; i
--)
213 static inline int serial_paranoia_check(struct cyclades_port
*info
, char *name
,
216 #ifdef SERIAL_PARANOIA_CHECK
218 printk("Warning: null cyclades_port for (%s) in %s\n", name
,
223 if ((long)info
< (long)(&cy_port
[0])
224 || (long)(&cy_port
[NR_PORTS
]) < (long)info
) {
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
);
248 local_irq_restore(flags
);
255 local_irq_save(flags
);
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
= (struct cyclades_port
*)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
= (struct cyclades_port
*)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 loose
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!!!");
524 info
= &cy_port
[channel
];
526 /* validate the port number (as configured and open) */
527 if ((channel
< 0) || (NR_PORTS
<= channel
)) {
528 base_addr
[CyIER
] &= ~(CyTxMpty
| CyTxRdy
);
529 base_addr
[CyTEOIR
] = CyNOTRANS
;
532 info
->last_active
= jiffies
;
533 if (info
->tty
== 0) {
534 base_addr
[CyIER
] &= ~(CyTxMpty
| CyTxRdy
);
535 base_addr
[CyTEOIR
] = CyNOTRANS
;
539 /* load the on-chip space available for outbound data */
540 saved_cnt
= char_count
= base_addr
[CyTFTC
];
542 if (info
->x_char
) { /* send special char */
543 outch
= info
->x_char
;
544 base_addr
[CyTDR
] = outch
;
550 /* The Cirrus chip requires the "Embedded Transmit
551 Commands" of start break, delay, and end break
552 sequences to be sent. The duration of the
553 break is given in TICs, which runs at HZ
554 (typically 100) and the PPR runs at 200 Hz,
555 so the delay is duration * 200/HZ, and thus a
556 break can run from 1/100 sec to about 5/4 sec.
557 Need to check these values - RGH 141095.
559 base_addr
[CyTDR
] = 0; /* start break */
560 base_addr
[CyTDR
] = 0x81;
561 base_addr
[CyTDR
] = 0; /* delay a bit */
562 base_addr
[CyTDR
] = 0x82;
563 base_addr
[CyTDR
] = info
->x_break
* 200 / HZ
;
564 base_addr
[CyTDR
] = 0; /* terminate break */
565 base_addr
[CyTDR
] = 0x83;
570 while (char_count
> 0) {
571 if (!info
->xmit_cnt
) {
572 base_addr
[CyIER
] &= ~(CyTxMpty
| CyTxRdy
);
575 if (info
->xmit_buf
== 0) {
576 base_addr
[CyIER
] &= ~(CyTxMpty
| CyTxRdy
);
579 if (info
->tty
->stopped
|| info
->tty
->hw_stopped
) {
580 base_addr
[CyIER
] &= ~(CyTxMpty
| CyTxRdy
);
583 /* Because the Embedded Transmit Commands have been
584 enabled, we must check to see if the escape
585 character, NULL, is being sent. If it is, we
586 must ensure that there is room for it to be
587 doubled in the output stream. Therefore we
588 no longer advance the pointer when the character
589 is fetched, but rather wait until after the check
590 for a NULL output character. (This is necessary
591 because there may not be room for the two chars
592 needed to send a NULL.
594 outch
= info
->xmit_buf
[info
->xmit_tail
];
597 info
->xmit_tail
= (info
->xmit_tail
+ 1)
599 base_addr
[CyTDR
] = outch
;
602 if (char_count
> 1) {
604 info
->xmit_tail
= (info
->xmit_tail
+ 1)
606 base_addr
[CyTDR
] = outch
;
607 base_addr
[CyTDR
] = 0;
616 if (info
->xmit_cnt
< WAKEUP_CHARS
)
617 tty_wakeup(info
->tty
);
619 base_addr
[CyTEOIR
] = (char_count
!= saved_cnt
) ? 0 : CyNOTRANS
;
621 } /* cy_tx_interrupt */
623 static irqreturn_t
cd2401_rx_interrupt(int irq
, void *dev_id
)
625 struct tty_struct
*tty
;
626 struct cyclades_port
*info
;
627 volatile unsigned char *base_addr
= (unsigned char *)BASE_ADDR
;
634 /* determine the channel and change to that context */
635 channel
= (u_short
) (base_addr
[CyLICR
] >> 2);
636 info
= &cy_port
[channel
];
637 info
->last_active
= jiffies
;
638 save_cnt
= char_count
= base_addr
[CyRFOC
];
640 #ifdef CONFIG_REMOTE_DEBUG
641 if (channel
== DEBUG_PORT
) {
642 while (char_count
--) {
643 data
= base_addr
[CyRDR
];
644 queueDebugChar(data
);
648 /* if there is nowhere to put the data, discard it */
649 if (info
->tty
== 0) {
650 while (char_count
--) {
651 data
= base_addr
[CyRDR
];
653 } else { /* there is an open port for this data */
655 /* load # characters available from the chip */
657 #ifdef CYCLOM_ENABLE_MONITORING
658 ++info
->mon
.int_count
;
659 info
->mon
.char_count
+= char_count
;
660 if (char_count
> info
->mon
.char_max
)
661 info
->mon
.char_max
= char_count
;
662 info
->mon
.char_last
= char_count
;
664 len
= tty_buffer_request_room(tty
, char_count
);
666 data
= base_addr
[CyRDR
];
667 tty_insert_flip_char(tty
, data
, TTY_NORMAL
);
668 #ifdef CYCLOM_16Y_HACK
672 tty_schedule_flip(tty
);
675 base_addr
[CyREOIR
] = save_cnt
? 0 : CyNOTRANS
;
677 } /* cy_rx_interrupt */
679 /* This is called whenever a port becomes active;
680 interrupts are enabled and DTR & RTS are turned on.
682 static int startup(struct cyclades_port
*info
)
685 volatile unsigned char *base_addr
= (unsigned char *)BASE_ADDR
;
688 if (info
->flags
& ASYNC_INITIALIZED
) {
694 set_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
698 if (!info
->xmit_buf
) {
699 info
->xmit_buf
= (unsigned char *)get_zeroed_page(GFP_KERNEL
);
700 if (!info
->xmit_buf
) {
707 channel
= info
->line
;
709 #ifdef SERIAL_DEBUG_OPEN
710 printk("startup channel %d\n", channel
);
713 local_irq_save(flags
);
714 base_addr
[CyCAR
] = (u_char
) channel
;
715 write_cy_cmd(base_addr
, CyENB_RCVR
| CyENB_XMTR
);
717 base_addr
[CyCAR
] = (u_char
) channel
; /* !!! Is this needed? */
718 base_addr
[CyMSVR1
] = CyRTS
;
719 /* CP('S');CP('1'); */
720 base_addr
[CyMSVR2
] = CyDTR
;
722 #ifdef SERIAL_DEBUG_DTR
723 printk("cyc: %d: raising DTR\n", __LINE__
);
724 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
728 base_addr
[CyIER
] |= CyRxData
;
729 info
->flags
|= ASYNC_INITIALIZED
;
732 clear_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
734 info
->xmit_cnt
= info
->xmit_head
= info
->xmit_tail
= 0;
736 local_irq_restore(flags
);
738 #ifdef SERIAL_DEBUG_OPEN
744 void start_xmit(struct cyclades_port
*info
)
747 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
750 channel
= info
->line
;
751 local_irq_save(flags
);
752 base_addr
[CyCAR
] = channel
;
753 base_addr
[CyIER
] |= CyTxMpty
;
754 local_irq_restore(flags
);
758 * This routine shuts down a serial port; interrupts are disabled,
759 * and DTR is dropped if the hangup on close termio flag is on.
761 static void shutdown(struct cyclades_port
*info
)
764 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
767 if (!(info
->flags
& ASYNC_INITIALIZED
)) {
772 channel
= info
->line
;
774 #ifdef SERIAL_DEBUG_OPEN
775 printk("shutdown channel %d\n", channel
);
778 /* !!! REALLY MUST WAIT FOR LAST CHARACTER TO BE
779 SENT BEFORE DROPPING THE LINE !!! (Perhaps
780 set some flag that is read when XMTY happens.)
781 Other choices are to delay some fixed interval
782 or schedule some later processing.
784 local_irq_save(flags
);
785 if (info
->xmit_buf
) {
786 free_page((unsigned long)info
->xmit_buf
);
787 info
->xmit_buf
= NULL
;
790 base_addr
[CyCAR
] = (u_char
) channel
;
791 if (!info
->tty
|| (info
->tty
->termios
->c_cflag
& HUPCL
)) {
792 base_addr
[CyMSVR1
] = 0;
793 /* CP('C');CP('1'); */
794 base_addr
[CyMSVR2
] = 0;
795 #ifdef SERIAL_DEBUG_DTR
796 printk("cyc: %d: dropping DTR\n", __LINE__
);
797 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
801 write_cy_cmd(base_addr
, CyDIS_RCVR
);
802 /* it may be appropriate to clear _XMIT at
803 some later date (after testing)!!! */
806 set_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
808 info
->flags
&= ~ASYNC_INITIALIZED
;
809 local_irq_restore(flags
);
811 #ifdef SERIAL_DEBUG_OPEN
817 * This routine finds or computes the various line characteristics.
819 static void config_setup(struct cyclades_port
*info
)
822 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
826 unsigned char ti
, need_init_chan
= 0;
828 if (!info
->tty
|| !info
->tty
->termios
) {
831 if (info
->line
== -1) {
834 cflag
= info
->tty
->termios
->c_cflag
;
839 /* Starting with kernel 1.1.65, there is direct support for
840 higher baud rates. The following code supports those
841 changes. The conditional aspect allows this driver to be
842 used for earlier as well as later kernel versions. (The
843 mapping is slightly different from serial.c because there
844 is still the possibility of supporting 75 kbit/sec with
850 else if (i
== B115200
)
853 else if (i
== B78600
)
857 info
->tty
->termios
->c_cflag
&= ~CBAUDEX
;
861 if ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
863 if ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
866 /* Don't ever change the speed of the console port. It will
867 * run at the speed specified in bootinfo, or at 19.2K */
868 /* Actually, it should run at whatever speed 166Bug was using */
869 /* Note info->timeout isn't used at present */
870 if (info
!= serial_console_info
) {
871 info
->tbpr
= baud_bpr
[i
]; /* Tx BPR */
872 info
->tco
= baud_co
[i
]; /* Tx CO */
873 info
->rbpr
= baud_bpr
[i
]; /* Rx BPR */
874 info
->rco
= baud_co
[i
] >> 5; /* Rx CO */
875 if (baud_table
[i
] == 134) {
877 (info
->xmit_fifo_size
* HZ
* 30 / 269) + 2;
878 /* get it right for 134.5 baud */
879 } else if (baud_table
[i
]) {
881 (info
->xmit_fifo_size
* HZ
* 15 / baud_table
[i
]) +
883 /* this needs to be propagated into the card info */
888 /* By tradition (is it a standard?) a baud rate of zero
889 implies the line should be/has been closed. A bit
890 later in this routine such a test is performed. */
892 /* byte size and parity */
896 info
->cor4
= (info
->default_threshold
? info
->default_threshold
: baud_cor4
[i
]); /* receive threshold */
897 /* Following two lines added 101295, RGH. */
898 /* It is obviously wrong to access CyCORx, and not info->corx here,
899 * try and remember to fix it later! */
900 channel
= info
->line
;
901 base_addr
[CyCAR
] = (u_char
) channel
;
902 if (C_CLOCAL(info
->tty
)) {
903 if (base_addr
[CyIER
] & CyMdmCh
)
904 base_addr
[CyIER
] &= ~CyMdmCh
; /* without modem intr */
905 /* ignore 1->0 modem transitions */
906 if (base_addr
[CyCOR4
] & (CyDSR
| CyCTS
| CyDCD
))
907 base_addr
[CyCOR4
] &= ~(CyDSR
| CyCTS
| CyDCD
);
908 /* ignore 0->1 modem transitions */
909 if (base_addr
[CyCOR5
] & (CyDSR
| CyCTS
| CyDCD
))
910 base_addr
[CyCOR5
] &= ~(CyDSR
| CyCTS
| CyDCD
);
912 if ((base_addr
[CyIER
] & CyMdmCh
) != CyMdmCh
)
913 base_addr
[CyIER
] |= CyMdmCh
; /* with modem intr */
914 /* act on 1->0 modem transitions */
915 if ((base_addr
[CyCOR4
] & (CyDSR
| CyCTS
| CyDCD
)) !=
916 (CyDSR
| CyCTS
| CyDCD
))
917 base_addr
[CyCOR4
] |= CyDSR
| CyCTS
| CyDCD
;
918 /* act on 0->1 modem transitions */
919 if ((base_addr
[CyCOR5
] & (CyDSR
| CyCTS
| CyDCD
)) !=
920 (CyDSR
| CyCTS
| CyDCD
))
921 base_addr
[CyCOR5
] |= CyDSR
| CyCTS
| CyDCD
;
923 info
->cor3
= (cflag
& CSTOPB
) ? Cy_2_STOP
: Cy_1_STOP
;
925 switch (cflag
& CSIZE
) {
927 info
->cor1
= Cy_5_BITS
;
930 info
->cor1
= Cy_6_BITS
;
933 info
->cor1
= Cy_7_BITS
;
936 info
->cor1
= Cy_8_BITS
;
939 if (cflag
& PARENB
) {
940 if (cflag
& PARODD
) {
941 info
->cor1
|= CyPARITY_O
;
943 info
->cor1
|= CyPARITY_E
;
946 info
->cor1
|= CyPARITY_NONE
;
949 /* CTS flow control flag */
951 /* Don't complcate matters for now! RGH 141095 */
952 if (cflag
& CRTSCTS
) {
953 info
->flags
|= ASYNC_CTS_FLOW
;
954 info
->cor2
|= CyCtsAE
;
956 info
->flags
&= ~ASYNC_CTS_FLOW
;
957 info
->cor2
&= ~CyCtsAE
;
961 info
->flags
&= ~ASYNC_CHECK_CD
;
963 info
->flags
|= ASYNC_CHECK_CD
;
965 /***********************************************
966 The hardware option, CyRtsAO, presents RTS when
967 the chip has characters to send. Since most modems
968 use RTS as reverse (inbound) flow control, this
969 option is not used. If inbound flow control is
970 necessary, DTR can be programmed to provide the
971 appropriate signals for use with a non-standard
972 cable. Contact Marcio Saito for details.
973 ***********************************************/
975 channel
= info
->line
;
977 local_irq_save(flags
);
978 base_addr
[CyCAR
] = (u_char
) channel
;
980 /* CyCMR set once only in mvme167_init_serial() */
981 if (base_addr
[CyLICR
] != channel
<< 2)
982 base_addr
[CyLICR
] = channel
<< 2;
983 if (base_addr
[CyLIVR
] != 0x5c)
984 base_addr
[CyLIVR
] = 0x5c;
986 /* tx and rx baud rate */
988 if (base_addr
[CyCOR1
] != info
->cor1
)
990 if (base_addr
[CyTCOR
] != info
->tco
)
991 base_addr
[CyTCOR
] = info
->tco
;
992 if (base_addr
[CyTBPR
] != info
->tbpr
)
993 base_addr
[CyTBPR
] = info
->tbpr
;
994 if (base_addr
[CyRCOR
] != info
->rco
)
995 base_addr
[CyRCOR
] = info
->rco
;
996 if (base_addr
[CyRBPR
] != info
->rbpr
)
997 base_addr
[CyRBPR
] = info
->rbpr
;
999 /* set line characteristics according configuration */
1001 if (base_addr
[CySCHR1
] != START_CHAR(info
->tty
))
1002 base_addr
[CySCHR1
] = START_CHAR(info
->tty
);
1003 if (base_addr
[CySCHR2
] != STOP_CHAR(info
->tty
))
1004 base_addr
[CySCHR2
] = STOP_CHAR(info
->tty
);
1005 if (base_addr
[CySCRL
] != START_CHAR(info
->tty
))
1006 base_addr
[CySCRL
] = START_CHAR(info
->tty
);
1007 if (base_addr
[CySCRH
] != START_CHAR(info
->tty
))
1008 base_addr
[CySCRH
] = START_CHAR(info
->tty
);
1009 if (base_addr
[CyCOR1
] != info
->cor1
)
1010 base_addr
[CyCOR1
] = info
->cor1
;
1011 if (base_addr
[CyCOR2
] != info
->cor2
)
1012 base_addr
[CyCOR2
] = info
->cor2
;
1013 if (base_addr
[CyCOR3
] != info
->cor3
)
1014 base_addr
[CyCOR3
] = info
->cor3
;
1015 if (base_addr
[CyCOR4
] != info
->cor4
)
1016 base_addr
[CyCOR4
] = info
->cor4
;
1017 if (base_addr
[CyCOR5
] != info
->cor5
)
1018 base_addr
[CyCOR5
] = info
->cor5
;
1019 if (base_addr
[CyCOR6
] != info
->cor6
)
1020 base_addr
[CyCOR6
] = info
->cor6
;
1021 if (base_addr
[CyCOR7
] != info
->cor7
)
1022 base_addr
[CyCOR7
] = info
->cor7
;
1025 write_cy_cmd(base_addr
, CyINIT_CHAN
);
1027 base_addr
[CyCAR
] = (u_char
) channel
; /* !!! Is this needed? */
1029 /* 2ms default rx timeout */
1030 ti
= info
->default_timeout
? info
->default_timeout
: 0x02;
1031 if (base_addr
[CyRTPRL
] != ti
)
1032 base_addr
[CyRTPRL
] = ti
;
1033 if (base_addr
[CyRTPRH
] != 0)
1034 base_addr
[CyRTPRH
] = 0;
1036 /* Set up RTS here also ????? RGH 141095 */
1037 if (i
== 0) { /* baud rate is zero, turn off line */
1038 if ((base_addr
[CyMSVR2
] & CyDTR
) == CyDTR
)
1039 base_addr
[CyMSVR2
] = 0;
1040 #ifdef SERIAL_DEBUG_DTR
1041 printk("cyc: %d: dropping DTR\n", __LINE__
);
1042 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
1043 base_addr
[CyMSVR2
]);
1046 if ((base_addr
[CyMSVR2
] & CyDTR
) != CyDTR
)
1047 base_addr
[CyMSVR2
] = CyDTR
;
1048 #ifdef SERIAL_DEBUG_DTR
1049 printk("cyc: %d: raising DTR\n", __LINE__
);
1050 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
1051 base_addr
[CyMSVR2
]);
1056 clear_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
1059 local_irq_restore(flags
);
1061 } /* config_setup */
1063 static void cy_put_char(struct tty_struct
*tty
, unsigned char ch
)
1065 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1066 unsigned long flags
;
1068 #ifdef SERIAL_DEBUG_IO
1069 printk("cy_put_char %s(0x%02x)\n", tty
->name
, ch
);
1072 if (serial_paranoia_check(info
, tty
->name
, "cy_put_char"))
1075 if (!info
->xmit_buf
)
1078 local_irq_save(flags
);
1079 if (info
->xmit_cnt
>= PAGE_SIZE
- 1) {
1080 local_irq_restore(flags
);
1084 info
->xmit_buf
[info
->xmit_head
++] = ch
;
1085 info
->xmit_head
&= PAGE_SIZE
- 1;
1087 local_irq_restore(flags
);
1090 static void cy_flush_chars(struct tty_struct
*tty
)
1092 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1093 unsigned long flags
;
1094 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1097 #ifdef SERIAL_DEBUG_IO
1098 printk("cy_flush_chars %s\n", tty
->name
); /* */
1101 if (serial_paranoia_check(info
, tty
->name
, "cy_flush_chars"))
1104 if (info
->xmit_cnt
<= 0 || tty
->stopped
1105 || tty
->hw_stopped
|| !info
->xmit_buf
)
1108 channel
= info
->line
;
1110 local_irq_save(flags
);
1111 base_addr
[CyCAR
] = channel
;
1112 base_addr
[CyIER
] |= CyTxMpty
;
1113 local_irq_restore(flags
);
1114 } /* cy_flush_chars */
1116 /* This routine gets called when tty_write has put something into
1117 the write_queue. If the port is not already transmitting stuff,
1118 start it off by enabling interrupts. The interrupt service
1119 routine will then ensure that the characters are sent. If the
1120 port is already active, there is no need to kick it.
1122 static int cy_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
1124 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1125 unsigned long flags
;
1128 #ifdef SERIAL_DEBUG_IO
1129 printk("cy_write %s\n", tty
->name
); /* */
1132 if (serial_paranoia_check(info
, tty
->name
, "cy_write")) {
1136 if (!info
->xmit_buf
) {
1141 local_irq_save(flags
);
1142 c
= min_t(int, count
, min(SERIAL_XMIT_SIZE
- info
->xmit_cnt
- 1,
1143 SERIAL_XMIT_SIZE
- info
->xmit_head
));
1145 local_irq_restore(flags
);
1149 memcpy(info
->xmit_buf
+ info
->xmit_head
, buf
, c
);
1151 (info
->xmit_head
+ c
) & (SERIAL_XMIT_SIZE
- 1);
1152 info
->xmit_cnt
+= c
;
1153 local_irq_restore(flags
);
1160 if (info
->xmit_cnt
&& !tty
->stopped
&& !tty
->hw_stopped
) {
1166 static int cy_write_room(struct tty_struct
*tty
)
1168 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1171 #ifdef SERIAL_DEBUG_IO
1172 printk("cy_write_room %s\n", tty
->name
); /* */
1175 if (serial_paranoia_check(info
, tty
->name
, "cy_write_room"))
1177 ret
= PAGE_SIZE
- info
->xmit_cnt
- 1;
1181 } /* cy_write_room */
1183 static int cy_chars_in_buffer(struct tty_struct
*tty
)
1185 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1187 #ifdef SERIAL_DEBUG_IO
1188 printk("cy_chars_in_buffer %s %d\n", tty
->name
, info
->xmit_cnt
); /* */
1191 if (serial_paranoia_check(info
, tty
->name
, "cy_chars_in_buffer"))
1194 return info
->xmit_cnt
;
1195 } /* cy_chars_in_buffer */
1197 static void cy_flush_buffer(struct tty_struct
*tty
)
1199 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1200 unsigned long flags
;
1202 #ifdef SERIAL_DEBUG_IO
1203 printk("cy_flush_buffer %s\n", tty
->name
); /* */
1206 if (serial_paranoia_check(info
, tty
->name
, "cy_flush_buffer"))
1208 local_irq_save(flags
);
1209 info
->xmit_cnt
= info
->xmit_head
= info
->xmit_tail
= 0;
1210 local_irq_restore(flags
);
1212 } /* cy_flush_buffer */
1214 /* This routine is called by the upper-layer tty layer to signal
1215 that incoming characters should be throttled or that the
1216 throttle should be released.
1218 static void cy_throttle(struct tty_struct
*tty
)
1220 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1221 unsigned long flags
;
1222 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1225 #ifdef SERIAL_DEBUG_THROTTLE
1228 printk("throttle %s: %d....\n", tty_name(tty
, buf
),
1229 tty
->ldisc
.chars_in_buffer(tty
));
1230 printk("cy_throttle %s\n", tty
->name
);
1233 if (serial_paranoia_check(info
, tty
->name
, "cy_nthrottle")) {
1238 info
->x_char
= STOP_CHAR(tty
);
1239 /* Should use the "Send Special Character" feature!!! */
1242 channel
= info
->line
;
1244 local_irq_save(flags
);
1245 base_addr
[CyCAR
] = (u_char
) channel
;
1246 base_addr
[CyMSVR1
] = 0;
1247 local_irq_restore(flags
);
1250 static void cy_unthrottle(struct tty_struct
*tty
)
1252 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1253 unsigned long flags
;
1254 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1257 #ifdef SERIAL_DEBUG_THROTTLE
1260 printk("throttle %s: %d....\n", tty_name(tty
, buf
),
1261 tty
->ldisc
.chars_in_buffer(tty
));
1262 printk("cy_unthrottle %s\n", tty
->name
);
1265 if (serial_paranoia_check(info
, tty
->name
, "cy_nthrottle")) {
1270 info
->x_char
= START_CHAR(tty
);
1271 /* Should use the "Send Special Character" feature!!! */
1274 channel
= info
->line
;
1276 local_irq_save(flags
);
1277 base_addr
[CyCAR
] = (u_char
) channel
;
1278 base_addr
[CyMSVR1
] = CyRTS
;
1279 local_irq_restore(flags
);
1280 } /* cy_unthrottle */
1283 get_serial_info(struct cyclades_port
*info
,
1284 struct serial_struct __user
* retinfo
)
1286 struct serial_struct tmp
;
1291 memset(&tmp
, 0, sizeof(tmp
));
1292 tmp
.type
= info
->type
;
1293 tmp
.line
= info
->line
;
1294 tmp
.port
= info
->line
;
1296 tmp
.flags
= info
->flags
;
1297 tmp
.baud_base
= 0; /*!!! */
1298 tmp
.close_delay
= info
->close_delay
;
1299 tmp
.custom_divisor
= 0; /*!!! */
1300 tmp
.hub6
= 0; /*!!! */
1301 return copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)) ? -EFAULT
: 0;
1302 } /* get_serial_info */
1305 set_serial_info(struct cyclades_port
*info
,
1306 struct serial_struct __user
* new_info
)
1308 struct serial_struct new_serial
;
1309 struct cyclades_port old_info
;
1314 if (copy_from_user(&new_serial
, new_info
, sizeof(new_serial
)))
1318 if (!capable(CAP_SYS_ADMIN
)) {
1319 if ((new_serial
.close_delay
!= info
->close_delay
) ||
1320 ((new_serial
.flags
& ASYNC_FLAGS
& ~ASYNC_USR_MASK
) !=
1321 (info
->flags
& ASYNC_FLAGS
& ~ASYNC_USR_MASK
)))
1323 info
->flags
= ((info
->flags
& ~ASYNC_USR_MASK
) |
1324 (new_serial
.flags
& ASYNC_USR_MASK
));
1325 goto check_and_exit
;
1329 * OK, past this point, all the error checking has been done.
1330 * At this point, we start making changes.....
1333 info
->flags
= ((info
->flags
& ~ASYNC_FLAGS
) |
1334 (new_serial
.flags
& ASYNC_FLAGS
));
1335 info
->close_delay
= new_serial
.close_delay
;
1338 if (info
->flags
& ASYNC_INITIALIZED
) {
1342 return startup(info
);
1343 } /* set_serial_info */
1345 static int cy_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1347 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1349 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1350 unsigned long flags
;
1351 unsigned char status
;
1353 channel
= info
->line
;
1355 local_irq_save(flags
);
1356 base_addr
[CyCAR
] = (u_char
) channel
;
1357 status
= base_addr
[CyMSVR1
] | base_addr
[CyMSVR2
];
1358 local_irq_restore(flags
);
1360 return ((status
& CyRTS
) ? TIOCM_RTS
: 0)
1361 | ((status
& CyDTR
) ? TIOCM_DTR
: 0)
1362 | ((status
& CyDCD
) ? TIOCM_CAR
: 0)
1363 | ((status
& CyDSR
) ? TIOCM_DSR
: 0)
1364 | ((status
& CyCTS
) ? TIOCM_CTS
: 0);
1368 cy_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1369 unsigned int set
, unsigned int clear
)
1371 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1373 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1374 unsigned long flags
;
1376 channel
= info
->line
;
1378 if (set
& TIOCM_RTS
) {
1379 local_irq_save(flags
);
1380 base_addr
[CyCAR
] = (u_char
) channel
;
1381 base_addr
[CyMSVR1
] = CyRTS
;
1382 local_irq_restore(flags
);
1384 if (set
& TIOCM_DTR
) {
1385 local_irq_save(flags
);
1386 base_addr
[CyCAR
] = (u_char
) channel
;
1387 /* CP('S');CP('2'); */
1388 base_addr
[CyMSVR2
] = CyDTR
;
1389 #ifdef SERIAL_DEBUG_DTR
1390 printk("cyc: %d: raising DTR\n", __LINE__
);
1391 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
1392 base_addr
[CyMSVR2
]);
1394 local_irq_restore(flags
);
1397 if (clear
& TIOCM_RTS
) {
1398 local_irq_save(flags
);
1399 base_addr
[CyCAR
] = (u_char
) channel
;
1400 base_addr
[CyMSVR1
] = 0;
1401 local_irq_restore(flags
);
1403 if (clear
& TIOCM_DTR
) {
1404 local_irq_save(flags
);
1405 base_addr
[CyCAR
] = (u_char
) channel
;
1406 /* CP('C');CP('2'); */
1407 base_addr
[CyMSVR2
] = 0;
1408 #ifdef SERIAL_DEBUG_DTR
1409 printk("cyc: %d: dropping DTR\n", __LINE__
);
1410 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
1411 base_addr
[CyMSVR2
]);
1413 local_irq_restore(flags
);
1417 } /* set_modem_info */
1419 static void send_break(struct cyclades_port
*info
, int duration
)
1420 { /* Let the transmit ISR take care of this (since it
1421 requires stuffing characters into the output stream).
1423 info
->x_break
= duration
;
1424 if (!info
->xmit_cnt
) {
1430 get_mon_info(struct cyclades_port
*info
, struct cyclades_monitor __user
* mon
)
1433 if (copy_to_user(mon
, &info
->mon
, sizeof(struct cyclades_monitor
)))
1435 info
->mon
.int_count
= 0;
1436 info
->mon
.char_count
= 0;
1437 info
->mon
.char_max
= 0;
1438 info
->mon
.char_last
= 0;
1442 static int set_threshold(struct cyclades_port
*info
, unsigned long __user
* arg
)
1444 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1445 unsigned long value
;
1448 if (get_user(value
, arg
))
1451 channel
= info
->line
;
1452 info
->cor4
&= ~CyREC_FIFO
;
1453 info
->cor4
|= value
& CyREC_FIFO
;
1454 base_addr
[CyCOR4
] = info
->cor4
;
1459 get_threshold(struct cyclades_port
*info
, unsigned long __user
* value
)
1461 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1465 channel
= info
->line
;
1467 tmp
= base_addr
[CyCOR4
] & CyREC_FIFO
;
1468 return put_user(tmp
, value
);
1472 set_default_threshold(struct cyclades_port
*info
, unsigned long __user
* arg
)
1474 unsigned long value
;
1476 if (get_user(value
, arg
))
1479 info
->default_threshold
= value
& 0x0f;
1484 get_default_threshold(struct cyclades_port
*info
, unsigned long __user
* value
)
1486 return put_user(info
->default_threshold
, value
);
1489 static int set_timeout(struct cyclades_port
*info
, unsigned long __user
* arg
)
1491 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1493 unsigned long value
;
1495 if (get_user(value
, arg
))
1498 channel
= info
->line
;
1500 base_addr
[CyRTPRL
] = value
& 0xff;
1501 base_addr
[CyRTPRH
] = (value
>> 8) & 0xff;
1505 static int get_timeout(struct cyclades_port
*info
, unsigned long __user
* value
)
1507 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1511 channel
= info
->line
;
1513 tmp
= base_addr
[CyRTPRL
];
1514 return put_user(tmp
, value
);
1517 static int set_default_timeout(struct cyclades_port
*info
, unsigned long value
)
1519 info
->default_timeout
= value
& 0xff;
1524 get_default_timeout(struct cyclades_port
*info
, unsigned long __user
* value
)
1526 return put_user(info
->default_timeout
, value
);
1530 cy_ioctl(struct tty_struct
*tty
, struct file
*file
,
1531 unsigned int cmd
, unsigned long arg
)
1534 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1536 void __user
*argp
= (void __user
*)arg
;
1538 #ifdef SERIAL_DEBUG_OTHER
1539 printk("cy_ioctl %s, cmd = %x arg = %lx\n", tty
->name
, cmd
, arg
); /* */
1544 ret_val
= get_mon_info(info
, argp
);
1547 ret_val
= get_threshold(info
, argp
);
1550 ret_val
= set_threshold(info
, argp
);
1552 case CYGETDEFTHRESH
:
1553 ret_val
= get_default_threshold(info
, argp
);
1555 case CYSETDEFTHRESH
:
1556 ret_val
= set_default_threshold(info
, argp
);
1559 ret_val
= get_timeout(info
, argp
);
1562 ret_val
= set_timeout(info
, argp
);
1564 case CYGETDEFTIMEOUT
:
1565 ret_val
= get_default_timeout(info
, argp
);
1567 case CYSETDEFTIMEOUT
:
1568 ret_val
= set_default_timeout(info
, (unsigned long)arg
);
1570 case TCSBRK
: /* SVID version: non-zero arg --> no break */
1571 ret_val
= tty_check_change(tty
);
1574 tty_wait_until_sent(tty
, 0);
1576 send_break(info
, HZ
/ 4); /* 1/4 second */
1578 case TCSBRKP
: /* support for POSIX tcsendbreak() */
1579 ret_val
= tty_check_change(tty
);
1582 tty_wait_until_sent(tty
, 0);
1583 send_break(info
, arg
? arg
* (HZ
/ 10) : HZ
/ 4);
1586 /* The following commands are incompletely implemented!!! */
1589 put_user(C_CLOCAL(tty
) ? 1 : 0,
1590 (unsigned long __user
*)argp
);
1593 ret_val
= get_user(val
, (unsigned long __user
*)argp
);
1596 tty
->termios
->c_cflag
=
1597 ((tty
->termios
->c_cflag
& ~CLOCAL
) | (val
? CLOCAL
: 0));
1600 ret_val
= get_serial_info(info
, argp
);
1603 ret_val
= set_serial_info(info
, argp
);
1606 ret_val
= -ENOIOCTLCMD
;
1609 #ifdef SERIAL_DEBUG_OTHER
1610 printk("cy_ioctl done\n");
1616 static void cy_set_termios(struct tty_struct
*tty
, struct ktermios
*old_termios
)
1618 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1620 #ifdef SERIAL_DEBUG_OTHER
1621 printk("cy_set_termios %s\n", tty
->name
);
1624 if (tty
->termios
->c_cflag
== old_termios
->c_cflag
)
1628 if ((old_termios
->c_cflag
& CRTSCTS
) &&
1629 !(tty
->termios
->c_cflag
& CRTSCTS
)) {
1633 #ifdef tytso_patch_94Nov25_1726
1634 if (!(old_termios
->c_cflag
& CLOCAL
) &&
1635 (tty
->termios
->c_cflag
& CLOCAL
))
1636 wake_up_interruptible(&info
->open_wait
);
1638 } /* cy_set_termios */
1640 static void cy_close(struct tty_struct
*tty
, struct file
*filp
)
1642 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1645 #ifdef SERIAL_DEBUG_OTHER
1646 printk("cy_close %s\n", tty
->name
);
1649 if (!info
|| serial_paranoia_check(info
, tty
->name
, "cy_close")) {
1652 #ifdef SERIAL_DEBUG_OPEN
1653 printk("cy_close %s, count = %d\n", tty
->name
, info
->count
);
1656 if ((tty
->count
== 1) && (info
->count
!= 1)) {
1658 * Uh, oh. tty->count is 1, which means that the tty
1659 * structure will be freed. Info->count should always
1660 * be one in these conditions. If it's greater than
1661 * one, we've got real problems, since it means the
1662 * serial port won't be shutdown.
1664 printk("cy_close: bad serial port count; tty->count is 1, "
1665 "info->count is %d\n", info
->count
);
1668 #ifdef SERIAL_DEBUG_COUNT
1669 printk("cyc: %d: decrementing count to %d\n", __LINE__
,
1672 if (--info
->count
< 0) {
1673 printk("cy_close: bad serial port count for ttys%d: %d\n",
1674 info
->line
, info
->count
);
1675 #ifdef SERIAL_DEBUG_COUNT
1676 printk("cyc: %d: setting count to 0\n", __LINE__
);
1682 info
->flags
|= ASYNC_CLOSING
;
1683 if (info
->flags
& ASYNC_INITIALIZED
)
1684 tty_wait_until_sent(tty
, 3000); /* 30 seconds timeout */
1686 if (tty
->driver
->flush_buffer
)
1687 tty
->driver
->flush_buffer(tty
);
1688 tty_ldisc_flush(tty
);
1690 if (info
->blocked_open
) {
1691 if (info
->close_delay
) {
1692 msleep_interruptible(jiffies_to_msecs
1693 (info
->close_delay
));
1695 wake_up_interruptible(&info
->open_wait
);
1697 info
->flags
&= ~(ASYNC_NORMAL_ACTIVE
| ASYNC_CLOSING
);
1698 wake_up_interruptible(&info
->close_wait
);
1700 #ifdef SERIAL_DEBUG_OTHER
1701 printk("cy_close done\n");
1706 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
1708 void cy_hangup(struct tty_struct
*tty
)
1710 struct cyclades_port
*info
= (struct cyclades_port
*)tty
->driver_data
;
1712 #ifdef SERIAL_DEBUG_OTHER
1713 printk("cy_hangup %s\n", tty
->name
); /* */
1716 if (serial_paranoia_check(info
, tty
->name
, "cy_hangup"))
1723 #ifdef SERIAL_DEBUG_COUNT
1724 printk("cyc: %d: setting count to 0\n", __LINE__
);
1728 info
->flags
&= ~ASYNC_NORMAL_ACTIVE
;
1729 wake_up_interruptible(&info
->open_wait
);
1733 * ------------------------------------------------------------
1734 * cy_open() and friends
1735 * ------------------------------------------------------------
1739 block_til_ready(struct tty_struct
*tty
, struct file
*filp
,
1740 struct cyclades_port
*info
)
1742 DECLARE_WAITQUEUE(wait
, current
);
1743 unsigned long flags
;
1746 volatile u_char
*base_addr
= (u_char
*) BASE_ADDR
;
1749 * If the device is in the middle of being closed, then block
1750 * until it's done, and then try again.
1752 if (info
->flags
& ASYNC_CLOSING
) {
1753 interruptible_sleep_on(&info
->close_wait
);
1754 if (info
->flags
& ASYNC_HUP_NOTIFY
) {
1757 return -ERESTARTSYS
;
1762 * If non-blocking mode is set, then make the check up front
1765 if (filp
->f_flags
& O_NONBLOCK
) {
1766 info
->flags
|= ASYNC_NORMAL_ACTIVE
;
1771 * Block waiting for the carrier detect and the line to become
1772 * free (i.e., not in use by the callout). While we are in
1773 * this loop, info->count is dropped by one, so that
1774 * cy_close() knows when to free things. We restore it upon
1775 * exit, either normal or abnormal.
1778 add_wait_queue(&info
->open_wait
, &wait
);
1779 #ifdef SERIAL_DEBUG_OPEN
1780 printk("block_til_ready before block: %s, count = %d\n",
1781 tty
->name
, info
->count
);
1785 #ifdef SERIAL_DEBUG_COUNT
1786 printk("cyc: %d: decrementing count to %d\n", __LINE__
, info
->count
);
1788 info
->blocked_open
++;
1790 channel
= info
->line
;
1793 local_irq_save(flags
);
1794 base_addr
[CyCAR
] = (u_char
) channel
;
1795 base_addr
[CyMSVR1
] = CyRTS
;
1796 /* CP('S');CP('4'); */
1797 base_addr
[CyMSVR2
] = CyDTR
;
1798 #ifdef SERIAL_DEBUG_DTR
1799 printk("cyc: %d: raising DTR\n", __LINE__
);
1800 printk(" status: 0x%x, 0x%x\n", base_addr
[CyMSVR1
],
1801 base_addr
[CyMSVR2
]);
1803 local_irq_restore(flags
);
1804 set_current_state(TASK_INTERRUPTIBLE
);
1805 if (tty_hung_up_p(filp
)
1806 || !(info
->flags
& ASYNC_INITIALIZED
)) {
1807 if (info
->flags
& ASYNC_HUP_NOTIFY
) {
1810 retval
= -ERESTARTSYS
;
1814 local_irq_save(flags
);
1815 base_addr
[CyCAR
] = (u_char
) channel
;
1816 /* CP('L');CP1(1 && C_CLOCAL(tty)); CP1(1 && (base_addr[CyMSVR1] & CyDCD) ); */
1817 if (!(info
->flags
& ASYNC_CLOSING
)
1819 || (base_addr
[CyMSVR1
] & CyDCD
))) {
1820 local_irq_restore(flags
);
1823 local_irq_restore(flags
);
1824 if (signal_pending(current
)) {
1825 retval
= -ERESTARTSYS
;
1828 #ifdef SERIAL_DEBUG_OPEN
1829 printk("block_til_ready blocking: %s, count = %d\n",
1830 tty
->name
, info
->count
);
1835 __set_current_state(TASK_RUNNING
);
1836 remove_wait_queue(&info
->open_wait
, &wait
);
1837 if (!tty_hung_up_p(filp
)) {
1839 #ifdef SERIAL_DEBUG_COUNT
1840 printk("cyc: %d: incrementing count to %d\n", __LINE__
,
1844 info
->blocked_open
--;
1845 #ifdef SERIAL_DEBUG_OPEN
1846 printk("block_til_ready after blocking: %s, count = %d\n",
1847 tty
->name
, info
->count
);
1852 info
->flags
|= ASYNC_NORMAL_ACTIVE
;
1854 } /* block_til_ready */
1857 * This routine is called whenever a serial port is opened. It
1858 * performs the serial-specific initialization for the tty structure.
1860 int cy_open(struct tty_struct
*tty
, struct file
*filp
)
1862 struct cyclades_port
*info
;
1867 if ((line
< 0) || (NR_PORTS
<= line
)) {
1870 info
= &cy_port
[line
];
1871 if (info
->line
< 0) {
1874 #ifdef SERIAL_DEBUG_OTHER
1875 printk("cy_open %s\n", tty
->name
); /* */
1877 if (serial_paranoia_check(info
, tty
->name
, "cy_open")) {
1880 #ifdef SERIAL_DEBUG_OPEN
1881 printk("cy_open %s, count = %d\n", tty
->name
, info
->count
);
1885 #ifdef SERIAL_DEBUG_COUNT
1886 printk("cyc: %d: incrementing count to %d\n", __LINE__
, info
->count
);
1888 tty
->driver_data
= info
;
1892 * Start up serial port
1894 retval
= startup(info
);
1899 retval
= block_til_ready(tty
, filp
, info
);
1901 #ifdef SERIAL_DEBUG_OPEN
1902 printk("cy_open returning after block_til_ready with %d\n",
1907 #ifdef SERIAL_DEBUG_OPEN
1908 printk("cy_open done\n");
1915 * ---------------------------------------------------------------------
1916 * serial167_init() and friends
1918 * serial167_init() is called at boot-time to initialize the serial driver.
1919 * ---------------------------------------------------------------------
1923 * This routine prints out the appropriate serial driver version
1924 * number, and identifies which options were configured into this
1927 static void show_version(void)
1929 printk("MVME166/167 cd2401 driver\n");
1930 } /* show_version */
1932 /* initialize chips on card -- return number of valid
1933 chips (which is number of ports/4) */
1936 * This initialises the hardware to a reasonable state. It should
1937 * probe the chip first so as to copy 166-Bug setup as a default for
1938 * port 0. It initialises CMR to CyASYNC; that is never done again, so
1939 * as to limit the number of CyINIT_CHAN commands in normal running.
1941 * ... I wonder what I should do if this fails ...
1944 void mvme167_serial_console_setup(int cflag
)
1946 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
1949 u_char rcor
, rbpr
, badspeed
= 0;
1950 unsigned long flags
;
1952 local_irq_save(flags
);
1955 * First probe channel zero of the chip, to see what speed has
1959 base_addr
[CyCAR
] = 0;
1961 rcor
= base_addr
[CyRCOR
] << 5;
1962 rbpr
= base_addr
[CyRBPR
];
1964 for (spd
= 0; spd
< sizeof(baud_bpr
); spd
++)
1965 if (rbpr
== baud_bpr
[spd
] && rcor
== baud_co
[spd
])
1967 if (spd
>= sizeof(baud_bpr
)) {
1968 spd
= 14; /* 19200 */
1969 badspeed
= 1; /* Failed to identify speed */
1971 initial_console_speed
= spd
;
1973 /* OK, we have chosen a speed, now reset and reinitialise */
1975 my_udelay(20000L); /* Allow time for any active o/p to complete */
1976 if (base_addr
[CyCCR
] != 0x00) {
1977 local_irq_restore(flags
);
1978 /* printk(" chip is never idle (CCR != 0)\n"); */
1982 base_addr
[CyCCR
] = CyCHIP_RESET
; /* Reset the chip */
1985 if (base_addr
[CyGFRCR
] == 0x00) {
1986 local_irq_restore(flags
);
1987 /* printk(" chip is not responding (GFRCR stayed 0)\n"); */
1992 * System clock is 20Mhz, divided by 2048, so divide by 10 for a 1.0ms
1996 base_addr
[CyTPR
] = 10;
1998 base_addr
[CyPILR1
] = 0x01; /* Interrupt level for modem change */
1999 base_addr
[CyPILR2
] = 0x02; /* Interrupt level for tx ints */
2000 base_addr
[CyPILR3
] = 0x03; /* Interrupt level for rx ints */
2003 * Attempt to set up all channels to something reasonable, and
2004 * bang out a INIT_CHAN command. We should then be able to limit
2005 * the ammount of fiddling we have to do in normal running.
2008 for (ch
= 3; ch
>= 0; ch
--) {
2009 base_addr
[CyCAR
] = (u_char
) ch
;
2010 base_addr
[CyIER
] = 0;
2011 base_addr
[CyCMR
] = CyASYNC
;
2012 base_addr
[CyLICR
] = (u_char
) ch
<< 2;
2013 base_addr
[CyLIVR
] = 0x5c;
2014 base_addr
[CyTCOR
] = baud_co
[spd
];
2015 base_addr
[CyTBPR
] = baud_bpr
[spd
];
2016 base_addr
[CyRCOR
] = baud_co
[spd
] >> 5;
2017 base_addr
[CyRBPR
] = baud_bpr
[spd
];
2018 base_addr
[CySCHR1
] = 'Q' & 0x1f;
2019 base_addr
[CySCHR2
] = 'X' & 0x1f;
2020 base_addr
[CySCRL
] = 0;
2021 base_addr
[CySCRH
] = 0;
2022 base_addr
[CyCOR1
] = Cy_8_BITS
| CyPARITY_NONE
;
2023 base_addr
[CyCOR2
] = 0;
2024 base_addr
[CyCOR3
] = Cy_1_STOP
;
2025 base_addr
[CyCOR4
] = baud_cor4
[spd
];
2026 base_addr
[CyCOR5
] = 0;
2027 base_addr
[CyCOR6
] = 0;
2028 base_addr
[CyCOR7
] = 0;
2029 base_addr
[CyRTPRL
] = 2;
2030 base_addr
[CyRTPRH
] = 0;
2031 base_addr
[CyMSVR1
] = 0;
2032 base_addr
[CyMSVR2
] = 0;
2033 write_cy_cmd(base_addr
, CyINIT_CHAN
| CyDIS_RCVR
| CyDIS_XMTR
);
2037 * Now do specials for channel zero....
2040 base_addr
[CyMSVR1
] = CyRTS
;
2041 base_addr
[CyMSVR2
] = CyDTR
;
2042 base_addr
[CyIER
] = CyRxData
;
2043 write_cy_cmd(base_addr
, CyENB_RCVR
| CyENB_XMTR
);
2045 local_irq_restore(flags
);
2047 my_udelay(20000L); /* Let it all settle down */
2049 printk("CD2401 initialised, chip is rev 0x%02x\n", base_addr
[CyGFRCR
]);
2052 (" WARNING: Failed to identify line speed, rcor=%02x,rbpr=%02x\n",
2054 } /* serial_console_init */
2056 static const struct tty_operations cy_ops
= {
2060 .put_char
= cy_put_char
,
2061 .flush_chars
= cy_flush_chars
,
2062 .write_room
= cy_write_room
,
2063 .chars_in_buffer
= cy_chars_in_buffer
,
2064 .flush_buffer
= cy_flush_buffer
,
2066 .throttle
= cy_throttle
,
2067 .unthrottle
= cy_unthrottle
,
2068 .set_termios
= cy_set_termios
,
2071 .hangup
= cy_hangup
,
2072 .tiocmget
= cy_tiocmget
,
2073 .tiocmset
= cy_tiocmset
,
2076 /* The serial driver boot-time initialization code!
2077 Hardware I/O ports are mapped to character special devices on a
2078 first found, first allocated manner. That is, this code searches
2079 for Cyclom cards in the system. As each is found, it is probed
2080 to discover how many chips (and thus how many ports) are present.
2081 These ports are mapped to the tty ports 64 and upward in monotonic
2082 fashion. If an 8-port card is replaced with a 16-port card, the
2083 port mapping on a following card will shift.
2085 This approach is different from what is used in the other serial
2086 device driver because the Cyclom is more properly a multiplexer,
2087 not just an aggregation of serial ports on one card.
2089 If there are more cards with more ports than have been statically
2090 allocated above, a warning is printed and the extra ports are ignored.
2092 static int __init
serial167_init(void)
2094 struct cyclades_port
*info
;
2101 struct sigaction sa
;
2104 if (!(mvme16x_config
& MVME16x_CONFIG_GOT_CD2401
))
2107 cy_serial_driver
= alloc_tty_driver(NR_PORTS
);
2108 if (!cy_serial_driver
)
2117 /* Has "console=0,9600n8" been used in bootinfo to change speed? */
2118 if (serial_console_cflag
)
2119 DefSpeed
= serial_console_cflag
& 0017;
2121 DefSpeed
= initial_console_speed
;
2122 serial_console_info
= &cy_port
[0];
2123 serial_console_cflag
= DefSpeed
| CS8
;
2125 serial_console
= 64; /*callout_driver.minor_start */
2129 /* Initialize the tty_driver structure */
2131 cy_serial_driver
->owner
= THIS_MODULE
;
2132 cy_serial_driver
->name
= "ttyS";
2133 cy_serial_driver
->major
= TTY_MAJOR
;
2134 cy_serial_driver
->minor_start
= 64;
2135 cy_serial_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
2136 cy_serial_driver
->subtype
= SERIAL_TYPE_NORMAL
;
2137 cy_serial_driver
->init_termios
= tty_std_termios
;
2138 cy_serial_driver
->init_termios
.c_cflag
=
2139 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
2140 cy_serial_driver
->flags
= TTY_DRIVER_REAL_RAW
;
2141 tty_set_operations(cy_serial_driver
, &cy_ops
);
2143 ret
= tty_register_driver(cy_serial_driver
);
2145 printk(KERN_ERR
"Couldn't register MVME166/7 serial driver\n");
2146 put_tty_driver(cy_serial_driver
);
2152 for (index
= 0; index
< 1; index
++) {
2156 if (port_num
< NR_PORTS
) {
2157 while (good_ports
-- && port_num
< NR_PORTS
) {
2158 /*** initialize port ***/
2159 info
->magic
= CYCLADES_MAGIC
;
2160 info
->type
= PORT_CIRRUS
;
2162 info
->line
= port_num
;
2163 info
->flags
= STD_COM_FLAGS
;
2165 info
->xmit_fifo_size
= 12;
2166 info
->cor1
= CyPARITY_NONE
| Cy_8_BITS
;
2168 info
->cor3
= Cy_1_STOP
;
2169 info
->cor4
= 0x08; /* _very_ small receive threshold */
2173 info
->tbpr
= baud_bpr
[DefSpeed
]; /* Tx BPR */
2174 info
->tco
= baud_co
[DefSpeed
]; /* Tx CO */
2175 info
->rbpr
= baud_bpr
[DefSpeed
]; /* Rx BPR */
2176 info
->rco
= baud_co
[DefSpeed
] >> 5; /* Rx CO */
2177 info
->close_delay
= 0;
2180 #ifdef SERIAL_DEBUG_COUNT
2181 printk("cyc: %d: setting count to 0\n",
2184 info
->blocked_open
= 0;
2185 info
->default_threshold
= 0;
2186 info
->default_timeout
= 0;
2187 init_waitqueue_head(&info
->open_wait
);
2188 init_waitqueue_head(&info
->close_wait
);
2191 /*** !!!!!!!! this may expose new bugs !!!!!!!!! *********/
2192 info
->read_status_mask
=
2193 CyTIMEOUT
| CySPECHAR
| CyBREAK
| CyPARITY
|
2194 CyFRAME
| CyOVERRUN
;
2197 printk("ttyS%d ", info
->line
);
2200 if (!(port_num
& 7)) {
2207 while (port_num
< NR_PORTS
) {
2212 #ifdef CONFIG_REMOTE_DEBUG
2215 ret
= request_irq(MVME167_IRQ_SER_ERR
, cd2401_rxerr_interrupt
, 0,
2216 "cd2401_errors", cd2401_rxerr_interrupt
);
2218 printk(KERN_ERR
"Could't get cd2401_errors IRQ");
2219 goto cleanup_serial_driver
;
2222 ret
= request_irq(MVME167_IRQ_SER_MODEM
, cd2401_modem_interrupt
, 0,
2223 "cd2401_modem", cd2401_modem_interrupt
);
2225 printk(KERN_ERR
"Could't get cd2401_modem IRQ");
2226 goto cleanup_irq_cd2401_errors
;
2229 ret
= request_irq(MVME167_IRQ_SER_TX
, cd2401_tx_interrupt
, 0,
2230 "cd2401_txints", cd2401_tx_interrupt
);
2232 printk(KERN_ERR
"Could't get cd2401_txints IRQ");
2233 goto cleanup_irq_cd2401_modem
;
2236 ret
= request_irq(MVME167_IRQ_SER_RX
, cd2401_rx_interrupt
, 0,
2237 "cd2401_rxints", cd2401_rx_interrupt
);
2239 printk(KERN_ERR
"Could't get cd2401_rxints IRQ");
2240 goto cleanup_irq_cd2401_txints
;
2243 /* Now we have registered the interrupt handlers, allow the interrupts */
2245 pcc2chip
[PccSCCMICR
] = 0x15; /* Serial ints are level 5 */
2246 pcc2chip
[PccSCCTICR
] = 0x15;
2247 pcc2chip
[PccSCCRICR
] = 0x15;
2249 pcc2chip
[PccIMLR
] = 3; /* Allow PCC2 ints above 3!? */
2252 cleanup_irq_cd2401_txints
:
2253 free_irq(MVME167_IRQ_SER_TX
, cd2401_tx_interrupt
);
2254 cleanup_irq_cd2401_modem
:
2255 free_irq(MVME167_IRQ_SER_MODEM
, cd2401_modem_interrupt
);
2256 cleanup_irq_cd2401_errors
:
2257 free_irq(MVME167_IRQ_SER_ERR
, cd2401_rxerr_interrupt
);
2258 cleanup_serial_driver
:
2259 if (tty_unregister_driver(cy_serial_driver
))
2261 "Couldn't unregister MVME166/7 serial driver\n");
2262 put_tty_driver(cy_serial_driver
);
2264 } /* serial167_init */
2266 module_init(serial167_init
);
2268 #ifdef CYCLOM_SHOW_STATUS
2269 static void show_status(int line_num
)
2271 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
2273 struct cyclades_port
*info
;
2274 unsigned long flags
;
2276 info
= &cy_port
[line_num
];
2277 channel
= info
->line
;
2278 printk(" channel %d\n", channel
);
2279 /**/ printk(" cy_port\n");
2280 printk(" card line flags = %d %d %x\n",
2281 info
->card
, info
->line
, info
->flags
);
2283 (" *tty read_status_mask timeout xmit_fifo_size = %lx %x %x %x\n",
2284 (long)info
->tty
, info
->read_status_mask
, info
->timeout
,
2285 info
->xmit_fifo_size
);
2286 printk(" cor1,cor2,cor3,cor4,cor5,cor6,cor7 = %x %x %x %x %x %x %x\n",
2287 info
->cor1
, info
->cor2
, info
->cor3
, info
->cor4
, info
->cor5
,
2288 info
->cor6
, info
->cor7
);
2289 printk(" tbpr,tco,rbpr,rco = %d %d %d %d\n", info
->tbpr
, info
->tco
,
2290 info
->rbpr
, info
->rco
);
2291 printk(" close_delay event count = %d %d %d\n", info
->close_delay
,
2292 info
->event
, info
->count
);
2293 printk(" x_char blocked_open = %x %x\n", info
->x_char
,
2294 info
->blocked_open
);
2295 printk(" open_wait = %lx %lx %lx\n", (long)info
->open_wait
);
2297 local_irq_save(flags
);
2299 /* Global Registers */
2301 printk(" CyGFRCR %x\n", base_addr
[CyGFRCR
]);
2302 printk(" CyCAR %x\n", base_addr
[CyCAR
]);
2303 printk(" CyRISR %x\n", base_addr
[CyRISR
]);
2304 printk(" CyTISR %x\n", base_addr
[CyTISR
]);
2305 printk(" CyMISR %x\n", base_addr
[CyMISR
]);
2306 printk(" CyRIR %x\n", base_addr
[CyRIR
]);
2307 printk(" CyTIR %x\n", base_addr
[CyTIR
]);
2308 printk(" CyMIR %x\n", base_addr
[CyMIR
]);
2309 printk(" CyTPR %x\n", base_addr
[CyTPR
]);
2311 base_addr
[CyCAR
] = (u_char
) channel
;
2313 /* Virtual Registers */
2316 printk(" CyRIVR %x\n", base_addr
[CyRIVR
]);
2317 printk(" CyTIVR %x\n", base_addr
[CyTIVR
]);
2318 printk(" CyMIVR %x\n", base_addr
[CyMIVR
]);
2319 printk(" CyMISR %x\n", base_addr
[CyMISR
]);
2322 /* Channel Registers */
2324 printk(" CyCCR %x\n", base_addr
[CyCCR
]);
2325 printk(" CyIER %x\n", base_addr
[CyIER
]);
2326 printk(" CyCOR1 %x\n", base_addr
[CyCOR1
]);
2327 printk(" CyCOR2 %x\n", base_addr
[CyCOR2
]);
2328 printk(" CyCOR3 %x\n", base_addr
[CyCOR3
]);
2329 printk(" CyCOR4 %x\n", base_addr
[CyCOR4
]);
2330 printk(" CyCOR5 %x\n", base_addr
[CyCOR5
]);
2332 printk(" CyCCSR %x\n", base_addr
[CyCCSR
]);
2333 printk(" CyRDCR %x\n", base_addr
[CyRDCR
]);
2335 printk(" CySCHR1 %x\n", base_addr
[CySCHR1
]);
2336 printk(" CySCHR2 %x\n", base_addr
[CySCHR2
]);
2338 printk(" CySCHR3 %x\n", base_addr
[CySCHR3
]);
2339 printk(" CySCHR4 %x\n", base_addr
[CySCHR4
]);
2340 printk(" CySCRL %x\n", base_addr
[CySCRL
]);
2341 printk(" CySCRH %x\n", base_addr
[CySCRH
]);
2342 printk(" CyLNC %x\n", base_addr
[CyLNC
]);
2343 printk(" CyMCOR1 %x\n", base_addr
[CyMCOR1
]);
2344 printk(" CyMCOR2 %x\n", base_addr
[CyMCOR2
]);
2346 printk(" CyRTPRL %x\n", base_addr
[CyRTPRL
]);
2347 printk(" CyRTPRH %x\n", base_addr
[CyRTPRH
]);
2348 printk(" CyMSVR1 %x\n", base_addr
[CyMSVR1
]);
2349 printk(" CyMSVR2 %x\n", base_addr
[CyMSVR2
]);
2350 printk(" CyRBPR %x\n", base_addr
[CyRBPR
]);
2351 printk(" CyRCOR %x\n", base_addr
[CyRCOR
]);
2352 printk(" CyTBPR %x\n", base_addr
[CyTBPR
]);
2353 printk(" CyTCOR %x\n", base_addr
[CyTCOR
]);
2355 local_irq_restore(flags
);
2360 /* Dummy routine in mvme16x/config.c for now */
2362 /* Serial console setup. Called from linux/init/main.c */
2364 void console_setup(char *str
, int *ints
)
2367 int baud
, bits
, parity
;
2371 if (ints
[0] > 3 || ints
[1] > 3)
2374 /* Get baud, bits and parity */
2380 if ((s
= strchr(str
, ','))) {
2383 } while (*s
>= '0' && *s
<= '9');
2390 /* Now construct a cflag setting. */
2429 serial_console_info
= &cy_port
[ints
[1]];
2430 serial_console_cflag
= cflag
;
2431 serial_console
= ints
[1] + 64; /*callout_driver.minor_start */
2436 * The following is probably out of date for 2.1.x serial console stuff.
2438 * The console is registered early on from arch/m68k/kernel/setup.c, and
2439 * it therefore relies on the chip being setup correctly by 166-Bug. This
2440 * seems reasonable, as the serial port has been used to invoke the system
2441 * boot. It also means that this function must not rely on any data
2442 * initialisation performed by serial167_init() etc.
2444 * Of course, once the console has been registered, we had better ensure
2445 * that serial167_init() doesn't leave the chip non-functional.
2447 * The console must be locked when we get here.
2450 void serial167_console_write(struct console
*co
, const char *str
,
2453 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
2454 unsigned long flags
;
2455 volatile u_char sink
;
2461 local_irq_save(flags
);
2463 /* Ensure transmitter is enabled! */
2466 base_addr
[CyCAR
] = (u_char
) port
;
2467 while (base_addr
[CyCCR
])
2469 base_addr
[CyCCR
] = CyENB_XMTR
;
2471 ier
= base_addr
[CyIER
];
2472 base_addr
[CyIER
] = CyTxMpty
;
2475 if (pcc2chip
[PccSCCTICR
] & 0x20) {
2476 /* We have a Tx int. Acknowledge it */
2477 sink
= pcc2chip
[PccTPIACKR
];
2478 if ((base_addr
[CyLICR
] >> 2) == port
) {
2480 /* Last char of string is now output */
2481 base_addr
[CyTEOIR
] = CyNOTRANS
;
2485 base_addr
[CyTDR
] = '\n';
2489 } else if (*str
== '\n') {
2490 base_addr
[CyTDR
] = '\r';
2493 base_addr
[CyTDR
] = *str
++;
2496 base_addr
[CyTEOIR
] = 0;
2498 base_addr
[CyTEOIR
] = CyNOTRANS
;
2502 base_addr
[CyIER
] = ier
;
2504 local_irq_restore(flags
);
2507 static struct tty_driver
*serial167_console_device(struct console
*c
,
2511 return cy_serial_driver
;
2514 static struct console sercons
= {
2516 .write
= serial167_console_write
,
2517 .device
= serial167_console_device
,
2518 .flags
= CON_PRINTBUFFER
,
2522 static int __init
serial167_console_init(void)
2524 if (vme_brdtype
== VME_TYPE_MVME166
||
2525 vme_brdtype
== VME_TYPE_MVME167
||
2526 vme_brdtype
== VME_TYPE_MVME177
) {
2527 mvme167_serial_console_setup(0);
2528 register_console(&sercons
);
2533 console_initcall(serial167_console_init
);
2535 #ifdef CONFIG_REMOTE_DEBUG
2536 void putDebugChar(int c
)
2538 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
2539 unsigned long flags
;
2540 volatile u_char sink
;
2544 local_irq_save(flags
);
2546 /* Ensure transmitter is enabled! */
2549 base_addr
[CyCAR
] = (u_char
) port
;
2550 while (base_addr
[CyCCR
])
2552 base_addr
[CyCCR
] = CyENB_XMTR
;
2554 ier
= base_addr
[CyIER
];
2555 base_addr
[CyIER
] = CyTxMpty
;
2558 if (pcc2chip
[PccSCCTICR
] & 0x20) {
2559 /* We have a Tx int. Acknowledge it */
2560 sink
= pcc2chip
[PccTPIACKR
];
2561 if ((base_addr
[CyLICR
] >> 2) == port
) {
2562 base_addr
[CyTDR
] = c
;
2563 base_addr
[CyTEOIR
] = 0;
2566 base_addr
[CyTEOIR
] = CyNOTRANS
;
2570 base_addr
[CyIER
] = ier
;
2572 local_irq_restore(flags
);
2577 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
2578 unsigned long flags
;
2579 volatile u_char sink
;
2585 if (i
!= debugiq
.in
) {
2587 if (++i
== DEBUG_LEN
)
2592 /* OK, nothing in queue, wait in poll loop */
2594 local_irq_save(flags
);
2596 /* Ensure receiver is enabled! */
2599 base_addr
[CyCAR
] = (u_char
) port
;
2601 while (base_addr
[CyCCR
])
2603 base_addr
[CyCCR
] = CyENB_RCVR
;
2605 ier
= base_addr
[CyIER
];
2606 base_addr
[CyIER
] = CyRxData
;
2609 if (pcc2chip
[PccSCCRICR
] & 0x20) {
2610 /* We have a Rx int. Acknowledge it */
2611 sink
= pcc2chip
[PccRPIACKR
];
2612 if ((base_addr
[CyLICR
] >> 2) == port
) {
2613 int cnt
= base_addr
[CyRFOC
];
2615 c
= base_addr
[CyRDR
];
2618 ("!! debug char is null (cnt=%d) !!",
2623 base_addr
[CyREOIR
] = 0;
2625 if (i
== debugiq
.in
)
2626 panic("Debug input queue empty!");
2628 if (++i
== DEBUG_LEN
)
2633 base_addr
[CyREOIR
] = CyNOTRANS
;
2637 base_addr
[CyIER
] = ier
;
2639 local_irq_restore(flags
);
2644 void queueDebugChar(int c
)
2650 if (++i
== DEBUG_LEN
)
2652 if (i
!= debugiq
.out
)
2656 static void debug_setup()
2658 unsigned long flags
;
2659 volatile unsigned char *base_addr
= (u_char
*) BASE_ADDR
;
2664 local_irq_save(flags
);
2666 for (i
= 0; i
< 4; i
++) {
2667 base_addr
[CyCAR
] = i
;
2668 base_addr
[CyLICR
] = i
<< 2;
2671 debugiq
.in
= debugiq
.out
= 0;
2673 base_addr
[CyCAR
] = DEBUG_PORT
;
2678 base_addr
[CyIER
] = 0;
2680 base_addr
[CyCMR
] = CyASYNC
;
2681 base_addr
[CyLICR
] = DEBUG_PORT
<< 2;
2682 base_addr
[CyLIVR
] = 0x5c;
2684 /* tx and rx baud rate */
2686 base_addr
[CyTCOR
] = baud_co
[i
];
2687 base_addr
[CyTBPR
] = baud_bpr
[i
];
2688 base_addr
[CyRCOR
] = baud_co
[i
] >> 5;
2689 base_addr
[CyRBPR
] = baud_bpr
[i
];
2691 /* set line characteristics according configuration */
2693 base_addr
[CySCHR1
] = 0;
2694 base_addr
[CySCHR2
] = 0;
2695 base_addr
[CySCRL
] = 0;
2696 base_addr
[CySCRH
] = 0;
2697 base_addr
[CyCOR1
] = Cy_8_BITS
| CyPARITY_NONE
;
2698 base_addr
[CyCOR2
] = 0;
2699 base_addr
[CyCOR3
] = Cy_1_STOP
;
2700 base_addr
[CyCOR4
] = baud_cor4
[i
];
2701 base_addr
[CyCOR5
] = 0;
2702 base_addr
[CyCOR6
] = 0;
2703 base_addr
[CyCOR7
] = 0;
2705 write_cy_cmd(base_addr
, CyINIT_CHAN
);
2706 write_cy_cmd(base_addr
, CyENB_RCVR
);
2708 base_addr
[CyCAR
] = DEBUG_PORT
; /* !!! Is this needed? */
2710 base_addr
[CyRTPRL
] = 2;
2711 base_addr
[CyRTPRH
] = 0;
2713 base_addr
[CyMSVR1
] = CyRTS
;
2714 base_addr
[CyMSVR2
] = CyDTR
;
2716 base_addr
[CyIER
] = CyRxData
;
2718 local_irq_restore(flags
);
2724 MODULE_LICENSE("GPL");