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 
35 struct 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  */
48 static 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 
66 static inline u8 aspeed_vuart_readb(struct aspeed_vuart *vuart, u8 reg)
67 {
68 	return readb(vuart->port->port.membase + reg);
69 }
70 
71 static inline void aspeed_vuart_writeb(struct aspeed_vuart *vuart, u8 val, u8 reg)
72 {
73 	writeb(val, vuart->port->port.membase + reg);
74 }
75 
76 static 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 
88 static 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 
99 static 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 
115 static DEVICE_ATTR_RW(lpc_address);
116 
117 static 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 
130 static 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 
148 static 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 
163 static DEVICE_ATTR_RW(sirq);
164 
165 static 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 
177 static 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 
190 static 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 
207 static DEVICE_ATTR_RW(sirq_polarity);
208 
209 static 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 
216 static const struct attribute_group aspeed_vuart_attr_group = {
217 	.attrs = aspeed_vuart_attrs,
218 };
219 
220 static 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 
232 static 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 
248 static 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 
263 static 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 
273 static 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 	up->ier &= ~irqs;
279 	if (!throttle)
280 		up->ier |= irqs;
281 	serial_out(up, UART_IER, up->ier);
282 }
283 static void aspeed_vuart_set_throttle(struct uart_port *port, bool throttle)
284 {
285 	struct uart_8250_port *up = up_to_u8250p(port);
286 	unsigned long flags;
287 
288 	spin_lock_irqsave(&port->lock, flags);
289 	__aspeed_vuart_set_throttle(up, throttle);
290 	spin_unlock_irqrestore(&port->lock, flags);
291 }
292 
293 static void aspeed_vuart_throttle(struct uart_port *port)
294 {
295 	aspeed_vuart_set_throttle(port, true);
296 }
297 
298 static void aspeed_vuart_unthrottle(struct uart_port *port)
299 {
300 	aspeed_vuart_set_throttle(port, false);
301 }
302 
303 static void aspeed_vuart_unthrottle_exp(struct timer_list *timer)
304 {
305 	struct aspeed_vuart *vuart = from_timer(vuart, timer, unthrottle_timer);
306 	struct uart_8250_port *up = vuart->port;
307 
308 	if (!tty_buffer_space_avail(&up->port.state->port)) {
309 		mod_timer(&vuart->unthrottle_timer,
310 			  jiffies + unthrottle_timeout);
311 		return;
312 	}
313 
314 	aspeed_vuart_unthrottle(&up->port);
315 }
316 
317 /*
318  * Custom interrupt handler to manage finer-grained flow control. Although we
319  * have throttle/unthrottle callbacks, we've seen that the VUART device can
320  * deliver characters faster than the ldisc has a chance to check buffer space
321  * against the throttle threshold. This results in dropped characters before
322  * the throttle.
323  *
324  * We do this by checking for flip buffer space before RX. If we have no space,
325  * throttle now and schedule an unthrottle for later, once the ldisc has had
326  * a chance to drain the buffers.
327  */
328 static int aspeed_vuart_handle_irq(struct uart_port *port)
329 {
330 	struct uart_8250_port *up = up_to_u8250p(port);
331 	unsigned int iir, lsr;
332 	unsigned long flags;
333 	unsigned int space, count;
334 
335 	iir = serial_port_in(port, UART_IIR);
336 
337 	if (iir & UART_IIR_NO_INT)
338 		return 0;
339 
340 	spin_lock_irqsave(&port->lock, flags);
341 
342 	lsr = serial_port_in(port, UART_LSR);
343 
344 	if (lsr & (UART_LSR_DR | UART_LSR_BI)) {
345 		space = tty_buffer_space_avail(&port->state->port);
346 
347 		if (!space) {
348 			/* throttle and schedule an unthrottle later */
349 			struct aspeed_vuart *vuart = port->private_data;
350 			__aspeed_vuart_set_throttle(up, true);
351 
352 			if (!timer_pending(&vuart->unthrottle_timer))
353 				mod_timer(&vuart->unthrottle_timer,
354 					  jiffies + unthrottle_timeout);
355 
356 		} else {
357 			count = min(space, 256U);
358 
359 			do {
360 				serial8250_read_char(up, lsr);
361 				lsr = serial_in(up, UART_LSR);
362 				if (--count == 0)
363 					break;
364 			} while (lsr & (UART_LSR_DR | UART_LSR_BI));
365 
366 			tty_flip_buffer_push(&port->state->port);
367 		}
368 	}
369 
370 	serial8250_modem_status(up);
371 	if (lsr & UART_LSR_THRE)
372 		serial8250_tx_chars(up);
373 
374 	uart_unlock_and_check_sysrq_irqrestore(port, flags);
375 
376 	return 1;
377 }
378 
379 static void aspeed_vuart_auto_configure_sirq_polarity(
380 	struct aspeed_vuart *vuart, struct device_node *syscon_np,
381 	u32 reg_offset, u32 reg_mask)
382 {
383 	struct regmap *regmap;
384 	u32 value;
385 
386 	regmap = syscon_node_to_regmap(syscon_np);
387 	if (IS_ERR(regmap)) {
388 		dev_warn(vuart->dev,
389 			 "could not get regmap for aspeed,sirq-polarity-sense\n");
390 		return;
391 	}
392 	if (regmap_read(regmap, reg_offset, &value)) {
393 		dev_warn(vuart->dev, "could not read hw strap table\n");
394 		return;
395 	}
396 
397 	aspeed_vuart_set_sirq_polarity(vuart, (value & reg_mask) == 0);
398 }
399 
400 static int aspeed_vuart_map_irq_polarity(u32 dt)
401 {
402 	switch (dt) {
403 	case IRQ_TYPE_LEVEL_LOW:
404 		return 0;
405 	case IRQ_TYPE_LEVEL_HIGH:
406 		return 1;
407 	default:
408 		return -EINVAL;
409 	}
410 }
411 
412 static int aspeed_vuart_probe(struct platform_device *pdev)
413 {
414 	struct of_phandle_args sirq_polarity_sense_args;
415 	struct uart_8250_port port;
416 	struct aspeed_vuart *vuart;
417 	struct device_node *np;
418 	struct resource *res;
419 	u32 clk, prop, sirq[2];
420 	int rc, sirq_polarity;
421 
422 	np = pdev->dev.of_node;
423 
424 	vuart = devm_kzalloc(&pdev->dev, sizeof(*vuart), GFP_KERNEL);
425 	if (!vuart)
426 		return -ENOMEM;
427 
428 	vuart->dev = &pdev->dev;
429 	timer_setup(&vuart->unthrottle_timer, aspeed_vuart_unthrottle_exp, 0);
430 
431 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
432 	if (!res)
433 		return -EINVAL;
434 
435 	memset(&port, 0, sizeof(port));
436 	port.port.private_data = vuart;
437 	port.port.mapbase = res->start;
438 	port.port.mapsize = resource_size(res);
439 	port.port.startup = aspeed_vuart_startup;
440 	port.port.shutdown = aspeed_vuart_shutdown;
441 	port.port.throttle = aspeed_vuart_throttle;
442 	port.port.unthrottle = aspeed_vuart_unthrottle;
443 	port.port.status = UPSTAT_SYNC_FIFO;
444 	port.port.dev = &pdev->dev;
445 	port.port.has_sysrq = IS_ENABLED(CONFIG_SERIAL_8250_CONSOLE);
446 	port.bugs |= UART_BUG_TXRACE;
447 
448 	rc = sysfs_create_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
449 	if (rc < 0)
450 		return rc;
451 
452 	if (of_property_read_u32(np, "clock-frequency", &clk)) {
453 		vuart->clk = devm_clk_get(&pdev->dev, NULL);
454 		if (IS_ERR(vuart->clk)) {
455 			dev_warn(&pdev->dev,
456 				"clk or clock-frequency not defined\n");
457 			rc = PTR_ERR(vuart->clk);
458 			goto err_sysfs_remove;
459 		}
460 
461 		rc = clk_prepare_enable(vuart->clk);
462 		if (rc < 0)
463 			goto err_sysfs_remove;
464 
465 		clk = clk_get_rate(vuart->clk);
466 	}
467 
468 	/* If current-speed was set, then try not to change it. */
469 	if (of_property_read_u32(np, "current-speed", &prop) == 0)
470 		port.port.custom_divisor = clk / (16 * prop);
471 
472 	/* Check for shifted address mapping */
473 	if (of_property_read_u32(np, "reg-offset", &prop) == 0)
474 		port.port.mapbase += prop;
475 
476 	/* Check for registers offset within the devices address range */
477 	if (of_property_read_u32(np, "reg-shift", &prop) == 0)
478 		port.port.regshift = prop;
479 
480 	/* Check for fifo size */
481 	if (of_property_read_u32(np, "fifo-size", &prop) == 0)
482 		port.port.fifosize = prop;
483 
484 	/* Check for a fixed line number */
485 	rc = of_alias_get_id(np, "serial");
486 	if (rc >= 0)
487 		port.port.line = rc;
488 
489 	port.port.irq = irq_of_parse_and_map(np, 0);
490 	port.port.handle_irq = aspeed_vuart_handle_irq;
491 	port.port.iotype = UPIO_MEM;
492 	port.port.type = PORT_ASPEED_VUART;
493 	port.port.uartclk = clk;
494 	port.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP
495 		| UPF_FIXED_PORT | UPF_FIXED_TYPE | UPF_NO_THRE_TEST;
496 
497 	if (of_property_read_bool(np, "no-loopback-test"))
498 		port.port.flags |= UPF_SKIP_TEST;
499 
500 	if (port.port.fifosize)
501 		port.capabilities = UART_CAP_FIFO;
502 
503 	if (of_property_read_bool(np, "auto-flow-control"))
504 		port.capabilities |= UART_CAP_AFE;
505 
506 	rc = serial8250_register_8250_port(&port);
507 	if (rc < 0)
508 		goto err_clk_disable;
509 
510 	vuart->line = rc;
511 	vuart->port = serial8250_get_port(vuart->line);
512 
513 	rc = of_parse_phandle_with_fixed_args(
514 		np, "aspeed,sirq-polarity-sense", 2, 0,
515 		&sirq_polarity_sense_args);
516 	if (rc < 0) {
517 		dev_dbg(&pdev->dev,
518 			"aspeed,sirq-polarity-sense property not found\n");
519 	} else {
520 		aspeed_vuart_auto_configure_sirq_polarity(
521 			vuart, sirq_polarity_sense_args.np,
522 			sirq_polarity_sense_args.args[0],
523 			BIT(sirq_polarity_sense_args.args[1]));
524 		of_node_put(sirq_polarity_sense_args.np);
525 	}
526 
527 	rc = of_property_read_u32(np, "aspeed,lpc-io-reg", &prop);
528 	if (rc < 0)
529 		prop = ASPEED_VUART_DEFAULT_LPC_ADDR;
530 
531 	rc = aspeed_vuart_set_lpc_address(vuart, prop);
532 	if (rc < 0) {
533 		dev_err(&pdev->dev, "invalid value in aspeed,lpc-io-reg property\n");
534 		goto err_clk_disable;
535 	}
536 
537 	rc = of_property_read_u32_array(np, "aspeed,lpc-interrupts", sirq, 2);
538 	if (rc < 0) {
539 		sirq[0] = ASPEED_VUART_DEFAULT_SIRQ;
540 		sirq[1] = ASPEED_VUART_DEFAULT_SIRQ_POLARITY;
541 	}
542 
543 	rc = aspeed_vuart_set_sirq(vuart, sirq[0]);
544 	if (rc < 0) {
545 		dev_err(&pdev->dev, "invalid sirq number in aspeed,lpc-interrupts property\n");
546 		goto err_clk_disable;
547 	}
548 
549 	sirq_polarity = aspeed_vuart_map_irq_polarity(sirq[1]);
550 	if (sirq_polarity < 0) {
551 		dev_err(&pdev->dev, "invalid sirq polarity in aspeed,lpc-interrupts property\n");
552 		rc = sirq_polarity;
553 		goto err_clk_disable;
554 	}
555 
556 	aspeed_vuart_set_sirq_polarity(vuart, sirq_polarity);
557 
558 	aspeed_vuart_set_enabled(vuart, true);
559 	aspeed_vuart_set_host_tx_discard(vuart, true);
560 	platform_set_drvdata(pdev, vuart);
561 
562 	return 0;
563 
564 err_clk_disable:
565 	clk_disable_unprepare(vuart->clk);
566 	irq_dispose_mapping(port.port.irq);
567 err_sysfs_remove:
568 	sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
569 	return rc;
570 }
571 
572 static int aspeed_vuart_remove(struct platform_device *pdev)
573 {
574 	struct aspeed_vuart *vuart = platform_get_drvdata(pdev);
575 
576 	del_timer_sync(&vuart->unthrottle_timer);
577 	aspeed_vuart_set_enabled(vuart, false);
578 	serial8250_unregister_port(vuart->line);
579 	sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
580 	clk_disable_unprepare(vuart->clk);
581 
582 	return 0;
583 }
584 
585 static const struct of_device_id aspeed_vuart_table[] = {
586 	{ .compatible = "aspeed,ast2400-vuart" },
587 	{ .compatible = "aspeed,ast2500-vuart" },
588 	{ },
589 };
590 
591 static struct platform_driver aspeed_vuart_driver = {
592 	.driver = {
593 		.name = "aspeed-vuart",
594 		.of_match_table = aspeed_vuart_table,
595 	},
596 	.probe = aspeed_vuart_probe,
597 	.remove = aspeed_vuart_remove,
598 };
599 
600 module_platform_driver(aspeed_vuart_driver);
601 
602 MODULE_AUTHOR("Jeremy Kerr <jk@ozlabs.org>");
603 MODULE_LICENSE("GPL");
604 MODULE_DESCRIPTION("Driver for Aspeed VUART device");
605