]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/serial/dz.c
2 * dz.c: Serial port driver for DECstations equipped
5 * Copyright (C) 1998 Olivier A. D. Lebaillif
7 * Email: olivier.lebaillif@ifrsys.com
9 * Copyright (C) 2004, 2006, 2007 Maciej W. Rozycki
12 * Changed IRQ to use Harald's dec internals interrupts.h
13 * removed base_addr code - moving address assignment to setup.c
14 * Changed name of dz_init to rs_init to be consistent with tc code
15 * [13-NOV-98] triemer fixed code to receive characters
16 * after patches by harald to irq code.
17 * [09-JAN-99] triemer minor fix for schedule - due to removal of timeout
18 * field from "current" - somewhere between 2.1.121 and 2.1.131
19 Qua Jun 27 15:02:26 BRT 2001
20 * [27-JUN-2001] Arnaldo Carvalho de Melo <acme@conectiva.com.br> - cleanups
22 * Parts (C) 1999 David Airlie, airlied@linux.ie
23 * [07-SEP-99] Bugfixes
25 * [06-Jan-2002] Russell King <rmk@arm.linux.org.uk>
26 * Converted to new serial core
31 #if defined(CONFIG_SERIAL_DZ_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
35 #include <linux/bitops.h>
36 #include <linux/compiler.h>
37 #include <linux/console.h>
38 #include <linux/delay.h>
39 #include <linux/errno.h>
40 #include <linux/init.h>
41 #include <linux/interrupt.h>
42 #include <linux/ioport.h>
43 #include <linux/kernel.h>
44 #include <linux/major.h>
45 #include <linux/module.h>
46 #include <linux/serial.h>
47 #include <linux/serial_core.h>
48 #include <linux/sysrq.h>
49 #include <linux/tty.h>
51 #include <asm/atomic.h>
52 #include <asm/bootinfo.h>
54 #include <asm/system.h>
56 #include <asm/dec/interrupts.h>
57 #include <asm/dec/kn01.h>
58 #include <asm/dec/kn02.h>
59 #include <asm/dec/machtype.h>
60 #include <asm/dec/prom.h>
61 #include <asm/dec/system.h>
66 MODULE_DESCRIPTION("DECstation DZ serial driver");
67 MODULE_LICENSE("GPL");
70 static char dz_name
[] __initdata
= "DECstation DZ serial driver version ";
71 static char dz_version
[] __initdata
= "1.04";
75 struct uart_port port
;
80 struct dz_port dport
[DZ_NB_PORT
];
86 static struct dz_mux dz_mux
;
88 static inline struct dz_port
*to_dport(struct uart_port
*uport
)
90 return container_of(uport
, struct dz_port
, port
);
94 * ------------------------------------------------------------
95 * dz_in () and dz_out ()
97 * These routines are used to access the registers of the DZ
98 * chip, hiding relocation differences between implementation.
99 * ------------------------------------------------------------
102 static u16
dz_in(struct dz_port
*dport
, unsigned offset
)
104 void __iomem
*addr
= dport
->port
.membase
+ offset
;
109 static void dz_out(struct dz_port
*dport
, unsigned offset
, u16 value
)
111 void __iomem
*addr
= dport
->port
.membase
+ offset
;
117 * ------------------------------------------------------------
118 * rs_stop () and rs_start ()
120 * These routines are called before setting or resetting
121 * tty->stopped. They enable or disable transmitter interrupts,
123 * ------------------------------------------------------------
126 static void dz_stop_tx(struct uart_port
*uport
)
128 struct dz_port
*dport
= to_dport(uport
);
129 u16 tmp
, mask
= 1 << dport
->port
.line
;
131 tmp
= dz_in(dport
, DZ_TCR
); /* read the TX flag */
132 tmp
&= ~mask
; /* clear the TX flag */
133 dz_out(dport
, DZ_TCR
, tmp
);
136 static void dz_start_tx(struct uart_port
*uport
)
138 struct dz_port
*dport
= to_dport(uport
);
139 u16 tmp
, mask
= 1 << dport
->port
.line
;
141 tmp
= dz_in(dport
, DZ_TCR
); /* read the TX flag */
142 tmp
|= mask
; /* set the TX flag */
143 dz_out(dport
, DZ_TCR
, tmp
);
146 static void dz_stop_rx(struct uart_port
*uport
)
148 struct dz_port
*dport
= to_dport(uport
);
150 dport
->cflag
&= ~DZ_RXENAB
;
151 dz_out(dport
, DZ_LPR
, dport
->cflag
);
154 static void dz_enable_ms(struct uart_port
*uport
)
160 * ------------------------------------------------------------
162 * Here start the interrupt handling routines. All of the following
163 * subroutines are declared as inline and are folded into
164 * dz_interrupt. They were separated out for readability's sake.
166 * Note: dz_interrupt() is a "fast" interrupt, which means that it
167 * runs with interrupts turned off. People who may want to modify
168 * dz_interrupt() should try to keep the interrupt handler as fast as
169 * possible. After you are done making modifications, it is not a bad
172 * make drivers/serial/dz.s
174 * and look at the resulting assemble code in dz.s.
176 * ------------------------------------------------------------
180 * ------------------------------------------------------------
183 * This routine deals with inputs from any lines.
184 * ------------------------------------------------------------
186 static inline void dz_receive_chars(struct dz_mux
*mux
)
188 struct uart_port
*uport
;
189 struct dz_port
*dport
= &mux
->dport
[0];
190 struct tty_struct
*tty
= NULL
;
191 struct uart_icount
*icount
;
192 int lines_rx
[DZ_NB_PORT
] = { [0 ... DZ_NB_PORT
- 1] = 0 };
193 unsigned char ch
, flag
;
197 while ((status
= dz_in(dport
, DZ_RBUF
)) & DZ_DVAL
) {
198 dport
= &mux
->dport
[LINE(status
)];
199 uport
= &dport
->port
;
200 tty
= uport
->state
->port
.tty
; /* point to the proper dev */
202 ch
= UCHAR(status
); /* grab the char */
205 icount
= &uport
->icount
;
208 if (unlikely(status
& (DZ_OERR
| DZ_FERR
| DZ_PERR
))) {
211 * There is no separate BREAK status bit, so treat
212 * null characters with framing errors as BREAKs;
213 * normally, otherwise. For this move the Framing
214 * Error bit to a simulated BREAK bit.
217 status
|= (status
& DZ_FERR
) >>
218 (ffs(DZ_FERR
) - ffs(DZ_BREAK
));
222 /* Handle SysRq/SAK & keep track of the statistics. */
223 if (status
& DZ_BREAK
) {
225 if (uart_handle_break(uport
))
227 } else if (status
& DZ_FERR
)
229 else if (status
& DZ_PERR
)
231 if (status
& DZ_OERR
)
234 status
&= uport
->read_status_mask
;
235 if (status
& DZ_BREAK
)
237 else if (status
& DZ_FERR
)
239 else if (status
& DZ_PERR
)
244 if (uart_handle_sysrq_char(uport
, ch
))
247 uart_insert_char(uport
, status
, DZ_OERR
, ch
, flag
);
248 lines_rx
[LINE(status
)] = 1;
250 for (i
= 0; i
< DZ_NB_PORT
; i
++)
252 tty_flip_buffer_push(mux
->dport
[i
].port
.state
->port
.tty
);
256 * ------------------------------------------------------------
259 * This routine deals with outputs to any lines.
260 * ------------------------------------------------------------
262 static inline void dz_transmit_chars(struct dz_mux
*mux
)
264 struct dz_port
*dport
= &mux
->dport
[0];
265 struct circ_buf
*xmit
;
269 status
= dz_in(dport
, DZ_CSR
);
270 dport
= &mux
->dport
[LINE(status
)];
271 xmit
= &dport
->port
.state
->xmit
;
273 if (dport
->port
.x_char
) { /* XON/XOFF chars */
274 dz_out(dport
, DZ_TDR
, dport
->port
.x_char
);
275 dport
->port
.icount
.tx
++;
276 dport
->port
.x_char
= 0;
279 /* If nothing to do or stopped or hardware stopped. */
280 if (uart_circ_empty(xmit
) || uart_tx_stopped(&dport
->port
)) {
281 spin_lock(&dport
->port
.lock
);
282 dz_stop_tx(&dport
->port
);
283 spin_unlock(&dport
->port
.lock
);
288 * If something to do... (remember the dz has no output fifo,
289 * so we go one char at a time) :-<
291 tmp
= xmit
->buf
[xmit
->tail
];
292 xmit
->tail
= (xmit
->tail
+ 1) & (DZ_XMIT_SIZE
- 1);
293 dz_out(dport
, DZ_TDR
, tmp
);
294 dport
->port
.icount
.tx
++;
296 if (uart_circ_chars_pending(xmit
) < DZ_WAKEUP_CHARS
)
297 uart_write_wakeup(&dport
->port
);
299 /* Are we are done. */
300 if (uart_circ_empty(xmit
)) {
301 spin_lock(&dport
->port
.lock
);
302 dz_stop_tx(&dport
->port
);
303 spin_unlock(&dport
->port
.lock
);
308 * ------------------------------------------------------------
309 * check_modem_status()
311 * DS 3100 & 5100: Only valid for the MODEM line, duh!
312 * DS 5000/200: Valid for the MODEM and PRINTER line.
313 * ------------------------------------------------------------
315 static inline void check_modem_status(struct dz_port
*dport
)
319 * 1. No status change interrupt; use a timer.
320 * 2. Handle the 3100/5000 as appropriate. --macro
324 /* If not the modem line just return. */
325 if (dport
->port
.line
!= DZ_MODEM
)
328 status
= dz_in(dport
, DZ_MSR
);
330 /* it's easy, since DSR2 is the only bit in the register */
332 dport
->port
.icount
.dsr
++;
336 * ------------------------------------------------------------
339 * this is the main interrupt routine for the DZ chip.
340 * It deals with the multiple ports.
341 * ------------------------------------------------------------
343 static irqreturn_t
dz_interrupt(int irq
, void *dev_id
)
345 struct dz_mux
*mux
= dev_id
;
346 struct dz_port
*dport
= &mux
->dport
[0];
349 /* get the reason why we just got an irq */
350 status
= dz_in(dport
, DZ_CSR
);
352 if ((status
& (DZ_RDONE
| DZ_RIE
)) == (DZ_RDONE
| DZ_RIE
))
353 dz_receive_chars(mux
);
355 if ((status
& (DZ_TRDY
| DZ_TIE
)) == (DZ_TRDY
| DZ_TIE
))
356 dz_transmit_chars(mux
);
362 * -------------------------------------------------------------------
363 * Here ends the DZ interrupt routines.
364 * -------------------------------------------------------------------
367 static unsigned int dz_get_mctrl(struct uart_port
*uport
)
370 * FIXME: Handle the 3100/5000 as appropriate. --macro
372 struct dz_port
*dport
= to_dport(uport
);
373 unsigned int mctrl
= TIOCM_CAR
| TIOCM_DSR
| TIOCM_CTS
;
375 if (dport
->port
.line
== DZ_MODEM
) {
376 if (dz_in(dport
, DZ_MSR
) & DZ_MODEM_DSR
)
383 static void dz_set_mctrl(struct uart_port
*uport
, unsigned int mctrl
)
386 * FIXME: Handle the 3100/5000 as appropriate. --macro
388 struct dz_port
*dport
= to_dport(uport
);
391 if (dport
->port
.line
== DZ_MODEM
) {
392 tmp
= dz_in(dport
, DZ_TCR
);
393 if (mctrl
& TIOCM_DTR
)
394 tmp
&= ~DZ_MODEM_DTR
;
397 dz_out(dport
, DZ_TCR
, tmp
);
402 * -------------------------------------------------------------------
405 * various initialization tasks
406 * -------------------------------------------------------------------
408 static int dz_startup(struct uart_port
*uport
)
410 struct dz_port
*dport
= to_dport(uport
);
411 struct dz_mux
*mux
= dport
->mux
;
417 irq_guard
= atomic_add_return(1, &mux
->irq_guard
);
421 ret
= request_irq(dport
->port
.irq
, dz_interrupt
,
422 IRQF_SHARED
, "dz", mux
);
424 atomic_add(-1, &mux
->irq_guard
);
425 printk(KERN_ERR
"dz: Cannot get IRQ %d!\n", dport
->port
.irq
);
429 spin_lock_irqsave(&dport
->port
.lock
, flags
);
431 /* Enable interrupts. */
432 tmp
= dz_in(dport
, DZ_CSR
);
433 tmp
|= DZ_RIE
| DZ_TIE
;
434 dz_out(dport
, DZ_CSR
, tmp
);
436 spin_unlock_irqrestore(&dport
->port
.lock
, flags
);
442 * -------------------------------------------------------------------
445 * This routine will shutdown a serial port; interrupts are disabled, and
446 * DTR is dropped if the hangup on close termio flag is on.
447 * -------------------------------------------------------------------
449 static void dz_shutdown(struct uart_port
*uport
)
451 struct dz_port
*dport
= to_dport(uport
);
452 struct dz_mux
*mux
= dport
->mux
;
457 spin_lock_irqsave(&dport
->port
.lock
, flags
);
458 dz_stop_tx(&dport
->port
);
459 spin_unlock_irqrestore(&dport
->port
.lock
, flags
);
461 irq_guard
= atomic_add_return(-1, &mux
->irq_guard
);
463 /* Disable interrupts. */
464 tmp
= dz_in(dport
, DZ_CSR
);
465 tmp
&= ~(DZ_RIE
| DZ_TIE
);
466 dz_out(dport
, DZ_CSR
, tmp
);
468 free_irq(dport
->port
.irq
, mux
);
473 * -------------------------------------------------------------------
474 * dz_tx_empty() -- get the transmitter empty status
476 * Purpose: Let user call ioctl() to get info when the UART physically
477 * is emptied. On bus types like RS485, the transmitter must
478 * release the bus after transmitting. This must be done when
479 * the transmit shift register is empty, not be done when the
480 * transmit holding register is empty. This functionality
481 * allows an RS485 driver to be written in user space.
482 * -------------------------------------------------------------------
484 static unsigned int dz_tx_empty(struct uart_port
*uport
)
486 struct dz_port
*dport
= to_dport(uport
);
487 unsigned short tmp
, mask
= 1 << dport
->port
.line
;
489 tmp
= dz_in(dport
, DZ_TCR
);
492 return tmp
? 0 : TIOCSER_TEMT
;
495 static void dz_break_ctl(struct uart_port
*uport
, int break_state
)
498 * FIXME: Can't access BREAK bits in TDR easily;
499 * reuse the code for polled TX. --macro
501 struct dz_port
*dport
= to_dport(uport
);
503 unsigned short tmp
, mask
= 1 << dport
->port
.line
;
505 spin_lock_irqsave(&uport
->lock
, flags
);
506 tmp
= dz_in(dport
, DZ_TCR
);
511 dz_out(dport
, DZ_TCR
, tmp
);
512 spin_unlock_irqrestore(&uport
->lock
, flags
);
515 static int dz_encode_baud_rate(unsigned int baud
)
554 static void dz_reset(struct dz_port
*dport
)
556 struct dz_mux
*mux
= dport
->mux
;
558 if (mux
->initialised
)
561 dz_out(dport
, DZ_CSR
, DZ_CLR
);
562 while (dz_in(dport
, DZ_CSR
) & DZ_CLR
);
565 /* Enable scanning. */
566 dz_out(dport
, DZ_CSR
, DZ_MSE
);
568 mux
->initialised
= 1;
571 static void dz_set_termios(struct uart_port
*uport
, struct ktermios
*termios
,
572 struct ktermios
*old_termios
)
574 struct dz_port
*dport
= to_dport(uport
);
576 unsigned int cflag
, baud
;
579 cflag
= dport
->port
.line
;
581 switch (termios
->c_cflag
& CSIZE
) {
596 if (termios
->c_cflag
& CSTOPB
)
598 if (termios
->c_cflag
& PARENB
)
600 if (termios
->c_cflag
& PARODD
)
603 baud
= uart_get_baud_rate(uport
, termios
, old_termios
, 50, 9600);
604 bflag
= dz_encode_baud_rate(baud
);
605 if (bflag
< 0) { /* Try to keep unchanged. */
606 baud
= uart_get_baud_rate(uport
, old_termios
, NULL
, 50, 9600);
607 bflag
= dz_encode_baud_rate(baud
);
608 if (bflag
< 0) { /* Resort to 9600. */
612 tty_termios_encode_baud_rate(termios
, baud
, baud
);
616 if (termios
->c_cflag
& CREAD
)
619 spin_lock_irqsave(&dport
->port
.lock
, flags
);
621 uart_update_timeout(uport
, termios
->c_cflag
, baud
);
623 dz_out(dport
, DZ_LPR
, cflag
);
624 dport
->cflag
= cflag
;
626 /* setup accept flag */
627 dport
->port
.read_status_mask
= DZ_OERR
;
628 if (termios
->c_iflag
& INPCK
)
629 dport
->port
.read_status_mask
|= DZ_FERR
| DZ_PERR
;
630 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
631 dport
->port
.read_status_mask
|= DZ_BREAK
;
633 /* characters to ignore */
634 uport
->ignore_status_mask
= 0;
635 if ((termios
->c_iflag
& (IGNPAR
| IGNBRK
)) == (IGNPAR
| IGNBRK
))
636 dport
->port
.ignore_status_mask
|= DZ_OERR
;
637 if (termios
->c_iflag
& IGNPAR
)
638 dport
->port
.ignore_status_mask
|= DZ_FERR
| DZ_PERR
;
639 if (termios
->c_iflag
& IGNBRK
)
640 dport
->port
.ignore_status_mask
|= DZ_BREAK
;
642 spin_unlock_irqrestore(&dport
->port
.lock
, flags
);
647 * Required solely so that the initial PROM-based console
648 * works undisturbed in parallel with this one.
650 static void dz_pm(struct uart_port
*uport
, unsigned int state
,
651 unsigned int oldstate
)
653 struct dz_port
*dport
= to_dport(uport
);
656 spin_lock_irqsave(&dport
->port
.lock
, flags
);
658 dz_start_tx(&dport
->port
);
660 dz_stop_tx(&dport
->port
);
661 spin_unlock_irqrestore(&dport
->port
.lock
, flags
);
665 static const char *dz_type(struct uart_port
*uport
)
670 static void dz_release_port(struct uart_port
*uport
)
672 struct dz_mux
*mux
= to_dport(uport
)->mux
;
675 iounmap(uport
->membase
);
676 uport
->membase
= NULL
;
678 map_guard
= atomic_add_return(-1, &mux
->map_guard
);
680 release_mem_region(uport
->mapbase
, dec_kn_slot_size
);
683 static int dz_map_port(struct uart_port
*uport
)
686 uport
->membase
= ioremap_nocache(uport
->mapbase
,
688 if (!uport
->membase
) {
689 printk(KERN_ERR
"dz: Cannot map MMIO\n");
695 static int dz_request_port(struct uart_port
*uport
)
697 struct dz_mux
*mux
= to_dport(uport
)->mux
;
701 map_guard
= atomic_add_return(1, &mux
->map_guard
);
702 if (map_guard
== 1) {
703 if (!request_mem_region(uport
->mapbase
, dec_kn_slot_size
,
705 atomic_add(-1, &mux
->map_guard
);
707 "dz: Unable to reserve MMIO resource\n");
711 ret
= dz_map_port(uport
);
713 map_guard
= atomic_add_return(-1, &mux
->map_guard
);
715 release_mem_region(uport
->mapbase
, dec_kn_slot_size
);
721 static void dz_config_port(struct uart_port
*uport
, int flags
)
723 struct dz_port
*dport
= to_dport(uport
);
725 if (flags
& UART_CONFIG_TYPE
) {
726 if (dz_request_port(uport
))
729 uport
->type
= PORT_DZ
;
736 * Verify the new serial_struct (for TIOCSSERIAL).
738 static int dz_verify_port(struct uart_port
*uport
, struct serial_struct
*ser
)
742 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_DZ
)
744 if (ser
->irq
!= uport
->irq
)
749 static struct uart_ops dz_ops
= {
750 .tx_empty
= dz_tx_empty
,
751 .get_mctrl
= dz_get_mctrl
,
752 .set_mctrl
= dz_set_mctrl
,
753 .stop_tx
= dz_stop_tx
,
754 .start_tx
= dz_start_tx
,
755 .stop_rx
= dz_stop_rx
,
756 .enable_ms
= dz_enable_ms
,
757 .break_ctl
= dz_break_ctl
,
758 .startup
= dz_startup
,
759 .shutdown
= dz_shutdown
,
760 .set_termios
= dz_set_termios
,
763 .release_port
= dz_release_port
,
764 .request_port
= dz_request_port
,
765 .config_port
= dz_config_port
,
766 .verify_port
= dz_verify_port
,
769 static void __init
dz_init_ports(void)
771 static int first
= 1;
779 if (mips_machtype
== MACH_DS23100
|| mips_machtype
== MACH_DS5100
)
780 base
= dec_kn_slot_base
+ KN01_DZ11
;
782 base
= dec_kn_slot_base
+ KN02_DZ11
;
784 for (line
= 0; line
< DZ_NB_PORT
; line
++) {
785 struct dz_port
*dport
= &dz_mux
.dport
[line
];
786 struct uart_port
*uport
= &dport
->port
;
788 dport
->mux
= &dz_mux
;
790 uport
->irq
= dec_interrupt
[DEC_IRQ_DZ11
];
792 uport
->iotype
= UPIO_MEM
;
793 uport
->flags
= UPF_BOOT_AUTOCONF
;
794 uport
->ops
= &dz_ops
;
796 uport
->mapbase
= base
;
800 #ifdef CONFIG_SERIAL_DZ_CONSOLE
802 * -------------------------------------------------------------------
803 * dz_console_putchar() -- transmit a character
805 * Polled transmission. This is tricky. We need to mask transmit
806 * interrupts so that they do not interfere, enable the transmitter
807 * for the line requested and then wait till the transmit scanner
808 * requests data for this line. But it may request data for another
809 * line first, in which case we have to disable its transmitter and
810 * repeat waiting till our line pops up. Only then the character may
811 * be transmitted. Finally, the state of the transmitter mask is
812 * restored. Welcome to the world of PDP-11!
813 * -------------------------------------------------------------------
815 static void dz_console_putchar(struct uart_port
*uport
, int ch
)
817 struct dz_port
*dport
= to_dport(uport
);
819 unsigned short csr
, tcr
, trdy
, mask
;
822 spin_lock_irqsave(&dport
->port
.lock
, flags
);
823 csr
= dz_in(dport
, DZ_CSR
);
824 dz_out(dport
, DZ_CSR
, csr
& ~DZ_TIE
);
825 tcr
= dz_in(dport
, DZ_TCR
);
826 tcr
|= 1 << dport
->port
.line
;
828 dz_out(dport
, DZ_TCR
, mask
);
830 spin_unlock_irqrestore(&dport
->port
.lock
, flags
);
833 trdy
= dz_in(dport
, DZ_CSR
);
834 if (!(trdy
& DZ_TRDY
))
836 trdy
= (trdy
& DZ_TLINE
) >> 8;
837 if (trdy
== dport
->port
.line
)
839 mask
&= ~(1 << trdy
);
840 dz_out(dport
, DZ_TCR
, mask
);
845 if (loops
) /* Cannot send otherwise. */
846 dz_out(dport
, DZ_TDR
, ch
);
848 dz_out(dport
, DZ_TCR
, tcr
);
849 dz_out(dport
, DZ_CSR
, csr
);
853 * -------------------------------------------------------------------
854 * dz_console_print ()
856 * dz_console_print is registered for printk.
857 * The console must be locked when we get here.
858 * -------------------------------------------------------------------
860 static void dz_console_print(struct console
*co
,
864 struct dz_port
*dport
= &dz_mux
.dport
[co
->index
];
866 prom_printf((char *) str
);
868 uart_console_write(&dport
->port
, str
, count
, dz_console_putchar
);
871 static int __init
dz_console_setup(struct console
*co
, char *options
)
873 struct dz_port
*dport
= &dz_mux
.dport
[co
->index
];
874 struct uart_port
*uport
= &dport
->port
;
881 ret
= dz_map_port(uport
);
885 spin_lock_init(&dport
->port
.lock
); /* For dz_pm(). */
891 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
893 return uart_set_options(&dport
->port
, co
, baud
, parity
, bits
, flow
);
896 static struct uart_driver dz_reg
;
897 static struct console dz_console
= {
899 .write
= dz_console_print
,
900 .device
= uart_console_device
,
901 .setup
= dz_console_setup
,
902 .flags
= CON_PRINTBUFFER
,
907 static int __init
dz_serial_console_init(void)
911 register_console(&dz_console
);
917 console_initcall(dz_serial_console_init
);
919 #define SERIAL_DZ_CONSOLE &dz_console
921 #define SERIAL_DZ_CONSOLE NULL
922 #endif /* CONFIG_SERIAL_DZ_CONSOLE */
924 static struct uart_driver dz_reg
= {
925 .owner
= THIS_MODULE
,
926 .driver_name
= "serial",
931 .cons
= SERIAL_DZ_CONSOLE
,
934 static int __init
dz_init(void)
941 printk("%s%s\n", dz_name
, dz_version
);
945 ret
= uart_register_driver(&dz_reg
);
949 for (i
= 0; i
< DZ_NB_PORT
; i
++)
950 uart_add_one_port(&dz_reg
, &dz_mux
.dport
[i
].port
);
955 module_init(dz_init
);