~hc/RK356X_SDK_RELEASE.git

..	..	@@ -14,14 +14,17 @@
14	14	#include <linux/sched/signal.h>
15	15	#include <linux/init.h>
16	16	#include <linux/console.h>
	17	+#include <linux/gpio/consumer.h>
17	18	#include <linux/of.h>
18	19	#include <linux/proc_fs.h>
19	20	#include <linux/seq_file.h>
20	21	#include <linux/device.h>
21	22	#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
22	23	#include <linux/serial_core.h>
	24	+#include <linux/sysrq.h>
23	25	#include <linux/delay.h>
24	26	#include <linux/mutex.h>
	27	+#include <linux/security.h>
25	28
26	29	#include <linux/irq.h>
27	30	#include <linux/uaccess.h>
..	..	@@ -38,6 +41,11 @@
38	41	static struct lock_class_key port_lock_key;
39	42
40	43	#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
	44	+
	45	+/*
	46	+ * Max time with active RTS before/after data is sent.
	47	+ */
	48	+#define RS485_MAX_RTS_DELAY 100 /* msecs */
41	49
42	50	static void uart_change_speed(struct tty_struct tty, struct uart_state state,
43	51	struct ktermios *old_termios);
..	..	@@ -144,7 +152,7 @@
144	152	spin_lock_irqsave(&port->lock, flags);
145	153	old = port->mctrl;
146	154	port->mctrl = (old & ~clear) \| set;
147		- if (old != port->mctrl)
	155	+ if (old != port->mctrl && !(port->rs485.flags & SER_RS485_ENABLED))
148	156	port->ops->set_mctrl(port, port->mctrl);
149	157	spin_unlock_irqrestore(&port->lock, flags);
150	158	}
..	..	@@ -154,23 +162,10 @@
154	162
155	163	static void uart_port_dtr_rts(struct uart_port *uport, int raise)
156	164	{
157		- int rs485_on = uport->rs485_config &&
158		- (uport->rs485.flags & SER_RS485_ENABLED);
159		- int RTS_after_send = !!(uport->rs485.flags & SER_RS485_RTS_AFTER_SEND);
160		-
161		- if (raise) {
162		- if (rs485_on && RTS_after_send) {
163		- uart_set_mctrl(uport, TIOCM_DTR);
164		- uart_clear_mctrl(uport, TIOCM_RTS);
165		- } else {
166		- uart_set_mctrl(uport, TIOCM_DTR \| TIOCM_RTS);
167		- }
168		- } else {
169		- unsigned int clear = TIOCM_DTR;
170		-
171		- clear \|= (!rs485_on \|\| RTS_after_send) ? TIOCM_RTS : 0;
172		- uart_clear_mctrl(uport, clear);
173		- }
	165	+ if (raise)
	166	+ uart_set_mctrl(uport, TIOCM_DTR \| TIOCM_RTS);
	167	+ else
	168	+ uart_clear_mctrl(uport, TIOCM_DTR \| TIOCM_RTS);
174	169	}
175	170
176	171	/*
..	..	@@ -667,6 +662,20 @@
667	662	}
668	663
669	664	/*
	665	+ * This function performs low-level write of high-priority XON/XOFF
	666	+ * character and accounting for it.
	667	+ *
	668	+ * Requires uart_port to implement .serial_out().
	669	+ */
	670	+void uart_xchar_out(struct uart_port *uport, int offset)
	671	+{
	672	+ serial_port_out(uport, offset, uport->x_char);
	673	+ uport->icount.tx++;
	674	+ uport->x_char = 0;
	675	+}
	676	+EXPORT_SYMBOL_GPL(uart_xchar_out);
	677	+
	678	+/*
670	679	* This function is used to send a high-priority XON/XOFF character to
671	680	* the device
672	681	*/
..	..	@@ -792,17 +801,13 @@
792	801	return ret;
793	802	}
794	803
795		-static int uart_get_info_user(struct tty_port *port,
796		- struct serial_struct __user *retinfo)
	804	+static int uart_get_info_user(struct tty_struct *tty,
	805	+ struct serial_struct *ss)
797	806	{
798		- struct serial_struct tmp;
	807	+ struct uart_state *state = tty->driver_data;
	808	+ struct tty_port *port = &state->port;
799	809
800		- if (uart_get_info(port, &tmp) < 0)
801		- return -EIO;
802		-
803		- if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
804		- return -EFAULT;
805		- return 0;
	810	+ return uart_get_info(port, ss) < 0 ? -EIO : 0;
806	811	}
807	812
808	813	static int uart_set_info(struct tty_struct tty, struct tty_port port,
..	..	@@ -864,6 +869,12 @@
864	869	(new_flags & UPF_USR_MASK));
865	870	uport->custom_divisor = new_info->custom_divisor;
866	871	goto check_and_exit;
	872	+ }
	873	+
	874	+ if (change_irq \|\| change_port) {
	875	+ retval = security_locked_down(LOCKDOWN_TIOCSSERIAL);
	876	+ if (retval)
	877	+ goto exit;
867	878	}
868	879
869	880	/*
..	..	@@ -1004,16 +1015,13 @@
1004	1015	return retval;
1005	1016	}
1006	1017
1007		-static int uart_set_info_user(struct tty_struct tty, struct uart_state state,
1008		- struct serial_struct __user *newinfo)
	1018	+static int uart_set_info_user(struct tty_struct tty, struct serial_struct ss)
1009	1019	{
1010		- struct serial_struct new_serial;
	1020	+ struct uart_state *state = tty->driver_data;
1011	1021	struct tty_port *port = &state->port;
1012	1022	int retval;
1013	1023
1014		- if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1015		- return -EFAULT;
1016		-
	1024	+ down_write(&tty->termios_rwsem);
1017	1025	/*
1018	1026	* This semaphore protects port->count. It is also
1019	1027	* very useful to prevent opens. Also, take the
..	..	@@ -1022,8 +1030,9 @@
1022	1030	* under us.
1023	1031	*/
1024	1032	mutex_lock(&port->mutex);
1025		- retval = uart_set_info(tty, port, state, &new_serial);
	1033	+ retval = uart_set_info(tty, port, state, ss);
1026	1034	mutex_unlock(&port->mutex);
	1035	+ up_write(&tty->termios_rwsem);
1027	1036	return retval;
1028	1037	}
1029	1038
..	..	@@ -1120,7 +1129,7 @@
1120	1129	return ret;
1121	1130	}
1122	1131
1123		-static int uart_do_autoconfig(struct tty_struct tty,struct uart_state state)
	1132	+static int uart_do_autoconfig(struct tty_struct tty, struct uart_state state)
1124	1133	{
1125	1134	struct tty_port *port = &state->port;
1126	1135	struct uart_port *uport;
..	..	@@ -1305,18 +1314,103 @@
1305	1314	unsigned long flags;
1306	1315
1307	1316	if (!port->rs485_config)
1308		- return -ENOIOCTLCMD;
	1317	+ return -ENOTTY;
1309	1318
1310	1319	if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user)))
1311	1320	return -EFAULT;
1312	1321
	1322	+ /* pick sane settings if the user hasn't */
	1323	+ if (!(rs485.flags & SER_RS485_RTS_ON_SEND) ==
	1324	+ !(rs485.flags & SER_RS485_RTS_AFTER_SEND)) {
	1325	+ dev_warn_ratelimited(port->dev,
	1326	+ "%s (%d): invalid RTS setting, using RTS_ON_SEND instead\n",
	1327	+ port->name, port->line);
	1328	+ rs485.flags \|= SER_RS485_RTS_ON_SEND;
	1329	+ rs485.flags &= ~SER_RS485_RTS_AFTER_SEND;
	1330	+ }
	1331	+
	1332	+ if (rs485.delay_rts_before_send > RS485_MAX_RTS_DELAY) {
	1333	+ rs485.delay_rts_before_send = RS485_MAX_RTS_DELAY;
	1334	+ dev_warn_ratelimited(port->dev,
	1335	+ "%s (%d): RTS delay before sending clamped to %u ms\n",
	1336	+ port->name, port->line, rs485.delay_rts_before_send);
	1337	+ }
	1338	+
	1339	+ if (rs485.delay_rts_after_send > RS485_MAX_RTS_DELAY) {
	1340	+ rs485.delay_rts_after_send = RS485_MAX_RTS_DELAY;
	1341	+ dev_warn_ratelimited(port->dev,
	1342	+ "%s (%d): RTS delay after sending clamped to %u ms\n",
	1343	+ port->name, port->line, rs485.delay_rts_after_send);
	1344	+ }
	1345	+ /* Return clean padding area to userspace */
	1346	+ memset(rs485.padding, 0, sizeof(rs485.padding));
	1347	+
1313	1348	spin_lock_irqsave(&port->lock, flags);
1314	1349	ret = port->rs485_config(port, &rs485);
	1350	+ if (!ret) {
	1351	+ port->rs485 = rs485;
	1352	+
	1353	+ /* Reset RTS and other mctrl lines when disabling RS485 */
	1354	+ if (!(rs485.flags & SER_RS485_ENABLED))
	1355	+ port->ops->set_mctrl(port, port->mctrl);
	1356	+ }
1315	1357	spin_unlock_irqrestore(&port->lock, flags);
1316	1358	if (ret)
1317	1359	return ret;
1318	1360
1319	1361	if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485)))
	1362	+ return -EFAULT;
	1363	+
	1364	+ return 0;
	1365	+}
	1366	+
	1367	+static int uart_get_iso7816_config(struct uart_port *port,
	1368	+ struct serial_iso7816 __user *iso7816)
	1369	+{
	1370	+ unsigned long flags;
	1371	+ struct serial_iso7816 aux;
	1372	+
	1373	+ if (!port->iso7816_config)
	1374	+ return -ENOTTY;
	1375	+
	1376	+ spin_lock_irqsave(&port->lock, flags);
	1377	+ aux = port->iso7816;
	1378	+ spin_unlock_irqrestore(&port->lock, flags);
	1379	+
	1380	+ if (copy_to_user(iso7816, &aux, sizeof(aux)))
	1381	+ return -EFAULT;
	1382	+
	1383	+ return 0;
	1384	+}
	1385	+
	1386	+static int uart_set_iso7816_config(struct uart_port *port,
	1387	+ struct serial_iso7816 __user *iso7816_user)
	1388	+{
	1389	+ struct serial_iso7816 iso7816;
	1390	+ int i, ret;
	1391	+ unsigned long flags;
	1392	+
	1393	+ if (!port->iso7816_config)
	1394	+ return -ENOTTY;
	1395	+
	1396	+ if (copy_from_user(&iso7816, iso7816_user, sizeof(*iso7816_user)))
	1397	+ return -EFAULT;
	1398	+
	1399	+ /*
	1400	+ * There are 5 words reserved for future use. Check that userspace
	1401	+ * doesn't put stuff in there to prevent breakages in the future.
	1402	+ */
	1403	+ for (i = 0; i < 5; i++)
	1404	+ if (iso7816.reserved[i])
	1405	+ return -EINVAL;
	1406	+
	1407	+ spin_lock_irqsave(&port->lock, flags);
	1408	+ ret = port->iso7816_config(port, &iso7816);
	1409	+ spin_unlock_irqrestore(&port->lock, flags);
	1410	+ if (ret)
	1411	+ return ret;
	1412	+
	1413	+ if (copy_to_user(iso7816_user, &port->iso7816, sizeof(port->iso7816)))
1320	1414	return -EFAULT;
1321	1415
1322	1416	return 0;
..	..	@@ -1339,25 +1433,10 @@
1339	1433	* These ioctls don't rely on the hardware to be present.
1340	1434	*/
1341	1435	switch (cmd) {
1342		- case TIOCGSERIAL:
1343		- ret = uart_get_info_user(port, uarg);
1344		- break;
1345		-
1346		- case TIOCSSERIAL:
1347		- down_write(&tty->termios_rwsem);
1348		- ret = uart_set_info_user(tty, state, uarg);
1349		- up_write(&tty->termios_rwsem);
1350		- break;
1351		-
1352	1436	case TIOCSERCONFIG:
1353	1437	down_write(&tty->termios_rwsem);
1354	1438	ret = uart_do_autoconfig(tty, state);
1355	1439	up_write(&tty->termios_rwsem);
1356		- break;
1357		-
1358		- case TIOCSERGWILD: /* obsolete */
1359		- case TIOCSERSWILD: /* obsolete */
1360		- ret = 0;
1361	1440	break;
1362	1441	}
1363	1442
..	..	@@ -1405,6 +1484,14 @@
1405	1484
1406	1485	case TIOCSRS485:
1407	1486	ret = uart_set_rs485_config(uport, uarg);
	1487	+ break;
	1488	+
	1489	+ case TIOCSISO7816:
	1490	+ ret = uart_set_iso7816_config(state->uart_port, uarg);
	1491	+ break;
	1492	+
	1493	+ case TIOCGISO7816:
	1494	+ ret = uart_get_iso7816_config(state->uart_port, uarg);
1408	1495	break;
1409	1496	default:
1410	1497	if (uport->ops->ioctl)
..	..	@@ -1473,7 +1560,7 @@
1473	1560	}
1474	1561
1475	1562	uart_change_speed(tty, state, old_termios);
1476		- /* reload cflag from termios; port driver may have overriden flags */
	1563	+ /* reload cflag from termios; port driver may have overridden flags */
1477	1564	cflag = tty->termios.c_cflag;
1478	1565
1479	1566	/* Handle transition to B0 status */
..	..	@@ -1482,6 +1569,7 @@
1482	1569	/* Handle transition away from B0 status */
1483	1570	else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1484	1571	unsigned int mask = TIOCM_DTR;
	1572	+
1485	1573	if (!(cflag & CRTSCTS) \|\| !tty_throttled(tty))
1486	1574	mask \|= TIOCM_RTS;
1487	1575	uart_set_mctrl(uport, mask);
..	..	@@ -1879,6 +1967,12 @@
1879	1967	}
1880	1968	#endif
1881	1969
	1970	+static void uart_port_spin_lock_init(struct uart_port *port)
	1971	+{
	1972	+ spin_lock_init(&port->lock);
	1973	+ lockdep_set_class(&port->lock, &port_lock_key);
	1974	+}
	1975	+
1882	1976	#if defined(CONFIG_SERIAL_CORE_CONSOLE) \|\| defined(CONFIG_CONSOLE_POLL)
1883	1977	/**
1884	1978	* uart_console_write - write a console message to a serial port
..	..	@@ -1935,8 +2029,10 @@
1935	2029	* console=<name>,io\|mmio\|mmio16\|mmio32\|mmio32be\|mmio32native,<addr>,<options>
1936	2030	*
1937	2031	* The optional form
	2032	+ *
1938	2033	* earlycon=<name>,0x<addr>,<options>
1939	2034	* console=<name>,0x<addr>,<options>
	2035	+ *
1940	2036	* is also accepted; the returned @iotype will be UPIO_MEM.
1941	2037	*
1942	2038	* Returns 0 on success or -EINVAL on failure
..	..	@@ -2030,15 +2126,14 @@
2030	2126	static struct ktermios dummy;
2031	2127
2032	2128	/*
2033		- * Ensure that the serial console lock is initialised
2034		- * early.
2035		- * If this port is a console, then the spinlock is already
2036		- * initialised.
	2129	+ * Ensure that the serial-console lock is initialised early.
	2130	+ *
	2131	+ * Note that the console-enabled check is needed because of kgdboc,
	2132	+ * which can end up calling uart_set_options() for an already enabled
	2133	+ * console via tty_find_polling_driver() and uart_poll_init().
2037	2134	*/
2038		- if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
2039		- spin_lock_init(&port->lock);
2040		- lockdep_set_class(&port->lock, &port_lock_key);
2041		- }
	2135	+ if (!uart_console_enabled(port) && !port->console_reinit)
	2136	+ uart_port_spin_lock_init(port);
2042	2137
2043	2138	memset(&termios, 0, sizeof(struct ktermios));
2044	2139
..	..	@@ -2053,7 +2148,7 @@
2053	2148	switch (parity) {
2054	2149	case 'o': case 'O':
2055	2150	termios.c_cflag \|= PARODD;
2056		- /fall through/
	2151	+ fallthrough;
2057	2152	case 'e': case 'E':
2058	2153	termios.c_cflag \|= PARENB;
2059	2154	break;
..	..	@@ -2228,17 +2323,22 @@
2228	2323
2229	2324	uart_change_pm(state, UART_PM_STATE_ON);
2230	2325	spin_lock_irq(&uport->lock);
2231		- ops->set_mctrl(uport, 0);
	2326	+ if (!(uport->rs485.flags & SER_RS485_ENABLED))
	2327	+ ops->set_mctrl(uport, 0);
2232	2328	spin_unlock_irq(&uport->lock);
2233	2329	if (console_suspend_enabled \|\| !uart_console(uport)) {
2234	2330	/* Protected by port mutex for now */
2235	2331	struct tty_struct *tty = port->tty;
	2332	+
2236	2333	ret = ops->startup(uport);
2237	2334	if (ret == 0) {
2238	2335	if (tty)
2239	2336	uart_change_speed(tty, state, NULL);
2240	2337	spin_lock_irq(&uport->lock);
2241		- ops->set_mctrl(uport, uport->mctrl);
	2338	+ if (!(uport->rs485.flags & SER_RS485_ENABLED))
	2339	+ ops->set_mctrl(uport, uport->mctrl);
	2340	+ else
	2341	+ uport->rs485_config(uport, &uport->rs485);
2242	2342	ops->start_tx(uport);
2243	2343	spin_unlock_irq(&uport->lock);
2244	2344	tty_port_set_initialized(port, 1);
..	..	@@ -2336,7 +2436,10 @@
2336	2436	*/
2337	2437	spin_lock_irqsave(&port->lock, flags);
2338	2438	port->mctrl &= TIOCM_DTR;
2339		- port->ops->set_mctrl(port, port->mctrl);
	2439	+ if (!(port->rs485.flags & SER_RS485_ENABLED))
	2440	+ port->ops->set_mctrl(port, port->mctrl);
	2441	+ else
	2442	+ port->rs485_config(port, &port->rs485);
2340	2443	spin_unlock_irqrestore(&port->lock, flags);
2341	2444
2342	2445	/*
..	..	@@ -2456,6 +2559,8 @@
2456	2559	#endif
2457	2560	.tiocmget = uart_tiocmget,
2458	2561	.tiocmset = uart_tiocmset,
	2562	+ .set_serial = uart_set_info_user,
	2563	+ .get_serial = uart_get_info_user,
2459	2564	.get_icount = uart_get_icount,
2460	2565	#ifdef CONFIG_CONSOLE_POLL
2461	2566	.poll_init = uart_poll_init,
..	..	@@ -2487,7 +2592,7 @@
2487	2592	int uart_register_driver(struct uart_driver *drv)
2488	2593	{
2489	2594	struct tty_driver *normal;
2490		- int i, retval;
	2595	+ int i, retval = -ENOMEM;
2491	2596
2492	2597	BUG_ON(drv->state);
2493	2598
..	..	@@ -2539,7 +2644,7 @@
2539	2644	out_kfree:
2540	2645	kfree(drv->state);
2541	2646	out:
2542		- return -ENOMEM;
	2647	+ return retval;
2543	2648	}
2544	2649
2545	2650	/**
..	..	@@ -2573,36 +2678,37 @@
2573	2678	}
2574	2679	EXPORT_SYMBOL_GPL(uart_console_device);
2575	2680
2576		-static ssize_t uart_get_attr_uartclk(struct device *dev,
	2681	+static ssize_t uartclk_show(struct device *dev,
2577	2682	struct device_attribute attr, char buf)
2578	2683	{
2579	2684	struct serial_struct tmp;
2580	2685	struct tty_port *port = dev_get_drvdata(dev);
2581	2686
2582	2687	uart_get_info(port, &tmp);
2583		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
	2688	+ return sprintf(buf, "%d\n", tmp.baud_base * 16);
2584	2689	}
2585	2690
2586		-static ssize_t uart_get_attr_type(struct device *dev,
	2691	+static ssize_t type_show(struct device *dev,
2587	2692	struct device_attribute attr, char buf)
2588	2693	{
2589	2694	struct serial_struct tmp;
2590	2695	struct tty_port *port = dev_get_drvdata(dev);
2591	2696
2592	2697	uart_get_info(port, &tmp);
2593		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type);
	2698	+ return sprintf(buf, "%d\n", tmp.type);
2594	2699	}
2595		-static ssize_t uart_get_attr_line(struct device *dev,
	2700	+
	2701	+static ssize_t line_show(struct device *dev,
2596	2702	struct device_attribute attr, char buf)
2597	2703	{
2598	2704	struct serial_struct tmp;
2599	2705	struct tty_port *port = dev_get_drvdata(dev);
2600	2706
2601	2707	uart_get_info(port, &tmp);
2602		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line);
	2708	+ return sprintf(buf, "%d\n", tmp.line);
2603	2709	}
2604	2710
2605		-static ssize_t uart_get_attr_port(struct device *dev,
	2711	+static ssize_t port_show(struct device *dev,
2606	2712	struct device_attribute attr, char buf)
2607	2713	{
2608	2714	struct serial_struct tmp;
..	..	@@ -2613,135 +2719,187 @@
2613	2719	ioaddr = tmp.port;
2614	2720	if (HIGH_BITS_OFFSET)
2615	2721	ioaddr \|= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
2616		- return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr);
	2722	+ return sprintf(buf, "0x%lX\n", ioaddr);
2617	2723	}
2618	2724
2619		-static ssize_t uart_get_attr_irq(struct device *dev,
	2725	+static ssize_t irq_show(struct device *dev,
2620	2726	struct device_attribute attr, char buf)
2621	2727	{
2622	2728	struct serial_struct tmp;
2623	2729	struct tty_port *port = dev_get_drvdata(dev);
2624	2730
2625	2731	uart_get_info(port, &tmp);
2626		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq);
	2732	+ return sprintf(buf, "%d\n", tmp.irq);
2627	2733	}
2628	2734
2629		-static ssize_t uart_get_attr_flags(struct device *dev,
	2735	+static ssize_t flags_show(struct device *dev,
2630	2736	struct device_attribute attr, char buf)
2631	2737	{
2632	2738	struct serial_struct tmp;
2633	2739	struct tty_port *port = dev_get_drvdata(dev);
2634	2740
2635	2741	uart_get_info(port, &tmp);
2636		- return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags);
	2742	+ return sprintf(buf, "0x%X\n", tmp.flags);
2637	2743	}
2638	2744
2639		-static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev,
	2745	+static ssize_t xmit_fifo_size_show(struct device *dev,
2640	2746	struct device_attribute attr, char buf)
2641	2747	{
2642	2748	struct serial_struct tmp;
2643	2749	struct tty_port *port = dev_get_drvdata(dev);
2644	2750
2645	2751	uart_get_info(port, &tmp);
2646		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size);
	2752	+ return sprintf(buf, "%d\n", tmp.xmit_fifo_size);
2647	2753	}
2648	2754
2649		-
2650		-static ssize_t uart_get_attr_close_delay(struct device *dev,
	2755	+static ssize_t close_delay_show(struct device *dev,
2651	2756	struct device_attribute attr, char buf)
2652	2757	{
2653	2758	struct serial_struct tmp;
2654	2759	struct tty_port *port = dev_get_drvdata(dev);
2655	2760
2656	2761	uart_get_info(port, &tmp);
2657		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay);
	2762	+ return sprintf(buf, "%d\n", tmp.close_delay);
2658	2763	}
2659	2764
2660		-
2661		-static ssize_t uart_get_attr_closing_wait(struct device *dev,
	2765	+static ssize_t closing_wait_show(struct device *dev,
2662	2766	struct device_attribute attr, char buf)
2663	2767	{
2664	2768	struct serial_struct tmp;
2665	2769	struct tty_port *port = dev_get_drvdata(dev);
2666	2770
2667	2771	uart_get_info(port, &tmp);
2668		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait);
	2772	+ return sprintf(buf, "%d\n", tmp.closing_wait);
2669	2773	}
2670	2774
2671		-static ssize_t uart_get_attr_custom_divisor(struct device *dev,
	2775	+static ssize_t custom_divisor_show(struct device *dev,
2672	2776	struct device_attribute attr, char buf)
2673	2777	{
2674	2778	struct serial_struct tmp;
2675	2779	struct tty_port *port = dev_get_drvdata(dev);
2676	2780
2677	2781	uart_get_info(port, &tmp);
2678		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor);
	2782	+ return sprintf(buf, "%d\n", tmp.custom_divisor);
2679	2783	}
2680	2784
2681		-static ssize_t uart_get_attr_io_type(struct device *dev,
	2785	+static ssize_t io_type_show(struct device *dev,
2682	2786	struct device_attribute attr, char buf)
2683	2787	{
2684	2788	struct serial_struct tmp;
2685	2789	struct tty_port *port = dev_get_drvdata(dev);
2686	2790
2687	2791	uart_get_info(port, &tmp);
2688		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type);
	2792	+ return sprintf(buf, "%d\n", tmp.io_type);
2689	2793	}
2690	2794
2691		-static ssize_t uart_get_attr_iomem_base(struct device *dev,
	2795	+static ssize_t iomem_base_show(struct device *dev,
2692	2796	struct device_attribute attr, char buf)
2693	2797	{
2694	2798	struct serial_struct tmp;
2695	2799	struct tty_port *port = dev_get_drvdata(dev);
2696	2800
2697	2801	uart_get_info(port, &tmp);
2698		- return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base);
	2802	+ return sprintf(buf, "0x%lX\n", (unsigned long)tmp.iomem_base);
2699	2803	}
2700	2804
2701		-static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev,
	2805	+static ssize_t iomem_reg_shift_show(struct device *dev,
2702	2806	struct device_attribute attr, char buf)
2703	2807	{
2704	2808	struct serial_struct tmp;
2705	2809	struct tty_port *port = dev_get_drvdata(dev);
2706	2810
2707	2811	uart_get_info(port, &tmp);
2708		- return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift);
	2812	+ return sprintf(buf, "%d\n", tmp.iomem_reg_shift);
2709	2813	}
2710	2814
2711		-static DEVICE_ATTR(type, S_IRUSR \| S_IRGRP, uart_get_attr_type, NULL);
2712		-static DEVICE_ATTR(line, S_IRUSR \| S_IRGRP, uart_get_attr_line, NULL);
2713		-static DEVICE_ATTR(port, S_IRUSR \| S_IRGRP, uart_get_attr_port, NULL);
2714		-static DEVICE_ATTR(irq, S_IRUSR \| S_IRGRP, uart_get_attr_irq, NULL);
2715		-static DEVICE_ATTR(flags, S_IRUSR \| S_IRGRP, uart_get_attr_flags, NULL);
2716		-static DEVICE_ATTR(xmit_fifo_size, S_IRUSR \| S_IRGRP, uart_get_attr_xmit_fifo_size, NULL);
2717		-static DEVICE_ATTR(uartclk, S_IRUSR \| S_IRGRP, uart_get_attr_uartclk, NULL);
2718		-static DEVICE_ATTR(close_delay, S_IRUSR \| S_IRGRP, uart_get_attr_close_delay, NULL);
2719		-static DEVICE_ATTR(closing_wait, S_IRUSR \| S_IRGRP, uart_get_attr_closing_wait, NULL);
2720		-static DEVICE_ATTR(custom_divisor, S_IRUSR \| S_IRGRP, uart_get_attr_custom_divisor, NULL);
2721		-static DEVICE_ATTR(io_type, S_IRUSR \| S_IRGRP, uart_get_attr_io_type, NULL);
2722		-static DEVICE_ATTR(iomem_base, S_IRUSR \| S_IRGRP, uart_get_attr_iomem_base, NULL);
2723		-static DEVICE_ATTR(iomem_reg_shift, S_IRUSR \| S_IRGRP, uart_get_attr_iomem_reg_shift, NULL);
	2815	+static ssize_t console_show(struct device *dev,
	2816	+ struct device_attribute attr, char buf)
	2817	+{
	2818	+ struct tty_port *port = dev_get_drvdata(dev);
	2819	+ struct uart_state *state = container_of(port, struct uart_state, port);
	2820	+ struct uart_port *uport;
	2821	+ bool console = false;
	2822	+
	2823	+ mutex_lock(&port->mutex);
	2824	+ uport = uart_port_check(state);
	2825	+ if (uport)
	2826	+ console = uart_console_enabled(uport);
	2827	+ mutex_unlock(&port->mutex);
	2828	+
	2829	+ return sprintf(buf, "%c\n", console ? 'Y' : 'N');
	2830	+}
	2831	+
	2832	+static ssize_t console_store(struct device *dev,
	2833	+ struct device_attribute attr, const char buf, size_t count)
	2834	+{
	2835	+ struct tty_port *port = dev_get_drvdata(dev);
	2836	+ struct uart_state *state = container_of(port, struct uart_state, port);
	2837	+ struct uart_port *uport;
	2838	+ bool oldconsole, newconsole;
	2839	+ int ret;
	2840	+
	2841	+ ret = kstrtobool(buf, &newconsole);
	2842	+ if (ret)
	2843	+ return ret;
	2844	+
	2845	+ mutex_lock(&port->mutex);
	2846	+ uport = uart_port_check(state);
	2847	+ if (uport) {
	2848	+ oldconsole = uart_console_enabled(uport);
	2849	+ if (oldconsole && !newconsole) {
	2850	+ ret = unregister_console(uport->cons);
	2851	+ } else if (!oldconsole && newconsole) {
	2852	+ if (uart_console(uport)) {
	2853	+ uport->console_reinit = 1;
	2854	+ register_console(uport->cons);
	2855	+ } else {
	2856	+ ret = -ENOENT;
	2857	+ }
	2858	+ }
	2859	+ } else {
	2860	+ ret = -ENXIO;
	2861	+ }
	2862	+ mutex_unlock(&port->mutex);
	2863	+
	2864	+ return ret < 0 ? ret : count;
	2865	+}
	2866	+
	2867	+static DEVICE_ATTR_RO(uartclk);
	2868	+static DEVICE_ATTR_RO(type);
	2869	+static DEVICE_ATTR_RO(line);
	2870	+static DEVICE_ATTR_RO(port);
	2871	+static DEVICE_ATTR_RO(irq);
	2872	+static DEVICE_ATTR_RO(flags);
	2873	+static DEVICE_ATTR_RO(xmit_fifo_size);
	2874	+static DEVICE_ATTR_RO(close_delay);
	2875	+static DEVICE_ATTR_RO(closing_wait);
	2876	+static DEVICE_ATTR_RO(custom_divisor);
	2877	+static DEVICE_ATTR_RO(io_type);
	2878	+static DEVICE_ATTR_RO(iomem_base);
	2879	+static DEVICE_ATTR_RO(iomem_reg_shift);
	2880	+static DEVICE_ATTR_RW(console);
2724	2881
2725	2882	static struct attribute *tty_dev_attrs[] = {
	2883	+ &dev_attr_uartclk.attr,
2726	2884	&dev_attr_type.attr,
2727	2885	&dev_attr_line.attr,
2728	2886	&dev_attr_port.attr,
2729	2887	&dev_attr_irq.attr,
2730	2888	&dev_attr_flags.attr,
2731	2889	&dev_attr_xmit_fifo_size.attr,
2732		- &dev_attr_uartclk.attr,
2733	2890	&dev_attr_close_delay.attr,
2734	2891	&dev_attr_closing_wait.attr,
2735	2892	&dev_attr_custom_divisor.attr,
2736	2893	&dev_attr_io_type.attr,
2737	2894	&dev_attr_iomem_base.attr,
2738	2895	&dev_attr_iomem_reg_shift.attr,
2739		- NULL,
2740		- };
	2896	+ &dev_attr_console.attr,
	2897	+ NULL
	2898	+};
2741	2899
2742	2900	static const struct attribute_group tty_dev_attr_group = {
2743	2901	.attrs = tty_dev_attrs,
2744		- };
	2902	+};
2745	2903
2746	2904	/**
2747	2905	* uart_add_one_port - attach a driver-defined port structure
..	..	@@ -2793,13 +2951,12 @@
2793	2951	}
2794	2952
2795	2953	/*
2796		- * If this port is a console, then the spinlock is already
	2954	+ * If this port is in use as a console then the spinlock is already
2797	2955	* initialised.
2798	2956	*/
2799		- if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
2800		- spin_lock_init(&uport->lock);
2801		- lockdep_set_class(&uport->lock, &port_lock_key);
2802		- }
	2957	+ if (!uart_console_enabled(uport))
	2958	+ uart_port_spin_lock_init(uport);
	2959	+
2803	2960	if (uport->cons && uport->dev)
2804	2961	of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
2805	2962
..	..	@@ -2828,7 +2985,7 @@
2828	2985	*/
2829	2986	tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver,
2830	2987	uport->line, uport->dev, port, uport->tty_groups);
2831		- if (likely(!IS_ERR(tty_dev))) {
	2988	+ if (!IS_ERR(tty_dev)) {
2832	2989	device_set_wakeup_capable(tty_dev, 1);
2833	2990	} else {
2834	2991	dev_err(uport->dev, "Cannot register tty device on line %d\n",
..	..	@@ -3050,6 +3207,56 @@
3050	3207	}
3051	3208	EXPORT_SYMBOL_GPL(uart_insert_char);
3052	3209
	3210	+#ifdef CONFIG_MAGIC_SYSRQ_SERIAL
	3211	+static const char sysrq_toggle_seq[] = CONFIG_MAGIC_SYSRQ_SERIAL_SEQUENCE;
	3212	+
	3213	+static void uart_sysrq_on(struct work_struct *w)
	3214	+{
	3215	+ int sysrq_toggle_seq_len = strlen(sysrq_toggle_seq);
	3216	+
	3217	+ sysrq_toggle_support(1);
	3218	+ pr_info("SysRq is enabled by magic sequence '%*pE' on serial\n",
	3219	+ sysrq_toggle_seq_len, sysrq_toggle_seq);
	3220	+}
	3221	+static DECLARE_WORK(sysrq_enable_work, uart_sysrq_on);
	3222	+
	3223	+/**
	3224	+ * uart_try_toggle_sysrq - Enables SysRq from serial line
	3225	+ * @port: uart_port structure where char(s) after BREAK met
	3226	+ * @ch: new character in the sequence after received BREAK
	3227	+ *
	3228	+ * Enables magic SysRq when the required sequence is met on port
	3229	+ * (see CONFIG_MAGIC_SYSRQ_SERIAL_SEQUENCE).
	3230	+ *
	3231	+ * Returns false if @ch is out of enabling sequence and should be
	3232	+ * handled some other way, true if @ch was consumed.
	3233	+ */
	3234	+bool uart_try_toggle_sysrq(struct uart_port *port, unsigned int ch)
	3235	+{
	3236	+ int sysrq_toggle_seq_len = strlen(sysrq_toggle_seq);
	3237	+
	3238	+ if (!sysrq_toggle_seq_len)
	3239	+ return false;
	3240	+
	3241	+ BUILD_BUG_ON(ARRAY_SIZE(sysrq_toggle_seq) >= U8_MAX);
	3242	+ if (sysrq_toggle_seq[port->sysrq_seq] != ch) {
	3243	+ port->sysrq_seq = 0;
	3244	+ return false;
	3245	+ }
	3246	+
	3247	+ if (++port->sysrq_seq < sysrq_toggle_seq_len) {
	3248	+ port->sysrq = jiffies + SYSRQ_TIMEOUT;
	3249	+ return true;
	3250	+ }
	3251	+
	3252	+ schedule_work(&sysrq_enable_work);
	3253	+
	3254	+ port->sysrq = 0;
	3255	+ return true;
	3256	+}
	3257	+EXPORT_SYMBOL_GPL(uart_try_toggle_sysrq);
	3258	+#endif
	3259	+
3053	3260	EXPORT_SYMBOL(uart_write_wakeup);
3054	3261	EXPORT_SYMBOL(uart_register_driver);
3055	3262	EXPORT_SYMBOL(uart_unregister_driver);
..	..	@@ -3060,14 +3267,15 @@
3060	3267
3061	3268	/**
3062	3269	* uart_get_rs485_mode() - retrieve rs485 properties for given uart
3063		- * @dev: uart device
3064		- * @rs485conf: output parameter
	3270	+ * @port: uart device's target port
3065	3271	*
3066	3272	* This function implements the device tree binding described in
3067	3273	* Documentation/devicetree/bindings/serial/rs485.txt.
3068	3274	*/
3069		-void uart_get_rs485_mode(struct device dev, struct serial_rs485 rs485conf)
	3275	+int uart_get_rs485_mode(struct uart_port *port)
3070	3276	{
	3277	+ struct serial_rs485 *rs485conf = &port->rs485;
	3278	+ struct device *dev = port->dev;
3071	3279	u32 rs485_delay[2];
3072	3280	int ret;
3073	3281
..	..	@@ -3086,6 +3294,7 @@
3086	3294	* to get to a defined state with the following properties:
3087	3295	*/
3088	3296	rs485conf->flags &= ~(SER_RS485_RX_DURING_TX \| SER_RS485_ENABLED \|
	3297	+ SER_RS485_TERMINATE_BUS \|
3089	3298	SER_RS485_RTS_AFTER_SEND);
3090	3299	rs485conf->flags \|= SER_RS485_RTS_ON_SEND;
3091	3300
..	..	@@ -3099,6 +3308,21 @@
3099	3308	rs485conf->flags &= ~SER_RS485_RTS_ON_SEND;
3100	3309	rs485conf->flags \|= SER_RS485_RTS_AFTER_SEND;
3101	3310	}
	3311	+
	3312	+ /*
	3313	+ * Disabling termination by default is the safe choice: Else if many
	3314	+ * bus participants enable it, no communication is possible at all.
	3315	+ * Works fine for short cables and users may enable for longer cables.
	3316	+ */
	3317	+ port->rs485_term_gpio = devm_gpiod_get_optional(dev, "rs485-term",
	3318	+ GPIOD_OUT_LOW);
	3319	+ if (IS_ERR(port->rs485_term_gpio)) {
	3320	+ ret = PTR_ERR(port->rs485_term_gpio);
	3321	+ port->rs485_term_gpio = NULL;
	3322	+ return dev_err_probe(dev, ret, "Cannot get rs485-term-gpios\n");
	3323	+ }
	3324	+
	3325	+ return 0;
3102	3326	}
3103	3327	EXPORT_SYMBOL_GPL(uart_get_rs485_mode);
3104	3328