1// SPDX-License-Identifier: GPL-2.0+
2/*
3 *  Serial Port driver for Aspeed VUART device
4 *
5 *    Copyright (C) 2016 Jeremy Kerr <jk@ozlabs.org>, IBM Corp.
6 *    Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp.
7 */
8#include <linux/device.h>
9#include <linux/module.h>
10#include <linux/of_address.h>
11#include <linux/of_irq.h>
12#include <linux/of_platform.h>
13#include <linux/regmap.h>
14#include <linux/mfd/syscon.h>
15#include <linux/tty.h>
16#include <linux/tty_flip.h>
17#include <linux/clk.h>
18
19#include "8250.h"
20
21#define ASPEED_VUART_GCRA		0x20
22#define ASPEED_VUART_GCRA_VUART_EN		BIT(0)
23#define ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY	BIT(1)
24#define ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD BIT(5)
25#define ASPEED_VUART_GCRB		0x24
26#define ASPEED_VUART_GCRB_HOST_SIRQ_MASK	GENMASK(7, 4)
27#define ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT	4
28#define ASPEED_VUART_ADDRL		0x28
29#define ASPEED_VUART_ADDRH		0x2c
30
31#define ASPEED_VUART_DEFAULT_LPC_ADDR	0x3f8
32#define ASPEED_VUART_DEFAULT_SIRQ	4
33#define ASPEED_VUART_DEFAULT_SIRQ_POLARITY	IRQ_TYPE_LEVEL_LOW
34
35struct aspeed_vuart {
36	struct device		*dev;
37	struct clk		*clk;
38	int			line;
39	struct timer_list	unthrottle_timer;
40	struct uart_8250_port	*port;
41};
42
43/*
44 * If we fill the tty flip buffers, we throttle the data ready interrupt
45 * to prevent dropped characters. This timeout defines how long we wait
46 * to (conditionally, depending on buffer state) unthrottle.
47 */
48static const int unthrottle_timeout = HZ/10;
49
50/*
51 * The VUART is basically two UART 'front ends' connected by their FIFO
52 * (no actual serial line in between). One is on the BMC side (management
53 * controller) and one is on the host CPU side.
54 *
55 * It allows the BMC to provide to the host a "UART" that pipes into
56 * the BMC itself and can then be turned by the BMC into a network console
57 * of some sort for example.
58 *
59 * This driver is for the BMC side. The sysfs files allow the BMC
60 * userspace which owns the system configuration policy, to specify
61 * at what IO port and interrupt number the host side will appear
62 * to the host on the Host <-> BMC LPC bus. It could be different on a
63 * different system (though most of them use 3f8/4).
64 */
65
66static inline u8 aspeed_vuart_readb(struct aspeed_vuart *vuart, u8 reg)
67{
68	return readb(vuart->port->port.membase + reg);
69}
70
71static inline void aspeed_vuart_writeb(struct aspeed_vuart *vuart, u8 val, u8 reg)
72{
73	writeb(val, vuart->port->port.membase + reg);
74}
75
76static ssize_t lpc_address_show(struct device *dev,
77				struct device_attribute *attr, char *buf)
78{
79	struct aspeed_vuart *vuart = dev_get_drvdata(dev);
80	u16 addr;
81
82	addr = (aspeed_vuart_readb(vuart, ASPEED_VUART_ADDRH) << 8) |
83		(aspeed_vuart_readb(vuart, ASPEED_VUART_ADDRL));
84
85	return sysfs_emit(buf, "0x%x\n", addr);
86}
87
88static int aspeed_vuart_set_lpc_address(struct aspeed_vuart *vuart, u32 addr)
89{
90	if (addr > U16_MAX)
91		return -EINVAL;
92
93	aspeed_vuart_writeb(vuart, addr >> 8, ASPEED_VUART_ADDRH);
94	aspeed_vuart_writeb(vuart, addr >> 0, ASPEED_VUART_ADDRL);
95
96	return 0;
97}
98
99static ssize_t lpc_address_store(struct device *dev,
100				 struct device_attribute *attr,
101				 const char *buf, size_t count)
102{
103	struct aspeed_vuart *vuart = dev_get_drvdata(dev);
104	u32 val;
105	int err;
106
107	err = kstrtou32(buf, 0, &val);
108	if (err)
109		return err;
110
111	err = aspeed_vuart_set_lpc_address(vuart, val);
112	return err ? : count;
113}
114
115static DEVICE_ATTR_RW(lpc_address);
116
117static ssize_t sirq_show(struct device *dev,
118			 struct device_attribute *attr, char *buf)
119{
120	struct aspeed_vuart *vuart = dev_get_drvdata(dev);
121	u8 reg;
122
123	reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRB);
124	reg &= ASPEED_VUART_GCRB_HOST_SIRQ_MASK;
125	reg >>= ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT;
126
127	return sysfs_emit(buf, "%u\n", reg);
128}
129
130static int aspeed_vuart_set_sirq(struct aspeed_vuart *vuart, u32 sirq)
131{
132	u8 reg;
133
134	if (sirq > (ASPEED_VUART_GCRB_HOST_SIRQ_MASK >> ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT))
135		return -EINVAL;
136
137	sirq <<= ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT;
138	sirq &= ASPEED_VUART_GCRB_HOST_SIRQ_MASK;
139
140	reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRB);
141	reg &= ~ASPEED_VUART_GCRB_HOST_SIRQ_MASK;
142	reg |= sirq;
143	aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRB);
144
145	return 0;
146}
147
148static ssize_t sirq_store(struct device *dev, struct device_attribute *attr,
149			  const char *buf, size_t count)
150{
151	struct aspeed_vuart *vuart = dev_get_drvdata(dev);
152	unsigned long val;
153	int err;
154
155	err = kstrtoul(buf, 0, &val);
156	if (err)
157		return err;
158
159	err = aspeed_vuart_set_sirq(vuart, val);
160	return err ? : count;
161}
162
163static DEVICE_ATTR_RW(sirq);
164
165static ssize_t sirq_polarity_show(struct device *dev,
166				  struct device_attribute *attr, char *buf)
167{
168	struct aspeed_vuart *vuart = dev_get_drvdata(dev);
169	u8 reg;
170
171	reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
172	reg &= ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY;
173
174	return sysfs_emit(buf, "%u\n", reg ? 1 : 0);
175}
176
177static void aspeed_vuart_set_sirq_polarity(struct aspeed_vuart *vuart,
178					   bool polarity)
179{
180	u8 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
181
182	if (polarity)
183		reg |= ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY;
184	else
185		reg &= ~ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY;
186
187	aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA);
188}
189
190static ssize_t sirq_polarity_store(struct device *dev,
191				   struct device_attribute *attr,
192				   const char *buf, size_t count)
193{
194	struct aspeed_vuart *vuart = dev_get_drvdata(dev);
195	unsigned long val;
196	int err;
197
198	err = kstrtoul(buf, 0, &val);
199	if (err)
200		return err;
201
202	aspeed_vuart_set_sirq_polarity(vuart, val != 0);
203
204	return count;
205}
206
207static DEVICE_ATTR_RW(sirq_polarity);
208
209static struct attribute *aspeed_vuart_attrs[] = {
210	&dev_attr_sirq.attr,
211	&dev_attr_sirq_polarity.attr,
212	&dev_attr_lpc_address.attr,
213	NULL,
214};
215
216static const struct attribute_group aspeed_vuart_attr_group = {
217	.attrs = aspeed_vuart_attrs,
218};
219
220static void aspeed_vuart_set_enabled(struct aspeed_vuart *vuart, bool enabled)
221{
222	u8 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
223
224	if (enabled)
225		reg |= ASPEED_VUART_GCRA_VUART_EN;
226	else
227		reg &= ~ASPEED_VUART_GCRA_VUART_EN;
228
229	aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA);
230}
231
232static void aspeed_vuart_set_host_tx_discard(struct aspeed_vuart *vuart,
233					     bool discard)
234{
235	u8 reg;
236
237	reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
238
239	/* If the DISABLE_HOST_TX_DISCARD bit is set, discard is disabled */
240	if (!discard)
241		reg |= ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD;
242	else
243		reg &= ~ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD;
244
245	aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA);
246}
247
248static int aspeed_vuart_startup(struct uart_port *uart_port)
249{
250	struct uart_8250_port *uart_8250_port = up_to_u8250p(uart_port);
251	struct aspeed_vuart *vuart = uart_8250_port->port.private_data;
252	int rc;
253
254	rc = serial8250_do_startup(uart_port);
255	if (rc)
256		return rc;
257
258	aspeed_vuart_set_host_tx_discard(vuart, false);
259
260	return 0;
261}
262
263static void aspeed_vuart_shutdown(struct uart_port *uart_port)
264{
265	struct uart_8250_port *uart_8250_port = up_to_u8250p(uart_port);
266	struct aspeed_vuart *vuart = uart_8250_port->port.private_data;
267
268	aspeed_vuart_set_host_tx_discard(vuart, true);
269
270	serial8250_do_shutdown(uart_port);
271}
272
273static void __aspeed_vuart_set_throttle(struct uart_8250_port *up,
274		bool throttle)
275{
276	unsigned char irqs = UART_IER_RLSI | UART_IER_RDI;
277
278	/* Port locked to synchronize UART_IER access against the console. */
279	lockdep_assert_held_once(&up->port.lock);
280
281	up->ier &= ~irqs;
282	if (!throttle)
283		up->ier |= irqs;
284	serial_out(up, UART_IER, up->ier);
285}
286static void aspeed_vuart_set_throttle(struct uart_port *port, bool throttle)
287{
288	struct uart_8250_port *up = up_to_u8250p(port);
289	unsigned long flags;
290
291	spin_lock_irqsave(&port->lock, flags);
292	__aspeed_vuart_set_throttle(up, throttle);
293	spin_unlock_irqrestore(&port->lock, flags);
294}
295
296static void aspeed_vuart_throttle(struct uart_port *port)
297{
298	aspeed_vuart_set_throttle(port, true);
299}
300
301static void aspeed_vuart_unthrottle(struct uart_port *port)
302{
303	aspeed_vuart_set_throttle(port, false);
304}
305
306static void aspeed_vuart_unthrottle_exp(struct timer_list *timer)
307{
308	struct aspeed_vuart *vuart = from_timer(vuart, timer, unthrottle_timer);
309	struct uart_8250_port *up = vuart->port;
310
311	if (!tty_buffer_space_avail(&up->port.state->port)) {
312		mod_timer(&vuart->unthrottle_timer,
313			  jiffies + unthrottle_timeout);
314		return;
315	}
316
317	aspeed_vuart_unthrottle(&up->port);
318}
319
320/*
321 * Custom interrupt handler to manage finer-grained flow control. Although we
322 * have throttle/unthrottle callbacks, we've seen that the VUART device can
323 * deliver characters faster than the ldisc has a chance to check buffer space
324 * against the throttle threshold. This results in dropped characters before
325 * the throttle.
326 *
327 * We do this by checking for flip buffer space before RX. If we have no space,
328 * throttle now and schedule an unthrottle for later, once the ldisc has had
329 * a chance to drain the buffers.
330 */
331static int aspeed_vuart_handle_irq(struct uart_port *port)
332{
333	struct uart_8250_port *up = up_to_u8250p(port);
334	unsigned int iir, lsr;
335	unsigned long flags;
336	unsigned int space, count;
337
338	iir = serial_port_in(port, UART_IIR);
339
340	if (iir & UART_IIR_NO_INT)
341		return 0;
342
343	spin_lock_irqsave(&port->lock, flags);
344
345	lsr = serial_port_in(port, UART_LSR);
346
347	if (lsr & (UART_LSR_DR | UART_LSR_BI)) {
348		space = tty_buffer_space_avail(&port->state->port);
349
350		if (!space) {
351			/* throttle and schedule an unthrottle later */
352			struct aspeed_vuart *vuart = port->private_data;
353			__aspeed_vuart_set_throttle(up, true);
354
355			if (!timer_pending(&vuart->unthrottle_timer))
356				mod_timer(&vuart->unthrottle_timer,
357					  jiffies + unthrottle_timeout);
358
359		} else {
360			count = min(space, 256U);
361
362			do {
363				serial8250_read_char(up, lsr);
364				lsr = serial_in(up, UART_LSR);
365				if (--count == 0)
366					break;
367			} while (lsr & (UART_LSR_DR | UART_LSR_BI));
368
369			tty_flip_buffer_push(&port->state->port);
370		}
371	}
372
373	serial8250_modem_status(up);
374	if (lsr & UART_LSR_THRE)
375		serial8250_tx_chars(up);
376
377	uart_unlock_and_check_sysrq_irqrestore(port, flags);
378
379	return 1;
380}
381
382static void aspeed_vuart_auto_configure_sirq_polarity(
383	struct aspeed_vuart *vuart, struct device_node *syscon_np,
384	u32 reg_offset, u32 reg_mask)
385{
386	struct regmap *regmap;
387	u32 value;
388
389	regmap = syscon_node_to_regmap(syscon_np);
390	if (IS_ERR(regmap)) {
391		dev_warn(vuart->dev,
392			 "could not get regmap for aspeed,sirq-polarity-sense\n");
393		return;
394	}
395	if (regmap_read(regmap, reg_offset, &value)) {
396		dev_warn(vuart->dev, "could not read hw strap table\n");
397		return;
398	}
399
400	aspeed_vuart_set_sirq_polarity(vuart, (value & reg_mask) == 0);
401}
402
403static int aspeed_vuart_map_irq_polarity(u32 dt)
404{
405	switch (dt) {
406	case IRQ_TYPE_LEVEL_LOW:
407		return 0;
408	case IRQ_TYPE_LEVEL_HIGH:
409		return 1;
410	default:
411		return -EINVAL;
412	}
413}
414
415static int aspeed_vuart_probe(struct platform_device *pdev)
416{
417	struct of_phandle_args sirq_polarity_sense_args;
418	struct uart_8250_port port;
419	struct aspeed_vuart *vuart;
420	struct device_node *np;
421	struct resource *res;
422	u32 clk, prop, sirq[2];
423	int rc, sirq_polarity;
424
425	np = pdev->dev.of_node;
426
427	vuart = devm_kzalloc(&pdev->dev, sizeof(*vuart), GFP_KERNEL);
428	if (!vuart)
429		return -ENOMEM;
430
431	vuart->dev = &pdev->dev;
432	timer_setup(&vuart->unthrottle_timer, aspeed_vuart_unthrottle_exp, 0);
433
434	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
435	if (!res)
436		return -EINVAL;
437
438	memset(&port, 0, sizeof(port));
439	port.port.private_data = vuart;
440	port.port.mapbase = res->start;
441	port.port.mapsize = resource_size(res);
442	port.port.startup = aspeed_vuart_startup;
443	port.port.shutdown = aspeed_vuart_shutdown;
444	port.port.throttle = aspeed_vuart_throttle;
445	port.port.unthrottle = aspeed_vuart_unthrottle;
446	port.port.status = UPSTAT_SYNC_FIFO;
447	port.port.dev = &pdev->dev;
448	port.port.has_sysrq = IS_ENABLED(CONFIG_SERIAL_8250_CONSOLE);
449	port.bugs |= UART_BUG_TXRACE;
450
451	rc = sysfs_create_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
452	if (rc < 0)
453		return rc;
454
455	if (of_property_read_u32(np, "clock-frequency", &clk)) {
456		vuart->clk = devm_clk_get(&pdev->dev, NULL);
457		if (IS_ERR(vuart->clk)) {
458			dev_warn(&pdev->dev,
459				"clk or clock-frequency not defined\n");
460			rc = PTR_ERR(vuart->clk);
461			goto err_sysfs_remove;
462		}
463
464		rc = clk_prepare_enable(vuart->clk);
465		if (rc < 0)
466			goto err_sysfs_remove;
467
468		clk = clk_get_rate(vuart->clk);
469	}
470
471	/* If current-speed was set, then try not to change it. */
472	if (of_property_read_u32(np, "current-speed", &prop) == 0)
473		port.port.custom_divisor = clk / (16 * prop);
474
475	/* Check for shifted address mapping */
476	if (of_property_read_u32(np, "reg-offset", &prop) == 0)
477		port.port.mapbase += prop;
478
479	/* Check for registers offset within the devices address range */
480	if (of_property_read_u32(np, "reg-shift", &prop) == 0)
481		port.port.regshift = prop;
482
483	/* Check for fifo size */
484	if (of_property_read_u32(np, "fifo-size", &prop) == 0)
485		port.port.fifosize = prop;
486
487	/* Check for a fixed line number */
488	rc = of_alias_get_id(np, "serial");
489	if (rc >= 0)
490		port.port.line = rc;
491
492	port.port.irq = irq_of_parse_and_map(np, 0);
493	port.port.handle_irq = aspeed_vuart_handle_irq;
494	port.port.iotype = UPIO_MEM;
495	port.port.type = PORT_ASPEED_VUART;
496	port.port.uartclk = clk;
497	port.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP
498		| UPF_FIXED_PORT | UPF_FIXED_TYPE | UPF_NO_THRE_TEST;
499
500	if (of_property_read_bool(np, "no-loopback-test"))
501		port.port.flags |= UPF_SKIP_TEST;
502
503	if (port.port.fifosize)
504		port.capabilities = UART_CAP_FIFO;
505
506	if (of_property_read_bool(np, "auto-flow-control"))
507		port.capabilities |= UART_CAP_AFE;
508
509	rc = serial8250_register_8250_port(&port);
510	if (rc < 0)
511		goto err_clk_disable;
512
513	vuart->line = rc;
514	vuart->port = serial8250_get_port(vuart->line);
515
516	rc = of_parse_phandle_with_fixed_args(
517		np, "aspeed,sirq-polarity-sense", 2, 0,
518		&sirq_polarity_sense_args);
519	if (rc < 0) {
520		dev_dbg(&pdev->dev,
521			"aspeed,sirq-polarity-sense property not found\n");
522	} else {
523		aspeed_vuart_auto_configure_sirq_polarity(
524			vuart, sirq_polarity_sense_args.np,
525			sirq_polarity_sense_args.args[0],
526			BIT(sirq_polarity_sense_args.args[1]));
527		of_node_put(sirq_polarity_sense_args.np);
528	}
529
530	rc = of_property_read_u32(np, "aspeed,lpc-io-reg", &prop);
531	if (rc < 0)
532		prop = ASPEED_VUART_DEFAULT_LPC_ADDR;
533
534	rc = aspeed_vuart_set_lpc_address(vuart, prop);
535	if (rc < 0) {
536		dev_err(&pdev->dev, "invalid value in aspeed,lpc-io-reg property\n");
537		goto err_clk_disable;
538	}
539
540	rc = of_property_read_u32_array(np, "aspeed,lpc-interrupts", sirq, 2);
541	if (rc < 0) {
542		sirq[0] = ASPEED_VUART_DEFAULT_SIRQ;
543		sirq[1] = ASPEED_VUART_DEFAULT_SIRQ_POLARITY;
544	}
545
546	rc = aspeed_vuart_set_sirq(vuart, sirq[0]);
547	if (rc < 0) {
548		dev_err(&pdev->dev, "invalid sirq number in aspeed,lpc-interrupts property\n");
549		goto err_clk_disable;
550	}
551
552	sirq_polarity = aspeed_vuart_map_irq_polarity(sirq[1]);
553	if (sirq_polarity < 0) {
554		dev_err(&pdev->dev, "invalid sirq polarity in aspeed,lpc-interrupts property\n");
555		rc = sirq_polarity;
556		goto err_clk_disable;
557	}
558
559	aspeed_vuart_set_sirq_polarity(vuart, sirq_polarity);
560
561	aspeed_vuart_set_enabled(vuart, true);
562	aspeed_vuart_set_host_tx_discard(vuart, true);
563	platform_set_drvdata(pdev, vuart);
564
565	return 0;
566
567err_clk_disable:
568	clk_disable_unprepare(vuart->clk);
569	irq_dispose_mapping(port.port.irq);
570err_sysfs_remove:
571	sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
572	return rc;
573}
574
575static int aspeed_vuart_remove(struct platform_device *pdev)
576{
577	struct aspeed_vuart *vuart = platform_get_drvdata(pdev);
578
579	del_timer_sync(&vuart->unthrottle_timer);
580	aspeed_vuart_set_enabled(vuart, false);
581	serial8250_unregister_port(vuart->line);
582	sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
583	clk_disable_unprepare(vuart->clk);
584
585	return 0;
586}
587
588static const struct of_device_id aspeed_vuart_table[] = {
589	{ .compatible = "aspeed,ast2400-vuart" },
590	{ .compatible = "aspeed,ast2500-vuart" },
591	{ },
592};
593
594static struct platform_driver aspeed_vuart_driver = {
595	.driver = {
596		.name = "aspeed-vuart",
597		.of_match_table = aspeed_vuart_table,
598	},
599	.probe = aspeed_vuart_probe,
600	.remove = aspeed_vuart_remove,
601};
602
603module_platform_driver(aspeed_vuart_driver);
604
605MODULE_AUTHOR("Jeremy Kerr <jk@ozlabs.org>");
606MODULE_LICENSE("GPL");
607MODULE_DESCRIPTION("Driver for Aspeed VUART device");
608