xref: /openbmc/linux/drivers/tty/serial/liteuart.c (revision 046b212a) 
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 	spin_lock_irqsave(&port->lock, 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 	spin_unlock_irqrestore(&port->lock, 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 	spin_lock_irqsave(&port->lock, flags);
199 	/* only enabling rx irqs during startup */
200 	liteuart_update_irq_reg(port, true, EV_RX);
201 	spin_unlock_irqrestore(&port->lock, 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 	spin_lock_irqsave(&port->lock, flags);
217 	liteuart_update_irq_reg(port, false, EV_RX | EV_TX);
218 	spin_unlock_irqrestore(&port->lock, 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 	spin_lock_irqsave(&port->lock, 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 	spin_unlock_irqrestore(&port->lock, 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 int 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 	return 0;
348 }
349 
350 static const struct of_device_id liteuart_of_match[] = {
351 	{ .compatible = "litex,liteuart" },
352 	{}
353 };
354 MODULE_DEVICE_TABLE(of, liteuart_of_match);
355 
356 static struct platform_driver liteuart_platform_driver = {
357 	.probe = liteuart_probe,
358 	.remove = liteuart_remove,
359 	.driver = {
360 		.name = KBUILD_MODNAME,
361 		.of_match_table = liteuart_of_match,
362 	},
363 };
364 
365 #ifdef CONFIG_SERIAL_LITEUART_CONSOLE
366 
367 static void liteuart_putchar(struct uart_port *port, unsigned char ch)
368 {
369 	while (litex_read8(port->membase + OFF_TXFULL))
370 		cpu_relax();
371 
372 	litex_write8(port->membase + OFF_RXTX, ch);
373 }
374 
375 static void liteuart_console_write(struct console *co, const char *s,
376 	unsigned int count)
377 {
378 	struct liteuart_port *uart;
379 	struct uart_port *port;
380 	unsigned long flags;
381 
382 	uart = (struct liteuart_port *)xa_load(&liteuart_array, co->index);
383 	port = &uart->port;
384 
385 	spin_lock_irqsave(&port->lock, flags);
386 	uart_console_write(port, s, count, liteuart_putchar);
387 	spin_unlock_irqrestore(&port->lock, flags);
388 }
389 
390 static int liteuart_console_setup(struct console *co, char *options)
391 {
392 	struct liteuart_port *uart;
393 	struct uart_port *port;
394 	int baud = 115200;
395 	int bits = 8;
396 	int parity = 'n';
397 	int flow = 'n';
398 
399 	uart = (struct liteuart_port *)xa_load(&liteuart_array, co->index);
400 	if (!uart)
401 		return -ENODEV;
402 
403 	port = &uart->port;
404 	if (!port->membase)
405 		return -ENODEV;
406 
407 	if (options)
408 		uart_parse_options(options, &baud, &parity, &bits, &flow);
409 
410 	return uart_set_options(port, co, baud, parity, bits, flow);
411 }
412 
413 static struct console liteuart_console = {
414 	.name = KBUILD_MODNAME,
415 	.write = liteuart_console_write,
416 	.device = uart_console_device,
417 	.setup = liteuart_console_setup,
418 	.flags = CON_PRINTBUFFER,
419 	.index = -1,
420 	.data = &liteuart_driver,
421 };
422 
423 static int __init liteuart_console_init(void)
424 {
425 	register_console(&liteuart_console);
426 
427 	return 0;
428 }
429 console_initcall(liteuart_console_init);
430 
431 static void early_liteuart_write(struct console *console, const char *s,
432 				    unsigned int count)
433 {
434 	struct earlycon_device *device = console->data;
435 	struct uart_port *port = &device->port;
436 
437 	uart_console_write(port, s, count, liteuart_putchar);
438 }
439 
440 static int __init early_liteuart_setup(struct earlycon_device *device,
441 				       const char *options)
442 {
443 	if (!device->port.membase)
444 		return -ENODEV;
445 
446 	device->con->write = early_liteuart_write;
447 	return 0;
448 }
449 
450 OF_EARLYCON_DECLARE(liteuart, "litex,liteuart", early_liteuart_setup);
451 #endif /* CONFIG_SERIAL_LITEUART_CONSOLE */
452 
453 static int __init liteuart_init(void)
454 {
455 	int res;
456 
457 	res = uart_register_driver(&liteuart_driver);
458 	if (res)
459 		return res;
460 
461 	res = platform_driver_register(&liteuart_platform_driver);
462 	if (res)
463 		uart_unregister_driver(&liteuart_driver);
464 
465 	return res;
466 }
467 
468 static void __exit liteuart_exit(void)
469 {
470 	platform_driver_unregister(&liteuart_platform_driver);
471 	uart_unregister_driver(&liteuart_driver);
472 }
473 
474 module_init(liteuart_init);
475 module_exit(liteuart_exit);
476 
477 MODULE_AUTHOR("Antmicro <www.antmicro.com>");
478 MODULE_DESCRIPTION("LiteUART serial driver");
479 MODULE_LICENSE("GPL v2");
480 MODULE_ALIAS("platform:liteuart");
481