xref: /linux/drivers/tty/serial/liteuart.c (revision 24168c5e6dfbdd5b414f048f47f75d64533296ca) 
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(port->membase + OFF_EV_ENABLE, uart->irq_reg);
82 }
83 
84 static void liteuart_stop_tx(struct uart_port *port)
85 {
86 	liteuart_update_irq_reg(port, false, EV_TX);
87 }
88 
89 static void liteuart_start_tx(struct uart_port *port)
90 {
91 	liteuart_update_irq_reg(port, 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(&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(membase + OFF_RXEMPTY)) {
108 		ch = litex_read8(membase + OFF_RXTX);
109 		port->icount.rx++;
110 
111 		/* necessary for RXEMPTY to refresh its value */
112 		litex_write8(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, 1, 0, ch, TTY_NORMAL);
117 	}
118 
119 	tty_flip_buffer_push(&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(port, &flags);
143 	isr = litex_read8(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(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(0, port);
159 	mod_timer(&uart->timer, 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(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(port->irq, liteuart_interrupt, 0,
189 				  KBUILD_MODNAME, 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(port, &flags);
199 	/* only enabling rx irqs during startup */
200 	liteuart_update_irq_reg(port, true, EV_RX);
201 	uart_port_unlock_irqrestore(port, flags);
202 
203 	if (!port->irq) {
204 		timer_setup(&uart->timer, liteuart_timer, 0);
205 		mod_timer(&uart->timer, 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(port, &flags);
217 	liteuart_update_irq_reg(port, false, EV_RX | EV_TX);
218 	uart_port_unlock_irqrestore(port, flags);
219 
220 	if (port->irq)
221 		free_irq(port->irq, port);
222 	else
223 		del_timer_sync(&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(port, &flags);
233 
234 	/* update baudrate */
235 	baud = uart_get_baud_rate(port, new, old, 0, 460800);
236 	uart_update_timeout(port, new->c_cflag, baud);
237 
238 	uart_port_unlock_irqrestore(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(&pdev->dev, 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, 0, NULL);
295 	if (IS_ERR(port->membase))
296 		return PTR_ERR(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(pdev->dev.of_node, "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(&liteuart_array, &dev_id, 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, port);
326 
327 	ret = uart_add_one_port(&liteuart_driver, &uart->port);
328 	if (ret)
329 		goto err_erase_id;
330 
331 	return 0;
332 
333 err_erase_id:
334 	xa_erase(&liteuart_array, 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(&liteuart_driver, port);
345 	xa_erase(&liteuart_array, 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(port->membase + OFF_TXFULL))
368 		cpu_relax();
369 
370 	litex_write8(port->membase + OFF_RXTX, 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, co->index);
381 	port = &uart->port;
382 
383 	uart_port_lock_irqsave(port, &flags);
384 	uart_console_write(port, s, count, liteuart_putchar);
385 	uart_port_unlock_irqrestore(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, 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, &parity, &bits, &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, 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(&liteuart_driver);
456 	if (res)
457 		return res;
458 
459 	res = platform_driver_register(&liteuart_platform_driver);
460 	if (res)
461 		uart_unregister_driver(&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(&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