2 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published
6 * by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 * Copyright (C) 2004 Infineon IFAP DC COM CPE
18 * Copyright (C) 2007 Felix Fietkau <nbd@openwrt.org>
19 * Copyright (C) 2007 John Crispin <blogic@openwrt.org>
20 * Copyright (C) 2010 Thomas Langer, <thomas.langer@lantiq.com>
23 #include <linux/slab.h>
24 #include <linux/module.h>
25 #include <linux/ioport.h>
26 #include <linux/init.h>
27 #include <linux/console.h>
28 #include <linux/sysrq.h>
29 #include <linux/device.h>
30 #include <linux/tty.h>
31 #include <linux/tty_flip.h>
32 #include <linux/serial_core.h>
33 #include <linux/serial.h>
34 #include <linux/of_platform.h>
35 #include <linux/of_address.h>
36 #include <linux/of_irq.h>
38 #include <linux/clk.h>
39 #include <linux/gpio.h>
41 #include <lantiq_soc.h>
43 #define PORT_LTQ_ASC 111
45 #define UART_DUMMY_UER_RX 1
46 #define DRVNAME "lantiq,asc"
48 #define LTQ_ASC_TBUF (0x0020 + 3)
49 #define LTQ_ASC_RBUF (0x0024 + 3)
51 #define LTQ_ASC_TBUF 0x0020
52 #define LTQ_ASC_RBUF 0x0024
54 #define LTQ_ASC_FSTAT 0x0048
55 #define LTQ_ASC_WHBSTATE 0x0018
56 #define LTQ_ASC_STATE 0x0014
57 #define LTQ_ASC_IRNCR 0x00F8
58 #define LTQ_ASC_CLC 0x0000
59 #define LTQ_ASC_ID 0x0008
60 #define LTQ_ASC_PISEL 0x0004
61 #define LTQ_ASC_TXFCON 0x0044
62 #define LTQ_ASC_RXFCON 0x0040
63 #define LTQ_ASC_CON 0x0010
64 #define LTQ_ASC_BG 0x0050
65 #define LTQ_ASC_IRNREN 0x00F4
67 #define ASC_IRNREN_TX 0x1
68 #define ASC_IRNREN_RX 0x2
69 #define ASC_IRNREN_ERR 0x4
70 #define ASC_IRNREN_TX_BUF 0x8
71 #define ASC_IRNCR_TIR 0x1
72 #define ASC_IRNCR_RIR 0x2
73 #define ASC_IRNCR_EIR 0x4
75 #define ASCOPT_CSIZE 0x3
78 #define ASCCLC_DISS 0x2
79 #define ASCCLC_RMCMASK 0x0000FF00
80 #define ASCCLC_RMCOFFSET 8
81 #define ASCCON_M_8ASYNC 0x0
82 #define ASCCON_M_7ASYNC 0x2
83 #define ASCCON_ODD 0x00000020
84 #define ASCCON_STP 0x00000080
85 #define ASCCON_BRS 0x00000100
86 #define ASCCON_FDE 0x00000200
87 #define ASCCON_R 0x00008000
88 #define ASCCON_FEN 0x00020000
89 #define ASCCON_ROEN 0x00080000
90 #define ASCCON_TOEN 0x00100000
91 #define ASCSTATE_PE 0x00010000
92 #define ASCSTATE_FE 0x00020000
93 #define ASCSTATE_ROE 0x00080000
94 #define ASCSTATE_ANY (ASCSTATE_ROE|ASCSTATE_PE|ASCSTATE_FE)
95 #define ASCWHBSTATE_CLRREN 0x00000001
96 #define ASCWHBSTATE_SETREN 0x00000002
97 #define ASCWHBSTATE_CLRPE 0x00000004
98 #define ASCWHBSTATE_CLRFE 0x00000008
99 #define ASCWHBSTATE_CLRROE 0x00000020
100 #define ASCTXFCON_TXFEN 0x0001
101 #define ASCTXFCON_TXFFLU 0x0002
102 #define ASCTXFCON_TXFITLMASK 0x3F00
103 #define ASCTXFCON_TXFITLOFF 8
104 #define ASCRXFCON_RXFEN 0x0001
105 #define ASCRXFCON_RXFFLU 0x0002
106 #define ASCRXFCON_RXFITLMASK 0x3F00
107 #define ASCRXFCON_RXFITLOFF 8
108 #define ASCFSTAT_RXFFLMASK 0x003F
109 #define ASCFSTAT_TXFFLMASK 0x3F00
110 #define ASCFSTAT_TXFREEMASK 0x3F000000
111 #define ASCFSTAT_TXFREEOFF 24
113 static void lqasc_tx_chars(struct uart_port
*port
);
114 static struct ltq_uart_port
*lqasc_port
[MAXPORTS
];
115 static struct uart_driver lqasc_reg
;
116 static DEFINE_SPINLOCK(ltq_asc_lock
);
118 struct ltq_uart_port
{
119 struct uart_port port
;
120 /* clock used to derive divider */
122 /* clock gating of the ASC core */
126 unsigned int err_irq
;
130 ltq_uart_port
*to_ltq_uart_port(struct uart_port
*port
)
132 return container_of(port
, struct ltq_uart_port
, port
);
136 lqasc_stop_tx(struct uart_port
*port
)
142 lqasc_start_tx(struct uart_port
*port
)
145 spin_lock_irqsave(<q_asc_lock
, flags
);
146 lqasc_tx_chars(port
);
147 spin_unlock_irqrestore(<q_asc_lock
, flags
);
152 lqasc_stop_rx(struct uart_port
*port
)
154 ltq_w32(ASCWHBSTATE_CLRREN
, port
->membase
+ LTQ_ASC_WHBSTATE
);
158 lqasc_enable_ms(struct uart_port
*port
)
163 lqasc_rx_chars(struct uart_port
*port
)
165 struct tty_struct
*tty
= tty_port_tty_get(&port
->state
->port
);
166 unsigned int ch
= 0, rsr
= 0, fifocnt
;
169 dev_dbg(port
->dev
, "%s:tty is busy now", __func__
);
173 ltq_r32(port
->membase
+ LTQ_ASC_FSTAT
) & ASCFSTAT_RXFFLMASK
;
175 u8 flag
= TTY_NORMAL
;
176 ch
= ltq_r8(port
->membase
+ LTQ_ASC_RBUF
);
177 rsr
= (ltq_r32(port
->membase
+ LTQ_ASC_STATE
)
178 & ASCSTATE_ANY
) | UART_DUMMY_UER_RX
;
179 tty_flip_buffer_push(tty
);
183 * Note that the error handling code is
184 * out of the main execution path
186 if (rsr
& ASCSTATE_ANY
) {
187 if (rsr
& ASCSTATE_PE
) {
188 port
->icount
.parity
++;
189 ltq_w32_mask(0, ASCWHBSTATE_CLRPE
,
190 port
->membase
+ LTQ_ASC_WHBSTATE
);
191 } else if (rsr
& ASCSTATE_FE
) {
192 port
->icount
.frame
++;
193 ltq_w32_mask(0, ASCWHBSTATE_CLRFE
,
194 port
->membase
+ LTQ_ASC_WHBSTATE
);
196 if (rsr
& ASCSTATE_ROE
) {
197 port
->icount
.overrun
++;
198 ltq_w32_mask(0, ASCWHBSTATE_CLRROE
,
199 port
->membase
+ LTQ_ASC_WHBSTATE
);
202 rsr
&= port
->read_status_mask
;
204 if (rsr
& ASCSTATE_PE
)
206 else if (rsr
& ASCSTATE_FE
)
210 if ((rsr
& port
->ignore_status_mask
) == 0)
211 tty_insert_flip_char(tty
, ch
, flag
);
213 if (rsr
& ASCSTATE_ROE
)
215 * Overrun is special, since it's reported
216 * immediately, and doesn't affect the current
219 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
222 tty_flip_buffer_push(tty
);
228 lqasc_tx_chars(struct uart_port
*port
)
230 struct circ_buf
*xmit
= &port
->state
->xmit
;
231 if (uart_tx_stopped(port
)) {
236 while (((ltq_r32(port
->membase
+ LTQ_ASC_FSTAT
) &
237 ASCFSTAT_TXFREEMASK
) >> ASCFSTAT_TXFREEOFF
) != 0) {
239 ltq_w8(port
->x_char
, port
->membase
+ LTQ_ASC_TBUF
);
245 if (uart_circ_empty(xmit
))
248 ltq_w8(port
->state
->xmit
.buf
[port
->state
->xmit
.tail
],
249 port
->membase
+ LTQ_ASC_TBUF
);
250 xmit
->tail
= (xmit
->tail
+ 1) & (UART_XMIT_SIZE
- 1);
254 if (uart_circ_chars_pending(xmit
) < WAKEUP_CHARS
)
255 uart_write_wakeup(port
);
259 lqasc_tx_int(int irq
, void *_port
)
262 struct uart_port
*port
= (struct uart_port
*)_port
;
263 spin_lock_irqsave(<q_asc_lock
, flags
);
264 ltq_w32(ASC_IRNCR_TIR
, port
->membase
+ LTQ_ASC_IRNCR
);
265 spin_unlock_irqrestore(<q_asc_lock
, flags
);
266 lqasc_start_tx(port
);
271 lqasc_err_int(int irq
, void *_port
)
274 struct uart_port
*port
= (struct uart_port
*)_port
;
275 spin_lock_irqsave(<q_asc_lock
, flags
);
276 /* clear any pending interrupts */
277 ltq_w32_mask(0, ASCWHBSTATE_CLRPE
| ASCWHBSTATE_CLRFE
|
278 ASCWHBSTATE_CLRROE
, port
->membase
+ LTQ_ASC_WHBSTATE
);
279 spin_unlock_irqrestore(<q_asc_lock
, flags
);
284 lqasc_rx_int(int irq
, void *_port
)
287 struct uart_port
*port
= (struct uart_port
*)_port
;
288 spin_lock_irqsave(<q_asc_lock
, flags
);
289 ltq_w32(ASC_IRNCR_RIR
, port
->membase
+ LTQ_ASC_IRNCR
);
290 lqasc_rx_chars(port
);
291 spin_unlock_irqrestore(<q_asc_lock
, flags
);
296 lqasc_tx_empty(struct uart_port
*port
)
299 status
= ltq_r32(port
->membase
+ LTQ_ASC_FSTAT
) & ASCFSTAT_TXFFLMASK
;
300 return status
? 0 : TIOCSER_TEMT
;
304 lqasc_get_mctrl(struct uart_port
*port
)
306 return TIOCM_CTS
| TIOCM_CAR
| TIOCM_DSR
;
310 lqasc_set_mctrl(struct uart_port
*port
, u_int mctrl
)
315 lqasc_break_ctl(struct uart_port
*port
, int break_state
)
320 lqasc_startup(struct uart_port
*port
)
322 struct ltq_uart_port
*ltq_port
= to_ltq_uart_port(port
);
326 clk_enable(ltq_port
->clk
);
327 port
->uartclk
= clk_get_rate(ltq_port
->fpiclk
);
329 ltq_w32_mask(ASCCLC_DISS
| ASCCLC_RMCMASK
, (1 << ASCCLC_RMCOFFSET
),
330 port
->membase
+ LTQ_ASC_CLC
);
332 ltq_w32(0, port
->membase
+ LTQ_ASC_PISEL
);
334 ((TXFIFO_FL
<< ASCTXFCON_TXFITLOFF
) & ASCTXFCON_TXFITLMASK
) |
335 ASCTXFCON_TXFEN
| ASCTXFCON_TXFFLU
,
336 port
->membase
+ LTQ_ASC_TXFCON
);
338 ((RXFIFO_FL
<< ASCRXFCON_RXFITLOFF
) & ASCRXFCON_RXFITLMASK
)
339 | ASCRXFCON_RXFEN
| ASCRXFCON_RXFFLU
,
340 port
->membase
+ LTQ_ASC_RXFCON
);
341 /* make sure other settings are written to hardware before
342 * setting enable bits
345 ltq_w32_mask(0, ASCCON_M_8ASYNC
| ASCCON_FEN
| ASCCON_TOEN
|
346 ASCCON_ROEN
, port
->membase
+ LTQ_ASC_CON
);
348 retval
= request_irq(ltq_port
->tx_irq
, lqasc_tx_int
,
351 pr_err("failed to request lqasc_tx_int\n");
355 retval
= request_irq(ltq_port
->rx_irq
, lqasc_rx_int
,
358 pr_err("failed to request lqasc_rx_int\n");
362 retval
= request_irq(ltq_port
->err_irq
, lqasc_err_int
,
365 pr_err("failed to request lqasc_err_int\n");
369 ltq_w32(ASC_IRNREN_RX
| ASC_IRNREN_ERR
| ASC_IRNREN_TX
,
370 port
->membase
+ LTQ_ASC_IRNREN
);
374 free_irq(ltq_port
->rx_irq
, port
);
376 free_irq(ltq_port
->tx_irq
, port
);
381 lqasc_shutdown(struct uart_port
*port
)
383 struct ltq_uart_port
*ltq_port
= to_ltq_uart_port(port
);
384 free_irq(ltq_port
->tx_irq
, port
);
385 free_irq(ltq_port
->rx_irq
, port
);
386 free_irq(ltq_port
->err_irq
, port
);
388 ltq_w32(0, port
->membase
+ LTQ_ASC_CON
);
389 ltq_w32_mask(ASCRXFCON_RXFEN
, ASCRXFCON_RXFFLU
,
390 port
->membase
+ LTQ_ASC_RXFCON
);
391 ltq_w32_mask(ASCTXFCON_TXFEN
, ASCTXFCON_TXFFLU
,
392 port
->membase
+ LTQ_ASC_TXFCON
);
394 clk_disable(ltq_port
->clk
);
398 lqasc_set_termios(struct uart_port
*port
,
399 struct ktermios
*new, struct ktermios
*old
)
403 unsigned int divisor
;
405 unsigned int con
= 0;
408 cflag
= new->c_cflag
;
409 iflag
= new->c_iflag
;
411 switch (cflag
& CSIZE
) {
413 con
= ASCCON_M_7ASYNC
;
419 new->c_cflag
&= ~ CSIZE
;
421 con
= ASCCON_M_8ASYNC
;
425 cflag
&= ~CMSPAR
; /* Mark/Space parity is not supported */
430 if (cflag
& PARENB
) {
431 if (!(cflag
& PARODD
))
437 port
->read_status_mask
= ASCSTATE_ROE
;
439 port
->read_status_mask
|= ASCSTATE_FE
| ASCSTATE_PE
;
441 port
->ignore_status_mask
= 0;
443 port
->ignore_status_mask
|= ASCSTATE_FE
| ASCSTATE_PE
;
445 if (iflag
& IGNBRK
) {
447 * If we're ignoring parity and break indicators,
448 * ignore overruns too (for real raw support).
451 port
->ignore_status_mask
|= ASCSTATE_ROE
;
454 if ((cflag
& CREAD
) == 0)
455 port
->ignore_status_mask
|= UART_DUMMY_UER_RX
;
457 /* set error signals - framing, parity and overrun, enable receiver */
458 con
|= ASCCON_FEN
| ASCCON_TOEN
| ASCCON_ROEN
;
460 spin_lock_irqsave(<q_asc_lock
, flags
);
463 ltq_w32_mask(0, con
, port
->membase
+ LTQ_ASC_CON
);
465 /* Set baud rate - take a divider of 2 into account */
466 baud
= uart_get_baud_rate(port
, new, old
, 0, port
->uartclk
/ 16);
467 divisor
= uart_get_divisor(port
, baud
);
468 divisor
= divisor
/ 2 - 1;
470 /* disable the baudrate generator */
471 ltq_w32_mask(ASCCON_R
, 0, port
->membase
+ LTQ_ASC_CON
);
473 /* make sure the fractional divider is off */
474 ltq_w32_mask(ASCCON_FDE
, 0, port
->membase
+ LTQ_ASC_CON
);
476 /* set up to use divisor of 2 */
477 ltq_w32_mask(ASCCON_BRS
, 0, port
->membase
+ LTQ_ASC_CON
);
479 /* now we can write the new baudrate into the register */
480 ltq_w32(divisor
, port
->membase
+ LTQ_ASC_BG
);
482 /* turn the baudrate generator back on */
483 ltq_w32_mask(0, ASCCON_R
, port
->membase
+ LTQ_ASC_CON
);
486 ltq_w32(ASCWHBSTATE_SETREN
, port
->membase
+ LTQ_ASC_WHBSTATE
);
488 spin_unlock_irqrestore(<q_asc_lock
, flags
);
490 /* Don't rewrite B0 */
491 if (tty_termios_baud_rate(new))
492 tty_termios_encode_baud_rate(new, baud
, baud
);
494 uart_update_timeout(port
, cflag
, baud
);
498 lqasc_type(struct uart_port
*port
)
500 if (port
->type
== PORT_LTQ_ASC
)
507 lqasc_release_port(struct uart_port
*port
)
509 if (port
->flags
& UPF_IOREMAP
) {
510 iounmap(port
->membase
);
511 port
->membase
= NULL
;
516 lqasc_request_port(struct uart_port
*port
)
518 struct platform_device
*pdev
= to_platform_device(port
->dev
);
519 struct resource
*res
;
522 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
524 dev_err(&pdev
->dev
, "cannot obtain I/O memory region");
527 size
= resource_size(res
);
529 res
= devm_request_mem_region(&pdev
->dev
, res
->start
,
530 size
, dev_name(&pdev
->dev
));
532 dev_err(&pdev
->dev
, "cannot request I/O memory region");
536 if (port
->flags
& UPF_IOREMAP
) {
537 port
->membase
= devm_ioremap_nocache(&pdev
->dev
,
538 port
->mapbase
, size
);
539 if (port
->membase
== NULL
)
546 lqasc_config_port(struct uart_port
*port
, int flags
)
548 if (flags
& UART_CONFIG_TYPE
) {
549 port
->type
= PORT_LTQ_ASC
;
550 lqasc_request_port(port
);
555 lqasc_verify_port(struct uart_port
*port
,
556 struct serial_struct
*ser
)
559 if (ser
->type
!= PORT_UNKNOWN
&& ser
->type
!= PORT_LTQ_ASC
)
561 if (ser
->irq
< 0 || ser
->irq
>= NR_IRQS
)
563 if (ser
->baud_base
< 9600)
568 static struct uart_ops lqasc_pops
= {
569 .tx_empty
= lqasc_tx_empty
,
570 .set_mctrl
= lqasc_set_mctrl
,
571 .get_mctrl
= lqasc_get_mctrl
,
572 .stop_tx
= lqasc_stop_tx
,
573 .start_tx
= lqasc_start_tx
,
574 .stop_rx
= lqasc_stop_rx
,
575 .enable_ms
= lqasc_enable_ms
,
576 .break_ctl
= lqasc_break_ctl
,
577 .startup
= lqasc_startup
,
578 .shutdown
= lqasc_shutdown
,
579 .set_termios
= lqasc_set_termios
,
581 .release_port
= lqasc_release_port
,
582 .request_port
= lqasc_request_port
,
583 .config_port
= lqasc_config_port
,
584 .verify_port
= lqasc_verify_port
,
588 lqasc_console_putchar(struct uart_port
*port
, int ch
)
596 fifofree
= (ltq_r32(port
->membase
+ LTQ_ASC_FSTAT
)
597 & ASCFSTAT_TXFREEMASK
) >> ASCFSTAT_TXFREEOFF
;
598 } while (fifofree
== 0);
599 ltq_w8(ch
, port
->membase
+ LTQ_ASC_TBUF
);
604 lqasc_console_write(struct console
*co
, const char *s
, u_int count
)
606 struct ltq_uart_port
*ltq_port
;
607 struct uart_port
*port
;
610 if (co
->index
>= MAXPORTS
)
613 ltq_port
= lqasc_port
[co
->index
];
617 port
= <q_port
->port
;
619 spin_lock_irqsave(<q_asc_lock
, flags
);
620 uart_console_write(port
, s
, count
, lqasc_console_putchar
);
621 spin_unlock_irqrestore(<q_asc_lock
, flags
);
625 lqasc_console_setup(struct console
*co
, char *options
)
627 struct ltq_uart_port
*ltq_port
;
628 struct uart_port
*port
;
634 if (co
->index
>= MAXPORTS
)
637 ltq_port
= lqasc_port
[co
->index
];
641 port
= <q_port
->port
;
643 port
->uartclk
= clk_get_rate(ltq_port
->fpiclk
);
646 uart_parse_options(options
, &baud
, &parity
, &bits
, &flow
);
647 return uart_set_options(port
, co
, baud
, parity
, bits
, flow
);
650 static struct console lqasc_console
= {
652 .write
= lqasc_console_write
,
653 .device
= uart_console_device
,
654 .setup
= lqasc_console_setup
,
655 .flags
= CON_PRINTBUFFER
,
661 lqasc_console_init(void)
663 register_console(&lqasc_console
);
666 console_initcall(lqasc_console_init
);
668 static struct uart_driver lqasc_reg
= {
669 .owner
= THIS_MODULE
,
670 .driver_name
= DRVNAME
,
671 .dev_name
= "ttyLTQ",
675 .cons
= &lqasc_console
,
679 lqasc_probe(struct platform_device
*pdev
)
681 struct device_node
*node
= pdev
->dev
.of_node
;
682 struct ltq_uart_port
*ltq_port
;
683 struct uart_port
*port
;
684 struct resource
*mmres
, irqres
[3];
688 mmres
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
689 ret
= of_irq_to_resource_table(node
, irqres
, 3);
690 if (!mmres
|| (ret
!= 3)) {
692 "failed to get memory/irq for serial port\n");
696 /* check if this is the console port */
697 if (mmres
->start
!= CPHYSADDR(LTQ_EARLY_ASC
))
700 if (lqasc_port
[line
]) {
701 dev_err(&pdev
->dev
, "port %d already allocated\n", line
);
705 ltq_port
= devm_kzalloc(&pdev
->dev
, sizeof(struct ltq_uart_port
),
710 port
= <q_port
->port
;
712 port
->iotype
= SERIAL_IO_MEM
;
713 port
->flags
= ASYNC_BOOT_AUTOCONF
| UPF_IOREMAP
;
714 port
->ops
= &lqasc_pops
;
716 port
->type
= PORT_LTQ_ASC
,
718 port
->dev
= &pdev
->dev
;
719 /* unused, just to be backward-compatible */
720 port
->irq
= irqres
[0].start
;
721 port
->mapbase
= mmres
->start
;
723 ltq_port
->fpiclk
= clk_get_fpi();
724 if (IS_ERR(ltq_port
->fpiclk
)) {
725 pr_err("failed to get fpi clk\n");
729 /* not all asc ports have clock gates, lets ignore the return code */
730 ltq_port
->clk
= clk_get(&pdev
->dev
, NULL
);
732 ltq_port
->tx_irq
= irqres
[0].start
;
733 ltq_port
->rx_irq
= irqres
[1].start
;
734 ltq_port
->err_irq
= irqres
[2].start
;
736 lqasc_port
[line
] = ltq_port
;
737 platform_set_drvdata(pdev
, ltq_port
);
739 ret
= uart_add_one_port(&lqasc_reg
, port
);
744 static const struct of_device_id ltq_asc_match
[] = {
745 { .compatible
= DRVNAME
},
748 MODULE_DEVICE_TABLE(of
, ltq_asc_match
);
750 static struct platform_driver lqasc_driver
= {
753 .owner
= THIS_MODULE
,
754 .of_match_table
= ltq_asc_match
,
763 ret
= uart_register_driver(&lqasc_reg
);
767 ret
= platform_driver_probe(&lqasc_driver
, lqasc_probe
);
769 uart_unregister_driver(&lqasc_reg
);
774 module_init(init_lqasc
);
776 MODULE_DESCRIPTION("Lantiq serial port driver");
777 MODULE_LICENSE("GPL");