Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * MPS2 UART driver
4 *
5 * Copyright (C) 2015 ARM Limited
6 *
7 * Author: Vladimir Murzin <vladimir.murzin@arm.com>
8 *
9 * TODO: support for SysRq
10 */
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/bitops.h>
15#include <linux/clk.h>
16#include <linux/console.h>
17#include <linux/io.h>
18#include <linux/kernel.h>
19#include <linux/of.h>
20#include <linux/platform_device.h>
21#include <linux/serial_core.h>
22#include <linux/tty_flip.h>
23#include <linux/types.h>
24#include <linux/idr.h>
25
26#define SERIAL_NAME "ttyMPS"
27#define DRIVER_NAME "mps2-uart"
28#define MAKE_NAME(x) (DRIVER_NAME # x)
29
30#define UARTn_DATA 0x00
31
32#define UARTn_STATE 0x04
33#define UARTn_STATE_TX_FULL BIT(0)
34#define UARTn_STATE_RX_FULL BIT(1)
35#define UARTn_STATE_TX_OVERRUN BIT(2)
36#define UARTn_STATE_RX_OVERRUN BIT(3)
37
38#define UARTn_CTRL 0x08
39#define UARTn_CTRL_TX_ENABLE BIT(0)
40#define UARTn_CTRL_RX_ENABLE BIT(1)
41#define UARTn_CTRL_TX_INT_ENABLE BIT(2)
42#define UARTn_CTRL_RX_INT_ENABLE BIT(3)
43#define UARTn_CTRL_TX_OVERRUN_INT_ENABLE BIT(4)
44#define UARTn_CTRL_RX_OVERRUN_INT_ENABLE BIT(5)
45
46#define UARTn_INT 0x0c
47#define UARTn_INT_TX BIT(0)
48#define UARTn_INT_RX BIT(1)
49#define UARTn_INT_TX_OVERRUN BIT(2)
50#define UARTn_INT_RX_OVERRUN BIT(3)
51
52#define UARTn_BAUDDIV 0x10
53#define UARTn_BAUDDIV_MASK GENMASK(20, 0)
54
55/*
56 * Helpers to make typical enable/disable operations more readable.
57 */
58#define UARTn_CTRL_TX_GRP (UARTn_CTRL_TX_ENABLE |\
59 UARTn_CTRL_TX_INT_ENABLE |\
60 UARTn_CTRL_TX_OVERRUN_INT_ENABLE)
61
62#define UARTn_CTRL_RX_GRP (UARTn_CTRL_RX_ENABLE |\
63 UARTn_CTRL_RX_INT_ENABLE |\
64 UARTn_CTRL_RX_OVERRUN_INT_ENABLE)
65
66#define MPS2_MAX_PORTS 3
67
68#define UART_PORT_COMBINED_IRQ BIT(0)
69
70struct mps2_uart_port {
71 struct uart_port port;
72 struct clk *clk;
73 unsigned int tx_irq;
74 unsigned int rx_irq;
75 unsigned int flags;
76};
77
78static inline struct mps2_uart_port *to_mps2_port(struct uart_port *port)
79{
80 return container_of(port, struct mps2_uart_port, port);
81}
82
83static void mps2_uart_write8(struct uart_port *port, u8 val, unsigned int off)
84{
85 struct mps2_uart_port *mps_port = to_mps2_port(port);
86
87 writeb(val, mps_port->port.membase + off);
88}
89
90static u8 mps2_uart_read8(struct uart_port *port, unsigned int off)
91{
92 struct mps2_uart_port *mps_port = to_mps2_port(port);
93
94 return readb(mps_port->port.membase + off);
95}
96
97static void mps2_uart_write32(struct uart_port *port, u32 val, unsigned int off)
98{
99 struct mps2_uart_port *mps_port = to_mps2_port(port);
100
101 writel_relaxed(val, mps_port->port.membase + off);
102}
103
104static unsigned int mps2_uart_tx_empty(struct uart_port *port)
105{
106 u8 status = mps2_uart_read8(port, UARTn_STATE);
107
108 return (status & UARTn_STATE_TX_FULL) ? 0 : TIOCSER_TEMT;
109}
110
111static void mps2_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
112{
113}
114
115static unsigned int mps2_uart_get_mctrl(struct uart_port *port)
116{
117 return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR;
118}
119
120static void mps2_uart_stop_tx(struct uart_port *port)
121{
122 u8 control = mps2_uart_read8(port, UARTn_CTRL);
123
124 control &= ~UARTn_CTRL_TX_INT_ENABLE;
125
126 mps2_uart_write8(port, control, UARTn_CTRL);
127}
128
129static void mps2_uart_tx_chars(struct uart_port *port)
130{
131 u8 ch;
132
133 uart_port_tx(port, ch,
134 mps2_uart_tx_empty(port),
135 mps2_uart_write8(port, ch, UARTn_DATA));
136}
137
138static void mps2_uart_start_tx(struct uart_port *port)
139{
140 u8 control = mps2_uart_read8(port, UARTn_CTRL);
141
142 control |= UARTn_CTRL_TX_INT_ENABLE;
143
144 mps2_uart_write8(port, control, UARTn_CTRL);
145
146 /*
147 * We've just unmasked the TX IRQ and now slow-starting via
148 * polling; if there is enough data to fill up the internal
149 * write buffer in one go, the TX IRQ should assert, at which
150 * point we switch to fully interrupt-driven TX.
151 */
152
153 mps2_uart_tx_chars(port);
154}
155
156static void mps2_uart_stop_rx(struct uart_port *port)
157{
158 u8 control = mps2_uart_read8(port, UARTn_CTRL);
159
160 control &= ~UARTn_CTRL_RX_GRP;
161
162 mps2_uart_write8(port, control, UARTn_CTRL);
163}
164
165static void mps2_uart_break_ctl(struct uart_port *port, int ctl)
166{
167}
168
169static void mps2_uart_rx_chars(struct uart_port *port)
170{
171 struct tty_port *tport = &port->state->port;
172
173 while (mps2_uart_read8(port, UARTn_STATE) & UARTn_STATE_RX_FULL) {
174 u8 rxdata = mps2_uart_read8(port, UARTn_DATA);
175
176 port->icount.rx++;
177 tty_insert_flip_char(&port->state->port, rxdata, TTY_NORMAL);
178 }
179
180 tty_flip_buffer_push(tport);
181}
182
183static irqreturn_t mps2_uart_rxirq(int irq, void *data)
184{
185 struct uart_port *port = data;
186 u8 irqflag = mps2_uart_read8(port, UARTn_INT);
187
188 if (unlikely(!(irqflag & UARTn_INT_RX)))
189 return IRQ_NONE;
190
191 uart_port_lock(port);
192
193 mps2_uart_write8(port, UARTn_INT_RX, UARTn_INT);
194 mps2_uart_rx_chars(port);
195
196 uart_port_unlock(port);
197
198 return IRQ_HANDLED;
199}
200
201static irqreturn_t mps2_uart_txirq(int irq, void *data)
202{
203 struct uart_port *port = data;
204 u8 irqflag = mps2_uart_read8(port, UARTn_INT);
205
206 if (unlikely(!(irqflag & UARTn_INT_TX)))
207 return IRQ_NONE;
208
209 uart_port_lock(port);
210
211 mps2_uart_write8(port, UARTn_INT_TX, UARTn_INT);
212 mps2_uart_tx_chars(port);
213
214 uart_port_unlock(port);
215
216 return IRQ_HANDLED;
217}
218
219static irqreturn_t mps2_uart_oerrirq(int irq, void *data)
220{
221 irqreturn_t handled = IRQ_NONE;
222 struct uart_port *port = data;
223 u8 irqflag = mps2_uart_read8(port, UARTn_INT);
224
225 uart_port_lock(port);
226
227 if (irqflag & UARTn_INT_RX_OVERRUN) {
228 struct tty_port *tport = &port->state->port;
229
230 mps2_uart_write8(port, UARTn_INT_RX_OVERRUN, UARTn_INT);
231 port->icount.overrun++;
232 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
233 tty_flip_buffer_push(tport);
234 handled = IRQ_HANDLED;
235 }
236
237 /*
238 * It's never been seen in practice and it never *should* happen since
239 * we check if there is enough room in TX buffer before sending data.
240 * So we keep this check in case something suspicious has happened.
241 */
242 if (irqflag & UARTn_INT_TX_OVERRUN) {
243 mps2_uart_write8(port, UARTn_INT_TX_OVERRUN, UARTn_INT);
244 handled = IRQ_HANDLED;
245 }
246
247 uart_port_unlock(port);
248
249 return handled;
250}
251
252static irqreturn_t mps2_uart_combinedirq(int irq, void *data)
253{
254 if (mps2_uart_rxirq(irq, data) == IRQ_HANDLED)
255 return IRQ_HANDLED;
256
257 if (mps2_uart_txirq(irq, data) == IRQ_HANDLED)
258 return IRQ_HANDLED;
259
260 if (mps2_uart_oerrirq(irq, data) == IRQ_HANDLED)
261 return IRQ_HANDLED;
262
263 return IRQ_NONE;
264}
265
266static int mps2_uart_startup(struct uart_port *port)
267{
268 struct mps2_uart_port *mps_port = to_mps2_port(port);
269 u8 control = mps2_uart_read8(port, UARTn_CTRL);
270 int ret;
271
272 control &= ~(UARTn_CTRL_RX_GRP | UARTn_CTRL_TX_GRP);
273
274 mps2_uart_write8(port, control, UARTn_CTRL);
275
276 if (mps_port->flags & UART_PORT_COMBINED_IRQ) {
277 ret = request_irq(port->irq, mps2_uart_combinedirq, 0,
278 MAKE_NAME(-combined), mps_port);
279
280 if (ret) {
281 dev_err(port->dev, "failed to register combinedirq (%d)\n", ret);
282 return ret;
283 }
284 } else {
285 ret = request_irq(port->irq, mps2_uart_oerrirq, IRQF_SHARED,
286 MAKE_NAME(-overrun), mps_port);
287
288 if (ret) {
289 dev_err(port->dev, "failed to register oerrirq (%d)\n", ret);
290 return ret;
291 }
292
293 ret = request_irq(mps_port->rx_irq, mps2_uart_rxirq, 0,
294 MAKE_NAME(-rx), mps_port);
295 if (ret) {
296 dev_err(port->dev, "failed to register rxirq (%d)\n", ret);
297 goto err_free_oerrirq;
298 }
299
300 ret = request_irq(mps_port->tx_irq, mps2_uart_txirq, 0,
301 MAKE_NAME(-tx), mps_port);
302 if (ret) {
303 dev_err(port->dev, "failed to register txirq (%d)\n", ret);
304 goto err_free_rxirq;
305 }
306
307 }
308
309 control |= UARTn_CTRL_RX_GRP | UARTn_CTRL_TX_GRP;
310
311 mps2_uart_write8(port, control, UARTn_CTRL);
312
313 return 0;
314
315err_free_rxirq:
316 free_irq(mps_port->rx_irq, mps_port);
317err_free_oerrirq:
318 free_irq(port->irq, mps_port);
319
320 return ret;
321}
322
323static void mps2_uart_shutdown(struct uart_port *port)
324{
325 struct mps2_uart_port *mps_port = to_mps2_port(port);
326 u8 control = mps2_uart_read8(port, UARTn_CTRL);
327
328 control &= ~(UARTn_CTRL_RX_GRP | UARTn_CTRL_TX_GRP);
329
330 mps2_uart_write8(port, control, UARTn_CTRL);
331
332 if (!(mps_port->flags & UART_PORT_COMBINED_IRQ)) {
333 free_irq(mps_port->rx_irq, mps_port);
334 free_irq(mps_port->tx_irq, mps_port);
335 }
336
337 free_irq(port->irq, mps_port);
338}
339
340static void
341mps2_uart_set_termios(struct uart_port *port, struct ktermios *termios,
342 const struct ktermios *old)
343{
344 unsigned long flags;
345 unsigned int baud, bauddiv;
346
347 termios->c_cflag &= ~(CRTSCTS | CMSPAR);
348 termios->c_cflag &= ~CSIZE;
349 termios->c_cflag |= CS8;
350 termios->c_cflag &= ~PARENB;
351 termios->c_cflag &= ~CSTOPB;
352
353 baud = uart_get_baud_rate(port, termios, old,
354 DIV_ROUND_CLOSEST(port->uartclk, UARTn_BAUDDIV_MASK),
355 DIV_ROUND_CLOSEST(port->uartclk, 16));
356
357 bauddiv = DIV_ROUND_CLOSEST(port->uartclk, baud);
358
359 uart_port_lock_irqsave(port, &flags);
360
361 uart_update_timeout(port, termios->c_cflag, baud);
362 mps2_uart_write32(port, bauddiv, UARTn_BAUDDIV);
363
364 uart_port_unlock_irqrestore(port, flags);
365
366 if (tty_termios_baud_rate(termios))
367 tty_termios_encode_baud_rate(termios, baud, baud);
368}
369
370static const char *mps2_uart_type(struct uart_port *port)
371{
372 return (port->type == PORT_MPS2UART) ? DRIVER_NAME : NULL;
373}
374
375static void mps2_uart_release_port(struct uart_port *port)
376{
377}
378
379static int mps2_uart_request_port(struct uart_port *port)
380{
381 return 0;
382}
383
384static void mps2_uart_config_port(struct uart_port *port, int type)
385{
386 if (type & UART_CONFIG_TYPE && !mps2_uart_request_port(port))
387 port->type = PORT_MPS2UART;
388}
389
390static int mps2_uart_verify_port(struct uart_port *port, struct serial_struct *serinfo)
391{
392 return -EINVAL;
393}
394
395static const struct uart_ops mps2_uart_pops = {
396 .tx_empty = mps2_uart_tx_empty,
397 .set_mctrl = mps2_uart_set_mctrl,
398 .get_mctrl = mps2_uart_get_mctrl,
399 .stop_tx = mps2_uart_stop_tx,
400 .start_tx = mps2_uart_start_tx,
401 .stop_rx = mps2_uart_stop_rx,
402 .break_ctl = mps2_uart_break_ctl,
403 .startup = mps2_uart_startup,
404 .shutdown = mps2_uart_shutdown,
405 .set_termios = mps2_uart_set_termios,
406 .type = mps2_uart_type,
407 .release_port = mps2_uart_release_port,
408 .request_port = mps2_uart_request_port,
409 .config_port = mps2_uart_config_port,
410 .verify_port = mps2_uart_verify_port,
411};
412
413static DEFINE_IDR(ports_idr);
414
415#ifdef CONFIG_SERIAL_MPS2_UART_CONSOLE
416static void mps2_uart_console_putchar(struct uart_port *port, unsigned char ch)
417{
418 while (mps2_uart_read8(port, UARTn_STATE) & UARTn_STATE_TX_FULL)
419 cpu_relax();
420
421 mps2_uart_write8(port, ch, UARTn_DATA);
422}
423
424static void mps2_uart_console_write(struct console *co, const char *s, unsigned int cnt)
425{
426 struct mps2_uart_port *mps_port = idr_find(&ports_idr, co->index);
427 struct uart_port *port = &mps_port->port;
428
429 uart_console_write(port, s, cnt, mps2_uart_console_putchar);
430}
431
432static int mps2_uart_console_setup(struct console *co, char *options)
433{
434 struct mps2_uart_port *mps_port;
435 int baud = 9600;
436 int bits = 8;
437 int parity = 'n';
438 int flow = 'n';
439
440 if (co->index < 0 || co->index >= MPS2_MAX_PORTS)
441 return -ENODEV;
442
443 mps_port = idr_find(&ports_idr, co->index);
444
445 if (!mps_port)
446 return -ENODEV;
447
448 if (options)
449 uart_parse_options(options, &baud, &parity, &bits, &flow);
450
451 return uart_set_options(&mps_port->port, co, baud, parity, bits, flow);
452}
453
454static struct uart_driver mps2_uart_driver;
455
456static struct console mps2_uart_console = {
457 .name = SERIAL_NAME,
458 .device = uart_console_device,
459 .write = mps2_uart_console_write,
460 .setup = mps2_uart_console_setup,
461 .flags = CON_PRINTBUFFER,
462 .index = -1,
463 .data = &mps2_uart_driver,
464};
465
466#define MPS2_SERIAL_CONSOLE (&mps2_uart_console)
467
468static void mps2_early_putchar(struct uart_port *port, unsigned char ch)
469{
470 while (readb(port->membase + UARTn_STATE) & UARTn_STATE_TX_FULL)
471 cpu_relax();
472
473 writeb((unsigned char)ch, port->membase + UARTn_DATA);
474}
475
476static void mps2_early_write(struct console *con, const char *s, unsigned int n)
477{
478 struct earlycon_device *dev = con->data;
479
480 uart_console_write(&dev->port, s, n, mps2_early_putchar);
481}
482
483static int __init mps2_early_console_setup(struct earlycon_device *device,
484 const char *opt)
485{
486 if (!device->port.membase)
487 return -ENODEV;
488
489 device->con->write = mps2_early_write;
490
491 return 0;
492}
493
494OF_EARLYCON_DECLARE(mps2, "arm,mps2-uart", mps2_early_console_setup);
495
496#else
497#define MPS2_SERIAL_CONSOLE NULL
498#endif
499
500static struct uart_driver mps2_uart_driver = {
501 .driver_name = DRIVER_NAME,
502 .dev_name = SERIAL_NAME,
503 .nr = MPS2_MAX_PORTS,
504 .cons = MPS2_SERIAL_CONSOLE,
505};
506
507static int mps2_of_get_port(struct platform_device *pdev,
508 struct mps2_uart_port *mps_port)
509{
510 struct device_node *np = pdev->dev.of_node;
511 int id;
512
513 if (!np)
514 return -ENODEV;
515
516 id = of_alias_get_id(np, "serial");
517
518 if (id < 0)
519 id = idr_alloc_cyclic(&ports_idr, (void *)mps_port, 0, MPS2_MAX_PORTS, GFP_KERNEL);
520 else
521 id = idr_alloc(&ports_idr, (void *)mps_port, id, MPS2_MAX_PORTS, GFP_KERNEL);
522
523 if (id < 0)
524 return id;
525
526 /* Only combined irq is presesnt */
527 if (platform_irq_count(pdev) == 1)
528 mps_port->flags |= UART_PORT_COMBINED_IRQ;
529
530 mps_port->port.line = id;
531
532 return 0;
533}
534
535static int mps2_init_port(struct platform_device *pdev,
536 struct mps2_uart_port *mps_port)
537{
538 struct resource *res;
539 int ret;
540
541 mps_port->port.membase = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
542 if (IS_ERR(mps_port->port.membase))
543 return PTR_ERR(mps_port->port.membase);
544
545 mps_port->port.mapbase = res->start;
546 mps_port->port.mapsize = resource_size(res);
547 mps_port->port.iotype = UPIO_MEM;
548 mps_port->port.flags = UPF_BOOT_AUTOCONF;
549 mps_port->port.fifosize = 1;
550 mps_port->port.ops = &mps2_uart_pops;
551 mps_port->port.dev = &pdev->dev;
552
553 mps_port->clk = devm_clk_get(&pdev->dev, NULL);
554 if (IS_ERR(mps_port->clk))
555 return PTR_ERR(mps_port->clk);
556
557 ret = clk_prepare_enable(mps_port->clk);
558 if (ret)
559 return ret;
560
561 mps_port->port.uartclk = clk_get_rate(mps_port->clk);
562
563 clk_disable_unprepare(mps_port->clk);
564
565
566 if (mps_port->flags & UART_PORT_COMBINED_IRQ) {
567 mps_port->port.irq = platform_get_irq(pdev, 0);
568 } else {
569 mps_port->rx_irq = platform_get_irq(pdev, 0);
570 mps_port->tx_irq = platform_get_irq(pdev, 1);
571 mps_port->port.irq = platform_get_irq(pdev, 2);
572 }
573
574 return ret;
575}
576
577static int mps2_serial_probe(struct platform_device *pdev)
578{
579 struct mps2_uart_port *mps_port;
580 int ret;
581
582 mps_port = devm_kzalloc(&pdev->dev, sizeof(struct mps2_uart_port), GFP_KERNEL);
583
584 if (!mps_port)
585 return -ENOMEM;
586
587 ret = mps2_of_get_port(pdev, mps_port);
588 if (ret)
589 return ret;
590
591 ret = mps2_init_port(pdev, mps_port);
592 if (ret)
593 return ret;
594
595 ret = uart_add_one_port(&mps2_uart_driver, &mps_port->port);
596 if (ret)
597 return ret;
598
599 platform_set_drvdata(pdev, mps_port);
600
601 return 0;
602}
603
604#ifdef CONFIG_OF
605static const struct of_device_id mps2_match[] = {
606 { .compatible = "arm,mps2-uart", },
607 {},
608};
609#endif
610
611static struct platform_driver mps2_serial_driver = {
612 .probe = mps2_serial_probe,
613
614 .driver = {
615 .name = DRIVER_NAME,
616 .of_match_table = of_match_ptr(mps2_match),
617 .suppress_bind_attrs = true,
618 },
619};
620
621static int __init mps2_uart_init(void)
622{
623 int ret;
624
625 ret = uart_register_driver(&mps2_uart_driver);
626 if (ret)
627 return ret;
628
629 ret = platform_driver_register(&mps2_serial_driver);
630 if (ret)
631 uart_unregister_driver(&mps2_uart_driver);
632
633 return ret;
634}
635arch_initcall(mps2_uart_init);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * MPS2 UART driver
4 *
5 * Copyright (C) 2015 ARM Limited
6 *
7 * Author: Vladimir Murzin <vladimir.murzin@arm.com>
8 *
9 * TODO: support for SysRq
10 */
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/bitops.h>
15#include <linux/clk.h>
16#include <linux/console.h>
17#include <linux/io.h>
18#include <linux/kernel.h>
19#include <linux/of_device.h>
20#include <linux/of.h>
21#include <linux/platform_device.h>
22#include <linux/serial_core.h>
23#include <linux/tty_flip.h>
24#include <linux/types.h>
25#include <linux/idr.h>
26
27#define SERIAL_NAME "ttyMPS"
28#define DRIVER_NAME "mps2-uart"
29#define MAKE_NAME(x) (DRIVER_NAME # x)
30
31#define UARTn_DATA 0x00
32
33#define UARTn_STATE 0x04
34#define UARTn_STATE_TX_FULL BIT(0)
35#define UARTn_STATE_RX_FULL BIT(1)
36#define UARTn_STATE_TX_OVERRUN BIT(2)
37#define UARTn_STATE_RX_OVERRUN BIT(3)
38
39#define UARTn_CTRL 0x08
40#define UARTn_CTRL_TX_ENABLE BIT(0)
41#define UARTn_CTRL_RX_ENABLE BIT(1)
42#define UARTn_CTRL_TX_INT_ENABLE BIT(2)
43#define UARTn_CTRL_RX_INT_ENABLE BIT(3)
44#define UARTn_CTRL_TX_OVERRUN_INT_ENABLE BIT(4)
45#define UARTn_CTRL_RX_OVERRUN_INT_ENABLE BIT(5)
46
47#define UARTn_INT 0x0c
48#define UARTn_INT_TX BIT(0)
49#define UARTn_INT_RX BIT(1)
50#define UARTn_INT_TX_OVERRUN BIT(2)
51#define UARTn_INT_RX_OVERRUN BIT(3)
52
53#define UARTn_BAUDDIV 0x10
54#define UARTn_BAUDDIV_MASK GENMASK(20, 0)
55
56/*
57 * Helpers to make typical enable/disable operations more readable.
58 */
59#define UARTn_CTRL_TX_GRP (UARTn_CTRL_TX_ENABLE |\
60 UARTn_CTRL_TX_INT_ENABLE |\
61 UARTn_CTRL_TX_OVERRUN_INT_ENABLE)
62
63#define UARTn_CTRL_RX_GRP (UARTn_CTRL_RX_ENABLE |\
64 UARTn_CTRL_RX_INT_ENABLE |\
65 UARTn_CTRL_RX_OVERRUN_INT_ENABLE)
66
67#define MPS2_MAX_PORTS 3
68
69#define UART_PORT_COMBINED_IRQ BIT(0)
70
71struct mps2_uart_port {
72 struct uart_port port;
73 struct clk *clk;
74 unsigned int tx_irq;
75 unsigned int rx_irq;
76 unsigned int flags;
77};
78
79static inline struct mps2_uart_port *to_mps2_port(struct uart_port *port)
80{
81 return container_of(port, struct mps2_uart_port, port);
82}
83
84static void mps2_uart_write8(struct uart_port *port, u8 val, unsigned int off)
85{
86 struct mps2_uart_port *mps_port = to_mps2_port(port);
87
88 writeb(val, mps_port->port.membase + off);
89}
90
91static u8 mps2_uart_read8(struct uart_port *port, unsigned int off)
92{
93 struct mps2_uart_port *mps_port = to_mps2_port(port);
94
95 return readb(mps_port->port.membase + off);
96}
97
98static void mps2_uart_write32(struct uart_port *port, u32 val, unsigned int off)
99{
100 struct mps2_uart_port *mps_port = to_mps2_port(port);
101
102 writel_relaxed(val, mps_port->port.membase + off);
103}
104
105static unsigned int mps2_uart_tx_empty(struct uart_port *port)
106{
107 u8 status = mps2_uart_read8(port, UARTn_STATE);
108
109 return (status & UARTn_STATE_TX_FULL) ? 0 : TIOCSER_TEMT;
110}
111
112static void mps2_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
113{
114}
115
116static unsigned int mps2_uart_get_mctrl(struct uart_port *port)
117{
118 return TIOCM_CAR | TIOCM_CTS | TIOCM_DSR;
119}
120
121static void mps2_uart_stop_tx(struct uart_port *port)
122{
123 u8 control = mps2_uart_read8(port, UARTn_CTRL);
124
125 control &= ~UARTn_CTRL_TX_INT_ENABLE;
126
127 mps2_uart_write8(port, control, UARTn_CTRL);
128}
129
130static void mps2_uart_tx_chars(struct uart_port *port)
131{
132 u8 ch;
133
134 uart_port_tx(port, ch,
135 mps2_uart_tx_empty(port),
136 mps2_uart_write8(port, ch, UARTn_DATA));
137}
138
139static void mps2_uart_start_tx(struct uart_port *port)
140{
141 u8 control = mps2_uart_read8(port, UARTn_CTRL);
142
143 control |= UARTn_CTRL_TX_INT_ENABLE;
144
145 mps2_uart_write8(port, control, UARTn_CTRL);
146
147 /*
148 * We've just unmasked the TX IRQ and now slow-starting via
149 * polling; if there is enough data to fill up the internal
150 * write buffer in one go, the TX IRQ should assert, at which
151 * point we switch to fully interrupt-driven TX.
152 */
153
154 mps2_uart_tx_chars(port);
155}
156
157static void mps2_uart_stop_rx(struct uart_port *port)
158{
159 u8 control = mps2_uart_read8(port, UARTn_CTRL);
160
161 control &= ~UARTn_CTRL_RX_GRP;
162
163 mps2_uart_write8(port, control, UARTn_CTRL);
164}
165
166static void mps2_uart_break_ctl(struct uart_port *port, int ctl)
167{
168}
169
170static void mps2_uart_rx_chars(struct uart_port *port)
171{
172 struct tty_port *tport = &port->state->port;
173
174 while (mps2_uart_read8(port, UARTn_STATE) & UARTn_STATE_RX_FULL) {
175 u8 rxdata = mps2_uart_read8(port, UARTn_DATA);
176
177 port->icount.rx++;
178 tty_insert_flip_char(&port->state->port, rxdata, TTY_NORMAL);
179 }
180
181 tty_flip_buffer_push(tport);
182}
183
184static irqreturn_t mps2_uart_rxirq(int irq, void *data)
185{
186 struct uart_port *port = data;
187 u8 irqflag = mps2_uart_read8(port, UARTn_INT);
188
189 if (unlikely(!(irqflag & UARTn_INT_RX)))
190 return IRQ_NONE;
191
192 spin_lock(&port->lock);
193
194 mps2_uart_write8(port, UARTn_INT_RX, UARTn_INT);
195 mps2_uart_rx_chars(port);
196
197 spin_unlock(&port->lock);
198
199 return IRQ_HANDLED;
200}
201
202static irqreturn_t mps2_uart_txirq(int irq, void *data)
203{
204 struct uart_port *port = data;
205 u8 irqflag = mps2_uart_read8(port, UARTn_INT);
206
207 if (unlikely(!(irqflag & UARTn_INT_TX)))
208 return IRQ_NONE;
209
210 spin_lock(&port->lock);
211
212 mps2_uart_write8(port, UARTn_INT_TX, UARTn_INT);
213 mps2_uart_tx_chars(port);
214
215 spin_unlock(&port->lock);
216
217 return IRQ_HANDLED;
218}
219
220static irqreturn_t mps2_uart_oerrirq(int irq, void *data)
221{
222 irqreturn_t handled = IRQ_NONE;
223 struct uart_port *port = data;
224 u8 irqflag = mps2_uart_read8(port, UARTn_INT);
225
226 spin_lock(&port->lock);
227
228 if (irqflag & UARTn_INT_RX_OVERRUN) {
229 struct tty_port *tport = &port->state->port;
230
231 mps2_uart_write8(port, UARTn_INT_RX_OVERRUN, UARTn_INT);
232 port->icount.overrun++;
233 tty_insert_flip_char(tport, 0, TTY_OVERRUN);
234 tty_flip_buffer_push(tport);
235 handled = IRQ_HANDLED;
236 }
237
238 /*
239 * It's never been seen in practice and it never *should* happen since
240 * we check if there is enough room in TX buffer before sending data.
241 * So we keep this check in case something suspicious has happened.
242 */
243 if (irqflag & UARTn_INT_TX_OVERRUN) {
244 mps2_uart_write8(port, UARTn_INT_TX_OVERRUN, UARTn_INT);
245 handled = IRQ_HANDLED;
246 }
247
248 spin_unlock(&port->lock);
249
250 return handled;
251}
252
253static irqreturn_t mps2_uart_combinedirq(int irq, void *data)
254{
255 if (mps2_uart_rxirq(irq, data) == IRQ_HANDLED)
256 return IRQ_HANDLED;
257
258 if (mps2_uart_txirq(irq, data) == IRQ_HANDLED)
259 return IRQ_HANDLED;
260
261 if (mps2_uart_oerrirq(irq, data) == IRQ_HANDLED)
262 return IRQ_HANDLED;
263
264 return IRQ_NONE;
265}
266
267static int mps2_uart_startup(struct uart_port *port)
268{
269 struct mps2_uart_port *mps_port = to_mps2_port(port);
270 u8 control = mps2_uart_read8(port, UARTn_CTRL);
271 int ret;
272
273 control &= ~(UARTn_CTRL_RX_GRP | UARTn_CTRL_TX_GRP);
274
275 mps2_uart_write8(port, control, UARTn_CTRL);
276
277 if (mps_port->flags & UART_PORT_COMBINED_IRQ) {
278 ret = request_irq(port->irq, mps2_uart_combinedirq, 0,
279 MAKE_NAME(-combined), mps_port);
280
281 if (ret) {
282 dev_err(port->dev, "failed to register combinedirq (%d)\n", ret);
283 return ret;
284 }
285 } else {
286 ret = request_irq(port->irq, mps2_uart_oerrirq, IRQF_SHARED,
287 MAKE_NAME(-overrun), mps_port);
288
289 if (ret) {
290 dev_err(port->dev, "failed to register oerrirq (%d)\n", ret);
291 return ret;
292 }
293
294 ret = request_irq(mps_port->rx_irq, mps2_uart_rxirq, 0,
295 MAKE_NAME(-rx), mps_port);
296 if (ret) {
297 dev_err(port->dev, "failed to register rxirq (%d)\n", ret);
298 goto err_free_oerrirq;
299 }
300
301 ret = request_irq(mps_port->tx_irq, mps2_uart_txirq, 0,
302 MAKE_NAME(-tx), mps_port);
303 if (ret) {
304 dev_err(port->dev, "failed to register txirq (%d)\n", ret);
305 goto err_free_rxirq;
306 }
307
308 }
309
310 control |= UARTn_CTRL_RX_GRP | UARTn_CTRL_TX_GRP;
311
312 mps2_uart_write8(port, control, UARTn_CTRL);
313
314 return 0;
315
316err_free_rxirq:
317 free_irq(mps_port->rx_irq, mps_port);
318err_free_oerrirq:
319 free_irq(port->irq, mps_port);
320
321 return ret;
322}
323
324static void mps2_uart_shutdown(struct uart_port *port)
325{
326 struct mps2_uart_port *mps_port = to_mps2_port(port);
327 u8 control = mps2_uart_read8(port, UARTn_CTRL);
328
329 control &= ~(UARTn_CTRL_RX_GRP | UARTn_CTRL_TX_GRP);
330
331 mps2_uart_write8(port, control, UARTn_CTRL);
332
333 if (!(mps_port->flags & UART_PORT_COMBINED_IRQ)) {
334 free_irq(mps_port->rx_irq, mps_port);
335 free_irq(mps_port->tx_irq, mps_port);
336 }
337
338 free_irq(port->irq, mps_port);
339}
340
341static void
342mps2_uart_set_termios(struct uart_port *port, struct ktermios *termios,
343 const struct ktermios *old)
344{
345 unsigned long flags;
346 unsigned int baud, bauddiv;
347
348 termios->c_cflag &= ~(CRTSCTS | CMSPAR);
349 termios->c_cflag &= ~CSIZE;
350 termios->c_cflag |= CS8;
351 termios->c_cflag &= ~PARENB;
352 termios->c_cflag &= ~CSTOPB;
353
354 baud = uart_get_baud_rate(port, termios, old,
355 DIV_ROUND_CLOSEST(port->uartclk, UARTn_BAUDDIV_MASK),
356 DIV_ROUND_CLOSEST(port->uartclk, 16));
357
358 bauddiv = DIV_ROUND_CLOSEST(port->uartclk, baud);
359
360 spin_lock_irqsave(&port->lock, flags);
361
362 uart_update_timeout(port, termios->c_cflag, baud);
363 mps2_uart_write32(port, bauddiv, UARTn_BAUDDIV);
364
365 spin_unlock_irqrestore(&port->lock, flags);
366
367 if (tty_termios_baud_rate(termios))
368 tty_termios_encode_baud_rate(termios, baud, baud);
369}
370
371static const char *mps2_uart_type(struct uart_port *port)
372{
373 return (port->type == PORT_MPS2UART) ? DRIVER_NAME : NULL;
374}
375
376static void mps2_uart_release_port(struct uart_port *port)
377{
378}
379
380static int mps2_uart_request_port(struct uart_port *port)
381{
382 return 0;
383}
384
385static void mps2_uart_config_port(struct uart_port *port, int type)
386{
387 if (type & UART_CONFIG_TYPE && !mps2_uart_request_port(port))
388 port->type = PORT_MPS2UART;
389}
390
391static int mps2_uart_verify_port(struct uart_port *port, struct serial_struct *serinfo)
392{
393 return -EINVAL;
394}
395
396static const struct uart_ops mps2_uart_pops = {
397 .tx_empty = mps2_uart_tx_empty,
398 .set_mctrl = mps2_uart_set_mctrl,
399 .get_mctrl = mps2_uart_get_mctrl,
400 .stop_tx = mps2_uart_stop_tx,
401 .start_tx = mps2_uart_start_tx,
402 .stop_rx = mps2_uart_stop_rx,
403 .break_ctl = mps2_uart_break_ctl,
404 .startup = mps2_uart_startup,
405 .shutdown = mps2_uart_shutdown,
406 .set_termios = mps2_uart_set_termios,
407 .type = mps2_uart_type,
408 .release_port = mps2_uart_release_port,
409 .request_port = mps2_uart_request_port,
410 .config_port = mps2_uart_config_port,
411 .verify_port = mps2_uart_verify_port,
412};
413
414static DEFINE_IDR(ports_idr);
415
416#ifdef CONFIG_SERIAL_MPS2_UART_CONSOLE
417static void mps2_uart_console_putchar(struct uart_port *port, unsigned char ch)
418{
419 while (mps2_uart_read8(port, UARTn_STATE) & UARTn_STATE_TX_FULL)
420 cpu_relax();
421
422 mps2_uart_write8(port, ch, UARTn_DATA);
423}
424
425static void mps2_uart_console_write(struct console *co, const char *s, unsigned int cnt)
426{
427 struct mps2_uart_port *mps_port = idr_find(&ports_idr, co->index);
428 struct uart_port *port = &mps_port->port;
429
430 uart_console_write(port, s, cnt, mps2_uart_console_putchar);
431}
432
433static int mps2_uart_console_setup(struct console *co, char *options)
434{
435 struct mps2_uart_port *mps_port;
436 int baud = 9600;
437 int bits = 8;
438 int parity = 'n';
439 int flow = 'n';
440
441 if (co->index < 0 || co->index >= MPS2_MAX_PORTS)
442 return -ENODEV;
443
444 mps_port = idr_find(&ports_idr, co->index);
445
446 if (!mps_port)
447 return -ENODEV;
448
449 if (options)
450 uart_parse_options(options, &baud, &parity, &bits, &flow);
451
452 return uart_set_options(&mps_port->port, co, baud, parity, bits, flow);
453}
454
455static struct uart_driver mps2_uart_driver;
456
457static struct console mps2_uart_console = {
458 .name = SERIAL_NAME,
459 .device = uart_console_device,
460 .write = mps2_uart_console_write,
461 .setup = mps2_uart_console_setup,
462 .flags = CON_PRINTBUFFER,
463 .index = -1,
464 .data = &mps2_uart_driver,
465};
466
467#define MPS2_SERIAL_CONSOLE (&mps2_uart_console)
468
469static void mps2_early_putchar(struct uart_port *port, unsigned char ch)
470{
471 while (readb(port->membase + UARTn_STATE) & UARTn_STATE_TX_FULL)
472 cpu_relax();
473
474 writeb((unsigned char)ch, port->membase + UARTn_DATA);
475}
476
477static void mps2_early_write(struct console *con, const char *s, unsigned int n)
478{
479 struct earlycon_device *dev = con->data;
480
481 uart_console_write(&dev->port, s, n, mps2_early_putchar);
482}
483
484static int __init mps2_early_console_setup(struct earlycon_device *device,
485 const char *opt)
486{
487 if (!device->port.membase)
488 return -ENODEV;
489
490 device->con->write = mps2_early_write;
491
492 return 0;
493}
494
495OF_EARLYCON_DECLARE(mps2, "arm,mps2-uart", mps2_early_console_setup);
496
497#else
498#define MPS2_SERIAL_CONSOLE NULL
499#endif
500
501static struct uart_driver mps2_uart_driver = {
502 .driver_name = DRIVER_NAME,
503 .dev_name = SERIAL_NAME,
504 .nr = MPS2_MAX_PORTS,
505 .cons = MPS2_SERIAL_CONSOLE,
506};
507
508static int mps2_of_get_port(struct platform_device *pdev,
509 struct mps2_uart_port *mps_port)
510{
511 struct device_node *np = pdev->dev.of_node;
512 int id;
513
514 if (!np)
515 return -ENODEV;
516
517 id = of_alias_get_id(np, "serial");
518
519 if (id < 0)
520 id = idr_alloc_cyclic(&ports_idr, (void *)mps_port, 0, MPS2_MAX_PORTS, GFP_KERNEL);
521 else
522 id = idr_alloc(&ports_idr, (void *)mps_port, id, MPS2_MAX_PORTS, GFP_KERNEL);
523
524 if (id < 0)
525 return id;
526
527 /* Only combined irq is presesnt */
528 if (platform_irq_count(pdev) == 1)
529 mps_port->flags |= UART_PORT_COMBINED_IRQ;
530
531 mps_port->port.line = id;
532
533 return 0;
534}
535
536static int mps2_init_port(struct platform_device *pdev,
537 struct mps2_uart_port *mps_port)
538{
539 struct resource *res;
540 int ret;
541
542 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
543 mps_port->port.membase = devm_ioremap_resource(&pdev->dev, res);
544 if (IS_ERR(mps_port->port.membase))
545 return PTR_ERR(mps_port->port.membase);
546
547 mps_port->port.mapbase = res->start;
548 mps_port->port.mapsize = resource_size(res);
549 mps_port->port.iotype = UPIO_MEM;
550 mps_port->port.flags = UPF_BOOT_AUTOCONF;
551 mps_port->port.fifosize = 1;
552 mps_port->port.ops = &mps2_uart_pops;
553 mps_port->port.dev = &pdev->dev;
554
555 mps_port->clk = devm_clk_get(&pdev->dev, NULL);
556 if (IS_ERR(mps_port->clk))
557 return PTR_ERR(mps_port->clk);
558
559 ret = clk_prepare_enable(mps_port->clk);
560 if (ret)
561 return ret;
562
563 mps_port->port.uartclk = clk_get_rate(mps_port->clk);
564
565 clk_disable_unprepare(mps_port->clk);
566
567
568 if (mps_port->flags & UART_PORT_COMBINED_IRQ) {
569 mps_port->port.irq = platform_get_irq(pdev, 0);
570 } else {
571 mps_port->rx_irq = platform_get_irq(pdev, 0);
572 mps_port->tx_irq = platform_get_irq(pdev, 1);
573 mps_port->port.irq = platform_get_irq(pdev, 2);
574 }
575
576 return ret;
577}
578
579static int mps2_serial_probe(struct platform_device *pdev)
580{
581 struct mps2_uart_port *mps_port;
582 int ret;
583
584 mps_port = devm_kzalloc(&pdev->dev, sizeof(struct mps2_uart_port), GFP_KERNEL);
585
586 if (!mps_port)
587 return -ENOMEM;
588
589 ret = mps2_of_get_port(pdev, mps_port);
590 if (ret)
591 return ret;
592
593 ret = mps2_init_port(pdev, mps_port);
594 if (ret)
595 return ret;
596
597 ret = uart_add_one_port(&mps2_uart_driver, &mps_port->port);
598 if (ret)
599 return ret;
600
601 platform_set_drvdata(pdev, mps_port);
602
603 return 0;
604}
605
606#ifdef CONFIG_OF
607static const struct of_device_id mps2_match[] = {
608 { .compatible = "arm,mps2-uart", },
609 {},
610};
611#endif
612
613static struct platform_driver mps2_serial_driver = {
614 .probe = mps2_serial_probe,
615
616 .driver = {
617 .name = DRIVER_NAME,
618 .of_match_table = of_match_ptr(mps2_match),
619 .suppress_bind_attrs = true,
620 },
621};
622
623static int __init mps2_uart_init(void)
624{
625 int ret;
626
627 ret = uart_register_driver(&mps2_uart_driver);
628 if (ret)
629 return ret;
630
631 ret = platform_driver_register(&mps2_serial_driver);
632 if (ret)
633 uart_unregister_driver(&mps2_uart_driver);
634
635 return ret;
636}
637arch_initcall(mps2_uart_init);