1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * LiteUART serial controller (LiteX) Driver |
4 | * |
5 | * Copyright (C) 2019-2020 Antmicro <www.antmicro.com> |
6 | */ |
7 | |
8 | #include <linux/bits.h> |
9 | #include <linux/console.h> |
10 | #include <linux/interrupt.h> |
11 | #include <linux/litex.h> |
12 | #include <linux/module.h> |
13 | #include <linux/of.h> |
14 | #include <linux/platform_device.h> |
15 | #include <linux/serial.h> |
16 | #include <linux/serial_core.h> |
17 | #include <linux/slab.h> |
18 | #include <linux/timer.h> |
19 | #include <linux/tty_flip.h> |
20 | #include <linux/xarray.h> |
21 | |
22 | /* |
23 | * CSRs definitions (base address offsets + width) |
24 | * |
25 | * The definitions below are true for LiteX SoC configured for 8-bit CSR Bus, |
26 | * 32-bit aligned. |
27 | * |
28 | * Supporting other configurations might require new definitions or a more |
29 | * generic way of indexing the LiteX CSRs. |
30 | * |
31 | * For more details on how CSRs are defined and handled in LiteX, see comments |
32 | * in the LiteX SoC Driver: drivers/soc/litex/litex_soc_ctrl.c |
33 | */ |
34 | #define OFF_RXTX 0x00 |
35 | #define OFF_TXFULL 0x04 |
36 | #define OFF_RXEMPTY 0x08 |
37 | #define OFF_EV_STATUS 0x0c |
38 | #define OFF_EV_PENDING 0x10 |
39 | #define OFF_EV_ENABLE 0x14 |
40 | |
41 | /* events */ |
42 | #define EV_TX BIT(0) |
43 | #define EV_RX BIT(1) |
44 | |
45 | struct liteuart_port { |
46 | struct uart_port port; |
47 | struct timer_list timer; |
48 | u8 irq_reg; |
49 | }; |
50 | |
51 | #define to_liteuart_port(port) container_of(port, struct liteuart_port, port) |
52 | |
53 | static DEFINE_XARRAY_FLAGS(liteuart_array, XA_FLAGS_ALLOC); |
54 | |
55 | #ifdef CONFIG_SERIAL_LITEUART_CONSOLE |
56 | static struct console liteuart_console; |
57 | #endif |
58 | |
59 | static struct uart_driver liteuart_driver = { |
60 | .owner = THIS_MODULE, |
61 | .driver_name = KBUILD_MODNAME, |
62 | .dev_name = "ttyLXU" , |
63 | .major = 0, |
64 | .minor = 0, |
65 | .nr = CONFIG_SERIAL_LITEUART_MAX_PORTS, |
66 | #ifdef CONFIG_SERIAL_LITEUART_CONSOLE |
67 | .cons = &liteuart_console, |
68 | #endif |
69 | }; |
70 | |
71 | static void liteuart_update_irq_reg(struct uart_port *port, bool set, u8 mask) |
72 | { |
73 | struct liteuart_port *uart = to_liteuart_port(port); |
74 | |
75 | if (set) |
76 | uart->irq_reg |= mask; |
77 | else |
78 | uart->irq_reg &= ~mask; |
79 | |
80 | if (port->irq) |
81 | litex_write8(reg: port->membase + OFF_EV_ENABLE, val: uart->irq_reg); |
82 | } |
83 | |
84 | static void liteuart_stop_tx(struct uart_port *port) |
85 | { |
86 | liteuart_update_irq_reg(port, set: false, EV_TX); |
87 | } |
88 | |
89 | static void liteuart_start_tx(struct uart_port *port) |
90 | { |
91 | liteuart_update_irq_reg(port, set: true, EV_TX); |
92 | } |
93 | |
94 | static void liteuart_stop_rx(struct uart_port *port) |
95 | { |
96 | struct liteuart_port *uart = to_liteuart_port(port); |
97 | |
98 | /* just delete timer */ |
99 | del_timer(timer: &uart->timer); |
100 | } |
101 | |
102 | static void liteuart_rx_chars(struct uart_port *port) |
103 | { |
104 | unsigned char __iomem *membase = port->membase; |
105 | u8 ch; |
106 | |
107 | while (!litex_read8(reg: membase + OFF_RXEMPTY)) { |
108 | ch = litex_read8(reg: membase + OFF_RXTX); |
109 | port->icount.rx++; |
110 | |
111 | /* necessary for RXEMPTY to refresh its value */ |
112 | litex_write8(reg: membase + OFF_EV_PENDING, EV_RX); |
113 | |
114 | /* no overflow bits in status */ |
115 | if (!(uart_handle_sysrq_char(port, ch))) |
116 | uart_insert_char(port, status: 1, overrun: 0, ch, TTY_NORMAL); |
117 | } |
118 | |
119 | tty_flip_buffer_push(port: &port->state->port); |
120 | } |
121 | |
122 | static void liteuart_tx_chars(struct uart_port *port) |
123 | { |
124 | u8 ch; |
125 | |
126 | uart_port_tx(port, ch, |
127 | !litex_read8(port->membase + OFF_TXFULL), |
128 | litex_write8(port->membase + OFF_RXTX, ch)); |
129 | } |
130 | |
131 | static irqreturn_t liteuart_interrupt(int irq, void *data) |
132 | { |
133 | struct liteuart_port *uart = data; |
134 | struct uart_port *port = &uart->port; |
135 | unsigned long flags; |
136 | u8 isr; |
137 | |
138 | /* |
139 | * if polling, the context would be "in_serving_softirq", so use |
140 | * irq[save|restore] spin_lock variants to cover all possibilities |
141 | */ |
142 | uart_port_lock_irqsave(up: port, flags: &flags); |
143 | isr = litex_read8(reg: port->membase + OFF_EV_PENDING) & uart->irq_reg; |
144 | if (isr & EV_RX) |
145 | liteuart_rx_chars(port); |
146 | if (isr & EV_TX) |
147 | liteuart_tx_chars(port); |
148 | uart_port_unlock_irqrestore(up: port, flags); |
149 | |
150 | return IRQ_RETVAL(isr); |
151 | } |
152 | |
153 | static void liteuart_timer(struct timer_list *t) |
154 | { |
155 | struct liteuart_port *uart = from_timer(uart, t, timer); |
156 | struct uart_port *port = &uart->port; |
157 | |
158 | liteuart_interrupt(irq: 0, data: port); |
159 | mod_timer(timer: &uart->timer, expires: jiffies + uart_poll_timeout(port)); |
160 | } |
161 | |
162 | static unsigned int liteuart_tx_empty(struct uart_port *port) |
163 | { |
164 | /* not really tx empty, just checking if tx is not full */ |
165 | if (!litex_read8(reg: port->membase + OFF_TXFULL)) |
166 | return TIOCSER_TEMT; |
167 | |
168 | return 0; |
169 | } |
170 | |
171 | static void liteuart_set_mctrl(struct uart_port *port, unsigned int mctrl) |
172 | { |
173 | /* modem control register is not present in LiteUART */ |
174 | } |
175 | |
176 | static unsigned int liteuart_get_mctrl(struct uart_port *port) |
177 | { |
178 | return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR; |
179 | } |
180 | |
181 | static int liteuart_startup(struct uart_port *port) |
182 | { |
183 | struct liteuart_port *uart = to_liteuart_port(port); |
184 | unsigned long flags; |
185 | int ret; |
186 | |
187 | if (port->irq) { |
188 | ret = request_irq(irq: port->irq, handler: liteuart_interrupt, flags: 0, |
189 | KBUILD_MODNAME, dev: uart); |
190 | if (ret) { |
191 | dev_warn(port->dev, |
192 | "line %d irq %d failed: switch to polling\n" , |
193 | port->line, port->irq); |
194 | port->irq = 0; |
195 | } |
196 | } |
197 | |
198 | uart_port_lock_irqsave(up: port, flags: &flags); |
199 | /* only enabling rx irqs during startup */ |
200 | liteuart_update_irq_reg(port, set: true, EV_RX); |
201 | uart_port_unlock_irqrestore(up: port, flags); |
202 | |
203 | if (!port->irq) { |
204 | timer_setup(&uart->timer, liteuart_timer, 0); |
205 | mod_timer(timer: &uart->timer, expires: jiffies + uart_poll_timeout(port)); |
206 | } |
207 | |
208 | return 0; |
209 | } |
210 | |
211 | static void liteuart_shutdown(struct uart_port *port) |
212 | { |
213 | struct liteuart_port *uart = to_liteuart_port(port); |
214 | unsigned long flags; |
215 | |
216 | uart_port_lock_irqsave(up: port, flags: &flags); |
217 | liteuart_update_irq_reg(port, set: false, EV_RX | EV_TX); |
218 | uart_port_unlock_irqrestore(up: port, flags); |
219 | |
220 | if (port->irq) |
221 | free_irq(port->irq, port); |
222 | else |
223 | del_timer_sync(timer: &uart->timer); |
224 | } |
225 | |
226 | static void liteuart_set_termios(struct uart_port *port, struct ktermios *new, |
227 | const struct ktermios *old) |
228 | { |
229 | unsigned int baud; |
230 | unsigned long flags; |
231 | |
232 | uart_port_lock_irqsave(up: port, flags: &flags); |
233 | |
234 | /* update baudrate */ |
235 | baud = uart_get_baud_rate(port, termios: new, old, min: 0, max: 460800); |
236 | uart_update_timeout(port, cflag: new->c_cflag, baud); |
237 | |
238 | uart_port_unlock_irqrestore(up: port, flags); |
239 | } |
240 | |
241 | static const char *liteuart_type(struct uart_port *port) |
242 | { |
243 | return "liteuart" ; |
244 | } |
245 | |
246 | static void liteuart_config_port(struct uart_port *port, int flags) |
247 | { |
248 | /* |
249 | * Driver core for serial ports forces a non-zero value for port type. |
250 | * Write an arbitrary value here to accommodate the serial core driver, |
251 | * as ID part of UAPI is redundant. |
252 | */ |
253 | port->type = 1; |
254 | } |
255 | |
256 | static int liteuart_verify_port(struct uart_port *port, |
257 | struct serial_struct *ser) |
258 | { |
259 | if (port->type != PORT_UNKNOWN && ser->type != 1) |
260 | return -EINVAL; |
261 | |
262 | return 0; |
263 | } |
264 | |
265 | static const struct uart_ops liteuart_ops = { |
266 | .tx_empty = liteuart_tx_empty, |
267 | .set_mctrl = liteuart_set_mctrl, |
268 | .get_mctrl = liteuart_get_mctrl, |
269 | .stop_tx = liteuart_stop_tx, |
270 | .start_tx = liteuart_start_tx, |
271 | .stop_rx = liteuart_stop_rx, |
272 | .startup = liteuart_startup, |
273 | .shutdown = liteuart_shutdown, |
274 | .set_termios = liteuart_set_termios, |
275 | .type = liteuart_type, |
276 | .config_port = liteuart_config_port, |
277 | .verify_port = liteuart_verify_port, |
278 | }; |
279 | |
280 | static int liteuart_probe(struct platform_device *pdev) |
281 | { |
282 | struct liteuart_port *uart; |
283 | struct uart_port *port; |
284 | struct xa_limit limit; |
285 | int dev_id, ret; |
286 | |
287 | uart = devm_kzalloc(dev: &pdev->dev, size: sizeof(struct liteuart_port), GFP_KERNEL); |
288 | if (!uart) |
289 | return -ENOMEM; |
290 | |
291 | port = &uart->port; |
292 | |
293 | /* get membase */ |
294 | port->membase = devm_platform_get_and_ioremap_resource(pdev, index: 0, NULL); |
295 | if (IS_ERR(ptr: port->membase)) |
296 | return PTR_ERR(ptr: port->membase); |
297 | |
298 | ret = platform_get_irq_optional(pdev, 0); |
299 | if (ret < 0 && ret != -ENXIO) |
300 | return ret; |
301 | if (ret > 0) |
302 | port->irq = ret; |
303 | |
304 | /* look for aliases; auto-enumerate for free index if not found */ |
305 | dev_id = of_alias_get_id(np: pdev->dev.of_node, stem: "serial" ); |
306 | if (dev_id < 0) |
307 | limit = XA_LIMIT(0, CONFIG_SERIAL_LITEUART_MAX_PORTS); |
308 | else |
309 | limit = XA_LIMIT(dev_id, dev_id); |
310 | |
311 | ret = xa_alloc(xa: &liteuart_array, id: &dev_id, entry: uart, limit, GFP_KERNEL); |
312 | if (ret) |
313 | return ret; |
314 | |
315 | /* values not from device tree */ |
316 | port->dev = &pdev->dev; |
317 | port->iotype = UPIO_MEM; |
318 | port->flags = UPF_BOOT_AUTOCONF; |
319 | port->ops = &liteuart_ops; |
320 | port->fifosize = 16; |
321 | port->type = PORT_UNKNOWN; |
322 | port->line = dev_id; |
323 | spin_lock_init(&port->lock); |
324 | |
325 | platform_set_drvdata(pdev, data: port); |
326 | |
327 | ret = uart_add_one_port(reg: &liteuart_driver, port: &uart->port); |
328 | if (ret) |
329 | goto err_erase_id; |
330 | |
331 | return 0; |
332 | |
333 | err_erase_id: |
334 | xa_erase(&liteuart_array, index: dev_id); |
335 | |
336 | return ret; |
337 | } |
338 | |
339 | static void liteuart_remove(struct platform_device *pdev) |
340 | { |
341 | struct uart_port *port = platform_get_drvdata(pdev); |
342 | unsigned int line = port->line; |
343 | |
344 | uart_remove_one_port(reg: &liteuart_driver, port); |
345 | xa_erase(&liteuart_array, index: line); |
346 | } |
347 | |
348 | static const struct of_device_id liteuart_of_match[] = { |
349 | { .compatible = "litex,liteuart" }, |
350 | {} |
351 | }; |
352 | MODULE_DEVICE_TABLE(of, liteuart_of_match); |
353 | |
354 | static struct platform_driver liteuart_platform_driver = { |
355 | .probe = liteuart_probe, |
356 | .remove_new = liteuart_remove, |
357 | .driver = { |
358 | .name = KBUILD_MODNAME, |
359 | .of_match_table = liteuart_of_match, |
360 | }, |
361 | }; |
362 | |
363 | #ifdef CONFIG_SERIAL_LITEUART_CONSOLE |
364 | |
365 | static void liteuart_putchar(struct uart_port *port, unsigned char ch) |
366 | { |
367 | while (litex_read8(reg: port->membase + OFF_TXFULL)) |
368 | cpu_relax(); |
369 | |
370 | litex_write8(reg: port->membase + OFF_RXTX, val: ch); |
371 | } |
372 | |
373 | static void liteuart_console_write(struct console *co, const char *s, |
374 | unsigned int count) |
375 | { |
376 | struct liteuart_port *uart; |
377 | struct uart_port *port; |
378 | unsigned long flags; |
379 | |
380 | uart = (struct liteuart_port *)xa_load(&liteuart_array, index: co->index); |
381 | port = &uart->port; |
382 | |
383 | uart_port_lock_irqsave(up: port, flags: &flags); |
384 | uart_console_write(port, s, count, putchar: liteuart_putchar); |
385 | uart_port_unlock_irqrestore(up: port, flags); |
386 | } |
387 | |
388 | static int liteuart_console_setup(struct console *co, char *options) |
389 | { |
390 | struct liteuart_port *uart; |
391 | struct uart_port *port; |
392 | int baud = 115200; |
393 | int bits = 8; |
394 | int parity = 'n'; |
395 | int flow = 'n'; |
396 | |
397 | uart = (struct liteuart_port *)xa_load(&liteuart_array, index: co->index); |
398 | if (!uart) |
399 | return -ENODEV; |
400 | |
401 | port = &uart->port; |
402 | if (!port->membase) |
403 | return -ENODEV; |
404 | |
405 | if (options) |
406 | uart_parse_options(options, baud: &baud, parity: &parity, bits: &bits, flow: &flow); |
407 | |
408 | return uart_set_options(port, co, baud, parity, bits, flow); |
409 | } |
410 | |
411 | static struct console liteuart_console = { |
412 | .name = KBUILD_MODNAME, |
413 | .write = liteuart_console_write, |
414 | .device = uart_console_device, |
415 | .setup = liteuart_console_setup, |
416 | .flags = CON_PRINTBUFFER, |
417 | .index = -1, |
418 | .data = &liteuart_driver, |
419 | }; |
420 | |
421 | static int __init liteuart_console_init(void) |
422 | { |
423 | register_console(&liteuart_console); |
424 | |
425 | return 0; |
426 | } |
427 | console_initcall(liteuart_console_init); |
428 | |
429 | static void early_liteuart_write(struct console *console, const char *s, |
430 | unsigned int count) |
431 | { |
432 | struct earlycon_device *device = console->data; |
433 | struct uart_port *port = &device->port; |
434 | |
435 | uart_console_write(port, s, count, putchar: liteuart_putchar); |
436 | } |
437 | |
438 | static int __init early_liteuart_setup(struct earlycon_device *device, |
439 | const char *options) |
440 | { |
441 | if (!device->port.membase) |
442 | return -ENODEV; |
443 | |
444 | device->con->write = early_liteuart_write; |
445 | return 0; |
446 | } |
447 | |
448 | OF_EARLYCON_DECLARE(liteuart, "litex,liteuart" , early_liteuart_setup); |
449 | #endif /* CONFIG_SERIAL_LITEUART_CONSOLE */ |
450 | |
451 | static int __init liteuart_init(void) |
452 | { |
453 | int res; |
454 | |
455 | res = uart_register_driver(uart: &liteuart_driver); |
456 | if (res) |
457 | return res; |
458 | |
459 | res = platform_driver_register(&liteuart_platform_driver); |
460 | if (res) |
461 | uart_unregister_driver(uart: &liteuart_driver); |
462 | |
463 | return res; |
464 | } |
465 | |
466 | static void __exit liteuart_exit(void) |
467 | { |
468 | platform_driver_unregister(&liteuart_platform_driver); |
469 | uart_unregister_driver(uart: &liteuart_driver); |
470 | } |
471 | |
472 | module_init(liteuart_init); |
473 | module_exit(liteuart_exit); |
474 | |
475 | MODULE_AUTHOR("Antmicro <www.antmicro.com>" ); |
476 | MODULE_DESCRIPTION("LiteUART serial driver" ); |
477 | MODULE_LICENSE("GPL v2" ); |
478 | MODULE_ALIAS("platform:liteuart" ); |
479 | |