2 * dz.c: Serial port driver for DECStations equiped
5 * Copyright (C) 1998 Olivier A. D. Lebaillif
7 * Email: olivier.lebaillif@ifrsys.com
10 * Changed IRQ to use Harald's dec internals interrupts.h
11 * removed base_addr code - moving address assignment to setup.c
12 * Changed name of dz_init to rs_init to be consistent with tc code
13 * [13-NOV-98] triemer fixed code to receive characters
14 * after patches by harald to irq code.
15 * [09-JAN-99] triemer minor fix for schedule - due to removal of timeout
16 * field from "current" - somewhere between 2.1.121 and 2.1.131
17 Qua Jun 27 15:02:26 BRT 2001
18 * [27-JUN-2001] Arnaldo Carvalho de Melo <acme@conectiva.com.br> - cleanups
20 * Parts (C) 1999 David Airlie, airlied@linux.ie
21 * [07-SEP-99] Bugfixes
23 * [06-Jan-2002] Russell King <rmk@arm.linux.org.uk>
24 * Converted to new serial core
29 #include <linux/config.h>
30 #include <linux/module.h>
31 #include <linux/tty.h>
32 #include <linux/interrupt.h>
33 #include <linux/init.h>
34 #include <linux/console.h>
35 #include <linux/serial.h>
36 #include <linux/serial_core.h>
38 #include <asm/bootinfo.h>
39 #include <asm/dec/interrupts.h>
40 #include <asm/dec/kn01.h>
41 #include <asm/dec/kn02.h>
42 #include <asm/dec/machtype.h>
43 #include <asm/dec/prom.h>
45 #include <asm/system.h>
46 #include <asm/uaccess.h>
48 #define CONSOLE_LINE (3) /* for definition of struct console */
52 #define DZ_INTR_DEBUG 1
54 static char *dz_name = "DECstation DZ serial driver version ";
55 static char *dz_version = "1.02";
58 struct uart_port port;
62 static struct dz_port dz_ports[DZ_NB_PORT];
66 * debugging code to send out chars via prom
68 static void debug_console(const char *s, int count)
72 for (i = 0; i < count; i++) {
74 prom_printf("%c", 13);
75 prom_printf("%c", *s++);
81 * ------------------------------------------------------------
82 * dz_in () and dz_out ()
84 * These routines are used to access the registers of the DZ
85 * chip, hiding relocation differences between implementation.
86 * ------------------------------------------------------------
89 static inline unsigned short dz_in(struct dz_port *dport, unsigned offset)
91 volatile unsigned short *addr =
92 (volatile unsigned short *) (dport->port.membase + offset);
96 static inline void dz_out(struct dz_port *dport, unsigned offset,
99 volatile unsigned short *addr =
100 (volatile unsigned short *) (dport->port.membase + offset);
105 * ------------------------------------------------------------
106 * rs_stop () and rs_start ()
108 * These routines are called before setting or resetting
109 * tty->stopped. They enable or disable transmitter interrupts,
111 * ------------------------------------------------------------
114 static void dz_stop_tx(struct uart_port *uport, unsigned int tty_stop)
116 struct dz_port *dport = (struct dz_port *)uport;
117 unsigned short tmp, mask = 1 << dport->port.line;
120 spin_lock_irqsave(&dport->port.lock, flags);
121 tmp = dz_in(dport, DZ_TCR); /* read the TX flag */
122 tmp &= ~mask; /* clear the TX flag */
123 dz_out(dport, DZ_TCR, tmp);
124 spin_unlock_irqrestore(&dport->port.lock, flags);
127 static void dz_start_tx(struct uart_port *uport, unsigned int tty_start)
129 struct dz_port *dport = (struct dz_port *)uport;
130 unsigned short tmp, mask = 1 << dport->port.line;
133 spin_lock_irqsave(&dport->port.lock, flags);
134 tmp = dz_in(dport, DZ_TCR); /* read the TX flag */
135 tmp |= mask; /* set the TX flag */
136 dz_out(dport, DZ_TCR, tmp);
137 spin_unlock_irqrestore(&dport->port.lock, flags);
140 static void dz_stop_rx(struct uart_port *uport)
142 struct dz_port *dport = (struct dz_port *)uport;
145 spin_lock_irqsave(&dport->port.lock, flags);
146 dport->cflag &= ~DZ_CREAD;
147 dz_out(dport, DZ_LPR, dport->cflag);
148 spin_unlock_irqrestore(&dport->port.lock, flags);
151 static void dz_enable_ms(struct uart_port *port)
157 * ------------------------------------------------------------
158 * Here starts the interrupt handling routines. All of the
159 * following subroutines are declared as inline and are folded
160 * into dz_interrupt. They were separated out for readability's
163 * Note: rs_interrupt() is a "fast" interrupt, which means that it
164 * runs with interrupts turned off. People who may want to modify
165 * rs_interrupt() should try to keep the interrupt handler as fast as
166 * possible. After you are done making modifications, it is not a bad
169 * make drivers/serial/dz.s
171 * and look at the resulting assemble code in dz.s.
173 * ------------------------------------------------------------
177 * ------------------------------------------------------------
180 * This routine deals with inputs from any lines.
181 * ------------------------------------------------------------
183 static inline void dz_receive_chars(struct dz_port *dport)
185 struct tty_struct *tty = NULL;
186 struct uart_icount *icount;
188 unsigned short status, tmp;
191 /* this code is going to be a problem...
192 the call to tty_flip_buffer is going to need
196 status = dz_in(dport, DZ_RBUF);
198 /* punt so we don't get duplicate characters */
199 if (!(status & DZ_DVAL))
203 ch = UCHAR(status); /* grab the char */
206 if (info->is_console) {
208 return; /* it's a break ... */
212 tty = dport->port.info->tty;/* now tty points to the proper dev */
213 icount = &dport->port.icount;
217 if (tty->flip.count >= TTY_FLIPBUF_SIZE)
220 *tty->flip.char_buf_ptr = ch;
221 *tty->flip.flag_buf_ptr = 0;
224 /* keep track of the statistics */
225 if (status & (DZ_OERR | DZ_FERR | DZ_PERR)) {
226 if (status & DZ_PERR) /* parity error */
228 else if (status & DZ_FERR) /* frame error */
230 if (status & DZ_OERR) /* overrun error */
233 /* check to see if we should ignore the character
234 and mask off conditions that should be ignored
237 if (status & dport->port.ignore_status_mask) {
242 /* mask off the error conditions we want to ignore */
243 tmp = status & dport->port.read_status_mask;
246 *tty->flip.flag_buf_ptr = TTY_PARITY;
248 debug_console("PERR\n", 5);
250 } else if (tmp & DZ_FERR) {
251 *tty->flip.flag_buf_ptr = TTY_FRAME;
253 debug_console("FERR\n", 5);
258 debug_console("OERR\n", 5);
260 if (tty->flip.count < TTY_FLIPBUF_SIZE) {
262 tty->flip.flag_buf_ptr++;
263 tty->flip.char_buf_ptr++;
264 *tty->flip.flag_buf_ptr = TTY_OVERRUN;
268 tty->flip.flag_buf_ptr++;
269 tty->flip.char_buf_ptr++;
272 } while (status & DZ_DVAL);
275 tty_flip_buffer_push(tty);
279 * ------------------------------------------------------------
282 * This routine deals with outputs to any lines.
283 * ------------------------------------------------------------
285 static inline void dz_transmit_chars(struct dz_port *dport)
287 struct circ_buf *xmit = &dport->port.info->xmit;
290 if (dport->port.x_char) { /* XON/XOFF chars */
291 dz_out(dport, DZ_TDR, dport->port.x_char);
292 dport->port.icount.tx++;
293 dport->port.x_char = 0;
296 /* if nothing to do or stopped or hardware stopped */
297 if (uart_circ_empty(xmit) || uart_tx_stopped(&dport->port)) {
298 dz_stop_tx(&dport->port, 0);
303 * if something to do ... (rember the dz has no output fifo so we go
304 * one char at a time :-<
306 tmp = xmit->buf[xmit->tail];
307 xmit->tail = (xmit->tail + 1) & (DZ_XMIT_SIZE - 1);
308 dz_out(dport, DZ_TDR, tmp);
309 dport->port.icount.tx++;
311 if (uart_circ_chars_pending(xmit) < DZ_WAKEUP_CHARS)
312 uart_write_wakeup(&dport->port);
315 if (uart_circ_empty(xmit))
316 dz_stop_tx(&dport->port, 0);
320 * ------------------------------------------------------------
321 * check_modem_status ()
323 * Only valid for the MODEM line duh !
324 * ------------------------------------------------------------
326 static inline void check_modem_status(struct dz_port *dport)
328 unsigned short status;
330 /* if not ne modem line just return */
331 if (dport->port.line != DZ_MODEM)
334 status = dz_in(dport, DZ_MSR);
336 /* it's easy, since DSR2 is the only bit in the register */
338 dport->port.icount.dsr++;
342 * ------------------------------------------------------------
345 * this is the main interrupt routine for the DZ chip.
346 * It deals with the multiple ports.
347 * ------------------------------------------------------------
349 static irqreturn_t dz_interrupt(int irq, void *dev, struct pt_regs *regs)
351 struct dz_port *dport;
352 unsigned short status;
354 /* get the reason why we just got an irq */
355 status = dz_in((struct dz_port *)dev, DZ_CSR);
356 dport = &dz_ports[LINE(status)];
358 if (status & DZ_RDONE)
359 dz_receive_chars(dport);
361 if (status & DZ_TRDY)
362 dz_transmit_chars(dport);
364 /* FIXME: what about check modem status??? --rmk */
370 * -------------------------------------------------------------------
371 * Here ends the DZ interrupt routines.
372 * -------------------------------------------------------------------
375 static unsigned int dz_get_mctrl(struct uart_port *uport)
377 struct dz_port *dport = (struct dz_port *)uport;
378 unsigned int mctrl = TIOCM_CAR | TIOCM_DSR | TIOCM_CTS;
380 if (dport->port.line == DZ_MODEM) {
382 * CHECKME: This is a guess from the other code... --rmk
384 if (dz_in(dport, DZ_MSR) & DZ_MODEM_DSR)
391 static void dz_set_mctrl(struct uart_port *uport, unsigned int mctrl)
393 struct dz_port *dport = (struct dz_port *)uport;
396 if (dport->port.line == DZ_MODEM) {
397 tmp = dz_in(dport, DZ_TCR);
398 if (mctrl & TIOCM_DTR)
399 tmp &= ~DZ_MODEM_DTR;
402 dz_out(dport, DZ_TCR, tmp);
407 * -------------------------------------------------------------------
410 * various initialization tasks
411 * -------------------------------------------------------------------
413 static int dz_startup(struct uart_port *uport)
415 struct dz_port *dport = (struct dz_port *)uport;
419 /* The dz lines for the mouse/keyboard must be
420 * opened using their respective drivers.
422 if ((dport->port.line == DZ_KEYBOARD) ||
423 (dport->port.line == DZ_MOUSE))
426 spin_lock_irqsave(&dport->port.lock, flags);
428 /* enable the interrupt and the scanning */
429 tmp = dz_in(dport, DZ_CSR);
430 tmp |= DZ_RIE | DZ_TIE | DZ_MSE;
431 dz_out(dport, DZ_CSR, tmp);
433 spin_unlock_irqrestore(&dport->port.lock, flags);
439 * -------------------------------------------------------------------
442 * This routine will shutdown a serial port; interrupts are disabled, and
443 * DTR is dropped if the hangup on close termio flag is on.
444 * -------------------------------------------------------------------
446 static void dz_shutdown(struct uart_port *uport)
448 dz_stop_tx(uport, 0);
452 * get_lsr_info - get line status register info
454 * Purpose: Let user call ioctl() to get info when the UART physically
455 * is emptied. On bus types like RS485, the transmitter must
456 * release the bus after transmitting. This must be done when
457 * the transmit shift register is empty, not be done when the
458 * transmit holding register is empty. This functionality
459 * allows an RS485 driver to be written in user space.
461 static unsigned int dz_tx_empty(struct uart_port *uport)
463 struct dz_port *dport = (struct dz_port *)uport;
464 unsigned short status = dz_in(dport, DZ_LPR);
466 /* FIXME: this appears to be obviously broken --rmk. */
467 return status ? TIOCSER_TEMT : 0;
470 static void dz_break_ctl(struct uart_port *uport, int break_state)
472 struct dz_port *dport = (struct dz_port *)uport;
474 unsigned short tmp, mask = 1 << uport->line;
476 spin_lock_irqsave(&uport->lock, flags);
477 tmp = dz_in(dport, DZ_TCR);
482 dz_out(dport, DZ_TCR, tmp);
483 spin_unlock_irqrestore(&uport->lock, flags);
486 static void dz_set_termios(struct uart_port *uport, struct termios *termios,
487 struct termios *old_termios)
489 struct dz_port *dport = (struct dz_port *)uport;
491 unsigned int cflag, baud;
493 cflag = dport->port.line;
495 switch (termios->c_cflag & CSIZE) {
510 if (termios->c_cflag & CSTOPB)
512 if (termios->c_cflag & PARENB)
514 if (termios->c_cflag & PARODD)
517 baud = uart_get_baud_rate(uport, termios, old_termios, 50, 9600);
566 if (termios->c_cflag & CREAD)
569 spin_lock_irqsave(&dport->port.lock, flags);
571 dz_out(dport, DZ_LPR, cflag);
572 dport->cflag = cflag;
574 /* setup accept flag */
575 dport->port.read_status_mask = DZ_OERR;
576 if (termios->c_iflag & INPCK)
577 dport->port.read_status_mask |= DZ_FERR | DZ_PERR;
579 /* characters to ignore */
580 uport->ignore_status_mask = 0;
581 if (termios->c_iflag & IGNPAR)
582 dport->port.ignore_status_mask |= DZ_FERR | DZ_PERR;
584 spin_unlock_irqrestore(&dport->port.lock, flags);
587 static const char *dz_type(struct uart_port *port)
592 static void dz_release_port(struct uart_port *port)
597 static int dz_request_port(struct uart_port *port)
602 static void dz_config_port(struct uart_port *port, int flags)
604 if (flags & UART_CONFIG_TYPE)
605 port->type = PORT_DZ;
609 * verify the new serial_struct (for TIOCSSERIAL).
611 static int dz_verify_port(struct uart_port *port, struct serial_struct *ser)
614 if (ser->type != PORT_UNKNOWN && ser->type != PORT_DZ)
616 if (ser->irq != port->irq)
621 static struct uart_ops dz_ops = {
622 .tx_empty = dz_tx_empty,
623 .get_mctrl = dz_get_mctrl,
624 .set_mctrl = dz_set_mctrl,
625 .stop_tx = dz_stop_tx,
626 .start_tx = dz_start_tx,
627 .stop_rx = dz_stop_rx,
628 .enable_ms = dz_enable_ms,
629 .break_ctl = dz_break_ctl,
630 .startup = dz_startup,
631 .shutdown = dz_shutdown,
632 .set_termios = dz_set_termios,
634 .release_port = dz_release_port,
635 .request_port = dz_request_port,
636 .config_port = dz_config_port,
637 .verify_port = dz_verify_port,
640 static void __init dz_init_ports(void)
642 static int first = 1;
643 struct dz_port *dport;
651 if (mips_machtype == MACH_DS23100 ||
652 mips_machtype == MACH_DS5100)
653 base = (unsigned long) KN01_DZ11_BASE;
655 base = (unsigned long) KN02_DZ11_BASE;
657 for (i = 0, dport = dz_ports; i < DZ_NB_PORT; i++, dport++) {
658 spin_lock_init(&dport->port.lock);
659 dport->port.membase = (char *) base;
660 dport->port.iotype = SERIAL_IO_PORT;
661 dport->port.irq = dec_interrupt[DEC_IRQ_DZ11];
662 dport->port.line = i;
663 dport->port.fifosize = 1;
664 dport->port.ops = &dz_ops;
665 dport->port.flags = UPF_BOOT_AUTOCONF;
669 static void dz_reset(struct dz_port *dport)
671 dz_out(dport, DZ_CSR, DZ_CLR);
673 while (dz_in(dport, DZ_CSR) & DZ_CLR);
674 /* FIXME: cpu_relax? */
678 /* enable scanning */
679 dz_out(dport, DZ_CSR, DZ_MSE);
682 #ifdef CONFIG_SERIAL_DZ_CONSOLE
683 static void dz_console_put_char(struct dz_port *dport, unsigned char ch)
687 unsigned short tmp = ch;
688 /* this code sends stuff out to serial device - spinning its
689 wheels and waiting. */
691 spin_lock_irqsave(&dport->port.lock, flags);
693 /* spin our wheels */
694 while (((dz_in(dport, DZ_CSR) & DZ_TRDY) != DZ_TRDY) && loops--)
695 /* FIXME: cpu_relax, udelay? --rmk */
698 /* Actually transmit the character. */
699 dz_out(dport, DZ_TDR, tmp);
701 spin_unlock_irqrestore(&dport->port.lock, flags);
704 * -------------------------------------------------------------------
705 * dz_console_print ()
707 * dz_console_print is registered for printk.
708 * The console must be locked when we get here.
709 * -------------------------------------------------------------------
711 static void dz_console_print(struct console *cons,
715 struct dz_port *dport = &dz_ports[CONSOLE_LINE];
717 prom_printf((char *) str);
721 dz_console_put_char(dport, '\r');
722 dz_console_put_char(dport, *str++);
726 static int __init dz_console_setup(struct console *co, char *options)
728 struct dz_port *dport = &dz_ports[CONSOLE_LINE];
734 unsigned short mask, tmp;
737 uart_parse_options(options, &baud, &parity, &bits, &flow);
741 ret = uart_set_options(&dport->port, co, baud, parity, bits, flow);
743 mask = 1 << dport->port.line;
744 tmp = dz_in(dport, DZ_TCR); /* read the TX flag */
746 tmp |= mask; /* set the TX flag */
747 dz_out(dport, DZ_TCR, tmp);
754 static struct console dz_sercons =
757 .write = dz_console_print,
758 .device = uart_console_device,
759 .setup = dz_console_setup,
760 .flags = CON_CONSDEV | CON_PRINTBUFFER,
761 .index = CONSOLE_LINE,
764 void __init dz_serial_console_init(void)
768 register_console(&dz_sercons);
771 #define SERIAL_DZ_CONSOLE &dz_sercons
773 #define SERIAL_DZ_CONSOLE NULL
774 #endif /* CONFIG_SERIAL_DZ_CONSOLE */
776 static struct uart_driver dz_reg = {
777 .owner = THIS_MODULE,
778 .driver_name = "serial",
780 .dev_name = "tts/%d",
782 .dev_name = "ttyS%d",
787 .cons = SERIAL_DZ_CONSOLE,
790 int __init dz_init(void)
795 printk("%s%s\n", dz_name, dz_version);
802 #ifndef CONFIG_SERIAL_DZ_CONSOLE
804 dz_reset(&dz_ports[0]);
807 /* order matters here... the trick is that flags
808 is updated... in request_irq - to immediatedly obliterate
810 restore_flags(flags);
812 if (request_irq(dz_ports[0].port.irq, dz_interrupt,
813 SA_INTERRUPT, "DZ", &dz_ports[0]))
814 panic("Unable to register DZ interrupt");
816 ret = uart_register_driver(&dz_reg);
820 for (i = 0; i < DZ_NB_PORT; i++)
821 uart_add_one_port(&dz_reg, &dz_ports[i].port);
826 MODULE_DESCRIPTION("DECstation DZ serial driver");
827 MODULE_LICENSE("GPL");