2 * drivers/serial/netx-serial.c
4 * Copyright (c) 2005 Sascha Hauer <s.hauer@pengutronix.de>, Pengutronix
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #if defined(CONFIG_SERIAL_NETX_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
24 #include <linux/device.h>
25 #include <linux/module.h>
26 #include <linux/ioport.h>
27 #include <linux/init.h>
28 #include <linux/console.h>
29 #include <linux/sysrq.h>
30 #include <linux/platform_device.h>
31 #include <linux/tty.h>
32 #include <linux/tty_flip.h>
33 #include <linux/serial_core.h>
34 #include <linux/serial.h>
38 #include <asm/hardware.h>
39 #include <asm/arch/netx-regs.h>
41 /* We've been assigned a range on the "Low-density serial ports" major */
42 #define SERIAL_NX_MAJOR 204
43 #define MINOR_START 170
45 #ifdef CONFIG_SERIAL_NETX_CONSOLE
51 UART_BAUDDIV_MSB
= 0x0c,
52 UART_BAUDDIV_LSB
= 0x10,
59 UART_RTS_TRAIL
= 0x2c,
60 UART_DRV_ENABLE
= 0x30,
62 UART_RXFIFO_IRQLEVEL
= 0x38,
63 UART_TXFIFO_IRQLEVEL
= 0x3c,
71 #define LINE_CR_BRK (1<<0)
72 #define LINE_CR_PEN (1<<1)
73 #define LINE_CR_EPS (1<<2)
74 #define LINE_CR_STP2 (1<<3)
75 #define LINE_CR_FEN (1<<4)
76 #define LINE_CR_5BIT (0<<5)
77 #define LINE_CR_6BIT (1<<5)
78 #define LINE_CR_7BIT (2<<5)
79 #define LINE_CR_8BIT (3<<5)
80 #define LINE_CR_BITS_MASK (3<<5)
82 #define CR_UART_EN (1<<0)
83 #define CR_SIREN (1<<1)
84 #define CR_SIRLP (1<<2)
85 #define CR_MSIE (1<<3)
88 #define CR_RTIE (1<<6)
94 #define FR_BUSY (1<<3)
95 #define FR_RXFE (1<<4)
96 #define FR_TXFF (1<<5)
97 #define FR_RXFF (1<<6)
98 #define FR_TXFE (1<<7)
100 #define IIR_MIS (1<<0)
101 #define IIR_RIS (1<<1)
102 #define IIR_TIS (1<<2)
103 #define IIR_RTIS (1<<3)
106 #define RTS_CR_AUTO (1<<0)
107 #define RTS_CR_RTS (1<<1)
108 #define RTS_CR_COUNT (1<<2)
109 #define RTS_CR_MOD2 (1<<3)
110 #define RTS_CR_RTS_POL (1<<4)
111 #define RTS_CR_CTS_CTR (1<<5)
112 #define RTS_CR_CTS_POL (1<<6)
113 #define RTS_CR_STICK (1<<7)
115 #define UART_PORT_SIZE 0x40
116 #define DRIVER_NAME "netx-uart"
119 struct uart_port port
;
122 static void netx_stop_tx(struct uart_port
*port
)
125 val
= readl(port
->membase
+ UART_CR
);
126 writel(val
& ~CR_TIE
, port
->membase
+ UART_CR
);
129 static void netx_stop_rx(struct uart_port
*port
)
132 val
= readl(port
->membase
+ UART_CR
);
133 writel(val
& ~CR_RIE
, port
->membase
+ UART_CR
);
136 static void netx_enable_ms(struct uart_port
*port
)
139 val
= readl(port
->membase
+ UART_CR
);
140 writel(val
| CR_MSIE
, port
->membase
+ UART_CR
);
143 static inline void netx_transmit_buffer(struct uart_port
*port
)
145 struct circ_buf
*xmit
= &port
->info
->xmit
;
148 writel(port
->x_char
, port
->membase
+ UART_DR
);
154 if (uart_tx_stopped(port
) || uart_circ_empty(xmit
)) {
160 /* send xmit->buf[xmit->tail]
161 * out the port here */
162 writel(xmit
->buf
[xmit
->tail
], port
->membase
+ UART_DR
);
163 xmit
->tail
= (xmit
->tail
+ 1) &
164 (UART_XMIT_SIZE
- 1);
166 if (uart_circ_empty(xmit
))
168 } while (!(readl(port
->membase
+ UART_FR
) & FR_TXFF
));
170 if (uart_circ_empty(xmit
))
174 static void netx_start_tx(struct uart_port
*port
)
177 readl(port
->membase
+ UART_CR
) | CR_TIE
, port
->membase
+ UART_CR
);
179 if (!(readl(port
->membase
+ UART_FR
) & FR_TXFF
))
180 netx_transmit_buffer(port
);
183 static unsigned int netx_tx_empty(struct uart_port
*port
)
185 return readl(port
->membase
+ UART_FR
) & FR_BUSY
? 0 : TIOCSER_TEMT
;
188 static void netx_txint(struct uart_port
*port
)
190 struct circ_buf
*xmit
= &port
->info
->xmit
;
192 if (uart_circ_empty(xmit
) || uart_tx_stopped(port
)) {
197 netx_transmit_buffer(port
);
199 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
200 uart_write_wakeup(port
);
203 static void netx_rxint(struct uart_port
*port
)
205 unsigned char rx
, flg
, status
;
206 struct tty_struct
*tty
= port
->info
->tty
;
208 while (!(readl(port
->membase
+ UART_FR
) & FR_RXFE
)) {
209 rx
= readl(port
->membase
+ UART_DR
);
212 status
= readl(port
->membase
+ UART_SR
);
213 if (status
& SR_BE
) {
214 writel(0, port
->membase
+ UART_SR
);
215 if (uart_handle_break(port
))
219 if (unlikely(status
& (SR_FE
| SR_PE
| SR_OE
))) {
222 port
->icount
.parity
++;
223 else if (status
& SR_FE
)
224 port
->icount
.frame
++;
226 port
->icount
.overrun
++;
228 status
&= port
->read_status_mask
;
232 else if (status
& SR_PE
)
234 else if (status
& SR_FE
)
238 if (uart_handle_sysrq_char(port
, rx
))
241 uart_insert_char(port
, status
, SR_OE
, rx
, flg
);
244 tty_flip_buffer_push(tty
);
248 static irqreturn_t
netx_int(int irq
, void *dev_id
)
250 struct uart_port
*port
= (struct uart_port
*)dev_id
;
252 unsigned char status
;
254 spin_lock_irqsave(&port
->lock
,flags
);
256 status
= readl(port
->membase
+ UART_IIR
) & IIR_MASK
;
258 if (status
& IIR_RIS
)
260 if (status
& IIR_TIS
)
262 if (status
& IIR_MIS
) {
263 if (readl(port
->membase
+ UART_FR
) & FR_CTS
)
264 uart_handle_cts_change(port
, 1);
266 uart_handle_cts_change(port
, 0);
268 writel(0, port
->membase
+ UART_IIR
);
269 status
= readl(port
->membase
+ UART_IIR
) & IIR_MASK
;
272 spin_unlock_irqrestore(&port
->lock
,flags
);
276 static unsigned int netx_get_mctrl(struct uart_port
*port
)
278 unsigned int ret
= TIOCM_DSR
| TIOCM_CAR
;
280 if (readl(port
->membase
+ UART_FR
) & FR_CTS
)
286 static void netx_set_mctrl(struct uart_port
*port
, unsigned int mctrl
)
290 if (mctrl
& TIOCM_RTS
) {
291 val
= readl(port
->membase
+ UART_RTS_CR
);
292 writel(val
| RTS_CR_RTS
, port
->membase
+ UART_RTS_CR
);
296 static void netx_break_ctl(struct uart_port
*port
, int break_state
)
298 unsigned int line_cr
;
299 spin_lock_irq(&port
->lock
);
301 line_cr
= readl(port
->membase
+ UART_LINE_CR
);
302 if (break_state
!= 0)
303 line_cr
|= LINE_CR_BRK
;
305 line_cr
&= ~LINE_CR_BRK
;
306 writel(line_cr
, port
->membase
+ UART_LINE_CR
);
308 spin_unlock_irq(&port
->lock
);
311 static int netx_startup(struct uart_port
*port
)
315 ret
= request_irq(port
->irq
, netx_int
, 0,
318 dev_err(port
->dev
, "unable to grab irq%d\n",port
->irq
);
322 writel(readl(port
->membase
+ UART_LINE_CR
) | LINE_CR_FEN
,
323 port
->membase
+ UART_LINE_CR
);
325 writel(CR_MSIE
| CR_RIE
| CR_TIE
| CR_RTIE
| CR_UART_EN
,
326 port
->membase
+ UART_CR
);
332 static void netx_shutdown(struct uart_port
*port
)
334 writel(0, port
->membase
+ UART_CR
) ;
336 free_irq(port
->irq
, port
);
340 netx_set_termios(struct uart_port
*port
, struct termios
*termios
,
343 unsigned int baud
, quot
;
344 unsigned char old_cr
;
345 unsigned char line_cr
= LINE_CR_FEN
;
346 unsigned char rts_cr
= 0;
348 switch (termios
->c_cflag
& CSIZE
) {
350 line_cr
|= LINE_CR_5BIT
;
353 line_cr
|= LINE_CR_6BIT
;
356 line_cr
|= LINE_CR_7BIT
;
359 line_cr
|= LINE_CR_8BIT
;
363 if (termios
->c_cflag
& CSTOPB
)
364 line_cr
|= LINE_CR_STP2
;
366 if (termios
->c_cflag
& PARENB
) {
367 line_cr
|= LINE_CR_PEN
;
368 if (!(termios
->c_cflag
& PARODD
))
369 line_cr
|= LINE_CR_EPS
;
372 if (termios
->c_cflag
& CRTSCTS
)
373 rts_cr
= RTS_CR_AUTO
| RTS_CR_CTS_CTR
| RTS_CR_RTS_POL
;
375 baud
= uart_get_baud_rate(port
, termios
, old
, 0, port
->uartclk
/16);
381 spin_lock_irq(&port
->lock
);
383 uart_update_timeout(port
, termios
->c_cflag
, baud
);
385 old_cr
= readl(port
->membase
+ UART_CR
);
387 /* disable interrupts */
388 writel(old_cr
& ~(CR_MSIE
| CR_RIE
| CR_TIE
| CR_RTIE
),
389 port
->membase
+ UART_CR
);
391 /* drain transmitter */
392 while (readl(port
->membase
+ UART_FR
) & FR_BUSY
);
395 writel(old_cr
& ~CR_UART_EN
, port
->membase
+ UART_CR
);
397 /* modem status interrupts */
399 if (UART_ENABLE_MS(port
, termios
->c_cflag
))
402 writel((quot
>>8) & 0xff, port
->membase
+ UART_BAUDDIV_MSB
);
403 writel(quot
& 0xff, port
->membase
+ UART_BAUDDIV_LSB
);
404 writel(line_cr
, port
->membase
+ UART_LINE_CR
);
406 writel(rts_cr
, port
->membase
+ UART_RTS_CR
);
409 * Characters to ignore
411 port
->ignore_status_mask
= 0;
412 if (termios
->c_iflag
& IGNPAR
)
413 port
->ignore_status_mask
|= SR_PE
;
414 if (termios
->c_iflag
& IGNBRK
) {
415 port
->ignore_status_mask
|= SR_BE
;
417 * If we're ignoring parity and break indicators,
418 * ignore overruns too (for real raw support).
420 if (termios
->c_iflag
& IGNPAR
)
421 port
->ignore_status_mask
|= SR_PE
;
424 port
->read_status_mask
= 0;
425 if (termios
->c_iflag
& (BRKINT
| PARMRK
))
426 port
->read_status_mask
|= SR_BE
;
427 if (termios
->c_iflag
& INPCK
)
428 port
->read_status_mask
|= SR_PE
| SR_FE
;
430 writel(old_cr
, port
->membase
+ UART_CR
);
432 spin_unlock_irq(&port
->lock
);
435 static const char *netx_type(struct uart_port
*port
)
437 return port
->type
== PORT_NETX
? "NETX" : NULL
;
440 static void netx_release_port(struct uart_port
*port
)
442 release_mem_region(port
->mapbase
, UART_PORT_SIZE
);
445 static int netx_request_port(struct uart_port
*port
)
447 return request_mem_region(port
->mapbase
, UART_PORT_SIZE
,
448 DRIVER_NAME
) != NULL
? 0 : -EBUSY
;
451 static void netx_config_port(struct uart_port
*port
, int flags
)
453 if (flags
& UART_CONFIG_TYPE
&& netx_request_port(port
) == 0)
454 port
->type
= PORT_NETX
;
458 netx_verify_port(struct uart_port
*port
, struct serial_struct
*ser
)
462 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_NETX
)
468 static struct uart_ops netx_pops
= {
469 .tx_empty
= netx_tx_empty
,
470 .set_mctrl
= netx_set_mctrl
,
471 .get_mctrl
= netx_get_mctrl
,
472 .stop_tx
= netx_stop_tx
,
473 .start_tx
= netx_start_tx
,
474 .stop_rx
= netx_stop_rx
,
475 .enable_ms
= netx_enable_ms
,
476 .break_ctl
= netx_break_ctl
,
477 .startup
= netx_startup
,
478 .shutdown
= netx_shutdown
,
479 .set_termios
= netx_set_termios
,
481 .release_port
= netx_release_port
,
482 .request_port
= netx_request_port
,
483 .config_port
= netx_config_port
,
484 .verify_port
= netx_verify_port
,
487 static struct netx_port netx_ports
[] = {
492 .membase
= (char __iomem
*)io_p2v(NETX_PA_UART0
),
493 .mapbase
= NETX_PA_UART0
,
494 .irq
= NETX_IRQ_UART0
,
495 .uartclk
= 100000000,
497 .flags
= UPF_BOOT_AUTOCONF
,
505 .membase
= (char __iomem
*)io_p2v(NETX_PA_UART1
),
506 .mapbase
= NETX_PA_UART1
,
507 .irq
= NETX_IRQ_UART1
,
508 .uartclk
= 100000000,
510 .flags
= UPF_BOOT_AUTOCONF
,
518 .membase
= (char __iomem
*)io_p2v(NETX_PA_UART2
),
519 .mapbase
= NETX_PA_UART2
,
520 .irq
= NETX_IRQ_UART2
,
521 .uartclk
= 100000000,
523 .flags
= UPF_BOOT_AUTOCONF
,
530 static void netx_console_putchar(struct uart_port
*port
, int ch
)
532 while (readl(port
->membase
+ UART_FR
) & FR_BUSY
);
533 writel(ch
, port
->membase
+ UART_DR
);
537 netx_console_write(struct console
*co
, const char *s
, unsigned int count
)
539 struct uart_port
*port
= &netx_ports
[co
->index
].port
;
540 unsigned char cr_save
;
542 cr_save
= readl(port
->membase
+ UART_CR
);
543 writel(cr_save
| CR_UART_EN
, port
->membase
+ UART_CR
);
545 uart_console_write(port
, s
, count
, netx_console_putchar
);
547 while (readl(port
->membase
+ UART_FR
) & FR_BUSY
);
548 writel(cr_save
, port
->membase
+ UART_CR
);
552 netx_console_get_options(struct uart_port
*port
, int *baud
,
553 int *parity
, int *bits
, int *flow
)
555 unsigned char line_cr
;
557 *baud
= (readl(port
->membase
+ UART_BAUDDIV_MSB
) << 8) |
558 readl(port
->membase
+ UART_BAUDDIV_LSB
);
565 line_cr
= readl(port
->membase
+ UART_LINE_CR
);
567 if (line_cr
& LINE_CR_PEN
) {
568 if (line_cr
& LINE_CR_EPS
)
574 switch (line_cr
& LINE_CR_BITS_MASK
) {
589 if (readl(port
->membase
+ UART_RTS_CR
) & RTS_CR_AUTO
)
594 netx_console_setup(struct console
*co
, char *options
)
596 struct netx_port
*sport
;
603 * Check whether an invalid uart number has been specified, and
604 * if so, search for the first available port that does have
607 if (co
->index
== -1 || co
->index
>= ARRAY_SIZE(netx_ports
))
609 sport
= &netx_ports
[co
->index
];
612 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
614 /* if the UART is enabled, assume it has been correctly setup
615 * by the bootloader and get the options
617 if (readl(sport
->port
.membase
+ UART_CR
) & CR_UART_EN
) {
618 netx_console_get_options(&sport
->port
, &baud
,
619 &parity
, &bits
, &flow
);
624 return uart_set_options(&sport
->port
, co
, baud
, parity
, bits
, flow
);
627 static struct uart_driver netx_reg
;
628 static struct console netx_console
= {
630 .write
= netx_console_write
,
631 .device
= uart_console_device
,
632 .setup
= netx_console_setup
,
633 .flags
= CON_PRINTBUFFER
,
638 static int __init
netx_console_init(void)
640 register_console(&netx_console
);
643 console_initcall(netx_console_init
);
645 #define NETX_CONSOLE &netx_console
647 #define NETX_CONSOLE NULL
650 static struct uart_driver netx_reg
= {
651 .owner
= THIS_MODULE
,
652 .driver_name
= DRIVER_NAME
,
654 .major
= SERIAL_NX_MAJOR
,
655 .minor
= MINOR_START
,
656 .nr
= ARRAY_SIZE(netx_ports
),
657 .cons
= NETX_CONSOLE
,
660 static int serial_netx_suspend(struct platform_device
*pdev
, pm_message_t state
)
662 struct netx_port
*sport
= platform_get_drvdata(pdev
);
665 uart_suspend_port(&netx_reg
, &sport
->port
);
670 static int serial_netx_resume(struct platform_device
*pdev
)
672 struct netx_port
*sport
= platform_get_drvdata(pdev
);
675 uart_resume_port(&netx_reg
, &sport
->port
);
680 static int serial_netx_probe(struct platform_device
*pdev
)
682 struct uart_port
*port
= &netx_ports
[pdev
->id
].port
;
684 dev_info(&pdev
->dev
, "initialising\n");
686 port
->dev
= &pdev
->dev
;
688 writel(1, port
->membase
+ UART_RXFIFO_IRQLEVEL
);
689 uart_add_one_port(&netx_reg
, &netx_ports
[pdev
->id
].port
);
690 platform_set_drvdata(pdev
, &netx_ports
[pdev
->id
]);
695 static int serial_netx_remove(struct platform_device
*pdev
)
697 struct netx_port
*sport
= platform_get_drvdata(pdev
);
699 platform_set_drvdata(pdev
, NULL
);
702 uart_remove_one_port(&netx_reg
, &sport
->port
);
707 static struct platform_driver serial_netx_driver
= {
708 .probe
= serial_netx_probe
,
709 .remove
= serial_netx_remove
,
711 .suspend
= serial_netx_suspend
,
712 .resume
= serial_netx_resume
,
719 static int __init
netx_serial_init(void)
723 printk(KERN_INFO
"Serial: NetX driver\n");
725 ret
= uart_register_driver(&netx_reg
);
729 ret
= platform_driver_register(&serial_netx_driver
);
731 uart_unregister_driver(&netx_reg
);
736 static void __exit
netx_serial_exit(void)
738 platform_driver_unregister(&serial_netx_driver
);
739 uart_unregister_driver(&netx_reg
);
742 module_init(netx_serial_init
);
743 module_exit(netx_serial_exit
);
745 MODULE_AUTHOR("Sascha Hauer");
746 MODULE_DESCRIPTION("NetX serial port driver");
747 MODULE_LICENSE("GPL");