lael-labs/linux

Documentation/admin-guide/serial-console.rst+33−3

@@ -33,8 +33,11 @@ The format of this option is:: · 32 unmodified lines
33	9600n8. The maximum baudrate is 115200.	33	9600n8. The maximum baudrate is 115200.
34		34
35	You can specify multiple console= options on the kernel command line.	35	You can specify multiple console= options on the kernel command line.
36	Output will appear on all of them. The last device will be used when	36
37	you open ``/dev/console``. So, for example::	37	The behavior is well defined when each device type is mentioned only once.
		38	In this case, the output will appear on all requested consoles. And
		39	the last device will be used when you open ``/dev/console``.
		40	So, for example::
38		41
39	console=ttyS1,9600 console=tty0	42	console=ttyS1,9600 console=tty0
40		43
@@ -42,7 +45,34 @@ defines that opening ``/dev/console`` will get you the current foreground · 1 unmodified line
42	virtual console, and kernel messages will appear on both the VGA	45	virtual console, and kernel messages will appear on both the VGA
43	console and the 2nd serial port (ttyS1 or COM2) at 9600 baud.	46	console and the 2nd serial port (ttyS1 or COM2) at 9600 baud.
44		47
45	Note that you can only define one console per device type (serial, video).	48	The behavior is more complicated when the same device type is defined more
		49	times. In this case, there are the following two rules:
		50
		51	1. The output will appear only on the first device of each defined type.
		52
		53	2. ``/dev/console`` will be associated with the first registered device.
		54	Where the registration order depends on how kernel initializes various
		55	subsystems.
		56
		57	This rule is used also when the last console= parameter is not used
		58	for other reasons. For example, because of a typo or because
		59	the hardware is not available.
		60
		61	The result might be surprising. For example, the following two command
		62	lines have the same result:
		63
		64	console=ttyS1,9600 console=tty0 console=tty1
		65	console=tty0 console=ttyS1,9600 console=tty1
		66
		67	The kernel messages are printed only on ``tty0`` and ``ttyS1``. And
		68	``/dev/console`` gets associated with ``tty0``. It is because kernel
		69	tries to register graphical consoles before serial ones. It does it
		70	because of the default behavior when no console device is specified,
		71	see below.
		72
		73	Note that the last ``console=tty1`` parameter still makes a difference.
		74	The kernel command line is used also by systemd. It would use the last
		75	defined ``tty1`` as the login console.
46		76
47	If no console device is specified, the first device found capable of	77	If no console device is specified, the first device found capable of
48	acting as a system console will be used. At this time, the system	78	acting as a system console will be used. At this time, the system

Documentation/devicetree/bindings/serial/amlogic,meson-uart.yaml+11−2

 # Copyright 2019 BayLibre, SAS
 %YAML 1.2
 ---
-$id: "http://devicetree.org/schemas/serial/amlogic,meson-uart.yaml#"
+$id: http://devicetree.org/schemas/serial/amlogic,meson-uart.yaml#
-$schema: "http://devicetree.org/meta-schemas/core.yaml#"
+$schema: http://devicetree.org/meta-schemas/core.yaml#
 title: Amlogic Meson SoC UART Serial Interface
               - amlogic,meson-gx-uart
               - amlogic,meson-s4-uart
           - const: amlogic,meson-ao-uart
+      - description: Always-on power domain UART controller on G12A SoCs
+        items:
+          - const: amlogic,meson-g12a-uart
+          - const: amlogic,meson-gx-uart
+          - const: amlogic,meson-ao-uart
       - description: Everything-Else power domain UART controller
         enum:
           - amlogic,meson6-uart
           - amlogic,meson8b-uart
           - amlogic,meson-gx-uart
           - amlogic,meson-s4-uart
+      - description: Everything-Else power domain UART controller on G12A SoCs
+        items:
+          - const: amlogic,meson-g12a-uart
+          - const: amlogic,meson-gx-uart
   reg:
     maxItems: 1

Documentation/devicetree/bindings/serial/fsl-imx-uart.yaml+27−0

@@ -49,6 +49,24 @@ properties: · 48 unmodified lines
49	reg:	49	reg:
50	maxItems: 1	50	maxItems: 1
51		51
		52	clocks:
		53	maxItems: 2
		54
		55	clock-names:
		56	items:
		57	- const: ipg
		58	- const: per
		59
		60	dmas:
		61	items:
		62	- description: DMA controller phandle and request line for RX
		63	- description: DMA controller phandle and request line for TX
		64
		65	dma-names:
		66	items:
		67	- const: rx
		68	- const: tx
		69
52	interrupts:	70	interrupts:
53	maxItems: 1	71	maxItems: 1
54		72
@@ -86,12 +104,16 @@ properties: · 31 unmodified lines
86	required:	104	required:
87	- compatible	105	- compatible
88	- reg	106	- reg
		107	- clocks
		108	- clock-names
89	- interrupts	109	- interrupts
90		110
91	unevaluatedProperties: false	111	unevaluatedProperties: false
92		112
93	examples:	113	examples:
94	- \|	114	- \|
		115	#include <dt-bindings/clock/imx5-clock.h>
		116
95	aliases {	117	aliases {
96	serial0 = &uart1;	118	serial0 = &uart1;
97	};	119	};
@@ -100,6 +122,11 @@ examples: · 2 unmodified lines
100	compatible = "fsl,imx51-uart", "fsl,imx21-uart";	122	compatible = "fsl,imx51-uart", "fsl,imx21-uart";
101	reg = <0x73fbc000 0x4000>;	123	reg = <0x73fbc000 0x4000>;
102	interrupts = <31>;	124	interrupts = <31>;
		125	clocks = <&clks IMX5_CLK_UART1_IPG_GATE>,
		126	<&clks IMX5_CLK_UART1_PER_GATE>;
		127	clock-names = "ipg", "per";
		128	dmas = <&sdma 18 4 1>, <&sdma 19 4 2>;
		129	dma-names = "rx", "tx";
103	uart-has-rtscts;	130	uart-has-rtscts;
104	fsl,dte-mode;	131	fsl,dte-mode;
105	};	132	};

Documentation/devicetree/bindings/serial/fsl-lpuart.yaml+3−0

@@ -65,6 +65,9 @@ properties: · 64 unmodified lines
65	- const: rx	65	- const: rx
66	- const: tx	66	- const: tx
67		67
		68	power-domains:
		69	maxItems: 1
		70
68	required:	71	required:
69	- compatible	72	- compatible
70	- reg	73	- reg

Documentation/devicetree/bindings/serial/qcom,serial-geni-qcom.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/qcom,serial-geni-qcom.yaml#"	4	$id: http://devicetree.org/schemas/serial/qcom,serial-geni-qcom.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Qualcomm Geni based QUP UART interface	7	title: Qualcomm Geni based QUP UART interface
8		8

Documentation/devicetree/bindings/serial/renesas,em-uart.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/renesas,em-uart.yaml#"	4	$id: http://devicetree.org/schemas/serial/renesas,em-uart.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Renesas EMMA Mobile UART Interface	7	title: Renesas EMMA Mobile UART Interface
8		8

Documentation/devicetree/bindings/serial/renesas,hscif.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/renesas,hscif.yaml#"	4	$id: http://devicetree.org/schemas/serial/renesas,hscif.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Renesas High Speed Serial Communication Interface with FIFO (HSCIF)	7	title: Renesas High Speed Serial Communication Interface with FIFO (HSCIF)
8		8

Documentation/devicetree/bindings/serial/renesas,sci.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/renesas,sci.yaml#"	4	$id: http://devicetree.org/schemas/serial/renesas,sci.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Renesas Serial Communication Interface	7	title: Renesas Serial Communication Interface
8		8

Documentation/devicetree/bindings/serial/renesas,scif.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/renesas,scif.yaml#"	4	$id: http://devicetree.org/schemas/serial/renesas,scif.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Renesas Serial Communication Interface with FIFO (SCIF)	7	title: Renesas Serial Communication Interface with FIFO (SCIF)
8		8

Documentation/devicetree/bindings/serial/renesas,scifa.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/renesas,scifa.yaml#"	4	$id: http://devicetree.org/schemas/serial/renesas,scifa.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Renesas Serial Communications Interface with FIFO A (SCIFA)	7	title: Renesas Serial Communications Interface with FIFO A (SCIFA)
8		8

Documentation/devicetree/bindings/serial/renesas,scifb.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/renesas,scifb.yaml#"	4	$id: http://devicetree.org/schemas/serial/renesas,scifb.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Renesas Serial Communications Interface with FIFO B (SCIFB)	7	title: Renesas Serial Communications Interface with FIFO B (SCIFB)
8		8

Documentation/devicetree/bindings/serial/serial.yaml+2−2

@@ -1,8 +1,8 @@
1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	%YAML 1.2	2	%YAML 1.2
3	---	3	---
4	$id: "http://devicetree.org/schemas/serial/serial.yaml#"	4	$id: http://devicetree.org/schemas/serial/serial.yaml#
5	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	5	$schema: http://devicetree.org/meta-schemas/core.yaml#
6		6
7	title: Serial Interface Generic	7	title: Serial Interface Generic
8		8

Documentation/devicetree/bindings/serial/snps-dw-apb-uart.yaml+2−2

       - const: apb_pclk
   dmas:
-    minItems: 2
+    maxItems: 2
   dma-names:
     items:
-      - const: rx
       - const: tx
+      - const: rx
   snps,uart-16550-compatible:
     description: reflects the value of UART_16550_COMPATIBLE configuration

Documentation/devicetree/bindings/serial/sprd-uart.yaml+2−2

@@ -2,8 +2,8 @@ · 1 unmodified line
2	# Copyright 2019 Unisoc Inc.	2	# Copyright 2019 Unisoc Inc.
3	%YAML 1.2	3	%YAML 1.2
4	---	4	---
5	$id: "http://devicetree.org/schemas/serial/sprd-uart.yaml#"	5	$id: http://devicetree.org/schemas/serial/sprd-uart.yaml#
6	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	6	$schema: http://devicetree.org/meta-schemas/core.yaml#
7		7
8	title: Spreadtrum serial UART	8	title: Spreadtrum serial UART
9		9

Documentation/devicetree/bindings/serial/sunplus,sp7021-uart.yaml+2−2

@@ -2,8 +2,8 @@ · 1 unmodified line
2	# Copyright (C) Sunplus Co., Ltd. 2021	2	# Copyright (C) Sunplus Co., Ltd. 2021
3	%YAML 1.2	3	%YAML 1.2
4	---	4	---
5	$id: "http://devicetree.org/schemas/serial/sunplus,sp7021-uart.yaml#"	5	$id: http://devicetree.org/schemas/serial/sunplus,sp7021-uart.yaml#
6	$schema: "http://devicetree.org/meta-schemas/core.yaml#"	6	$schema: http://devicetree.org/meta-schemas/core.yaml#
7		7
8	title: Sunplus SoC SP7021 UART Controller	8	title: Sunplus SoC SP7021 UART Controller
9		9

Documentation/driver-api/tty/n_gsm.rst+20−0

 #. Configure the mux using ``GSMIOC_GETCONF``/``GSMIOC_SETCONF`` ioctl.
+#. Configure DLCs using ``GSMIOC_GETCONF_DLCI``/``GSMIOC_SETCONF_DLCI`` ioctl for non-defaults.
 #. Obtain base gsmtty number for the used serial port.
    Major parts of the initialization program
       int ldisc = N_GSM0710;
       struct gsm_config c;
       struct gsm_config_ext ce;
+      struct gsm_dlci_config dc;
       struct termios configuration;
       uint32_t first;
       c.mtu = 127;
       /* set the new configuration */
       ioctl(fd, GSMIOC_SETCONF, &c);
+      /* get DLC 1 configuration */
+      dc.channel = 1;
+      ioctl(fd, GSMIOC_GETCONF_DLCI, &dc);
+      /* the first user channel gets a higher priority */
+      dc.priority = 1;
+      /* set the new DLC 1 specific configuration */
+      ioctl(fd, GSMIOC_SETCONF_DLCI, &dc);
       /* get first gsmtty device node */
       ioctl(fd, GSMIOC_GETFIRST, &first);
       printf("first muxed line: /dev/gsmtty%i\n", first);
 #. Configure the mux using ``GSMIOC_GETCONF``/``GSMIOC_SETCONF`` ioctl.
+#. Configure DLCs using ``GSMIOC_GETCONF_DLCI``/``GSMIOC_SETCONF_DLCI`` ioctl for non-defaults.
 #. Obtain base gsmtty number for the used serial port::
         #include <stdio.h>
 	int ldisc = N_GSM0710;
 	struct gsm_config c;
 	struct gsm_config_ext ce;
+	struct gsm_dlci_config dc;
 	struct termios configuration;
 	uint32_t first;
 	c.mtu = 127;
 	/* set the new configuration */
 	ioctl(fd, GSMIOC_SETCONF, &c);
+	/* get DLC 1 configuration */
+	dc.channel = 1;
+	ioctl(fd, GSMIOC_GETCONF_DLCI, &dc);
+	/* the first user channel gets a higher priority */
+	dc.priority = 1;
+	/* set the new DLC 1 specific configuration */
+	ioctl(fd, GSMIOC_SETCONF_DLCI, &dc);
 	/* get first gsmtty device node */
 	ioctl(fd, GSMIOC_GETFIRST, &first);
 	printf("first muxed line: /dev/gsmtty%i\n", first);

arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi+10−5

 			};
 			uart_AO: serial@3000 {
-				compatible = "amlogic,meson-gx-uart",
+				compatible = "amlogic,meson-g12a-uart",
+					     "amlogic,meson-gx-uart",
 					     "amlogic,meson-ao-uart";
 				reg = <0x0 0x3000 0x0 0x18>;
 				interrupts = <GIC_SPI 193 IRQ_TYPE_EDGE_RISING>;
 			};
 			uart_AO_B: serial@4000 {
-				compatible = "amlogic,meson-gx-uart",
+				compatible = "amlogic,meson-g12a-uart",
+					     "amlogic,meson-gx-uart",
 					     "amlogic,meson-ao-uart";
 				reg = <0x0 0x4000 0x0 0x18>;
 				interrupts = <GIC_SPI 197 IRQ_TYPE_EDGE_RISING>;
 			};
 			uart_C: serial@22000 {
-				compatible = "amlogic,meson-gx-uart";
+				compatible = "amlogic,meson-g12a-uart",
+					     "amlogic,meson-gx-uart";
 				reg = <0x0 0x22000 0x0 0x18>;
 				interrupts = <GIC_SPI 93 IRQ_TYPE_EDGE_RISING>;
 				clocks = <&xtal>, <&clkc CLKID_UART2>, <&xtal>;
 			};
 			uart_B: serial@23000 {
-				compatible = "amlogic,meson-gx-uart";
+				compatible = "amlogic,meson-g12a-uart",
+					     "amlogic,meson-gx-uart";
 				reg = <0x0 0x23000 0x0 0x18>;
 				interrupts = <GIC_SPI 75 IRQ_TYPE_EDGE_RISING>;
 				clocks = <&xtal>, <&clkc CLKID_UART1>, <&xtal>;
 			};
 			uart_A: serial@24000 {
-				compatible = "amlogic,meson-gx-uart";
+				compatible = "amlogic,meson-g12a-uart",
+					     "amlogic,meson-gx-uart";
 				reg = <0x0 0x24000 0x0 0x18>;
 				interrupts = <GIC_SPI 26 IRQ_TYPE_EDGE_RISING>;
 				clocks = <&xtal>, <&clkc CLKID_UART0>, <&xtal>;

drivers/char/pcmcia/synclink_cs.c+3−3

@@ -1060,7 +1060,7 @@ static void cts_change(MGSLPC_INFO info, struct tty_struct tty) · 1059 unmodified lines
1060	if (info->serial_signals & SerialSignal_CTS) {	1060	if (info->serial_signals & SerialSignal_CTS) {
1061	if (debug_level >= DEBUG_LEVEL_ISR)	1061	if (debug_level >= DEBUG_LEVEL_ISR)
1062	printk("CTS tx start...");	1062	printk("CTS tx start...");
1063	tty->hw_stopped = 0;	1063	tty->hw_stopped = false;
1064	tx_start(info, tty);	1064	tx_start(info, tty);
1065	info->pending_bh \|= BH_TRANSMIT;	1065	info->pending_bh \|= BH_TRANSMIT;
1066	return;	1066	return;
@@ -1069,7 +1069,7 @@ static void cts_change(MGSLPC_INFO info, struct tty_struct tty) · 2 unmodified lines
1069	if (!(info->serial_signals & SerialSignal_CTS)) {	1069	if (!(info->serial_signals & SerialSignal_CTS)) {
1070	if (debug_level >= DEBUG_LEVEL_ISR)	1070	if (debug_level >= DEBUG_LEVEL_ISR)
1071	printk("CTS tx stop...");	1071	printk("CTS tx stop...");
1072	tty->hw_stopped = 1;	1072	tty->hw_stopped = true;
1073	tx_stop(info);	1073	tx_stop(info);
1074	}	1074	}
1075	}	1075	}
@@ -2312,7 +2312,7 @@ static void mgslpc_set_termios(struct tty_struct *tty, · 1236 unmodified lines
2312		2312
2313	/* Handle turning off CRTSCTS */	2313	/* Handle turning off CRTSCTS */
2314	if (old_termios->c_cflag & CRTSCTS && !C_CRTSCTS(tty)) {	2314	if (old_termios->c_cflag & CRTSCTS && !C_CRTSCTS(tty)) {
2315	tty->hw_stopped = 0;	2315	tty->hw_stopped = false;
2316	tx_release(tty);	2316	tx_release(tty);
2317	}	2317	}
2318	}	2318	}

drivers/mmc/core/sdio_uart.c+5−5

@@ -478,13 +478,13 @@ static void sdio_uart_check_modem_status(struct sdio_uart_port *port) · 477 unmodified lines
478	int cts = (status & UART_MSR_CTS);	478	int cts = (status & UART_MSR_CTS);
479	if (tty->hw_stopped) {	479	if (tty->hw_stopped) {
480	if (cts) {	480	if (cts) {
481	tty->hw_stopped = 0;	481	tty->hw_stopped = false;
482	sdio_uart_start_tx(port);	482	sdio_uart_start_tx(port);
483	tty_wakeup(tty);	483	tty_wakeup(tty);
484	}	484	}
485	} else {	485	} else {
486	if (!cts) {	486	if (!cts) {
487	tty->hw_stopped = 1;	487	tty->hw_stopped = true;
488	sdio_uart_stop_tx(port);	488	sdio_uart_stop_tx(port);
489	}	489	}
490	}	490	}
@@ -633,7 +633,7 @@ static int sdio_uart_activate(struct tty_port tport, struct tty_struct tty) · 142 unmodified lines
633		633
634	if (C_CRTSCTS(tty))	634	if (C_CRTSCTS(tty))
635	if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS))	635	if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS))
636	tty->hw_stopped = 1;	636	tty->hw_stopped = true;
637		637
638	clear_bit(TTY_IO_ERROR, &tty->flags);	638	clear_bit(TTY_IO_ERROR, &tty->flags);
639		639
@@ -882,14 +882,14 @@ static void sdio_uart_set_termios(struct tty_struct *tty, · 242 unmodified lines
882		882
883	/* Handle turning off CRTSCTS */	883	/* Handle turning off CRTSCTS */
884	if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {	884	if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
885	tty->hw_stopped = 0;	885	tty->hw_stopped = false;
886	sdio_uart_start_tx(port);	886	sdio_uart_start_tx(port);
887	}	887	}
888		888
889	/* Handle turning on CRTSCTS */	889	/* Handle turning on CRTSCTS */
890	if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {	890	if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
891	if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS)) {	891	if (!(sdio_uart_get_mctrl(port) & TIOCM_CTS)) {
892	tty->hw_stopped = 1;	892	tty->hw_stopped = true;
893	sdio_uart_stop_tx(port);	893	sdio_uart_stop_tx(port);
894	}	894	}
895	}	895	}

drivers/tty/Kconfig+1−1

@@ -160,7 +160,7 @@ config LEGACY_TIOCSTI · 159 unmodified lines
160	a dangerous legacy operation, and can be disabled on most	160	a dangerous legacy operation, and can be disabled on most
161	systems.	161	systems.
162		162
163	Say 'Y here only if you have confirmed that your system's	163	Say Y here only if you have confirmed that your system's
164	userspace depends on this functionality to continue operating	164	userspace depends on this functionality to continue operating
165	normally.	165	normally.
166		166

drivers/tty/amiserial.c+3−3

@@ -347,7 +347,7 @@ static void check_modem_status(struct serial_state *info) · 346 unmodified lines
347	#if (defined(SERIAL_DEBUG_INTR) \|\| defined(SERIAL_DEBUG_FLOW))	347	#if (defined(SERIAL_DEBUG_INTR) \|\| defined(SERIAL_DEBUG_FLOW))
348	printk("CTS tx start...");	348	printk("CTS tx start...");
349	#endif	349	#endif
350	port->tty->hw_stopped = 0;	350	port->tty->hw_stopped = false;
351	info->IER \|= UART_IER_THRI;	351	info->IER \|= UART_IER_THRI;
352	amiga_custom.intena = IF_SETCLR \| IF_TBE;	352	amiga_custom.intena = IF_SETCLR \| IF_TBE;
353	mb();	353	mb();
@@ -362,7 +362,7 @@ static void check_modem_status(struct serial_state *info) · 8 unmodified lines
362	#if (defined(SERIAL_DEBUG_INTR) \|\| defined(SERIAL_DEBUG_FLOW))	362	#if (defined(SERIAL_DEBUG_INTR) \|\| defined(SERIAL_DEBUG_FLOW))
363	printk("CTS tx stop...");	363	printk("CTS tx stop...");
364	#endif	364	#endif
365	port->tty->hw_stopped = 1;	365	port->tty->hw_stopped = true;
366	info->IER &= ~UART_IER_THRI;	366	info->IER &= ~UART_IER_THRI;
367	/* disable Tx interrupt and remove any pending interrupts */	367	/* disable Tx interrupt and remove any pending interrupts */
368	amiga_custom.intena = IF_TBE;	368	amiga_custom.intena = IF_TBE;
@@ -1197,7 +1197,7 @@ static void rs_set_termios(struct tty_struct tty, const struct ktermios old_te · 828 unmodified lines
1197		1197
1198	/* Handle turning off CRTSCTS */	1198	/* Handle turning off CRTSCTS */
1199	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {	1199	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
1200	tty->hw_stopped = 0;	1200	tty->hw_stopped = false;
1201	rs_start(tty);	1201	rs_start(tty);
1202	}	1202	}
1203		1203

drivers/tty/mxser.c+3−3

@@ -553,7 +553,7 @@ static void mxser_handle_cts(struct tty_struct tty, struct mxser_port info, · 552 unmodified lines
553		553
554	if (tty->hw_stopped) {	554	if (tty->hw_stopped) {
555	if (cts) {	555	if (cts) {
556	tty->hw_stopped = 0;	556	tty->hw_stopped = false;
557		557
558	if (!mxser_16550A_or_MUST(info))	558	if (!mxser_16550A_or_MUST(info))
559	__mxser_start_tx(info);	559	__mxser_start_tx(info);
@@ -563,7 +563,7 @@ static void mxser_handle_cts(struct tty_struct tty, struct mxser_port info, · 3 unmodified lines
563	} else if (cts)	563	} else if (cts)
564	return;	564	return;
565		565
566	tty->hw_stopped = 1;	566	tty->hw_stopped = true;
567	if (!mxser_16550A_or_MUST(info))	567	if (!mxser_16550A_or_MUST(info))
568	__mxser_stop_tx(info);	568	__mxser_stop_tx(info);
569	}	569	}
@@ -1361,7 +1361,7 @@ static void mxser_set_termios(struct tty_struct *tty, · 791 unmodified lines
1361	spin_unlock_irqrestore(&info->slock, flags);	1361	spin_unlock_irqrestore(&info->slock, flags);
1362		1362
1363	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {	1363	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
1364	tty->hw_stopped = 0;	1364	tty->hw_stopped = false;
1365	mxser_start(tty);	1365	mxser_start(tty);
1366	}	1366	}
1367		1367

drivers/tty/n_gsm.c+222−9

@@ -42,6 +42,7 @@ · 41 unmodified lines
42	#include <linux/ctype.h>	42	#include <linux/ctype.h>
43	#include <linux/mm.h>	43	#include <linux/mm.h>
44	#include <linux/math.h>	44	#include <linux/math.h>
		45	#include <linux/nospec.h>
45	#include <linux/string.h>	46	#include <linux/string.h>
46	#include <linux/slab.h>	47	#include <linux/slab.h>
47	#include <linux/poll.h>	48	#include <linux/poll.h>
@@ -128,6 +129,7 @@ struct gsm_msg { · 80 unmodified lines
128		129
129	enum gsm_dlci_state {	130	enum gsm_dlci_state {
130	DLCI_CLOSED,	131	DLCI_CLOSED,
		132	DLCI_WAITING_CONFIG, /* Waiting for DLCI configuration from user */
131	DLCI_CONFIGURE, /* Sending PN (for adaption > 1) */	133	DLCI_CONFIGURE, /* Sending PN (for adaption > 1) */
132	DLCI_OPENING, /* Sending SABM not seen UA */	134	DLCI_OPENING, /* Sending SABM not seen UA */
133	DLCI_OPEN, /* SABM/UA complete */	135	DLCI_OPEN, /* SABM/UA complete */
@@ -330,6 +332,7 @@ struct gsm_mux { · 196 unmodified lines
330	unsigned int t3; /* Power wake-up timer in seconds. */	332	unsigned int t3; /* Power wake-up timer in seconds. */
331	int n2; /* Retry count */	333	int n2; /* Retry count */
332	u8 k; /* Window size */	334	u8 k; /* Window size */
		335	bool wait_config; /* Wait for configuration by ioctl before DLCI open */
333	u32 keep_alive; /* Control channel keep-alive in 10ms */	336	u32 keep_alive; /* Control channel keep-alive in 10ms */
334		337
335	/* Statistics (not currently exposed) */	338	/* Statistics (not currently exposed) */
@@ -451,6 +454,7 @@ static int gsm_modem_update(struct gsm_dlci *dlci, u8 brk); · 115 unmodified lines
451	static struct gsm_msg gsm_data_alloc(struct gsm_mux gsm, u8 addr, int len,	454	static struct gsm_msg gsm_data_alloc(struct gsm_mux gsm, u8 addr, int len,
452	u8 ctrl);	455	u8 ctrl);
453	static int gsm_send_packet(struct gsm_mux gsm, struct gsm_msg msg);	456	static int gsm_send_packet(struct gsm_mux gsm, struct gsm_msg msg);
		457	static struct gsm_dlci gsm_dlci_alloc(struct gsm_mux gsm, int addr);
454	static void gsmld_write_trigger(struct gsm_mux *gsm);	458	static void gsmld_write_trigger(struct gsm_mux *gsm);
455	static void gsmld_write_task(struct work_struct *work);	459	static void gsmld_write_task(struct work_struct *work);
456		460
@@ -2280,6 +2284,7 @@ static void gsm_dlci_begin_open(struct gsm_dlci *dlci) · 1823 unmodified lines
2280		2284
2281	switch (dlci->state) {	2285	switch (dlci->state) {
2282	case DLCI_CLOSED:	2286	case DLCI_CLOSED:
		2287	case DLCI_WAITING_CONFIG:
2283	case DLCI_CLOSING:	2288	case DLCI_CLOSING:
2284	dlci->retries = gsm->n2;	2289	dlci->retries = gsm->n2;
2285	if (!need_pn) {	2290	if (!need_pn) {
@@ -2311,6 +2316,7 @@ static void gsm_dlci_set_opening(struct gsm_dlci *dlci) · 25 unmodified lines
2311	{	2316	{
2312	switch (dlci->state) {	2317	switch (dlci->state) {
2313	case DLCI_CLOSED:	2318	case DLCI_CLOSED:
		2319	case DLCI_WAITING_CONFIG:
2314	case DLCI_CLOSING:	2320	case DLCI_CLOSING:
2315	dlci->state = DLCI_OPENING;	2321	dlci->state = DLCI_OPENING;
2316	break;	2322	break;
@@ -2319,6 +2325,24 @@ static void gsm_dlci_set_opening(struct gsm_dlci *dlci) · 2 unmodified lines
2319	}	2325	}
2320	}	2326	}
2321		2327
		2328	/**
		2329	* gsm_dlci_set_wait_config - wait for channel configuration
		2330	* @dlci: DLCI to configure
		2331	*
		2332	* Wait for a DLCI configuration from the application.
		2333	*/
		2334	static void gsm_dlci_set_wait_config(struct gsm_dlci *dlci)
		2335	{
		2336	switch (dlci->state) {
		2337	case DLCI_CLOSED:
		2338	case DLCI_CLOSING:
		2339	dlci->state = DLCI_WAITING_CONFIG;
		2340	break;
		2341	default:
		2342	break;
		2343	}
		2344	}
		2345
2322	/**	2346	/**
2323	* gsm_dlci_begin_close - start channel open procedure	2347	* gsm_dlci_begin_close - start channel open procedure
2324	* @dlci: DLCI to open	2348	* @dlci: DLCI to open
@@ -2453,6 +2477,128 @@ static void gsm_kick_timer(struct timer_list *t) · 128 unmodified lines
2453	pr_info("%s TX queue stalled\n", __func__);	2477	pr_info("%s TX queue stalled\n", __func__);
2454	}	2478	}
2455		2479
		2480	/**
		2481	* gsm_dlci_copy_config_values - copy DLCI configuration
		2482	* @dlci: source DLCI
		2483	* @dc: configuration structure to fill
		2484	*/
		2485	static void gsm_dlci_copy_config_values(struct gsm_dlci dlci, struct gsm_dlci_config dc)
		2486	{
		2487	memset(dc, 0, sizeof(*dc));
		2488	dc->channel = (u32)dlci->addr;
		2489	dc->adaption = (u32)dlci->adaption;
		2490	dc->mtu = (u32)dlci->mtu;
		2491	dc->priority = (u32)dlci->prio;
		2492	if (dlci->ftype == UIH)
		2493	dc->i = 1;
		2494	else
		2495	dc->i = 2;
		2496	dc->k = (u32)dlci->k;
		2497	}
		2498
		2499	/**
		2500	* gsm_dlci_config - configure DLCI from configuration
		2501	* @dlci: DLCI to configure
		2502	* @dc: DLCI configuration
		2503	* @open: open DLCI after configuration?
		2504	*/
		2505	static int gsm_dlci_config(struct gsm_dlci dlci, struct gsm_dlci_config dc, int open)
		2506	{
		2507	struct gsm_mux *gsm;
		2508	bool need_restart = false;
		2509	bool need_open = false;
		2510	unsigned int i;
		2511
		2512	/*
		2513	* Check that userspace doesn't put stuff in here to prevent breakages
		2514	* in the future.
		2515	*/
		2516	for (i = 0; i < ARRAY_SIZE(dc->reserved); i++)
		2517	if (dc->reserved[i])
		2518	return -EINVAL;
		2519
		2520	if (!dlci)
		2521	return -EINVAL;
		2522	gsm = dlci->gsm;
		2523
		2524	/* Stuff we don't support yet - I frame transport */
		2525	if (dc->adaption != 1 && dc->adaption != 2)
		2526	return -EOPNOTSUPP;
		2527	if (dc->mtu > MAX_MTU \|\| dc->mtu < MIN_MTU \|\| dc->mtu > gsm->mru)
		2528	return -EINVAL;
		2529	if (dc->priority >= 64)
		2530	return -EINVAL;
		2531	if (dc->i == 0 \|\| dc->i > 2) /* UIH and UI only */
		2532	return -EINVAL;
		2533	if (dc->k > 7)
		2534	return -EINVAL;
		2535
		2536	/*
		2537	* See what is needed for reconfiguration
		2538	*/
		2539	/* Framing fields */
		2540	if (dc->adaption != dlci->adaption)
		2541	need_restart = true;
		2542	if (dc->mtu != dlci->mtu)
		2543	need_restart = true;
		2544	if (dc->i != dlci->ftype)
		2545	need_restart = true;
		2546	/* Requires care */
		2547	if (dc->priority != dlci->prio)
		2548	need_restart = true;
		2549
		2550	if ((open && gsm->wait_config) \|\| need_restart)
		2551	need_open = true;
		2552	if (dlci->state == DLCI_WAITING_CONFIG) {
		2553	need_restart = false;
		2554	need_open = true;
		2555	}
		2556
		2557	/*
		2558	* Close down what is needed, restart and initiate the new
		2559	* configuration.
		2560	*/
		2561	if (need_restart) {
		2562	gsm_dlci_begin_close(dlci);
		2563	wait_event_interruptible(gsm->event, dlci->state == DLCI_CLOSED);
		2564	if (signal_pending(current))
		2565	return -EINTR;
		2566	}
		2567	/*
		2568	* Setup the new configuration values
		2569	*/
		2570	dlci->adaption = (int)dc->adaption;
		2571
		2572	if (dc->mtu)
		2573	dlci->mtu = (unsigned int)dc->mtu;
		2574	else
		2575	dlci->mtu = gsm->mtu;
		2576
		2577	if (dc->priority)
		2578	dlci->prio = (u8)dc->priority;
		2579	else
		2580	dlci->prio = roundup(dlci->addr + 1, 8) - 1;
		2581
		2582	if (dc->i == 1)
		2583	dlci->ftype = UIH;
		2584	else if (dc->i == 2)
		2585	dlci->ftype = UI;
		2586
		2587	if (dc->k)
		2588	dlci->k = (u8)dc->k;
		2589	else
		2590	dlci->k = gsm->k;
		2591
		2592	if (need_open) {
		2593	if (gsm->initiator)
		2594	gsm_dlci_begin_open(dlci);
		2595	else
		2596	gsm_dlci_set_opening(dlci);
		2597	}
		2598
		2599	return 0;
		2600	}
		2601
2456	/*	2602	/*
2457	* Allocate/Free DLCI channels	2603	* Allocate/Free DLCI channels
2458	*/	2604	*/
@@ -3078,6 +3224,7 @@ static struct gsm_mux *gsm_alloc_mux(void) · 619 unmodified lines
3078	gsm->mru = 64; /* Default to encoding 1 so these should be 64 */	3224	gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
3079	gsm->mtu = 64;	3225	gsm->mtu = 64;
3080	gsm->dead = true; /* Avoid early tty opens */	3226	gsm->dead = true; /* Avoid early tty opens */
		3227	gsm->wait_config = false; /* Disabled */
3081	gsm->keep_alive = 0; /* Disabled */	3228	gsm->keep_alive = 0; /* Disabled */
3082		3229
3083	/* Store the instance to the mux array or abort if no space is	3230	/* Store the instance to the mux array or abort if no space is
@@ -3130,8 +3277,8 @@ static int gsm_config(struct gsm_mux gsm, struct gsm_config c) · 46 unmodified lines
3130	int need_close = 0;	3277	int need_close = 0;
3131	int need_restart = 0;	3278	int need_restart = 0;
3132		3279
3133	/* Stuff we don't support yet - UI or I frame transport, windowing */	3280	/* Stuff we don't support yet - UI or I frame transport */
3134	if ((c->adaption != 1 && c->adaption != 2) \|\| c->k)	3281	if (c->adaption != 1 && c->adaption != 2)
3135	return -EOPNOTSUPP;	3282	return -EOPNOTSUPP;
3136	/* Check the MRU/MTU range looks sane */	3283	/* Check the MRU/MTU range looks sane */
3137	if (c->mru < MIN_MTU \|\| c->mtu < MIN_MTU)	3284	if (c->mru < MIN_MTU \|\| c->mtu < MIN_MTU)
@@ -3218,6 +3365,7 @@ static void gsm_copy_config_ext_values(struct gsm_mux *gsm, · 80 unmodified lines
3218	struct gsm_config_ext *ce)	3365	struct gsm_config_ext *ce)
3219	{	3366	{
3220	memset(ce, 0, sizeof(*ce));	3367	memset(ce, 0, sizeof(*ce));
		3368	ce->wait_config = gsm->wait_config ? 1 : 0;
3221	ce->keep_alive = gsm->keep_alive;	3369	ce->keep_alive = gsm->keep_alive;
3222	}	3370	}
3223		3371
@@ -3233,7 +3381,12 @@ static int gsm_config_ext(struct gsm_mux gsm, struct gsm_config_ext ce) · 9 unmodified lines
3233	if (ce->reserved[i])	3381	if (ce->reserved[i])
3234	return -EINVAL;	3382	return -EINVAL;
3235		3383
		3384	/*
		3385	* Setup the new configuration values
		3386	*/
		3387	gsm->wait_config = ce->wait_config ? true : false;
3236	gsm->keep_alive = ce->keep_alive;	3388	gsm->keep_alive = ce->keep_alive;
		3389
3237	return 0;	3390	return 0;
3238	}	3391	}
3239		3392
@@ -3433,9 +3586,16 @@ static int gsmld_open(struct tty_struct *tty) · 193 unmodified lines
3433	tty->receive_room = 65536;	3586	tty->receive_room = 65536;
3434		3587
3435	/* Attach the initial passive connection */	3588	/* Attach the initial passive connection */
3436	gsm->encoding = GSM_ADV_OPT;
3437	gsmld_attach_gsm(tty, gsm);	3589	gsmld_attach_gsm(tty, gsm);
3438		3590
		3591	/* The mux will not be activated yet, we wait for correct
		3592	* configuration first.
		3593	*/
		3594	if (gsm->encoding == GSM_BASIC_OPT)
		3595	gsm->receive = gsm0_receive;
		3596	else
		3597	gsm->receive = gsm1_receive;
		3598
3439	return 0;	3599	return 0;
3440	}	3600	}
3441		3601
@@ -3556,8 +3716,10 @@ static int gsmld_ioctl(struct tty_struct *tty, unsigned int cmd, · 114 unmodified lines
3556	{	3716	{
3557	struct gsm_config c;	3717	struct gsm_config c;
3558	struct gsm_config_ext ce;	3718	struct gsm_config_ext ce;
		3719	struct gsm_dlci_config dc;
3559	struct gsm_mux *gsm = tty->disc_data;	3720	struct gsm_mux *gsm = tty->disc_data;
3560	unsigned int base;	3721	unsigned int base, addr;
		3722	struct gsm_dlci *dlci;
3561		3723
3562	switch (cmd) {	3724	switch (cmd) {
3563	case GSMIOC_GETCONF:	3725	case GSMIOC_GETCONF:
@@ -3581,6 +3743,35 @@ static int gsmld_ioctl(struct tty_struct *tty, unsigned int cmd, · 17 unmodified lines
3581	if (copy_from_user(&ce, (void __user *)arg, sizeof(ce)))	3743	if (copy_from_user(&ce, (void __user *)arg, sizeof(ce)))
3582	return -EFAULT;	3744	return -EFAULT;
3583	return gsm_config_ext(gsm, &ce);	3745	return gsm_config_ext(gsm, &ce);
		3746	case GSMIOC_GETCONF_DLCI:
		3747	if (copy_from_user(&dc, (void __user *)arg, sizeof(dc)))
		3748	return -EFAULT;
		3749	if (dc.channel == 0 \|\| dc.channel >= NUM_DLCI)
		3750	return -EINVAL;
		3751	addr = array_index_nospec(dc.channel, NUM_DLCI);
		3752	dlci = gsm->dlci[addr];
		3753	if (!dlci) {
		3754	dlci = gsm_dlci_alloc(gsm, addr);
		3755	if (!dlci)
		3756	return -ENOMEM;
		3757	}
		3758	gsm_dlci_copy_config_values(dlci, &dc);
		3759	if (copy_to_user((void __user *)arg, &dc, sizeof(dc)))
		3760	return -EFAULT;
		3761	return 0;
		3762	case GSMIOC_SETCONF_DLCI:
		3763	if (copy_from_user(&dc, (void __user *)arg, sizeof(dc)))
		3764	return -EFAULT;
		3765	if (dc.channel == 0 \|\| dc.channel >= NUM_DLCI)
		3766	return -EINVAL;
		3767	addr = array_index_nospec(dc.channel, NUM_DLCI);
		3768	dlci = gsm->dlci[addr];
		3769	if (!dlci) {
		3770	dlci = gsm_dlci_alloc(gsm, addr);
		3771	if (!dlci)
		3772	return -ENOMEM;
		3773	}
		3774	return gsm_dlci_config(dlci, &dc, 0);
3584	default:	3775	default:
3585	return n_tty_ioctl_helper(tty, cmd, arg);	3776	return n_tty_ioctl_helper(tty, cmd, arg);
3586	}	3777	}
@@ -4008,7 +4199,6 @@ static int gsmtty_open(struct tty_struct tty, struct file filp) · 421 unmodified lines
4008	{	4199	{
4009	struct gsm_dlci *dlci = tty->driver_data;	4200	struct gsm_dlci *dlci = tty->driver_data;
4010	struct tty_port *port = &dlci->port;	4201	struct tty_port *port = &dlci->port;
4011	struct gsm_mux *gsm = dlci->gsm;
4012		4202
4013	port->count++;	4203	port->count++;
4014	tty_port_tty_set(port, tty);	4204	tty_port_tty_set(port, tty);
@@ -4018,10 +4208,15 @@ static int gsmtty_open(struct tty_struct tty, struct file filp) · 3 unmodified lines
4018	a DM straight back. This is ok as that will have caused a hangup */	4208	a DM straight back. This is ok as that will have caused a hangup */
4019	tty_port_set_initialized(port, true);	4209	tty_port_set_initialized(port, true);
4020	/* Start sending off SABM messages */	4210	/* Start sending off SABM messages */
4021	if (gsm->initiator)	4211	if (!dlci->gsm->wait_config) {
4022	gsm_dlci_begin_open(dlci);	4212	/* Start sending off SABM messages */
4023	else	4213	if (dlci->gsm->initiator)
4024	gsm_dlci_set_opening(dlci);	4214	gsm_dlci_begin_open(dlci);
		4215	else
		4216	gsm_dlci_set_opening(dlci);
		4217	} else {
		4218	gsm_dlci_set_wait_config(dlci);
		4219	}
4025	/* And wait for virtual carrier */	4220	/* And wait for virtual carrier */
4026	return tty_port_block_til_ready(port, tty, filp);	4221	return tty_port_block_til_ready(port, tty, filp);
4027	}	4222	}
@@ -4142,6 +4337,7 @@ static int gsmtty_ioctl(struct tty_struct *tty, · 114 unmodified lines
4142	{	4337	{
4143	struct gsm_dlci *dlci = tty->driver_data;	4338	struct gsm_dlci *dlci = tty->driver_data;
4144	struct gsm_netconfig nc;	4339	struct gsm_netconfig nc;
		4340	struct gsm_dlci_config dc;
4145	int index;	4341	int index;
4146		4342
4147	if (dlci->state == DLCI_CLOSED)	4343	if (dlci->state == DLCI_CLOSED)
@@ -4165,6 +4361,23 @@ static int gsmtty_ioctl(struct tty_struct *tty, · 17 unmodified lines
4165	gsm_destroy_network(dlci);	4361	gsm_destroy_network(dlci);
4166	mutex_unlock(&dlci->mutex);	4362	mutex_unlock(&dlci->mutex);
4167	return 0;	4363	return 0;
		4364	case GSMIOC_GETCONF_DLCI:
		4365	if (copy_from_user(&dc, (void __user *)arg, sizeof(dc)))
		4366	return -EFAULT;
		4367	if (dc.channel != dlci->addr)
		4368	return -EPERM;
		4369	gsm_dlci_copy_config_values(dlci, &dc);
		4370	if (copy_to_user((void __user *)arg, &dc, sizeof(dc)))
		4371	return -EFAULT;
		4372	return 0;
		4373	case GSMIOC_SETCONF_DLCI:
		4374	if (copy_from_user(&dc, (void __user *)arg, sizeof(dc)))
		4375	return -EFAULT;
		4376	if (dc.channel >= NUM_DLCI)
		4377	return -EINVAL;
		4378	if (dc.channel != 0 && dc.channel != dlci->addr)
		4379	return -EPERM;
		4380	return gsm_dlci_config(dlci, &dc, 1);
4168	case TIOCMIWAIT:	4381	case TIOCMIWAIT:
4169	return gsm_wait_modem_change(dlci, (u32)arg);	4382	return gsm_wait_modem_change(dlci, (u32)arg);
4170	default:	4383	default:

drivers/tty/n_tty.c+21−22

  *		EAGAIN
  */
-#include <linux/types.h>
+#include <linux/bitmap.h>
-#include <linux/major.h>
+#include <linux/bitops.h>
+#include <linux/ctype.h>
 #include <linux/errno.h>
-#include <linux/signal.h>
+#include <linux/export.h>
 #include <linux/fcntl.h>
+#include <linux/file.h>
+#include <linux/jiffies.h>
+#include <linux/math.h>
+#include <linux/poll.h>
+#include <linux/ratelimit.h>
 #include <linux/sched.h>
-#include <linux/interrupt.h>
+#include <linux/signal.h>
-#include <linux/tty.h>
-#include <linux/timer.h>
-#include <linux/ctype.h>
-#include <linux/mm.h>
-#include <linux/string.h>
 #include <linux/slab.h>
-#include <linux/poll.h>
+#include <linux/string.h>
-#include <linux/bitops.h>
+#include <linux/tty.h>
-#include <linux/audit.h>
+#include <linux/types.h>
-#include <linux/file.h>
 #include <linux/uaccess.h>
-#include <linux/module.h>
-#include <linux/ratelimit.h>
 #include <linux/vmalloc.h>
 #include "tty.h"
 /*
 		c = echo_buf(ldata, tail);
 		if (c == ECHO_OP_START) {
 			unsigned char op;
-			int no_space_left = 0;
+			bool space_left = true;
 			/*
 			 * Since add_echo_byte() is called without holding
 				num_bs = 8 - (num_chars & 7);
 				if (num_bs > space) {
-					no_space_left = 1;
+					space_left = false;
 					break;
 				}
 				space -= num_bs;
 			case ECHO_OP_START:
 				/* This is an escaped echo op start code */
 				if (!space) {
-					no_space_left = 1;
+					space_left = false;
 					break;
 				}
 				tty_put_char(tty, ECHO_OP_START);
 				 *
 				 */
 				if (space < 2) {
-					no_space_left = 1;
+					space_left = false;
 					break;
 				}
 				tty_put_char(tty, '^');
 				tail += 2;
 			}
-			if (no_space_left)
+			if (!space_left)
 				break;
 		} else {
 			if (O_OPOST(tty)) {
 	ldata->num_overrun++;
 	if (time_after(jiffies, ldata->overrun_time + HZ) ||
-			time_after(ldata->overrun_time, jiffies)) {
+	    time_after(ldata->overrun_time, jiffies)) {
 		tty_warn(tty, "%d input overrun(s)\n", ldata->num_overrun);
 		ldata->overrun_time = jiffies;
 		ldata->num_overrun = 0;
 		room = N_TTY_BUF_SIZE - (ldata->read_head - tail);
 		if (I_PARMRK(tty))
-			room = (room + 2) / 3;
+			room = DIV_ROUND_UP(room, 3);
 		room--;
 		if (room <= 0) {
 			overflow = ldata->icanon && ldata->canon_head == tail;

drivers/tty/serial/8250/8250.h+12−0

 	if (dma->prepare_rx_dma)
 		dma->prepare_rx_dma(p);
 }
+static inline bool serial8250_tx_dma_running(struct uart_8250_port *p)
+{
+	struct uart_8250_dma *dma = p->dma;
+	return dma && dma->tx_running;
+}
 #else
 static inline int serial8250_tx_dma(struct uart_8250_port *p)
 {
 	return -1;
 }
 static inline void serial8250_release_dma(struct uart_8250_port *p) { }
+static inline bool serial8250_tx_dma_running(struct uart_8250_port *p)
+{
+	return false;
+}
 #endif
 static inline int ns16550a_goto_highspeed(struct uart_8250_port *up)

drivers/tty/serial/8250/8250_bcm7271.c+12−6

 	/* See if a Baud clock has been specified */
 	baud_mux_clk = of_clk_get_by_name(np, "sw_baud");
 	if (IS_ERR(baud_mux_clk)) {
-		if (PTR_ERR(baud_mux_clk) == -EPROBE_DEFER)
+		if (PTR_ERR(baud_mux_clk) == -EPROBE_DEFER) {
-			return -EPROBE_DEFER;
+			ret = -EPROBE_DEFER;
+			goto release_dma;
+		}
 		dev_dbg(dev, "BAUD MUX clock not specified\n");
 	} else {
 		dev_dbg(dev, "BAUD MUX clock found\n");
 		ret = clk_prepare_enable(baud_mux_clk);
 		if (ret)
-			return ret;
+			goto release_dma;
 		priv->baud_mux_clk = baud_mux_clk;
 		init_real_clk_rates(dev, priv);
 		clk_rate = priv->default_mux_rate;
 	if (clk_rate == 0) {
 		dev_err(dev, "clock-frequency or clk not defined\n");
-		return -EINVAL;
+		ret = -EINVAL;
+		goto release_dma;
 	}
 	dev_dbg(dev, "DMA is %senabled\n", priv->dma_enabled ? "" : "not ");
 	serial8250_unregister_port(priv->line);
 err:
 	brcmuart_free_bufs(dev, priv);
-	brcmuart_arbitration(priv, 0);
+release_dma:
+	if (priv->dma_enabled)
+		brcmuart_arbitration(priv, 0);
 	return ret;
 }
 	hrtimer_cancel(&priv->hrt);
 	serial8250_unregister_port(priv->line);
 	brcmuart_free_bufs(&pdev->dev, priv);
-	brcmuart_arbitration(priv, 0);
+	if (priv->dma_enabled)
+		brcmuart_arbitration(priv, 0);
 	return 0;
 }

drivers/tty/serial/8250/8250_core.c+1−0

@@ -1158,6 +1158,7 @@ void serial8250_unregister_port(int line) · 1157 unmodified lines
1158	uart->port.type = PORT_UNKNOWN;	1158	uart->port.type = PORT_UNKNOWN;
1159	uart->port.dev = &serial8250_isa_devs->dev;	1159	uart->port.dev = &serial8250_isa_devs->dev;
1160	uart->capabilities = 0;	1160	uart->capabilities = 0;
		1161	serial8250_init_port(uart);
1161	serial8250_apply_quirks(uart);	1162	serial8250_apply_quirks(uart);
1162	uart_add_one_port(&serial8250_reg, &uart->port);	1163	uart_add_one_port(&serial8250_reg, &uart->port);
1163	} else {	1164	} else {

drivers/tty/serial/8250/8250_em.c+90−23

 #include <linux/serial_reg.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
-#include <linux/slab.h>
 #include "8250.h"
 #define UART_DLL_EM 9
 #define UART_DLM_EM 10
+#define UART_HCR0_EM 11
+/*
+ * A high value for UART_FCR_EM avoids overlapping with existing UART_*
+ * register defines. UART_FCR_EM_HW is the real HW register offset.
+ */
+#define UART_FCR_EM 0x10003
+#define UART_FCR_EM_HW 3
+#define UART_HCR0_EM_SW_RESET	BIT(7) /* SW Reset */
 struct serial8250_em_priv {
-	struct clk *sclk;
 	int line;
 };
-static void serial8250_em_serial_out(struct uart_port *p, int offset, int value)
+static void serial8250_em_serial_out_helper(struct uart_port *p, int offset,
+					    int value)
 {
 	switch (offset) {
 	case UART_TX: /* TX @ 0x00 */
 		writeb(value, p->membase);
 		break;
-	case UART_FCR: /* FCR @ 0x0c (+1) */
 	case UART_LCR: /* LCR @ 0x10 (+1) */
 	case UART_MCR: /* MCR @ 0x14 (+1) */
 	case UART_SCR: /* SCR @ 0x20 (+1) */
 		writel(value, p->membase + ((offset + 1) << 2));
 		break;
+	case UART_FCR_EM:
+		writel(value, p->membase + (UART_FCR_EM_HW << 2));
+		break;
 	case UART_IER: /* IER @ 0x04 */
 		value &= 0x0f; /* only 4 valid bits - not Xscale */
 		fallthrough;
 	case UART_DLL_EM: /* DLL @ 0x24 (+9) */
 	case UART_DLM_EM: /* DLM @ 0x28 (+9) */
+	case UART_HCR0_EM: /* HCR0 @ 0x2c */
 		writel(value, p->membase + (offset << 2));
+		break;
 	}
 }
 	switch (offset) {
 	case UART_RX: /* RX @ 0x00 */
 		return readb(p->membase);
+	case UART_LCR: /* LCR @ 0x10 (+1) */
 	case UART_MCR: /* MCR @ 0x14 (+1) */
 	case UART_LSR: /* LSR @ 0x18 (+1) */
 	case UART_MSR: /* MSR @ 0x1c (+1) */
 	case UART_SCR: /* SCR @ 0x20 (+1) */
 		return readl(p->membase + ((offset + 1) << 2));
+	case UART_FCR_EM:
+		return readl(p->membase + (UART_FCR_EM_HW << 2));
 	case UART_IER: /* IER @ 0x04 */
 	case UART_IIR: /* IIR @ 0x08 */
 	case UART_DLL_EM: /* DLL @ 0x24 (+9) */
 	case UART_DLM_EM: /* DLM @ 0x28 (+9) */
+	case UART_HCR0_EM: /* HCR0 @ 0x2c */
 		return readl(p->membase + (offset << 2));
 	}
 	return 0;
 }
+static void serial8250_em_reg_update(struct uart_port *p, int off, int value)
+{
+	unsigned int ier, fcr, lcr, mcr, hcr0;
+	ier = serial8250_em_serial_in(p, UART_IER);
+	fcr = serial8250_em_serial_in(p, UART_FCR_EM);
+	lcr = serial8250_em_serial_in(p, UART_LCR);
+	mcr = serial8250_em_serial_in(p, UART_MCR);
+	hcr0 = serial8250_em_serial_in(p, UART_HCR0_EM);
+	serial8250_em_serial_out_helper(p, UART_FCR_EM, fcr |
+							UART_FCR_CLEAR_RCVR |
+							UART_FCR_CLEAR_XMIT);
+	serial8250_em_serial_out_helper(p, UART_HCR0_EM, hcr0 |
+							 UART_HCR0_EM_SW_RESET);
+	serial8250_em_serial_out_helper(p, UART_HCR0_EM, hcr0 &
+							 ~UART_HCR0_EM_SW_RESET);
+	switch (off) {
+	case UART_FCR_EM:
+		fcr = value;
+		break;
+	case UART_LCR:
+		lcr = value;
+		break;
+	case UART_MCR:
+		mcr = value;
+		break;
+	}
+	serial8250_em_serial_out_helper(p, UART_IER, ier);
+	serial8250_em_serial_out_helper(p, UART_FCR_EM, fcr);
+	serial8250_em_serial_out_helper(p, UART_MCR, mcr);
+	serial8250_em_serial_out_helper(p, UART_LCR, lcr);
+	serial8250_em_serial_out_helper(p, UART_HCR0_EM, hcr0);
+}
+static void serial8250_em_serial_out(struct uart_port *p, int offset, int value)
+{
+	switch (offset) {
+	case UART_TX:
+	case UART_SCR:
+	case UART_IER:
+	case UART_DLL_EM:
+	case UART_DLM_EM:
+		serial8250_em_serial_out_helper(p, offset, value);
+		break;
+	case UART_FCR:
+		serial8250_em_reg_update(p, UART_FCR_EM, value);
+		break;
+	case UART_LCR:
+	case UART_MCR:
+		serial8250_em_reg_update(p, offset, value);
+		break;
+	}
+}
 static int serial8250_em_serial_dl_read(struct uart_8250_port *up)
 {
 	return serial_in(up, UART_DLL_EM) | serial_in(up, UART_DLM_EM) << 8;
 static int serial8250_em_probe(struct platform_device *pdev)
 {
 	struct serial8250_em_priv *priv;
+	struct device *dev = &pdev->dev;
 	struct uart_8250_port up;
 	struct resource *regs;
+	struct clk *sclk;
 	int irq, ret;
 	irq = platform_get_irq(pdev, 0);
 		return irq;
 	regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-	if (!regs) {
+	if (!regs)
-		dev_err(&pdev->dev, "missing registers\n");
+		return dev_err_probe(dev, -EINVAL, "missing registers\n");
-		return -EINVAL;
-	}
-	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
+	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
-	priv->sclk = devm_clk_get(&pdev->dev, "sclk");
+	sclk = devm_clk_get_enabled(dev, "sclk");
-	if (IS_ERR(priv->sclk)) {
+	if (IS_ERR(sclk))
-		dev_err(&pdev->dev, "unable to get clock\n");
+		return dev_err_probe(dev, PTR_ERR(sclk), "unable to get clock\n");
-		return PTR_ERR(priv->sclk);
-	}
 	memset(&up, 0, sizeof(up));
 	up.port.mapbase = regs->start;
 	up.port.irq = irq;
 	up.port.type = PORT_16750;
 	up.port.flags = UPF_FIXED_PORT | UPF_IOREMAP | UPF_FIXED_TYPE;
-	up.port.dev = &pdev->dev;
+	up.port.dev = dev;
 	up.port.private_data = priv;
-	clk_prepare_enable(priv->sclk);
+	up.port.uartclk = clk_get_rate(sclk);
-	up.port.uartclk = clk_get_rate(priv->sclk);
 	up.port.iotype = UPIO_MEM32;
 	up.port.serial_in = serial8250_em_serial_in;
 	up.dl_write = serial8250_em_serial_dl_write;
 	ret = serial8250_register_8250_port(&up);
-	if (ret < 0) {
+	if (ret < 0)
-		dev_err(&pdev->dev, "unable to register 8250 port\n");
+		return dev_err_probe(dev, ret, "unable to register 8250 port\n");
-		clk_disable_unprepare(priv->sclk);
-		return ret;
-	}
 	priv->line = ret;
 	platform_set_drvdata(pdev, priv);
 	struct serial8250_em_priv *priv = platform_get_drvdata(pdev);
 	serial8250_unregister_port(priv->line);
-	clk_disable_unprepare(priv->sclk);
 	return 0;
 }

drivers/tty/serial/8250/8250_port.c+8−3

 #include <linux/moduleparam.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
+#include <linux/irq.h>
 #include <linux/console.h>
 #include <linux/gpio/consumer.h>
 #include <linux/sysrq.h>
 int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
+	struct tty_port *tport = &port->state->port;
 	bool skip_rx = false;
 	unsigned long flags;
 	u16 status;
 		skip_rx = true;
 	if (status & (UART_LSR_DR | UART_LSR_BI) && !skip_rx) {
+		if (irqd_is_wakeup_set(irq_get_irq_data(port->irq)))
+			pm_wakeup_event(tport->tty->dev, 0);
 		if (!up->dma || handle_rx_dma(up, iir))
 			status = serial8250_rx_chars(up, status);
 	}
 static unsigned int serial8250_tx_empty(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
+	unsigned int result = 0;
 	unsigned long flags;
-	u16 lsr;
 	serial8250_rpm_get(up);
 	spin_lock_irqsave(&port->lock, flags);
-	lsr = serial_lsr_in(up);
+	if (!serial8250_tx_dma_running(up) && uart_lsr_tx_empty(serial_lsr_in(up)))
+		result = TIOCSER_TEMT;
 	spin_unlock_irqrestore(&port->lock, flags);
 	serial8250_rpm_put(up);
-	return uart_lsr_tx_empty(lsr) ? TIOCSER_TEMT : 0;
+	return result;
 }
 unsigned int serial8250_do_get_mctrl(struct uart_port *port)

drivers/tty/serial/Kconfig+2−9

 	  Choose Y/M here only if you build for such SoC.
-config SERIAL_SAMSUNG_UARTS_4
-	bool
-	depends on SERIAL_SAMSUNG
-	default y
-	help
-	  Internal node for the common case of 4 Samsung compatible UARTs
 config SERIAL_SAMSUNG_UARTS
 	int
 	depends on SERIAL_SAMSUNG
 config SERIAL_SIFIVE
 	tristate "SiFive UART support"
 	depends on OF
-	default SOC_SIFIVE || SOC_CANAAN
+	default ARCH_SIFIVE || ARCH_CANAAN
 	select SERIAL_CORE
 	help
 	  Select this option if you are building a kernel for a device that
 config SERIAL_SIFIVE_CONSOLE
 	bool "Console on SiFive UART"
 	depends on SERIAL_SIFIVE=y
-	default SOC_SIFIVE || SOC_CANAAN
+	default ARCH_SIFIVE || ARCH_CANAAN
 	select SERIAL_CORE_CONSOLE
 	select SERIAL_EARLYCON
 	help

drivers/tty/serial/bcm63xx_uart.c+38−0

@@ -596,6 +596,40 @@ static int bcm_uart_verify_port(struct uart_port *port, · 595 unmodified lines
596	return 0;	596	return 0;
597	}	597	}
598		598
		599	#ifdef CONFIG_CONSOLE_POLL
		600	/*
		601	* return true when outstanding tx equals fifo size
		602	*/
		603	static bool bcm_uart_tx_full(struct uart_port *port)
		604	{
		605	unsigned int val;
		606
		607	val = bcm_uart_readl(port, UART_MCTL_REG);
		608	val = (val & UART_MCTL_TXFIFOFILL_MASK) >> UART_MCTL_TXFIFOFILL_SHIFT;
		609	return !(port->fifosize - val);
		610	}
		611
		612	static int bcm_uart_poll_get_char(struct uart_port *port)
		613	{
		614	unsigned int iestat;
		615
		616	iestat = bcm_uart_readl(port, UART_IR_REG);
		617	if (!(iestat & UART_IR_STAT(UART_IR_RXNOTEMPTY)))
		618	return NO_POLL_CHAR;
		619
		620	return bcm_uart_readl(port, UART_FIFO_REG);
		621	}
		622
		623	static void bcm_uart_poll_put_char(struct uart_port *port, unsigned char c)
		624	{
		625	while (bcm_uart_tx_full(port)) {
		626	cpu_relax();
		627	}
		628
		629	bcm_uart_writel(port, c, UART_FIFO_REG);
		630	}
		631	#endif
		632
599	/* serial core callbacks */	633	/* serial core callbacks */
600	static const struct uart_ops bcm_uart_ops = {	634	static const struct uart_ops bcm_uart_ops = {
601	.tx_empty = bcm_uart_tx_empty,	635	.tx_empty = bcm_uart_tx_empty,
@@ -614,6 +648,10 @@ static const struct uart_ops bcm_uart_ops = { · 12 unmodified lines
614	.request_port = bcm_uart_request_port,	648	.request_port = bcm_uart_request_port,
615	.config_port = bcm_uart_config_port,	649	.config_port = bcm_uart_config_port,
616	.verify_port = bcm_uart_verify_port,	650	.verify_port = bcm_uart_verify_port,
		651	#ifdef CONFIG_CONSOLE_POLL
		652	.poll_get_char = bcm_uart_poll_get_char,
		653	.poll_put_char = bcm_uart_poll_put_char,
		654	#endif
617	};	655	};
618		656
619		657

drivers/tty/serial/cpm_uart/cpm_uart_core.c+2−3

 	/* Pick next descriptor and fill from buffer */
 	bdp = pinfo->tx_cur;
-	while (!(in_be16(&bdp->cbd_sc) & BD_SC_READY) &&
+	while (!(in_be16(&bdp->cbd_sc) & BD_SC_READY) && !uart_circ_empty(xmit)) {
-	       xmit->tail != xmit->head) {
 		count = 0;
 		p = cpm2cpu_addr(in_be32(&bdp->cbd_bufaddr), pinfo);
 		while (count < pinfo->tx_fifosize) {
 			*p++ = xmit->buf[xmit->tail];
 			uart_xmit_advance(port, 1);
 			count++;
-			if (xmit->head == xmit->tail)
+			if (uart_circ_empty(xmit))
 				break;
 		}
 		out_be16(&bdp->cbd_datlen, count);

drivers/tty/serial/fsl_lpuart.c+5−5

@@ -1296,7 +1296,7 @@ static inline int lpuart_start_rx_dma(struct lpuart_port *sport) · 1295 unmodified lines
1296	* 10ms at any baud rate.	1296	* 10ms at any baud rate.
1297	*/	1297	*/
1298	sport->rx_dma_rng_buf_len = (DMA_RX_TIMEOUT * baud / bits / 1000) * 2;	1298	sport->rx_dma_rng_buf_len = (DMA_RX_TIMEOUT * baud / bits / 1000) * 2;
1299	sport->rx_dma_rng_buf_len = (1 << (fls(sport->rx_dma_rng_buf_len) - 1));	1299	sport->rx_dma_rng_buf_len = (1 << fls(sport->rx_dma_rng_buf_len));
1300	if (sport->rx_dma_rng_buf_len < 16)	1300	if (sport->rx_dma_rng_buf_len < 16)
1301	sport->rx_dma_rng_buf_len = 16;	1301	sport->rx_dma_rng_buf_len = 16;
1302		1302
@@ -1406,12 +1406,12 @@ static int lpuart32_config_rs485(struct uart_port port, struct ktermios termio · 103 unmodified lines
1406	struct lpuart_port, port);	1406	struct lpuart_port, port);
1407		1407
1408	unsigned long modem = lpuart32_read(&sport->port, UARTMODIR)	1408	unsigned long modem = lpuart32_read(&sport->port, UARTMODIR)
1409	& ~(UARTMODEM_TXRTSPOL \| UARTMODEM_TXRTSE);	1409	& ~(UARTMODIR_TXRTSPOL \| UARTMODIR_TXRTSE);
1410	lpuart32_write(&sport->port, modem, UARTMODIR);	1410	lpuart32_write(&sport->port, modem, UARTMODIR);
1411		1411
1412	if (rs485->flags & SER_RS485_ENABLED) {	1412	if (rs485->flags & SER_RS485_ENABLED) {
1413	/* Enable auto RS-485 RTS mode */	1413	/* Enable auto RS-485 RTS mode */
1414	modem \|= UARTMODEM_TXRTSE;	1414	modem \|= UARTMODIR_TXRTSE;
1415		1415
1416	/*	1416	/*
1417	* The hardware defaults to RTS logic HIGH while transfer.	1417	* The hardware defaults to RTS logic HIGH while transfer.
@@ -1420,9 +1420,9 @@ static int lpuart32_config_rs485(struct uart_port port, struct ktermios termio · 2 unmodified lines
1420	* Note: UART is assumed to be active high.	1420	* Note: UART is assumed to be active high.
1421	*/	1421	*/
1422	if (rs485->flags & SER_RS485_RTS_ON_SEND)	1422	if (rs485->flags & SER_RS485_RTS_ON_SEND)
1423	modem \|= UARTMODEM_TXRTSPOL;	1423	modem \|= UARTMODIR_TXRTSPOL;
1424	else if (rs485->flags & SER_RS485_RTS_AFTER_SEND)	1424	else if (rs485->flags & SER_RS485_RTS_AFTER_SEND)
1425	modem &= ~UARTMODEM_TXRTSPOL;	1425	modem &= ~UARTMODIR_TXRTSPOL;
1426	}	1426	}
1427		1427
1428	lpuart32_write(&sport->port, modem, UARTMODIR);	1428	lpuart32_write(&sport->port, modem, UARTMODIR);

drivers/tty/serial/imx.c+12−36

 	return sport->devdata->devtype == IMX1_UART;
 }
-static inline int imx_uart_is_imx21(struct imx_port *sport)
-{
-	return sport->devdata->devtype == IMX21_UART;
-}
-static inline int imx_uart_is_imx53(struct imx_port *sport)
-{
-	return sport->devdata->devtype == IMX53_UART;
-}
-static inline int imx_uart_is_imx6q(struct imx_port *sport)
-{
-	return sport->devdata->devtype == IMX6Q_UART;
-}
 /*
  * Save and restore functions for UCR1, UCR2 and UCR3 registers
  */
 static const char *imx_uart_type(struct uart_port *port)
 {
-	struct imx_port *sport = (struct imx_port *)port;
+	return port->type == PORT_IMX ? "IMX" : NULL;
-	return sport->port.type == PORT_IMX ? "IMX" : NULL;
 }
 /*
  */
 static void imx_uart_config_port(struct uart_port *port, int flags)
 {
-	struct imx_port *sport = (struct imx_port *)port;
 	if (flags & UART_CONFIG_TYPE)
-		sport->port.type = PORT_IMX;
+		port->type = PORT_IMX;
 }
 /*
 static int
 imx_uart_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-	struct imx_port *sport = (struct imx_port *)port;
 	int ret = 0;
 	if (ser->type != PORT_UNKNOWN && ser->type != PORT_IMX)
 		ret = -EINVAL;
-	if (sport->port.irq != ser->irq)
+	if (port->irq != ser->irq)
 		ret = -EINVAL;
 	if (ser->io_type != UPIO_MEM)
 		ret = -EINVAL;
-	if (sport->port.uartclk / 16 != ser->baud_base)
+	if (port->uartclk / 16 != ser->baud_base)
 		ret = -EINVAL;
-	if (sport->port.mapbase != (unsigned long)ser->iomem_base)
+	if (port->mapbase != (unsigned long)ser->iomem_base)
 		ret = -EINVAL;
-	if (sport->port.iobase != ser->port)
+	if (port->iobase != ser->port)
 		ret = -EINVAL;
 	if (ser->hub6 != 0)
 		ret = -EINVAL;
 	}
 	sport->port.line = ret;
-	if (of_get_property(np, "uart-has-rtscts", NULL) ||
+	sport->have_rtscts = of_property_read_bool(np, "uart-has-rtscts") ||
-	    of_get_property(np, "fsl,uart-has-rtscts", NULL) /* deprecated */)
+		of_property_read_bool(np, "fsl,uart-has-rtscts"); /* deprecated */
-		sport->have_rtscts = 1;
-	if (of_get_property(np, "fsl,dte-mode", NULL))
+	sport->dte_mode = of_property_read_bool(np, "fsl,dte-mode");
-		sport->dte_mode = 1;
-	if (of_get_property(np, "rts-gpios", NULL))
+	sport->have_rtsgpio = of_property_present(np, "rts-gpios");
-		sport->have_rtsgpio = 1;
-	if (of_get_property(np, "fsl,inverted-tx", NULL))
+	sport->inverted_tx = of_property_read_bool(np, "fsl,inverted-tx");
-		sport->inverted_tx = 1;
-	if (of_get_property(np, "fsl,inverted-rx", NULL))
+	sport->inverted_rx = of_property_read_bool(np, "fsl,inverted-rx");
-		sport->inverted_rx = 1;
 	if (!of_property_read_u32_array(np, "fsl,dma-info", dma_buf_conf, 2)) {
 		sport->rx_period_length = dma_buf_conf[0];

drivers/tty/serial/max310x.c+15−2

 	return false;
 }
+static bool max310x_reg_noinc(struct device *dev, unsigned int reg)
+{
+	return reg == MAX310X_RHR_REG;
+}
 static int max310x_set_baud(struct uart_port *port, int baud)
 {
 	unsigned int mode = 0, div = 0, frac = 0, c = 0, F = 0;
 {
 	struct max310x_one *one = to_max310x_port(port);
-	regmap_raw_write(one->regmap, MAX310X_THR_REG, txbuf, len);
+	regmap_noinc_write(one->regmap, MAX310X_THR_REG, txbuf, len);
 }
 static void max310x_batch_read(struct uart_port *port, u8 *rxbuf, unsigned int len)
 {
 	struct max310x_one *one = to_max310x_port(port);
-	regmap_raw_read(one->regmap, MAX310X_RHR_REG, rxbuf, len);
+	regmap_noinc_read(one->regmap, MAX310X_RHR_REG, rxbuf, len);
 }
 static void max310x_handle_rx(struct uart_port *port, unsigned int rxlen)
 	.writeable_reg = max310x_reg_writeable,
 	.volatile_reg = max310x_reg_volatile,
 	.precious_reg = max310x_reg_precious,
+	.writeable_noinc_reg = max310x_reg_noinc,
+	.readable_noinc_reg = max310x_reg_noinc,
+	.max_raw_read = MAX310X_FIFO_SIZE,
+	.max_raw_write = MAX310X_FIFO_SIZE,
 };
 #ifdef CONFIG_SPI_MASTER
 	.volatile_reg = max310x_reg_volatile,
 	.precious_reg = max310x_reg_precious,
 	.max_register = MAX310X_I2C_REVID_EXTREG,
+	.writeable_noinc_reg = max310x_reg_noinc,
+	.readable_noinc_reg = max310x_reg_noinc,
+	.max_raw_read = MAX310X_FIFO_SIZE,
+	.max_raw_write = MAX310X_FIFO_SIZE,
 };
 static const struct max310x_if_cfg max310x_i2c_if_cfg = {

drivers/tty/serial/meson_uart.c+6−2

 	return 0;
 }
-static struct meson_uart_data s4_uart_data = {
+static struct meson_uart_data meson_g12a_uart_data = {
 	.has_xtal_div2 = true,
 };
 	{ .compatible = "amlogic,meson8-uart" },
 	{ .compatible = "amlogic,meson8b-uart" },
 	{ .compatible = "amlogic,meson-gx-uart" },
+	{
+		.compatible = "amlogic,meson-g12a-uart",
+		.data = (void *)&meson_g12a_uart_data,
+	},
 	{
 		.compatible = "amlogic,meson-s4-uart",
-		.data = (void *)&s4_uart_data,
+		.data = (void *)&meson_g12a_uart_data,
 	},
 	{ /* sentinel */ },
 };

drivers/tty/serial/mxs-auart.c+2−2

@@ -1587,8 +1587,8 @@ static int mxs_auart_probe(struct platform_device *pdev) · 1586 unmodified lines
1587	}	1587	}
1588	s->port.line = ret;	1588	s->port.line = ret;
1589		1589
1590	if (of_get_property(np, "uart-has-rtscts", NULL) \|\|	1590	if (of_property_read_bool(np, "uart-has-rtscts") \|\|
1591	of_get_property(np, "fsl,uart-has-rtscts", NULL) /* deprecated */)	1591	of_property_read_bool(np, "fsl,uart-has-rtscts") /* deprecated */)
1592	set_bit(MXS_AUART_RTSCTS, &s->flags);	1592	set_bit(MXS_AUART_RTSCTS, &s->flags);
1593		1593
1594	if (s->port.line >= ARRAY_SIZE(auart_port)) {	1594	if (s->port.line >= ARRAY_SIZE(auart_port)) {

drivers/tty/serial/qcom_geni_serial.c+5−6

 }
 static void qcom_geni_serial_send_chunk_fifo(struct uart_port *uport,
-					     unsigned int chunk)
+					     unsigned int remaining)
 {
 	struct qcom_geni_serial_port *port = to_dev_port(uport);
 	struct circ_buf *xmit = &uport->state->xmit;
-	unsigned int tx_bytes, c, remaining = chunk;
+	unsigned int tx_bytes;
 	u8 buf[BYTES_PER_FIFO_WORD];
 	while (remaining) {
 		memset(buf, 0, sizeof(buf));
 		tx_bytes = min(remaining, BYTES_PER_FIFO_WORD);
-		for (c = 0; c < tx_bytes ; c++) {
+		memcpy(buf, &xmit->buf[xmit->tail], tx_bytes);
-			buf[c] = xmit->buf[xmit->tail];
+		uart_xmit_advance(uport, tx_bytes);
-			uart_xmit_advance(uport, 1);
-		}
 		iowrite32_rep(uport->membase + SE_GENI_TX_FIFOn, buf, 1);
 #ifdef CONFIG_CONSOLE_POLL
 	.poll_get_char	= qcom_geni_serial_get_char,
 	.poll_put_char	= qcom_geni_serial_poll_put_char,
+	.poll_init = qcom_geni_serial_port_setup,
 #endif
 	.pm = qcom_geni_serial_pm,
 };

drivers/tty/serial/sb1250-duart.c+1−1

@@ -41,7 +41,7 @@ · 40 unmodified lines
41	#include <asm/sibyte/swarm.h>	41	#include <asm/sibyte/swarm.h>
42		42
43		43
44	#if defined(CONFIG_SIBYTE_BCM1x55) \|\| defined(CONFIG_SIBYTE_BCM1x80)	44	#if defined(CONFIG_SIBYTE_BCM1x80)
45	#include <asm/sibyte/bcm1480_regs.h>	45	#include <asm/sibyte/bcm1480_regs.h>
46	#include <asm/sibyte/bcm1480_int.h>	46	#include <asm/sibyte/bcm1480_int.h>
47		47

drivers/tty/serial/serial_core.c+64−61

 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/gpio/consumer.h>
+#include <linux/kernel.h>
 #include <linux/of.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
  */
 #define RS485_MAX_RTS_DELAY	100 /* msecs */
-static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
-			      const struct ktermios *old_termios);
-static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
 static void uart_change_pm(struct uart_state *state,
 			   enum uart_pm_state pm_state);
 	struct uart_state *state = tty->driver_data;
 	struct uart_port *port = state->uart_port;
-	if (port && !uart_tx_stopped(port))
+	if (port && !(port->flags & UPF_DEAD) && !uart_tx_stopped(port))
 		port->ops->start_tx(port);
 }
 		uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
 }
+/* Caller holds port mutex */
+static void uart_change_line_settings(struct tty_struct *tty, struct uart_state *state,
+				      const struct ktermios *old_termios)
+{
+	struct uart_port *uport = uart_port_check(state);
+	struct ktermios *termios;
+	bool old_hw_stopped;
+	/*
+	 * If we have no tty, termios, or the port does not exist,
+	 * then we can't set the parameters for this port.
+	 */
+	if (!tty || uport->type == PORT_UNKNOWN)
+		return;
+	termios = &tty->termios;
+	uport->ops->set_termios(uport, termios, old_termios);
+	/*
+	 * Set modem status enables based on termios cflag
+	 */
+	spin_lock_irq(&uport->lock);
+	if (termios->c_cflag & CRTSCTS)
+		uport->status |= UPSTAT_CTS_ENABLE;
+	else
+		uport->status &= ~UPSTAT_CTS_ENABLE;
+	if (termios->c_cflag & CLOCAL)
+		uport->status &= ~UPSTAT_DCD_ENABLE;
+	else
+		uport->status |= UPSTAT_DCD_ENABLE;
+	/* reset sw-assisted CTS flow control based on (possibly) new mode */
+	old_hw_stopped = uport->hw_stopped;
+	uport->hw_stopped = uart_softcts_mode(uport) &&
+			    !(uport->ops->get_mctrl(uport) & TIOCM_CTS);
+	if (uport->hw_stopped != old_hw_stopped) {
+		if (!old_hw_stopped)
+			uport->ops->stop_tx(uport);
+		else
+			__uart_start(tty);
+	}
+	spin_unlock_irq(&uport->lock);
+}
 /*
  * Startup the port.  This will be called once per open.  All calls
  * will be serialised by the per-port mutex.
 		/*
 		 * Initialise the hardware port settings.
 		 */
-		uart_change_speed(tty, state, NULL);
+		uart_change_line_settings(tty, state, NULL);
 		/*
 		 * Setup the RTS and DTR signals once the
 }
 EXPORT_SYMBOL(uart_get_divisor);
-/* Caller holds port mutex */
-static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
-			      const struct ktermios *old_termios)
-{
-	struct uart_port *uport = uart_port_check(state);
-	struct ktermios *termios;
-	int hw_stopped;
-	/*
-	 * If we have no tty, termios, or the port does not exist,
-	 * then we can't set the parameters for this port.
-	 */
-	if (!tty || uport->type == PORT_UNKNOWN)
-		return;
-	termios = &tty->termios;
-	uport->ops->set_termios(uport, termios, old_termios);
-	/*
-	 * Set modem status enables based on termios cflag
-	 */
-	spin_lock_irq(&uport->lock);
-	if (termios->c_cflag & CRTSCTS)
-		uport->status |= UPSTAT_CTS_ENABLE;
-	else
-		uport->status &= ~UPSTAT_CTS_ENABLE;
-	if (termios->c_cflag & CLOCAL)
-		uport->status &= ~UPSTAT_DCD_ENABLE;
-	else
-		uport->status |= UPSTAT_DCD_ENABLE;
-	/* reset sw-assisted CTS flow control based on (possibly) new mode */
-	hw_stopped = uport->hw_stopped;
-	uport->hw_stopped = uart_softcts_mode(uport) &&
-				!(uport->ops->get_mctrl(uport) & TIOCM_CTS);
-	if (uport->hw_stopped) {
-		if (!hw_stopped)
-			uport->ops->stop_tx(uport);
-	} else {
-		if (hw_stopped)
-			__uart_start(tty);
-	}
-	spin_unlock_irq(&uport->lock);
-}
 static int uart_put_char(struct tty_struct *tty, unsigned char c)
 {
 	struct uart_state *state = tty->driver_data;
 				      current->comm,
 				      tty_name(port->tty));
 			}
-			uart_change_speed(tty, state, NULL);
+			uart_change_line_settings(tty, state, NULL);
 		}
 	} else {
 		retval = uart_startup(tty, state, true);
 	 * There are 5 words reserved for future use. Check that userspace
 	 * doesn't put stuff in there to prevent breakages in the future.
 	 */
-	for (i = 0; i < 5; i++)
+	for (i = 0; i < ARRAY_SIZE(iso7816.reserved); i++)
 		if (iso7816.reserved[i])
 			return -EINVAL;
 		goto out;
 	/* rs485_config requires more locking than others */
-	if (cmd == TIOCGRS485)
+	if (cmd == TIOCSRS485)
 		down_write(&tty->termios_rwsem);
 	mutex_lock(&port->mutex);
 	}
 out_up:
 	mutex_unlock(&port->mutex);
-	if (cmd == TIOCGRS485)
+	if (cmd == TIOCSRS485)
 		up_write(&tty->termios_rwsem);
 out:
 	return ret;
 		goto out;
 	}
-	uart_change_speed(tty, state, old_termios);
+	uart_change_line_settings(tty, state, old_termios);
 	/* reload cflag from termios; port driver may have overridden flags */
 	cflag = tty->termios.c_cflag;
 	/* Handle transition to B0 status */
-	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
+	if (((old_termios->c_cflag & CBAUD) != B0) && ((cflag & CBAUD) == B0))
 		uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
 	/* Handle transition away from B0 status */
-	else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
+	else if (((old_termios->c_cflag & CBAUD) == B0) && ((cflag & CBAUD) != B0)) {
 		unsigned int mask = TIOCM_DTR;
 		if (!(cflag & CRTSCTS) || !tty_throttled(tty))
 			ret = ops->startup(uport);
 			if (ret == 0) {
 				if (tty)
-					uart_change_speed(tty, state, NULL);
+					uart_change_line_settings(tty, state, NULL);
 				spin_lock_irq(&uport->lock);
 				if (!(uport->rs485.flags & SER_RS485_ENABLED))
 					ops->set_mctrl(uport, uport->mctrl);
 {
 	struct uart_driver *drv = driver->driver_state;
 	struct uart_state *state = drv->state + line;
+	enum uart_pm_state pm_state;
 	struct tty_port *tport;
 	struct uart_port *port;
 	int baud = 9600;
 		goto out;
 	}
+	pm_state = state->pm_state;
+	uart_change_pm(state, UART_PM_STATE_ON);
 	if (port->ops->poll_init) {
 		/*
 		 * We don't set initialized as we only initialized the hw,
 		console_list_unlock();
 	}
 out:
+	if (ret)
+		uart_change_pm(state, pm_state);
 	mutex_unlock(&tport->mutex);
 	return ret;
 }
 	if (uart_softcts_mode(uport)) {
 		if (uport->hw_stopped) {
 			if (active) {
-				uport->hw_stopped = 0;
+				uport->hw_stopped = false;
 				uport->ops->start_tx(uport);
 				uart_write_wakeup(uport);
 			}
 		} else {
 			if (!active) {
-				uport->hw_stopped = 1;
+				uport->hw_stopped = true;
 				uport->ops->stop_tx(uport);
 			}
 		}

drivers/tty/serial/sh-sci.c+90−25

 	if (s->chan_tx && !uart_circ_empty(&s->port.state->xmit) &&
 	    dma_submit_error(s->cookie_tx)) {
+		if (s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE)
+			/* Switch irq from SCIF to DMA */
+			disable_irq(s->irqs[SCIx_TXI_IRQ]);
 		s->cookie_tx = 0;
 		schedule_work(&s->work_tx);
 	}
 #endif
-	if (!s->chan_tx || port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
+	if (!s->chan_tx || s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE ||
+	    port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
 		/* Set TIE (Transmit Interrupt Enable) bit in SCSCR */
 		ctrl = serial_port_in(port, SCSCR);
+		/*
+		 * For SCI, TE (transmit enable) must be set after setting TIE
+		 * (transmit interrupt enable) or in the same instruction to start
+		 * the transmit process.
+		 */
+		if (port->type == PORT_SCI)
+			ctrl |= SCSCR_TE;
 		serial_port_out(port, SCSCR, ctrl | SCSCR_TIE);
 	}
 }
 		} else if (!uart_circ_empty(xmit) && !stopped) {
 			c = xmit->buf[xmit->tail];
 			xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+		} else if (port->type == PORT_SCI && uart_circ_empty(xmit)) {
+			ctrl = serial_port_in(port, SCSCR);
+			ctrl &= ~SCSCR_TE;
+			serial_port_out(port, SCSCR, ctrl);
+			return;
 		} else {
 			break;
 		}
 	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 		uart_write_wakeup(port);
-	if (uart_circ_empty(xmit))
+	if (uart_circ_empty(xmit)) {
-		sci_stop_tx(port);
+		if (port->type == PORT_SCI) {
+			ctrl = serial_port_in(port, SCSCR);
+			ctrl &= ~SCSCR_TIE;
+			ctrl |= SCSCR_TEIE;
+			serial_port_out(port, SCSCR, ctrl);
+		}
+		sci_stop_tx(port);
+	}
 }
 static void sci_receive_chars(struct uart_port *port)
 		schedule_work(&s->work_tx);
 	} else {
 		s->cookie_tx = -EINVAL;
-		if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
+		if (port->type == PORT_SCIFA || port->type == PORT_SCIFB ||
+		    s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE) {
 			u16 ctrl = serial_port_in(port, SCSCR);
 			serial_port_out(port, SCSCR, ctrl & ~SCSCR_TIE);
+			if (s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE) {
+				/* Switch irq from DMA to SCIF */
+				dmaengine_pause(s->chan_tx_saved);
+				enable_irq(s->irqs[SCIx_TXI_IRQ]);
+			}
 		}
 	}
 	/* Direct new serial port interrupts back to CPU */
 	scr = serial_port_in(port, SCSCR);
-	if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
+	if (port->type == PORT_SCIFA || port->type == PORT_SCIFB ||
-		scr &= ~SCSCR_RDRQE;
+	    s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE) {
 		enable_irq(s->irqs[SCIx_RXI_IRQ]);
+		if (s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE)
+			scif_set_rtrg(port, s->rx_trigger);
+		else
+			scr &= ~SCSCR_RDRQE;
 	}
 	serial_port_out(port, SCSCR, scr | SCSCR_RIE);
 }
 			tty_flip_buffer_push(&port->state->port);
 	}
-	if (port->type == PORT_SCIFA || port->type == PORT_SCIFB)
+	if (port->type == PORT_SCIFA || port->type == PORT_SCIFB ||
+	    s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE)
 		sci_dma_rx_submit(s, true);
 	sci_dma_rx_reenable_irq(s);
 	memset(&cfg, 0, sizeof(cfg));
 	cfg.direction = dir;
-	if (dir == DMA_MEM_TO_DEV) {
+	cfg.dst_addr = port->mapbase +
-		cfg.dst_addr = port->mapbase +
+		(sci_getreg(port, SCxTDR)->offset << port->regshift);
-			(sci_getreg(port, SCxTDR)->offset << port->regshift);
+	cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
-		cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+	cfg.src_addr = port->mapbase +
-	} else {
+		(sci_getreg(port, SCxRDR)->offset << port->regshift);
-		cfg.src_addr = port->mapbase +
+	cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
-			(sci_getreg(port, SCxRDR)->offset << port->regshift);
-		cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
-	}
 	ret = dmaengine_slave_config(chan, &cfg);
 	if (ret) {
 	 * Don't request a dma channel if no channel was specified
 	 * in the device tree.
 	 */
-	if (!of_find_property(port->dev->of_node, "dmas", NULL))
+	if (!of_property_present(port->dev->of_node, "dmas"))
 		return;
 	chan = sci_request_dma_chan(port, DMA_MEM_TO_DEV);
 		s->chan_rx_saved = s->chan_rx = chan;
-		if (port->type == PORT_SCIFA || port->type == PORT_SCIFB)
+		if (port->type == PORT_SCIFA || port->type == PORT_SCIFB ||
+		    s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE)
 			sci_dma_rx_submit(s, false);
 	}
 }
 		u16 ssr = serial_port_in(port, SCxSR);
 		/* Disable future Rx interrupts */
-		if (port->type == PORT_SCIFA || port->type == PORT_SCIFB) {
+		if (port->type == PORT_SCIFA || port->type == PORT_SCIFB ||
-			disable_irq_nosync(irq);
+		    s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE) {
-			scr |= SCSCR_RDRQE;
+			disable_irq_nosync(s->irqs[SCIx_RXI_IRQ]);
+			if (s->cfg->regtype == SCIx_RZ_SCIFA_REGTYPE) {
+				scif_set_rtrg(port, 1);
+				scr |= SCSCR_RIE;
+			} else {
+				scr |= SCSCR_RDRQE;
+			}
 		} else {
 			if (sci_dma_rx_submit(s, false) < 0)
 				goto handle_pio;
 	return IRQ_HANDLED;
 }
+static irqreturn_t sci_tx_end_interrupt(int irq, void *ptr)
+{
+	struct uart_port *port = ptr;
+	unsigned long flags;
+	unsigned short ctrl;
+	if (port->type != PORT_SCI)
+		return sci_tx_interrupt(irq, ptr);
+	spin_lock_irqsave(&port->lock, flags);
+	ctrl = serial_port_in(port, SCSCR);
+	ctrl &= ~(SCSCR_TE | SCSCR_TEIE);
+	serial_port_out(port, SCSCR, ctrl);
+	spin_unlock_irqrestore(&port->lock, flags);
+	return IRQ_HANDLED;
+}
 static irqreturn_t sci_br_interrupt(int irq, void *ptr)
 {
 	struct uart_port *port = ptr;
 	[SCIx_TEI_IRQ] = {
 		.desc = "tx end",
-		.handler = sci_tx_interrupt,
+		.handler = sci_tx_end_interrupt,
 	},
 	/*
 		sci_set_mctrl(port, port->mctrl);
 	}
-	scr_val |= SCSCR_RE | SCSCR_TE |
+	/*
-		   (s->cfg->scscr & ~(SCSCR_CKE1 | SCSCR_CKE0));
+	 * For SCI, TE (transmit enable) must be set after setting TIE
+	 * (transmit interrupt enable) or in the same instruction to
+	 * start the transmitting process. So skip setting TE here for SCI.
+	 */
+	if (port->type != PORT_SCI)
+		scr_val |= SCSCR_TE;
+	scr_val |= SCSCR_RE | (s->cfg->scscr & ~(SCSCR_CKE1 | SCSCR_CKE0));
 	serial_port_out(port, SCSCR, scr_val | s->hscif_tot);
 	if ((srr + 1 == 5) &&
 	    (port->type == PORT_SCIFA || port->type == PORT_SCIFB)) {
 #define SCI_OF_TYPE(data)		((unsigned long)(data) >> 16)
 #define SCI_OF_REGTYPE(data)		((unsigned long)(data) & 0xffff)
-static const struct of_device_id of_sci_match[] = {
+static const struct of_device_id of_sci_match[] __maybe_unused = {
 	/* SoC-specific types */
 	{
 		.compatible = "renesas,scif-r7s72100",

drivers/tty/serial/sh-sci.h+3−0

@@ -59,6 +59,9 @@ enum { · 58 unmodified lines
59	#define SCSMR_SRC_19 0x0600 /* Sampling rate 1/19 */	59	#define SCSMR_SRC_19 0x0600 /* Sampling rate 1/19 */
60	#define SCSMR_SRC_27 0x0700 /* Sampling rate 1/27 */	60	#define SCSMR_SRC_27 0x0700 /* Sampling rate 1/27 */
61		61
		62	/* Serial Control Register, SCI only bits */
		63	#define SCSCR_TEIE BIT(2) /* Transmit End Interrupt Enable */
		64
62	/* Serial Control Register, SCIFA/SCIFB only bits */	65	/* Serial Control Register, SCIFA/SCIFB only bits */
63	#define SCSCR_TDRQE BIT(15) /* Tx Data Transfer Request Enable */	66	#define SCSCR_TDRQE BIT(15) /* Tx Data Transfer Request Enable */
64	#define SCSCR_RDRQE BIT(14) /* Rx Data Transfer Request Enable */	67	#define SCSCR_RDRQE BIT(14) /* Rx Data Transfer Request Enable */

drivers/tty/serial/sprd_serial.c+1−1

@@ -1250,7 +1250,7 @@ static struct platform_driver sprd_platform_driver = { · 1249 unmodified lines
1250	.remove = sprd_remove,	1250	.remove = sprd_remove,
1251	.driver = {	1251	.driver = {
1252	.name = "sprd_serial",	1252	.name = "sprd_serial",
1253	.of_match_table = of_match_ptr(serial_ids),	1253	.of_match_table = serial_ids,
1254	.pm = &sprd_pm_ops,	1254	.pm = &sprd_pm_ops,
1255	},	1255	},
1256	};	1256	};

drivers/tty/serial/stm32-usart.c+3−3

 	int ret;
 	if (!stm32_port->hw_flow_control &&
-	    port->rs485.flags & SER_RS485_ENABLED) {
+	    port->rs485.flags & SER_RS485_ENABLED &&
-		stm32_port->txdone = false;
+	    (port->x_char ||
+	     !(uart_circ_empty(xmit) || uart_tx_stopped(port)))) {
 		stm32_usart_tc_interrupt_disable(port);
 		stm32_usart_rs485_rts_enable(port);
 	}
 		stm32_usart_tx_interrupt_disable(port);
 		if (!stm32_port->hw_flow_control &&
 		    port->rs485.flags & SER_RS485_ENABLED) {
-			stm32_port->txdone = true;
 			stm32_usart_tc_interrupt_enable(port);
 		}
 	}

drivers/tty/serial/stm32-usart.h+0−1

@@ -203,7 +203,6 @@ struct stm32_port { · 202 unmodified lines
203	bool hw_flow_control;	203	bool hw_flow_control;
204	bool swap; /* swap RX & TX pins */	204	bool swap; /* swap RX & TX pins */
205	bool fifoen;	205	bool fifoen;
206	bool txdone;
207	int rxftcfg; /* RX FIFO threshold CFG */	206	int rxftcfg; /* RX FIFO threshold CFG */
208	int txftcfg; /* TX FIFO threshold CFG */	207	int txftcfg; /* TX FIFO threshold CFG */
209	bool wakeup_src;	208	bool wakeup_src;

drivers/tty/serial/sunzilog.c+2−2

@@ -1403,7 +1403,7 @@ static int zs_probe(struct platform_device *op) · 1402 unmodified lines
1403	int keyboard_mouse = 0;	1403	int keyboard_mouse = 0;
1404	int err;	1404	int err;
1405		1405
1406	if (of_find_property(op->dev.of_node, "keyboard", NULL))	1406	if (of_property_present(op->dev.of_node, "keyboard"))
1407	keyboard_mouse = 1;	1407	keyboard_mouse = 1;
1408		1408
1409	/* uarts must come before keyboards/mice */	1409	/* uarts must come before keyboards/mice */
@@ -1553,7 +1553,7 @@ static int __init sunzilog_init(void) · 143 unmodified lines
1553		1553
1554	for_each_node_by_name(dp, "zs") {	1554	for_each_node_by_name(dp, "zs") {
1555	num_sunzilog++;	1555	num_sunzilog++;
1556	if (of_find_property(dp, "keyboard", NULL))	1556	if (of_property_present(dp, "keyboard"))
1557	num_keybms++;	1557	num_keybms++;
1558	}	1558	}
1559		1559

drivers/tty/serial/ucc_uart.c+3−4

 	/* Pick next descriptor and fill from buffer */
 	bdp = qe_port->tx_cur;
-	while (!(ioread16be(&bdp->status) & BD_SC_READY) &&
+	while (!(ioread16be(&bdp->status) & BD_SC_READY) && !uart_circ_empty(xmit)) {
-	       (xmit->tail != xmit->head)) {
 		count = 0;
 		p = qe2cpu_addr(be32_to_cpu(bdp->buf), qe_port);
 		while (count < qe_port->tx_fifosize) {
 			*p++ = xmit->buf[xmit->tail];
 			uart_xmit_advance(port, 1);
 			count++;
-			if (xmit->head == xmit->tail)
+			if (uart_circ_empty(xmit))
 				break;
 		}
 	struct qe_firmware_info *qe_fw_info;
 	int ret;
-	if (of_find_property(np, "soft-uart", NULL)) {
+	if (of_property_read_bool(np, "soft-uart")) {
 		dev_dbg(&ofdev->dev, "using Soft-UART mode\n");
 		soft_uart = 1;
 	} else {

drivers/tty/synclink_gt.c+8−16

@@ -287,7 +287,6 @@ struct slgt_info { · 286 unmodified lines
287	unsigned char *tx_buf;	287	unsigned char *tx_buf;
288	int tx_count;	288	int tx_count;
289		289
290	char *flag_buf;
291	bool drop_rts_on_tx_done;	290	bool drop_rts_on_tx_done;
292	struct _input_signal_events input_signal_events;	291	struct _input_signal_events input_signal_events;
293		292
@@ -730,7 +729,7 @@ static void set_termios(struct tty_struct *tty, · 436 unmodified lines
730		729
731	/* Handle turning off CRTSCTS */	730	/* Handle turning off CRTSCTS */
732	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {	731	if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
733	tty->hw_stopped = 0;	732	tty->hw_stopped = false;
734	tx_release(tty);	733	tx_release(tty);
735	}	734	}
736	}	735	}
@@ -1953,13 +1952,13 @@ static void cts_change(struct slgt_info *info, unsigned short status) · 1216 unmodified lines
1953	if (info->port.tty) {	1952	if (info->port.tty) {
1954	if (info->port.tty->hw_stopped) {	1953	if (info->port.tty->hw_stopped) {
1955	if (info->signals & SerialSignal_CTS) {	1954	if (info->signals & SerialSignal_CTS) {
1956	info->port.tty->hw_stopped = 0;	1955	info->port.tty->hw_stopped = false;
1957	info->pending_bh \|= BH_TRANSMIT;	1956	info->pending_bh \|= BH_TRANSMIT;
1958	return;	1957	return;
1959	}	1958	}
1960	} else {	1959	} else {
1961	if (!(info->signals & SerialSignal_CTS))	1960	if (!(info->signals & SerialSignal_CTS))
1962	info->port.tty->hw_stopped = 1;	1961	info->port.tty->hw_stopped = true;
1963	}	1962	}
1964	}	1963	}
1965	}	1964	}
@@ -3244,13 +3243,7 @@ static int alloc_tmp_rbuf(struct slgt_info *info) · 1278 unmodified lines
3244	info->tmp_rbuf = kmalloc(info->max_frame_size + 5, GFP_KERNEL);	3243	info->tmp_rbuf = kmalloc(info->max_frame_size + 5, GFP_KERNEL);
3245	if (info->tmp_rbuf == NULL)	3244	if (info->tmp_rbuf == NULL)
3246	return -ENOMEM;	3245	return -ENOMEM;
3247	/* unused flag buffer to satisfy receive_buf calling interface */	3246
3248	info->flag_buf = kzalloc(info->max_frame_size + 5, GFP_KERNEL);
3249	if (!info->flag_buf) {
3250	kfree(info->tmp_rbuf);
3251	info->tmp_rbuf = NULL;
3252	return -ENOMEM;
3253	}
3254	return 0;	3247	return 0;
3255	}	3248	}
3256		3249
@@ -3258,8 +3251,6 @@ static void free_tmp_rbuf(struct slgt_info *info) · 1 unmodified line
3258	{	3251	{
3259	kfree(info->tmp_rbuf);	3252	kfree(info->tmp_rbuf);
3260	info->tmp_rbuf = NULL;	3253	info->tmp_rbuf = NULL;
3261	kfree(info->flag_buf);
3262	info->flag_buf = NULL;
3263	}	3254	}
3264		3255
3265	/*	3256	/*
@@ -4657,7 +4648,8 @@ check_again: · 1391 unmodified lines
4657	hdlcdev_rx(info,info->tmp_rbuf, framesize);	4648	hdlcdev_rx(info,info->tmp_rbuf, framesize);
4658	else	4649	else
4659	#endif	4650	#endif
4660	ldisc_receive_buf(tty, info->tmp_rbuf, info->flag_buf, framesize);	4651	ldisc_receive_buf(tty, info->tmp_rbuf, NULL,
		4652	framesize);
4661	}	4653	}
4662	}	4654	}
4663	free_rbufs(info, start, end);	4655	free_rbufs(info, start, end);
@@ -4691,8 +4683,8 @@ static bool rx_get_buf(struct slgt_info *info) · 27 unmodified lines
4691	DBGDATA(info, info->rbufs[i].buf, count, "rx");	4683	DBGDATA(info, info->rbufs[i].buf, count, "rx");
4692	DBGINFO(("rx_get_buf size=%d\n", count));	4684	DBGINFO(("rx_get_buf size=%d\n", count));
4693	if (count)	4685	if (count)
4694	ldisc_receive_buf(info->port.tty, info->rbufs[i].buf,	4686	ldisc_receive_buf(info->port.tty, info->rbufs[i].buf, NULL,
4695	info->flag_buf, count);	4687	count);
4696	free_rbufs(info, i, i);	4688	free_rbufs(info, i, i);
4697	return true;	4689	return true;
4698	}	4690	}

drivers/tty/tty.h+2−0

 int tty_check_change(struct tty_struct *tty);
 void __stop_tty(struct tty_struct *tty);
 void __start_tty(struct tty_struct *tty);
+void tty_write_unlock(struct tty_struct *tty);
+int tty_write_lock(struct tty_struct *tty, int ndelay);
 void tty_vhangup_session(struct tty_struct *tty);
 void tty_open_proc_set_tty(struct file *filp, struct tty_struct *tty);
 int tty_signal_session_leader(struct tty_struct *tty, int exit_session);

drivers/tty/tty_io.c+3−21

 	return i;
 }
-static void tty_write_unlock(struct tty_struct *tty)
+void tty_write_unlock(struct tty_struct *tty)
 {
 	mutex_unlock(&tty->atomic_write_lock);
 	wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
 }
-static int tty_write_lock(struct tty_struct *tty, int ndelay)
+int tty_write_lock(struct tty_struct *tty, int ndelay)
 {
 	if (!mutex_trylock(&tty->atomic_write_lock)) {
 		if (ndelay)
 	{ }
 };
-static struct ctl_table tty_dir_table[] = {
-	{
-		.procname	= "tty",
-		.mode		= 0555,
-		.child		= tty_table,
-	},
-	{ }
-};
-static struct ctl_table tty_root_table[] = {
-	{
-		.procname	= "dev",
-		.mode		= 0555,
-		.child		= tty_dir_table,
-	},
-	{ }
-};
 /*
  * Ok, now we can initialize the rest of the tty devices and can count
  * on memory allocations, interrupts etc..
  */
 int __init tty_init(void)
 {
-	register_sysctl_table(tty_root_table);
+	register_sysctl_init("dev/tty", tty_table);
 	cdev_init(&tty_cdev, &tty_fops);
 	if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
 	    register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)

drivers/tty/tty_ioctl.c+38−16

  * discipline handling modules (like SLIP).
  */
+#include <linux/bits.h>
 #include <linux/types.h>
 #include <linux/termios.h>
 #include <linux/errno.h>
 /*
  * Internal flag options for termios setting behavior
  */
-#define TERMIOS_FLUSH	1
+#define TERMIOS_FLUSH	BIT(0)
-#define TERMIOS_WAIT	2
+#define TERMIOS_WAIT	BIT(1)
-#define TERMIOS_TERMIO	4
+#define TERMIOS_TERMIO	BIT(2)
-#define TERMIOS_OLD	8
+#define TERMIOS_OLD	BIT(3)
 /**
 	tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
 	tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
-	ld = tty_ldisc_ref(tty);
+	if (opt & (TERMIOS_FLUSH|TERMIOS_WAIT)) {
+retry_write_wait:
+		retval = wait_event_interruptible(tty->write_wait, !tty_chars_in_buffer(tty));
+		if (retval < 0)
+			return retval;
-	if (ld != NULL) {
+		if (tty_write_lock(tty, 0) < 0)
-		if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
+			goto retry_write_wait;
-			ld->ops->flush_buffer(tty);
-		tty_ldisc_deref(ld);
-	}
-	if (opt & TERMIOS_WAIT) {
+		/* Racing writer? */
-		tty_wait_until_sent(tty, 0);
+		if (tty_chars_in_buffer(tty)) {
-		if (signal_pending(current))
+			tty_write_unlock(tty);
-			return -ERESTARTSYS;
+			goto retry_write_wait;
-	}
+		}
-	tty_set_termios(tty, &tmp_termios);
+		ld = tty_ldisc_ref(tty);
+		if (ld != NULL) {
+			if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
+				ld->ops->flush_buffer(tty);
+			tty_ldisc_deref(ld);
+		}
+		if ((opt & TERMIOS_WAIT) && tty->ops->wait_until_sent) {
+			tty->ops->wait_until_sent(tty, 0);
+			if (signal_pending(current)) {
+				tty_write_unlock(tty);
+				return -ERESTARTSYS;
+			}
+		}
+		tty_set_termios(tty, &tmp_termios);
+		tty_write_unlock(tty);
+	} else {
+		tty_set_termios(tty, &tmp_termios);
+	}
 	/* FIXME: Arguably if tmp_termios == tty->termios AND the
 	   actual requested termios was not tmp_termios then we may

drivers/tty/tty_ldisc.c+1−2

 int tty_register_ldisc(struct tty_ldisc_ops *new_ldisc)
 {
 	unsigned long flags;
-	int ret = 0;
 	if (new_ldisc->num < N_TTY || new_ldisc->num >= NR_LDISCS)
 		return -EINVAL;
 	tty_ldiscs[new_ldisc->num] = new_ldisc;
 	raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
-	return ret;
+	return 0;
 }
 EXPORT_SYMBOL(tty_register_ldisc);

drivers/tty/vt/vt.c+92−113

@@ -135,10 +135,9 @@ const struct consw *conswitchp; · 134 unmodified lines
135	#define DEFAULT_CURSOR_BLINK_MS 200	135	#define DEFAULT_CURSOR_BLINK_MS 200
136		136
137	struct vc vc_cons [MAX_NR_CONSOLES];	137	struct vc vc_cons [MAX_NR_CONSOLES];
		138	EXPORT_SYMBOL(vc_cons);
138		139
139	#ifndef VT_SINGLE_DRIVER
140	static const struct consw *con_driver_map[MAX_NR_CONSOLES];	140	static const struct consw *con_driver_map[MAX_NR_CONSOLES];
141	#endif
142		141
143	static int con_open(struct tty_struct , struct file );	142	static int con_open(struct tty_struct , struct file );
144	static void vc_init(struct vc_data *vc, unsigned int rows,	143	static void vc_init(struct vc_data *vc, unsigned int rows,
@@ -162,6 +161,7 @@ int default_utf8 = true; · 17 unmodified lines
162	module_param(default_utf8, int, S_IRUGO \| S_IWUSR);	161	module_param(default_utf8, int, S_IRUGO \| S_IWUSR);
163	int global_cursor_default = -1;	162	int global_cursor_default = -1;
164	module_param(global_cursor_default, int, S_IRUGO \| S_IWUSR);	163	module_param(global_cursor_default, int, S_IRUGO \| S_IWUSR);
		164	EXPORT_SYMBOL(global_cursor_default);
165		165
166	static int cur_default = CUR_UNDERLINE;	166	static int cur_default = CUR_UNDERLINE;
167	module_param(cur_default, int, S_IRUGO \| S_IWUSR);	167	module_param(cur_default, int, S_IRUGO \| S_IWUSR);
@@ -174,6 +174,7 @@ static int ignore_poke; · 6 unmodified lines
174		174
175	int do_poke_blanked_console;	175	int do_poke_blanked_console;
176	int console_blanked;	176	int console_blanked;
		177	EXPORT_SYMBOL(console_blanked);
177		178
178	static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */	179	static int vesa_blank_mode; /* 0:none 1:suspendV 2:suspendH 3:powerdown */
179	static int vesa_off_interval;	180	static int vesa_off_interval;
@@ -190,8 +191,10 @@ static DECLARE_WORK(con_driver_unregister_work, con_driver_unregister_callback); · 10 unmodified lines
190	* saved_* variants are for save/restore around kernel debugger enter/leave	191	* saved_* variants are for save/restore around kernel debugger enter/leave
191	*/	192	*/
192	int fg_console;	193	int fg_console;
		194	EXPORT_SYMBOL(fg_console);
193	int last_console;	195	int last_console;
194	int want_console = -1;	196	int want_console = -1;
		197
195	static int saved_fg_console;	198	static int saved_fg_console;
196	static int saved_last_console;	199	static int saved_last_console;
197	static int saved_want_console;	200	static int saved_want_console;
@@ -223,6 +226,7 @@ static int scrollback_delta; · 25 unmodified lines
223	* the console on our behalf.	226	* the console on our behalf.
224	*/	227	*/
225	int (*console_blank_hook)(int);	228	int (*console_blank_hook)(int);
		229	EXPORT_SYMBOL(console_blank_hook);
226		230
227	static DEFINE_TIMER(console_timer, blank_screen_t);	231	static DEFINE_TIMER(console_timer, blank_screen_t);
228	static int blank_state;	232	static int blank_state;
@@ -639,6 +643,7 @@ void update_region(struct vc_data *vc, unsigned long start, int count) · 410 unmodified lines
639	set_cursor(vc);	643	set_cursor(vc);
640	}	644	}
641	}	645	}
		646	EXPORT_SYMBOL(update_region);
642		647
643	/* Structure of attributes is hardware-dependent */	648	/* Structure of attributes is hardware-dependent */
644		649
@@ -984,6 +989,7 @@ void redraw_screen(struct vc_data *vc, int is_switch) · 339 unmodified lines
984	notify_update(vc);	989	notify_update(vc);
985	}	990	}
986	}	991	}
		992	EXPORT_SYMBOL(redraw_screen);
987		993
988	/*	994	/*
989	* Allocation, freeing and resizing of VTs.	995	* Allocation, freeing and resizing of VTs.
@@ -1000,10 +1006,10 @@ static void visual_init(struct vc_data *vc, int num, int init) · 10 unmodified lines
1000	if (vc->vc_sw)	1006	if (vc->vc_sw)
1001	module_put(vc->vc_sw->owner);	1007	module_put(vc->vc_sw->owner);
1002	vc->vc_sw = conswitchp;	1008	vc->vc_sw = conswitchp;
1003	#ifndef VT_SINGLE_DRIVER	1009
1004	if (con_driver_map[num])	1010	if (con_driver_map[num])
1005	vc->vc_sw = con_driver_map[num];	1011	vc->vc_sw = con_driver_map[num];
1006	#endif	1012
1007	__module_get(vc->vc_sw->owner);	1013	__module_get(vc->vc_sw->owner);
1008	vc->vc_num = num;	1014	vc->vc_num = num;
1009	vc->vc_display_fg = &master_display_fg;	1015	vc->vc_display_fg = &master_display_fg;
@@ -1305,6 +1311,7 @@ int vc_resize(struct vc_data *vc, unsigned int cols, unsigned int rows) · 295 unmodified lines
1305	{	1311	{
1306	return vc_do_resize(vc->port.tty, vc, cols, rows);	1312	return vc_do_resize(vc->port.tty, vc, cols, rows);
1307	}	1313	}
		1314	EXPORT_SYMBOL(vc_resize);
1308		1315
1309	/**	1316	/**
1310	* vt_resize - resize a VT	1317	* vt_resize - resize a VT
@@ -1368,6 +1375,7 @@ enum { EPecma = 0, EPdec, EPeq, EPgt, EPlt}; · 57 unmodified lines
1368		1375
1369	const unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,	1376	const unsigned char color_table[] = { 0, 4, 2, 6, 1, 5, 3, 7,
1370	8,12,10,14, 9,13,11,15 };	1377	8,12,10,14, 9,13,11,15 };
		1378	EXPORT_SYMBOL(color_table);
1371		1379
1372	/* the default colour table, for VGA+ colour systems */	1380	/* the default colour table, for VGA+ colour systems */
1373	unsigned char default_red[] = {	1381	unsigned char default_red[] = {
@@ -1375,18 +1383,21 @@ unsigned char default_red[] = { · 1 unmodified line
1375	0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff	1383	0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff
1376	};	1384	};
1377	module_param_array(default_red, byte, NULL, S_IRUGO \| S_IWUSR);	1385	module_param_array(default_red, byte, NULL, S_IRUGO \| S_IWUSR);
		1386	EXPORT_SYMBOL(default_red);
1378		1387
1379	unsigned char default_grn[] = {	1388	unsigned char default_grn[] = {
1380	0x00, 0x00, 0xaa, 0x55, 0x00, 0x00, 0xaa, 0xaa,	1389	0x00, 0x00, 0xaa, 0x55, 0x00, 0x00, 0xaa, 0xaa,
1381	0x55, 0x55, 0xff, 0xff, 0x55, 0x55, 0xff, 0xff	1390	0x55, 0x55, 0xff, 0xff, 0x55, 0x55, 0xff, 0xff
1382	};	1391	};
1383	module_param_array(default_grn, byte, NULL, S_IRUGO \| S_IWUSR);	1392	module_param_array(default_grn, byte, NULL, S_IRUGO \| S_IWUSR);
		1393	EXPORT_SYMBOL(default_grn);
1384		1394
1385	unsigned char default_blu[] = {	1395	unsigned char default_blu[] = {
1386	0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xaa,	1396	0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xaa,
1387	0x55, 0x55, 0x55, 0x55, 0xff, 0xff, 0xff, 0xff	1397	0x55, 0x55, 0x55, 0x55, 0xff, 0xff, 0xff, 0xff
1388	};	1398	};
1389	module_param_array(default_blu, byte, NULL, S_IRUGO \| S_IWUSR);	1399	module_param_array(default_blu, byte, NULL, S_IRUGO \| S_IWUSR);
		1400	EXPORT_SYMBOL(default_blu);
1390		1401
1391	/*	1402	/*
1392	* gotoxy() must verify all boundaries, because the arguments	1403	* gotoxy() must verify all boundaries, because the arguments
@@ -3143,93 +3154,84 @@ int tioclinux(struct tty_struct *tty, unsigned long arg) · 1750 unmodified lines
3143	return -EFAULT;	3154	return -EFAULT;
3144	ret = 0;	3155	ret = 0;
3145		3156
3146	switch (type)	3157	switch (type) {
3147	{	3158	case TIOCL_SETSEL:
3148	case TIOCL_SETSEL:	3159	return set_selection_user((struct tiocl_selection
3149	ret = set_selection_user((struct tiocl_selection	3160	__user *)(p+1), tty);
3150	__user *)(p+1), tty);	3161	case TIOCL_PASTESEL:
3151	break;	3162	return paste_selection(tty);
3152	case TIOCL_PASTESEL:	3163	case TIOCL_UNBLANKSCREEN:
3153	ret = paste_selection(tty);	3164	console_lock();
3154	break;	3165	unblank_screen();
3155	case TIOCL_UNBLANKSCREEN:	3166	console_unlock();
3156	console_lock();	3167	break;
3157	unblank_screen();	3168	case TIOCL_SELLOADLUT:
3158	console_unlock();	3169	console_lock();
3159	break;	3170	ret = sel_loadlut(p);
3160	case TIOCL_SELLOADLUT:	3171	console_unlock();
3161	console_lock();	3172	break;
3162	ret = sel_loadlut(p);	3173	case TIOCL_GETSHIFTSTATE:
3163	console_unlock();	3174	/*
3164	break;	3175	* Make it possible to react to Shift+Mousebutton. Note that
3165	case TIOCL_GETSHIFTSTATE:	3176	* 'shift_state' is an undocumented kernel-internal variable;
		3177	* programs not closely related to the kernel should not use
		3178	* this.
		3179	*/
		3180	data = vt_get_shift_state();
		3181	return put_user(data, p);
		3182	case TIOCL_GETMOUSEREPORTING:
		3183	console_lock(); /* May be overkill */
		3184	data = mouse_reporting();
		3185	console_unlock();
		3186	return put_user(data, p);
		3187	case TIOCL_SETVESABLANK:
		3188	console_lock();
		3189	ret = set_vesa_blanking(p);
		3190	console_unlock();
		3191	break;
		3192	case TIOCL_GETKMSGREDIRECT:
		3193	data = vt_get_kmsg_redirect();
		3194	return put_user(data, p);
		3195	case TIOCL_SETKMSGREDIRECT:
		3196	if (!capable(CAP_SYS_ADMIN))
		3197	return -EPERM;
3166		3198
3167	/*	3199	if (get_user(data, p+1))
3168	* Make it possible to react to Shift+Mousebutton.	3200	return -EFAULT;
3169	* Note that 'shift_state' is an undocumented	3201
3170	* kernel-internal variable; programs not closely	3202	vt_kmsg_redirect(data);
3171	* related to the kernel should not use this.	3203
3172	*/	3204	break;
3173	data = vt_get_shift_state();	3205	case TIOCL_GETFGCONSOLE:
3174	ret = put_user(data, p);	3206	/*
3175	break;	3207	* No locking needed as this is a transiently correct return
3176	case TIOCL_GETMOUSEREPORTING:	3208	* anyway if the caller hasn't disabled switching.
3177	console_lock(); /* May be overkill */	3209	*/
3178	data = mouse_reporting();	3210	return fg_console;
3179	console_unlock();	3211	case TIOCL_SCROLLCONSOLE:
3180	ret = put_user(data, p);	3212	if (get_user(lines, (s32 __user *)(p+4)))
3181	break;	3213	return -EFAULT;
3182	case TIOCL_SETVESABLANK:	3214
3183	console_lock();	3215	/*
3184	ret = set_vesa_blanking(p);	3216	* Needs the console lock here. Note that lots of other calls
3185	console_unlock();	3217	* need fixing before the lock is actually useful!
3186	break;	3218	*/
3187	case TIOCL_GETKMSGREDIRECT:	3219	console_lock();
3188	data = vt_get_kmsg_redirect();	3220	scrollfront(vc_cons[fg_console].d, lines);
3189	ret = put_user(data, p);	3221	console_unlock();
3190	break;	3222	break;
3191	case TIOCL_SETKMSGREDIRECT:	3223	case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */
3192	if (!capable(CAP_SYS_ADMIN)) {	3224	console_lock();
3193	ret = -EPERM;	3225	ignore_poke = 1;
3194	} else {	3226	do_blank_screen(0);
3195	if (get_user(data, p+1))	3227	console_unlock();
3196	ret = -EFAULT;	3228	break;
3197	else	3229	case TIOCL_BLANKEDSCREEN:
3198	vt_kmsg_redirect(data);	3230	return console_blanked;
3199	}	3231	default:
3200	break;	3232	return -EINVAL;
3201	case TIOCL_GETFGCONSOLE:
3202	/* No locking needed as this is a transiently
3203	correct return anyway if the caller hasn't
3204	disabled switching */
3205	ret = fg_console;
3206	break;
3207	case TIOCL_SCROLLCONSOLE:
3208	if (get_user(lines, (s32 __user *)(p+4))) {
3209	ret = -EFAULT;
3210	} else {
3211	/* Need the console lock here. Note that lots
3212	of other calls need fixing before the lock
3213	is actually useful ! */
3214	console_lock();
3215	scrollfront(vc_cons[fg_console].d, lines);
3216	console_unlock();
3217	ret = 0;
3218	}
3219	break;
3220	case TIOCL_BLANKSCREEN: /* until explicitly unblanked, not only poked */
3221	console_lock();
3222	ignore_poke = 1;
3223	do_blank_screen(0);
3224	console_unlock();
3225	break;
3226	case TIOCL_BLANKEDSCREEN:
3227	ret = console_blanked;
3228	break;
3229	default:
3230	ret = -EINVAL;
3231	break;
3232	}	3233	}
		3234
3233	return ret;	3235	return ret;
3234	}	3236	}
3235		3237
@@ -3571,8 +3573,6 @@ int __init vty_init(const struct file_operations *console_fops) · 335 unmodified lines
3571	return 0;	3573	return 0;
3572	}	3574	}
3573		3575
3574	#ifndef VT_SINGLE_DRIVER
3575
3576	static struct class *vtconsole_class;	3576	static struct class *vtconsole_class;
3577		3577
3578	static int do_bind_con_driver(const struct consw *csw, int first, int last,	3578	static int do_bind_con_driver(const struct consw *csw, int first, int last,
@@ -4236,6 +4236,7 @@ void give_up_console(const struct consw *csw) · 657 unmodified lines
4236	do_unregister_con_driver(csw);	4236	do_unregister_con_driver(csw);
4237	console_unlock();	4237	console_unlock();
4238	}	4238	}
		4239	EXPORT_SYMBOL(give_up_console);
4239		4240
4240	static int __init vtconsole_class_init(void)	4241	static int __init vtconsole_class_init(void)
4241	{	4242	{
@@ -4273,8 +4274,6 @@ static int __init vtconsole_class_init(void) · 31 unmodified lines
4273	}	4274	}
4274	postcore_initcall(vtconsole_class_init);	4275	postcore_initcall(vtconsole_class_init);
4275		4276
4276	#endif
4277
4278	/*	4277	/*
4279	* Screen blanking	4278	* Screen blanking
4280	*/	4279	*/
@@ -4792,23 +4791,3 @@ void vc_scrolldelta_helper(struct vc_data *c, int lines, · 511 unmodified lines
4792	c->vc_visible_origin = ubase + (from + from_off) % wrap;	4791	c->vc_visible_origin = ubase + (from + from_off) % wrap;
4793	}	4792	}
4794	EXPORT_SYMBOL_GPL(vc_scrolldelta_helper);	4793	EXPORT_SYMBOL_GPL(vc_scrolldelta_helper);
4795
4796	/*
4797	* Visible symbols for modules
4798	*/
4799
4800	EXPORT_SYMBOL(color_table);
4801	EXPORT_SYMBOL(default_red);
4802	EXPORT_SYMBOL(default_grn);
4803	EXPORT_SYMBOL(default_blu);
4804	EXPORT_SYMBOL(update_region);
4805	EXPORT_SYMBOL(redraw_screen);
4806	EXPORT_SYMBOL(vc_resize);
4807	EXPORT_SYMBOL(fg_console);
4808	EXPORT_SYMBOL(console_blank_hook);
4809	EXPORT_SYMBOL(console_blanked);
4810	EXPORT_SYMBOL(vc_cons);
4811	EXPORT_SYMBOL(global_cursor_default);
4812	#ifndef VT_SINGLE_DRIVER
4813	EXPORT_SYMBOL(give_up_console);
4814	#endif

include/linux/serial_8250.h+20−25

@@ -18,16 +18,16 @@ struct plat_serial8250_port { · 17 unmodified lines
18	unsigned long iobase; /* io base address */	18	unsigned long iobase; /* io base address */
19	void __iomem membase; / ioremap cookie or NULL */	19	void __iomem membase; / ioremap cookie or NULL */
20	resource_size_t mapbase; /* resource base */	20	resource_size_t mapbase; /* resource base */
		21	unsigned int uartclk; /* UART clock rate */
21	unsigned int irq; /* interrupt number */	22	unsigned int irq; /* interrupt number */
22	unsigned long irqflags; /* request_irq flags */	23	unsigned long irqflags; /* request_irq flags */
23	unsigned int uartclk; /* UART clock rate */
24	void *private_data;	24	void *private_data;
25	unsigned char regshift; /* register shift */	25	unsigned char regshift; /* register shift */
26	unsigned char iotype; /* UPIO_* */	26	unsigned char iotype; /* UPIO_* */
27	unsigned char hub6;	27	unsigned char hub6;
28	unsigned char has_sysrq; /* supports magic SysRq */	28	unsigned char has_sysrq; /* supports magic SysRq */
29	upf_t flags; /* UPF_* flags */
30	unsigned int type; /* If UPF_FIXED_TYPE */	29	unsigned int type; /* If UPF_FIXED_TYPE */
		30	upf_t flags; /* UPF_* flags */
31	unsigned int (serial_in)(struct uart_port , int);	31	unsigned int (serial_in)(struct uart_port , int);
32	void (serial_out)(struct uart_port , int, int);	32	void (serial_out)(struct uart_port , int, int);
33	void (set_termios)(struct uart_port ,	33	void (set_termios)(struct uart_port ,
@@ -151,26 +151,22 @@ void serial8250_unregister_port(int line); · 117 unmodified lines
151	void serial8250_suspend_port(int line);	151	void serial8250_suspend_port(int line);
152	void serial8250_resume_port(int line);	152	void serial8250_resume_port(int line);
153		153
154	extern int early_serial_setup(struct uart_port *port);	154	int early_serial_setup(struct uart_port *port);
155		155	int early_serial8250_setup(struct earlycon_device device, const char options);
156	extern int early_serial8250_setup(struct earlycon_device *device,	156
157	const char *options);	157	void serial8250_update_uartclk(struct uart_port *port, unsigned int uartclk);
158	extern void serial8250_update_uartclk(struct uart_port *port,	158	void serial8250_do_set_termios(struct uart_port port, struct ktermios termios,
159	unsigned int uartclk);	159	const struct ktermios *old);
160	extern void serial8250_do_set_termios(struct uart_port *port,	160	void serial8250_do_set_ldisc(struct uart_port port, struct ktermios termios);
161	struct ktermios termios, const struct ktermios old);	161	unsigned int serial8250_do_get_mctrl(struct uart_port *port);
162	extern void serial8250_do_set_ldisc(struct uart_port *port,	162	int serial8250_do_startup(struct uart_port *port);
163	struct ktermios *termios);	163	void serial8250_do_shutdown(struct uart_port *port);
164	extern unsigned int serial8250_do_get_mctrl(struct uart_port *port);	164	void serial8250_do_pm(struct uart_port *port, unsigned int state,
165	extern int serial8250_do_startup(struct uart_port *port);	165	unsigned int oldstate);
166	extern void serial8250_do_shutdown(struct uart_port *port);	166	void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl);
167	extern void serial8250_do_pm(struct uart_port *port, unsigned int state,	167	void serial8250_do_set_divisor(struct uart_port *port, unsigned int baud,
168	unsigned int oldstate);	168	unsigned int quot, unsigned int quot_frac);
169	extern void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl);	169	int fsl8250_handle_irq(struct uart_port *port);
170	extern void serial8250_do_set_divisor(struct uart_port *port, unsigned int baud,
171	unsigned int quot,
172	unsigned int quot_frac);
173	extern int fsl8250_handle_irq(struct uart_port *port);
174	int serial8250_handle_irq(struct uart_port *port, unsigned int iir);	170	int serial8250_handle_irq(struct uart_port *port, unsigned int iir);
175	u16 serial8250_rx_chars(struct uart_8250_port *up, u16 lsr);	171	u16 serial8250_rx_chars(struct uart_8250_port *up, u16 lsr);
176	void serial8250_read_char(struct uart_8250_port *up, u16 lsr);	172	void serial8250_read_char(struct uart_8250_port *up, u16 lsr);
@@ -183,9 +179,8 @@ void serial8250_console_write(struct uart_8250_port up, const char s, · 6 unmodified lines
183	int serial8250_console_setup(struct uart_port port, char options, bool probe);	179	int serial8250_console_setup(struct uart_port port, char options, bool probe);
184	int serial8250_console_exit(struct uart_port *port);	180	int serial8250_console_exit(struct uart_port *port);
185		181
186	extern void serial8250_set_isa_configurator(void (*v)	182	void serial8250_set_isa_configurator(void (v)(int port, struct uart_port up,
187	(int port, struct uart_port *up,	183	u32 *capabilities));
188	u32 *capabilities));
189		184
190	#ifdef CONFIG_SERIAL_8250_RT288X	185	#ifdef CONFIG_SERIAL_8250_RT288X
191	unsigned int au_serial_in(struct uart_port *p, int offset);	186	unsigned int au_serial_in(struct uart_port *p, int offset);

include/linux/serial_core.h+7−8

 #define UPSTAT_AUTOXOFF		((__force upstat_t) (1 << 4))
 #define UPSTAT_SYNC_FIFO	((__force upstat_t) (1 << 5))
-	int			hw_stopped;		/* sw-assisted CTS flow state */
+	bool			hw_stopped;		/* sw-assisted CTS flow state */
 	unsigned int		mctrl;			/* current modem ctrl settings */
 	unsigned int		frame_time;		/* frame timing in ns */
 	unsigned int		type;			/* port type */
 #define EARLYCON_DECLARE(_name, fn)	OF_EARLYCON_DECLARE(_name, "", fn)
-extern int of_setup_earlycon(const struct earlycon_id *match,
+int of_setup_earlycon(const struct earlycon_id *match, unsigned long node,
-			     unsigned long node,
+		      const char *options);
-			     const char *options);
 #ifdef CONFIG_SERIAL_EARLYCON
 extern bool earlycon_acpi_spcr_enable __initdata;
  * The following are helper functions for the low level drivers.
  */
-extern void uart_handle_dcd_change(struct uart_port *uport, bool active);
+void uart_handle_dcd_change(struct uart_port *uport, bool active);
-extern void uart_handle_cts_change(struct uart_port *uport, bool active);
+void uart_handle_cts_change(struct uart_port *uport, bool active);
-extern void uart_insert_char(struct uart_port *port, unsigned int status,
+void uart_insert_char(struct uart_port *port, unsigned int status,
-		 unsigned int overrun, unsigned int ch, unsigned int flag);
+		      unsigned int overrun, unsigned int ch, unsigned int flag);
 void uart_xchar_out(struct uart_port *uport, int offset);

include/linux/tty.h+1−1

@@ -227,7 +227,7 @@ struct tty_struct { · 226 unmodified lines
227	unsigned long unused[0];	227	unsigned long unused[0];
228	} __aligned(sizeof(unsigned long)) ctrl;	228	} __aligned(sizeof(unsigned long)) ctrl;
229		229
230	int hw_stopped;	230	bool hw_stopped;
231	unsigned int receive_room;	231	unsigned int receive_room;
232	int flow_change;	232	int flow_change;
233		233

include/uapi/linux/gsmmux.h+16−1

@@ -43,10 +43,25 @@ struct gsm_config_ext { · 42 unmodified lines
43	__u32 keep_alive; /* Control channel keep-alive in 1/100th of a	43	__u32 keep_alive; /* Control channel keep-alive in 1/100th of a
44	* second (0 to disable)	44	* second (0 to disable)
45	*/	45	*/
46	__u32 reserved[7]; /* For future use, must be initialized to zero */	46	__u32 wait_config; /* Wait for DLCI config before opening virtual link? */
		47	__u32 reserved[6]; /* For future use, must be initialized to zero */
47	};	48	};
48		49
49	#define GSMIOC_GETCONF_EXT _IOR('G', 5, struct gsm_config_ext)	50	#define GSMIOC_GETCONF_EXT _IOR('G', 5, struct gsm_config_ext)
50	#define GSMIOC_SETCONF_EXT _IOW('G', 6, struct gsm_config_ext)	51	#define GSMIOC_SETCONF_EXT _IOW('G', 6, struct gsm_config_ext)
51		52
		53	/* Set channel accordingly before calling GSMIOC_GETCONF_DLCI. */
		54	struct gsm_dlci_config {
		55	__u32 channel; /* DLCI (0 for the associated DLCI) */
		56	__u32 adaption; /* Convergence layer type */
		57	__u32 mtu; /* Maximum transfer unit */
		58	__u32 priority; /* Priority (0 for default value) */
		59	__u32 i; /* Frame type (1 = UIH, 2 = UI) */
		60	__u32 k; /* Window size (0 for default value) */
		61	__u32 reserved[8]; /* For future use, must be initialized to zero */
		62	};
		63
		64	#define GSMIOC_GETCONF_DLCI _IOWR('G', 7, struct gsm_dlci_config)
		65	#define GSMIOC_SETCONF_DLCI _IOW('G', 8, struct gsm_dlci_config)
		66
52	#endif	67	#endif