lael-labs/linux

Documentation/devicetree/bindings/serial/bcm63xx-uart.txt+30−0

@@ -0,0 +1,30 @@
	1	* BCM63xx UART
	2
	3	Required properties:
	4
	5	- compatible: "brcm,bcm6345-uart"
	6
	7	- reg: The base address of the UART register bank.
	8
	9	- interrupts: A single interrupt specifier.
	10
	11	- clocks: Clock driving the hardware; used to figure out the baud rate
	12	divisor.
	13
	14	Example:
	15
	16	uart0: serial@14e00520 {
	17	compatible = "brcm,bcm6345-uart";
	18	reg = <0x14e00520 0x18>;
	19	interrupt-parent = <&periph_intc>;
	20	interrupts = <2>;
	21	clocks = <&periph_clk>;
	22	};
	23
	24	clocks {
	25	periph_clk: periph_clk@0 {
	26	compatible = "fixed-clock";
	27	#clock-cells = <0>;
	28	clock-frequency = <54000000>;
	29	};
	30	};

Documentation/devicetree/bindings/serial/fsl-mxs-auart.txt+9−1

 - dma-names: "rx" for RX channel, "tx" for TX channel.
 Optional properties:
-- fsl,uart-has-rtscts : Indicate the UART has RTS and CTS lines,
+- fsl,uart-has-rtscts : Indicate the UART has RTS and CTS lines
+  for hardware flow control,
 	it also means you enable the DMA support for this UART.
+- {rts,cts,dtr,dsr,rng,dcd}-gpios: specify a GPIO for RTS/CTS/DTR/DSR/RI/DCD
+  line respectively. It will use specified PIO instead of the peripheral
+  function pin for the USART feature.
+  If unsure, don't specify this property.
 Example:
 auart0: serial@8006a000 {
 	interrupts = <112>;
 	dmas = <&dma_apbx 8>, <&dma_apbx 9>;
 	dma-names = "rx", "tx";
+	cts-gpios = <&gpio1 15 GPIO_ACTIVE_LOW>;
+	dsr-gpios = <&gpio1 16 GPIO_ACTIVE_LOW>;
+	dcd-gpios = <&gpio1 17 GPIO_ACTIVE_LOW>;
 };
 Note: Each auart port should have an alias correctly numbered in "aliases"

Documentation/devicetree/bindings/serial/of-serial.txt+1−0

@@ -10,6 +10,7 @@ Required properties: · 9 unmodified lines
10	- "ns16850"	10	- "ns16850"
11	- "nvidia,tegra20-uart"	11	- "nvidia,tegra20-uart"
12	- "nxp,lpc3220-uart"	12	- "nxp,lpc3220-uart"
		13	- "ralink,rt2880-uart"
13	- "ibm,qpace-nwp-serial"	14	- "ibm,qpace-nwp-serial"
14	- "altr,16550-FIFO32"	15	- "altr,16550-FIFO32"
15	- "altr,16550-FIFO64"	16	- "altr,16550-FIFO64"

Documentation/devicetree/bindings/serial/pl011.txt+16−4

 - interrupts: exactly one interrupt specifier
 Optional properties:
-- pinctrl: When present, must have one state named "default",
+- pinctrl:
+	   When present, must have one state named "default",
 	   and may contain a second name named "sleep". The former
 	   state sets up pins for ordinary operation whereas
 	   the latter state will put the associated pins to sleep
 	   when the UART is unused
-- clocks:  When present, the first clock listed must correspond to
+- clocks:
+	   When present, the first clock listed must correspond to
 	   the clock named UARTCLK on the IP block, i.e. the clock
 	   to the external serial line, whereas the second clock
 	   must correspond to the PCLK clocking the internal logic
 	   of the block. Just listing one clock (the first one) is
 	   deprecated.
-- clocks-names: When present, the first clock listed must be named
+- clocks-names:
+	   When present, the first clock listed must be named
 	   "uartclk" and the second clock listed must be named
 	   "apb_pclk"
-- dmas:	   When present, may have one or two dma channels.
+- dmas:
+	   When present, may have one or two dma channels.
 	   The first one must be named "rx", the second one
 	   must be named "tx".
+- auto-poll:
+	   Enables polling when using RX DMA.
+- poll-rate-ms:
+	   Rate at which poll occurs when auto-poll is set,
+	   default 100ms.
+- poll-timeout-ms:
+	   Poll timeout when auto-poll is set, default
+	   3000ms.
 See also bindings/arm/primecell.txt

Documentation/devicetree/bindings/serial/qcom,msm-uartdm.txt+47−22

@@ -27,27 +27,52 @@ Optional properties: · 26 unmodified lines
27	- dmas: Should contain dma specifiers for transmit and receive channels	27	- dmas: Should contain dma specifiers for transmit and receive channels
28	- dma-names: Should contain "tx" for transmit and "rx" for receive channels	28	- dma-names: Should contain "tx" for transmit and "rx" for receive channels
29		29
		30	Note: Aliases may be defined to ensure the correct ordering of the UARTs.
		31	The alias serialN will result in the UART being assigned port N. If any
		32	serialN alias exists, then an alias must exist for each enabled UART. The
		33	serialN aliases should be in a .dts file instead of in a .dtsi file.
		34
30	Examples:	35	Examples:
31		36
32	A uartdm v1.4 device with dma capabilities.	37	- A uartdm v1.4 device with dma capabilities.
33		38
34	serial@f991e000 {	39	serial@f991e000 {
35	compatible = "qcom,msm-uartdm-v1.4", "qcom,msm-uartdm";	40	compatible = "qcom,msm-uartdm-v1.4", "qcom,msm-uartdm";
36	reg = <0xf991e000 0x1000>;	41	reg = <0xf991e000 0x1000>;
37	interrupts = <0 108 0x0>;	42	interrupts = <0 108 0x0>;
38	clocks = <&blsp1_uart2_apps_cxc>, <&blsp1_ahb_cxc>;	43	clocks = <&blsp1_uart2_apps_cxc>, <&blsp1_ahb_cxc>;
39	clock-names = "core", "iface";	44	clock-names = "core", "iface";
40	dmas = <&dma0 0>, <&dma0 1>;	45	dmas = <&dma0 0>, <&dma0 1>;
41	dma-names = "tx", "rx";	46	dma-names = "tx", "rx";
42	};	47	};
43		48
44	A uartdm v1.3 device without dma capabilities and part of a GSBI complex.	49	- A uartdm v1.3 device without dma capabilities and part of a GSBI complex.
45		50
46	serial@19c40000 {	51	serial@19c40000 {
47	compatible = "qcom,msm-uartdm-v1.3", "qcom,msm-uartdm";	52	compatible = "qcom,msm-uartdm-v1.3", "qcom,msm-uartdm";
48	reg = <0x19c40000 0x1000>,	53	reg = <0x19c40000 0x1000>,
49	<0x19c00000 0x1000>;	54	<0x19c00000 0x1000>;
50	interrupts = <0 195 0x0>;	55	interrupts = <0 195 0x0>;
51	clocks = <&gsbi5_uart_cxc>, <&gsbi5_ahb_cxc>;	56	clocks = <&gsbi5_uart_cxc>, <&gsbi5_ahb_cxc>;
52	clock-names = "core", "iface";	57	clock-names = "core", "iface";
53	};	58	};
		59
		60	- serialN alias.
		61
		62	aliases {
		63	serial0 = &uarta;
		64	serial1 = &uartc;
		65	serial2 = &uartb;
		66	};
		67
		68	uarta: serial@12490000 {
		69	status = "ok";
		70	};
		71
		72	uartb: serial@16340000 {
		73	status = "ok";
		74	};
		75
		76	uartc: serial@1a240000 {
		77	status = "ok";
		78	};

Documentation/devicetree/bindings/serial/renesas,sci-serial.txt+7−2

   - compatible: Must contain one of the following:
-    - "renesas,scifa-sh73a0" for SH73A0 (SH-Mobile AG5) SCIFA compatible UART.
+    - "renesas,scif-r7s72100" for R7S72100 (RZ/A1H) SCIF compatible UART.
-    - "renesas,scifb-sh73a0" for SH73A0 (SH-Mobile AG5) SCIFB compatible UART.
     - "renesas,scifa-r8a73a4" for R8A73A4 (R-Mobile APE6) SCIFA compatible UART.
     - "renesas,scifb-r8a73a4" for R8A73A4 (R-Mobile APE6) SCIFB compatible UART.
     - "renesas,scifa-r8a7740" for R8A7740 (R-Mobile A1) SCIFA compatible UART.
     - "renesas,scifa-r8a7791" for R8A7791 (R-Car M2) SCIFA compatible UART.
     - "renesas,scifb-r8a7791" for R8A7791 (R-Car M2) SCIFB compatible UART.
     - "renesas,hscif-r8a7791" for R8A7791 (R-Car M2) HSCIF compatible UART.
+    - "renesas,scif-r8a7794" for R8A7794 (R-Car E2) SCIF compatible UART.
+    - "renesas,scifa-r8a7794" for R8A7794 (R-Car E2) SCIFA compatible UART.
+    - "renesas,scifb-r8a7794" for R8A7794 (R-Car E2) SCIFB compatible UART.
+    - "renesas,hscif-r8a7794" for R8A7794 (R-Car E2) HSCIF compatible UART.
+    - "renesas,scifa-sh73a0" for SH73A0 (SH-Mobile AG5) SCIFA compatible UART.
+    - "renesas,scifb-sh73a0" for SH73A0 (SH-Mobile AG5) SCIFB compatible UART.
     - "renesas,scif" for generic SCIF compatible UART.
     - "renesas,scifa" for generic SCIFA compatible UART.
     - "renesas,scifb" for generic SCIFB compatible UART.

Documentation/devicetree/bindings/serial/sirf-uart.txt+15−1

@@ -1,7 +1,9 @@
1	* CSR SiRFprimaII/atlasVI Universal Synchronous Asynchronous Receiver/Transmitter *	1	* CSR SiRFprimaII/atlasVI Universal Synchronous Asynchronous Receiver/Transmitter *
2		2
3	Required properties:	3	Required properties:
4	- compatible : Should be "sirf,prima2-uart" or "sirf, prima2-usp-uart"	4	- compatible : Should be "sirf,prima2-uart", "sirf, prima2-usp-uart",
		5	"sirf,marco-uart" or "sirf,marco-bt-uart" which means
		6	uart located in BT module and used for BT.
5	- reg : Offset and length of the register set for the device	7	- reg : Offset and length of the register set for the device
6	- interrupts : Should contain uart interrupt	8	- interrupts : Should contain uart interrupt
7	- fifosize : Should define hardware rx/tx fifo size	9	- fifosize : Should define hardware rx/tx fifo size
@@ -31,3 +33,15 @@ usp@b0090000 { · 23 unmodified lines
31	rts-gpios = <&gpio 15 0>;	33	rts-gpios = <&gpio 15 0>;
32	cts-gpios = <&gpio 46 0>;	34	cts-gpios = <&gpio 46 0>;
33	};	35	};
		36
		37	for uart use in BT module,
		38	uart6: uart@11000000 {
		39	cell-index = <6>;
		40	compatible = "sirf,marco-bt-uart", "sirf,marco-uart";
		41	reg = <0x11000000 0x1000>;
		42	interrupts = <0 100 0>;
		43	clocks = <&clks 138>, <&clks 140>, <&clks 141>;
		44	clock-names = "uart", "general", "noc";
		45	fifosize = <128>;
		46	status = "disabled";
		47	}

Documentation/serial/driver+4−2

 access to the info->tmpbuf bouncebuffer used for port writes.
 The port_sem semaphore is used to protect against ports being added/
-removed or reconfigured at inappropriate times.
+removed or reconfigured at inappropriate times. Since v2.6.27, this
+semaphore has been the 'mutex' member of the tty_port struct, and
+commonly referred to as the port mutex (or port->mutex).
 uart_ops
 	Other flags may be used (eg, xon/xoff characters) if your
 	hardware supports hardware "soft" flow control.
-	Locking: none.
+	Locking: caller holds port->mutex
 	Interrupts: caller dependent.
 	This call must not sleep

MAINTAINERS+6−0

@@ -8026,6 +8026,12 @@ S: Maintained · 8025 unmodified lines
8026	F: Documentation/serial/rocket.txt	8026	F: Documentation/serial/rocket.txt
8027	F: drivers/tty/rocket*	8027	F: drivers/tty/rocket*
8028		8028
		8029	ROCKETPORT EXPRESS/INFINITY DRIVER
		8030	M: Kevin Cernekee <cernekee@gmail.com>
		8031	L: linux-serial@vger.kernel.org
		8032	S: Odd Fixes
		8033	F: drivers/tty/serial/rp2.*
		8034
8029	ROSE NETWORK LAYER	8035	ROSE NETWORK LAYER
8030	M: Ralf Baechle <ralf@linux-mips.org>	8036	M: Ralf Baechle <ralf@linux-mips.org>
8031	L: linux-hams@vger.kernel.org	8037	L: linux-hams@vger.kernel.org

arch/blackfin/include/asm/bfin_serial.h+3−4

 #ifndef __BFIN_ASM_SERIAL_H__
 #define __BFIN_ASM_SERIAL_H__
+#include <linux/circ_buf.h>
 #include <linux/serial_core.h>
 #include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/workqueue.h>
 #include <mach/anomaly.h>
 #include <mach/bfin_serial.h>
 # endif
 #endif
-struct circ_buf;
-struct timer_list;
-struct work_struct;
 struct bfin_serial_port {
 	struct uart_port port;
 	unsigned int old_status;

arch/um/drivers/line.c+5−1

 	int fd = winch->fd;
 	int err;
 	char c;
+	struct pid *pgrp;
 	if (fd != -1) {
 		err = generic_read(fd, &c, NULL);
 		if (line != NULL) {
 			chan_window_size(line, &tty->winsize.ws_row,
 					 &tty->winsize.ws_col);
-			kill_pgrp(tty->pgrp, SIGWINCH, 1);
+			pgrp = tty_get_pgrp(tty);
+			if (pgrp)
+				kill_pgrp(pgrp, SIGWINCH, 1);
+			put_pid(pgrp);
 		}
 		tty_kref_put(tty);
 	}

drivers/parport/parport_serial.c+10−0

 	timedia_9079c,
 	wch_ch353_1s1p,
 	wch_ch353_2s1p,
+	wch_ch382_2s1p,
 	sunix_2s1p,
 };
 	/* timedia_9079c */             { 1, { { 2, 3 }, } },
 	/* wch_ch353_1s1p*/             { 1, { { 1, -1}, } },
 	/* wch_ch353_2s1p*/             { 1, { { 2, -1}, } },
+	/* wch_ch382_2s1p*/             { 1, { { 2, -1}, } },
 	/* sunix_2s1p */                { 1, { { 3, -1 }, } },
 };
 	/* WCH CARDS */
 	{ 0x4348, 0x5053, PCI_ANY_ID, PCI_ANY_ID, 0, 0, wch_ch353_1s1p},
 	{ 0x4348, 0x7053, 0x4348, 0x3253, 0, 0, wch_ch353_2s1p},
+	{ 0x1c00, 0x3250, 0x1c00, 0x3250, 0, 0, wch_ch382_2s1p},
 	/*
 	 * More SUNIX variations. At least one of these has part number
 		.base_baud      = 115200,
 		.uart_offset    = 8,
 	},
+	[wch_ch382_2s1p] = {
+		.flags          = FL_BASE0,
+		.num_ports      = 2,
+		.base_baud      = 115200,
+		.uart_offset    = 8,
+		.first_offset   = 0xC0,
+	},
 	[sunix_2s1p] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 2,

drivers/tty/ehv_bytechan.c+2−2

@@ -309,8 +309,8 @@ static int __init ehv_bc_console_init(void) · 308 unmodified lines
309	* handle for udbg.	309	* handle for udbg.
310	*/	310	*/
311	if (stdout_bc != CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE)	311	if (stdout_bc != CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE)
312	pr_warning("ehv-bc: udbg handle %u is not the stdout handle\n",	312	pr_warn("ehv-bc: udbg handle %u is not the stdout handle\n",
313	CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);	313	CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);
314	#endif	314	#endif
315		315
316	/* add_preferred_console() must be called before register_console(),	316	/* add_preferred_console() must be called before register_console(),

drivers/tty/goldfish.c+3−3

@@ -155,9 +155,9 @@ static struct tty_driver goldfish_tty_console_device(struct console c, · 154 unmodified lines
155		155
156	static int goldfish_tty_console_setup(struct console co, char options)	156	static int goldfish_tty_console_setup(struct console co, char options)
157	{	157	{
158	if ((unsigned)co->index > goldfish_tty_line_count)	158	if ((unsigned)co->index >= goldfish_tty_line_count)
159	return -ENODEV;	159	return -ENODEV;
160	if (goldfish_ttys[co->index].base == 0)	160	if (!goldfish_ttys[co->index].base)
161	return -ENODEV;	161	return -ENODEV;
162	return 0;	162	return 0;
163	}	163	}
@@ -317,7 +317,7 @@ static int goldfish_tty_remove(struct platform_device *pdev) · 153 unmodified lines
317	unregister_console(&qtty->console);	317	unregister_console(&qtty->console);
318	tty_unregister_device(goldfish_tty_driver, pdev->id);	318	tty_unregister_device(goldfish_tty_driver, pdev->id);
319	iounmap(qtty->base);	319	iounmap(qtty->base);
320	qtty->base = 0;	320	qtty->base = NULL;
321	free_irq(qtty->irq, pdev);	321	free_irq(qtty->irq, pdev);
322	goldfish_tty_current_line_count--;	322	goldfish_tty_current_line_count--;
323	if (goldfish_tty_current_line_count == 0)	323	if (goldfish_tty_current_line_count == 0)

drivers/tty/hvc/hvcs.c+1−1

@@ -1575,7 +1575,7 @@ static int __init hvcs_module_init(void) · 1574 unmodified lines
1575	*/	1575	*/
1576	rc = driver_create_file(&(hvcs_vio_driver.driver), &driver_attr_rescan);	1576	rc = driver_create_file(&(hvcs_vio_driver.driver), &driver_attr_rescan);
1577	if (rc)	1577	if (rc)
1578	pr_warning(KERN_ERR "HVCS: Failed to create rescan file (err %d)\n", rc);	1578	pr_warning("HVCS: Failed to create rescan file (err %d)\n", rc);
1579		1579
1580	return 0;	1580	return 0;
1581	}	1581	}

drivers/tty/hvc/hvsi_lib.c+1−2

@@ -405,8 +405,7 @@ void hvsilib_close(struct hvsi_priv pv, struct hvc_struct hp) · 404 unmodified lines
405	hvsi_send_close(pv);	405	hvsi_send_close(pv);
406	}	406	}
407		407
408	if (pv->tty)	408	tty_kref_put(pv->tty);
409	tty_kref_put(pv->tty);
410	pv->tty = NULL;	409	pv->tty = NULL;
411	}	410	}
412		411

drivers/tty/ipwireless/hardware.c+6−6

@@ -378,9 +378,9 @@ static void swap_packet_bitfield_to_le(unsigned char *data) · 377 unmodified lines
378	/*	378	/*
379	* transform bits from aa.bbb.ccc to ccc.bbb.aa	379	* transform bits from aa.bbb.ccc to ccc.bbb.aa
380	*/	380	*/
381	ret \|= tmp & 0xc0 >> 6;	381	ret \|= (tmp & 0xc0) >> 6;
382	ret \|= tmp & 0x38 >> 1;	382	ret \|= (tmp & 0x38) >> 1;
383	ret \|= tmp & 0x07 << 5;	383	ret \|= (tmp & 0x07) << 5;
384	*data = ret & 0xff;	384	*data = ret & 0xff;
385	#endif	385	#endif
386	}	386	}
@@ -393,9 +393,9 @@ static void swap_packet_bitfield_from_le(unsigned char *data) · 6 unmodified lines
393	/*	393	/*
394	* transform bits from ccc.bbb.aa to aa.bbb.ccc	394	* transform bits from ccc.bbb.aa to aa.bbb.ccc
395	*/	395	*/
396	ret \|= tmp & 0xe0 >> 5;	396	ret \|= (tmp & 0xe0) >> 5;
397	ret \|= tmp & 0x1c << 1;	397	ret \|= (tmp & 0x1c) << 1;
398	ret \|= tmp & 0x03 << 6;	398	ret \|= (tmp & 0x03) << 6;
399	*data = ret & 0xff;	399	*data = ret & 0xff;
400	#endif	400	#endif
401	}	401	}

drivers/tty/isicom.c+7−7

@@ -249,7 +249,7 @@ static int lock_card(struct isi_board *card) · 248 unmodified lines
249	spin_unlock_irqrestore(&card->card_lock, card->flags);	249	spin_unlock_irqrestore(&card->card_lock, card->flags);
250	msleep(10);	250	msleep(10);
251	}	251	}
252	pr_warning("Failed to lock Card (0x%lx)\n", card->base);	252	pr_warn("Failed to lock Card (0x%lx)\n", card->base);
253		253
254	return 0; /* Failed to acquire the card! */	254	return 0; /* Failed to acquire the card! */
255	}	255	}
@@ -378,13 +378,13 @@ static inline int __isicom_paranoia_check(struct isi_port const *port, · 122 unmodified lines
378	char name, const char routine)	378	char name, const char routine)
379	{	379	{
380	if (!port) {	380	if (!port) {
381	pr_warning("Warning: bad isicom magic for dev %s in %s.\n",	381	pr_warn("Warning: bad isicom magic for dev %s in %s\n",
382	name, routine);	382	name, routine);
383	return 1;	383	return 1;
384	}	384	}
385	if (port->magic != ISICOM_MAGIC) {	385	if (port->magic != ISICOM_MAGIC) {
386	pr_warning("Warning: NULL isicom port for dev %s in %s.\n",	386	pr_warn("Warning: NULL isicom port for dev %s in %s\n",
387	name, routine);	387	name, routine);
388	return 1;	388	return 1;
389	}	389	}
390		390
@@ -546,8 +546,8 @@ static irqreturn_t isicom_interrupt(int irq, void *dev_id) · 155 unmodified lines
546	byte_count = header & 0xff;	546	byte_count = header & 0xff;
547		547
548	if (channel + 1 > card->port_count) {	548	if (channel + 1 > card->port_count) {
549	pr_warning("%s(0x%lx): %d(channel) > port_count.\n",	549	pr_warn("%s(0x%lx): %d(channel) > port_count\n",
550	__func__, base, channel+1);	550	__func__, base, channel + 1);
551	outw(0x0000, base+0x04); /* enable interrupts */	551	outw(0x0000, base+0x04); /* enable interrupts */
552	spin_unlock(&card->card_lock);	552	spin_unlock(&card->card_lock);
553	return IRQ_HANDLED;	553	return IRQ_HANDLED;

drivers/tty/n_tty.c+37−44

@@ -321,7 +321,8 @@ static void n_tty_check_unthrottle(struct tty_struct *tty) · 320 unmodified lines
321		321
322	static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)	322	static inline void put_tty_queue(unsigned char c, struct n_tty_data *ldata)
323	{	323	{
324	*read_buf_addr(ldata, ldata->read_head++) = c;	324	*read_buf_addr(ldata, ldata->read_head) = c;
		325	ldata->read_head++;
325	}	326	}
326		327
327	/**	328	/**
@@ -351,13 +352,13 @@ static void n_tty_packet_mode_flush(struct tty_struct *tty) · 23 unmodified lines
351	{	352	{
352	unsigned long flags;	353	unsigned long flags;
353		354
354	spin_lock_irqsave(&tty->ctrl_lock, flags);
355	if (tty->link->packet) {	355	if (tty->link->packet) {
		356	spin_lock_irqsave(&tty->ctrl_lock, flags);
356	tty->ctrl_status \|= TIOCPKT_FLUSHREAD;	357	tty->ctrl_status \|= TIOCPKT_FLUSHREAD;
		358	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
357	if (waitqueue_active(&tty->link->read_wait))	359	if (waitqueue_active(&tty->link->read_wait))
358	wake_up_interruptible(&tty->link->read_wait);	360	wake_up_interruptible(&tty->link->read_wait);
359	}	361	}
360	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
361	}	362	}
362		363
363	/**	364	/**
@@ -2128,7 +2129,6 @@ static ssize_t n_tty_read(struct tty_struct tty, struct file file, · 1764 unmodified lines
2128	int minimum, time;	2129	int minimum, time;
2129	ssize_t retval = 0;	2130	ssize_t retval = 0;
2130	long timeout;	2131	long timeout;
2131	unsigned long flags;
2132	int packet;	2132	int packet;
2133		2133
2134	c = job_control(tty, file);	2134	c = job_control(tty, file);
@@ -2174,10 +2174,10 @@ static ssize_t n_tty_read(struct tty_struct tty, struct file file, · 39 unmodified lines
2174	unsigned char cs;	2174	unsigned char cs;
2175	if (b != buf)	2175	if (b != buf)
2176	break;	2176	break;
2177	spin_lock_irqsave(&tty->link->ctrl_lock, flags);	2177	spin_lock_irq(&tty->link->ctrl_lock);
2178	cs = tty->link->ctrl_status;	2178	cs = tty->link->ctrl_status;
2179	tty->link->ctrl_status = 0;	2179	tty->link->ctrl_status = 0;
2180	spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);	2180	spin_unlock_irq(&tty->link->ctrl_lock);
2181	if (tty_put_user(tty, cs, b++)) {	2181	if (tty_put_user(tty, cs, b++)) {
2182	retval = -EFAULT;	2182	retval = -EFAULT;
2183	b--;	2183	b--;
@@ -2193,45 +2193,29 @@ static ssize_t n_tty_read(struct tty_struct tty, struct file file, · 9 unmodified lines
2193		2193
2194	if (!input_available_p(tty, 0)) {	2194	if (!input_available_p(tty, 0)) {
2195	if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {	2195	if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) {
2196	up_read(&tty->termios_rwsem);	2196	retval = -EIO;
2197	tty_flush_to_ldisc(tty);	2197	break;
2198	down_read(&tty->termios_rwsem);
2199	if (!input_available_p(tty, 0)) {
2200	retval = -EIO;
2201	break;
2202	}
2203	} else {
2204	if (tty_hung_up_p(file))
2205	break;
2206	if (!timeout)
2207	break;
2208	if (file->f_flags & O_NONBLOCK) {
2209	retval = -EAGAIN;
2210	break;
2211	}
2212	if (signal_pending(current)) {
2213	retval = -ERESTARTSYS;
2214	break;
2215	}
2216	n_tty_set_room(tty);
2217	up_read(&tty->termios_rwsem);
2218
2219	timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
2220	timeout);
2221
2222	down_read(&tty->termios_rwsem);
2223	continue;
2224	}	2198	}
2225	}	2199	if (tty_hung_up_p(file))
2226		2200	break;
2227	/* Deal with packet mode. */	2201	if (!timeout)
2228	if (packet && b == buf) {	2202	break;
2229	if (tty_put_user(tty, TIOCPKT_DATA, b++)) {	2203	if (file->f_flags & O_NONBLOCK) {
2230	retval = -EFAULT;	2204	retval = -EAGAIN;
2231	b--;
2232	break;	2205	break;
2233	}	2206	}
2234	nr--;	2207	if (signal_pending(current)) {
		2208	retval = -ERESTARTSYS;
		2209	break;
		2210	}
		2211	n_tty_set_room(tty);
		2212	up_read(&tty->termios_rwsem);
		2213
		2214	timeout = wait_woken(&wait, TASK_INTERRUPTIBLE,
		2215	timeout);
		2216
		2217	down_read(&tty->termios_rwsem);
		2218	continue;
2235	}	2219	}
2236		2220
2237	if (ldata->icanon && !L_EXTPROC(tty)) {	2221	if (ldata->icanon && !L_EXTPROC(tty)) {
@@ -2243,8 +2227,17 @@ static ssize_t n_tty_read(struct tty_struct tty, struct file file, · 5 unmodified lines
2243	break;	2227	break;
2244	} else {	2228	} else {
2245	int uncopied;	2229	int uncopied;
2246	/* The copy function takes the read lock and handles	2230
2247	locking internally for this case */	2231	/* Deal with packet mode. */
		2232	if (packet && b == buf) {
		2233	if (tty_put_user(tty, TIOCPKT_DATA, b++)) {
		2234	retval = -EFAULT;
		2235	b--;
		2236	break;
		2237	}
		2238	nr--;
		2239	}
		2240
2248	uncopied = copy_from_read_buf(tty, &b, &nr);	2241	uncopied = copy_from_read_buf(tty, &b, &nr);
2249	uncopied += copy_from_read_buf(tty, &b, &nr);	2242	uncopied += copy_from_read_buf(tty, &b, &nr);
2250	if (uncopied) {	2243	if (uncopied) {

drivers/tty/pty.c+52−35

 	set_bit(TTY_IO_ERROR, &tty->flags);
 	wake_up_interruptible(&tty->read_wait);
 	wake_up_interruptible(&tty->write_wait);
+	spin_lock_irq(&tty->ctrl_lock);
 	tty->packet = 0;
+	spin_unlock_irq(&tty->ctrl_lock);
 	/* Review - krefs on tty_link ?? */
 	if (!tty->link)
 		return;
+	tty_flush_to_ldisc(tty->link);
 	set_bit(TTY_OTHER_CLOSED, &tty->link->flags);
 	wake_up_interruptible(&tty->link->read_wait);
 	wake_up_interruptible(&tty->link->write_wait);
 			mutex_unlock(&devpts_mutex);
 		}
 #endif
-		tty_unlock(tty);
 		tty_vhangup(tty->link);
-		tty_lock(tty);
 	}
 }
 /* Set the packet mode on a pty */
 static int pty_set_pktmode(struct tty_struct *tty, int __user *arg)
 {
-	unsigned long flags;
 	int pktmode;
 	if (get_user(pktmode, arg))
 		return -EFAULT;
-	spin_lock_irqsave(&tty->ctrl_lock, flags);
+	spin_lock_irq(&tty->ctrl_lock);
 	if (pktmode) {
 		if (!tty->packet) {
-			tty->packet = 1;
 			tty->link->ctrl_status = 0;
+			smp_mb();
+			tty->packet = 1;
 		}
 	} else
 		tty->packet = 0;
-	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
+	spin_unlock_irq(&tty->ctrl_lock);
 	return 0;
 }
 /* Send a signal to the slave */
 static int pty_signal(struct tty_struct *tty, int sig)
 {
-	unsigned long flags;
 	struct pid *pgrp;
 	if (tty->link) {
-		spin_lock_irqsave(&tty->link->ctrl_lock, flags);
+		pgrp = tty_get_pgrp(tty->link);
-		pgrp = get_pid(tty->link->pgrp);
+		if (pgrp)
-		spin_unlock_irqrestore(&tty->link->ctrl_lock, flags);
+			kill_pgrp(pgrp, sig, 1);
-		kill_pgrp(pgrp, sig, 1);
 		put_pid(pgrp);
 	}
 	return 0;
 static void pty_flush_buffer(struct tty_struct *tty)
 {
 	struct tty_struct *to = tty->link;
-	unsigned long flags;
 	if (!to)
 		return;
 	/* tty_buffer_flush(to); FIXME */
 	if (to->packet) {
-		spin_lock_irqsave(&tty->ctrl_lock, flags);
+		spin_lock_irq(&tty->ctrl_lock);
 		tty->ctrl_status |= TIOCPKT_FLUSHWRITE;
 		wake_up_interruptible(&to->read_wait);
-		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
+		spin_unlock_irq(&tty->ctrl_lock);
 	}
 }
 static void pty_set_termios(struct tty_struct *tty,
 					struct ktermios *old_termios)
 {
+	/* See if packet mode change of state. */
+	if (tty->link && tty->link->packet) {
+		int extproc = (old_termios->c_lflag & EXTPROC) |
+				(tty->termios.c_lflag & EXTPROC);
+		int old_flow = ((old_termios->c_iflag & IXON) &&
+				(old_termios->c_cc[VSTOP] == '\023') &&
+				(old_termios->c_cc[VSTART] == '\021'));
+		int new_flow = (I_IXON(tty) &&
+				STOP_CHAR(tty) == '\023' &&
+				START_CHAR(tty) == '\021');
+		if ((old_flow != new_flow) || extproc) {
+			spin_lock_irq(&tty->ctrl_lock);
+			if (old_flow != new_flow) {
+				tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
+				if (new_flow)
+					tty->ctrl_status |= TIOCPKT_DOSTOP;
+				else
+					tty->ctrl_status |= TIOCPKT_NOSTOP;
+			}
+			if (extproc)
+				tty->ctrl_status |= TIOCPKT_IOCTL;
+			spin_unlock_irq(&tty->ctrl_lock);
+			wake_up_interruptible(&tty->link->read_wait);
+		}
+	}
 	tty->termios.c_cflag &= ~(CSIZE | PARENB);
 	tty->termios.c_cflag |= (CS8 | CREAD);
 }
 static int pty_resize(struct tty_struct *tty,  struct winsize *ws)
 {
 	struct pid *pgrp, *rpgrp;
-	unsigned long flags;
 	struct tty_struct *pty = tty->link;
 	/* For a PTY we need to lock the tty side */
 	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
 		goto done;
-	/* Get the PID values and reference them so we can
+	/* Signal the foreground process group of both ptys */
-	   avoid holding the tty ctrl lock while sending signals.
+	pgrp = tty_get_pgrp(tty);
-	   We need to lock these individually however. */
+	rpgrp = tty_get_pgrp(pty);
-	spin_lock_irqsave(&tty->ctrl_lock, flags);
-	pgrp = get_pid(tty->pgrp);
-	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
-	spin_lock_irqsave(&pty->ctrl_lock, flags);
-	rpgrp = get_pid(pty->pgrp);
-	spin_unlock_irqrestore(&pty->ctrl_lock, flags);
 	if (pgrp)
 		kill_pgrp(pgrp, SIGWINCH, 1);
 {
 	unsigned long flags;
-	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	if (tty->link && tty->link->packet) {
+		spin_lock_irqsave(&tty->ctrl_lock, flags);
 		tty->ctrl_status &= ~TIOCPKT_STOP;
 		tty->ctrl_status |= TIOCPKT_START;
+		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 		wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 	}
-	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 }
 static void pty_stop(struct tty_struct *tty)
 {
 	unsigned long flags;
-	spin_lock_irqsave(&tty->ctrl_lock, flags);
 	if (tty->link && tty->link->packet) {
+		spin_lock_irqsave(&tty->ctrl_lock, flags);
 		tty->ctrl_status &= ~TIOCPKT_START;
 		tty->ctrl_status |= TIOCPKT_STOP;
+		spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 		wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 	}
-	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 }
 /**
 	int idx = tty->index;
 	int retval = -ENOMEM;
+	/* Opening the slave first has always returned -EIO */
+	if (driver->subtype != PTY_TYPE_MASTER)
+		return -EIO;
 	ports[0] = kmalloc(sizeof **ports, GFP_KERNEL);
 	ports[1] = kmalloc(sizeof **ports, GFP_KERNEL);
 	if (!ports[0] || !ports[1])
 	if (!o_tty)
 		goto err_put_module;
+	tty_set_lock_subclass(o_tty);
 	if (legacy) {
 		/* We always use new tty termios data so we can do this
 		   the easy way .. */
 	 * Everything allocated ... set up the o_tty structure.
 	 */
 	tty_driver_kref_get(driver->other);
-	if (driver->subtype == PTY_TYPE_MASTER)
-		o_tty->count++;
 	/* Establish the links in both directions */
 	tty->link   = o_tty;
 	o_tty->link = tty;
 	tty_driver_kref_get(driver);
 	tty->count++;
+	o_tty->count++;
 	return 0;
 err_free_termios:
 	if (legacy)
 	.flush_buffer = pty_flush_buffer,
 	.chars_in_buffer = pty_chars_in_buffer,
 	.unthrottle = pty_unthrottle,
-	.set_termios = pty_set_termios,
 	.ioctl = pty_bsd_ioctl,
 	.cleanup = pty_cleanup,
 	.resize = pty_resize,
 	.flush_buffer = pty_flush_buffer,
 	.chars_in_buffer = pty_chars_in_buffer,
 	.unthrottle = pty_unthrottle,
-	.set_termios = pty_set_termios,
 	.ioctl = pty_unix98_ioctl,
 	.resize = pty_resize,
 	.shutdown = pty_unix98_shutdown,

drivers/tty/serial/8250/8250.h+8−1

 #include <linux/dmaengine.h>
 struct uart_8250_dma {
+	int (*tx_dma)(struct uart_8250_port *p);
+	int (*rx_dma)(struct uart_8250_port *p, unsigned int iir);
 	/* Filter function */
 	dma_filter_fn		fn;
 	size_t			tx_size;
 	unsigned char		tx_running:1;
+	unsigned char		tx_err: 1;
+	unsigned char		rx_running:1;
 };
 struct old_serial_port {
 	unsigned int flags;
 	unsigned char hub6;
 	unsigned char io_type;
-	unsigned char *iomem_base;
+	unsigned char __iomem *iomem_base;
 	unsigned short iomem_reg_shift;
 	unsigned long irqflags;
 };
 }
 struct uart_8250_port *serial8250_get_port(int line);
+void serial8250_rpm_get(struct uart_8250_port *p);
+void serial8250_rpm_put(struct uart_8250_port *p);
 #if defined(__alpha__) && !defined(CONFIG_PCI)
 /*

drivers/tty/serial/8250/8250_core.c+56−56

 }
 EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos);
-static void serial8250_rpm_get(struct uart_8250_port *p)
+void serial8250_rpm_get(struct uart_8250_port *p)
 {
 	if (!(p->capabilities & UART_CAP_RPM))
 		return;
 	pm_runtime_get_sync(p->port.dev);
 }
+EXPORT_SYMBOL_GPL(serial8250_rpm_get);
-static void serial8250_rpm_put(struct uart_8250_port *p)
+void serial8250_rpm_put(struct uart_8250_port *p)
 {
 	if (!(p->capabilities & UART_CAP_RPM))
 		return;
 	pm_runtime_mark_last_busy(p->port.dev);
 	pm_runtime_put_autosuspend(p->port.dev);
 }
+EXPORT_SYMBOL_GPL(serial8250_rpm_put);
 /*
- * This two wrapper ensure, that enable_runtime_pm_tx() can be called more than
+ * These two wrappers ensure that enable_runtime_pm_tx() can be called more than
  * once and disable_runtime_pm_tx() will still disable RPM because the fifo is
  * empty and the HW can idle again.
  */
  */
 static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
 {
+	unsigned char lcr = 0, efr = 0;
 	/*
 	 * Exar UARTs have a SLEEP register that enables or disables
 	 * each UART to enter sleep mode separately.  On the XR17V35x the
 	if (p->capabilities & UART_CAP_SLEEP) {
 		if (p->capabilities & UART_CAP_EFR) {
+			lcr = serial_in(p, UART_LCR);
+			efr = serial_in(p, UART_EFR);
 			serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
 			serial_out(p, UART_EFR, UART_EFR_ECB);
 			serial_out(p, UART_LCR, 0);
 		serial_out(p, UART_IER, sleep ? UART_IERX_SLEEP : 0);
 		if (p->capabilities & UART_CAP_EFR) {
 			serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
-			serial_out(p, UART_EFR, 0);
+			serial_out(p, UART_EFR, efr);
-			serial_out(p, UART_LCR, 0);
+			serial_out(p, UART_LCR, lcr);
 		}
 	}
 out:
 	struct uart_8250_port *up = up_to_u8250p(port);
 	serial8250_rpm_get_tx(up);
-	if (up->dma && !serial8250_tx_dma(up)) {
+	if (up->dma && !up->dma->tx_dma(up)) {
 		return;
 	} else if (!(up->ier & UART_IER_THRI)) {
 		up->ier |= UART_IER_THRI;
 	serial8250_rpm_put(up);
 }
+static void serial8250_disable_ms(struct uart_port *port)
+{
+	struct uart_8250_port *up =
+		container_of(port, struct uart_8250_port, port);
+	/* no MSR capabilities */
+	if (up->bugs & UART_BUG_NOMSR)
+		return;
+	up->ier &= ~UART_IER_MSI;
+	serial_port_out(port, UART_IER, up->ier);
+}
 static void serial8250_enable_ms(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 ignore_char:
 		lsr = serial_in(up, UART_LSR);
-	} while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));
+	} while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (--max_count > 0));
 	spin_unlock(&port->lock);
 	tty_flip_buffer_push(&port->state->port);
 	spin_lock(&port->lock);
 	DEBUG_INTR("THRE...");
 	/*
-	 * With RPM enabled, we have to wait once the FIFO is empty before the
+	 * With RPM enabled, we have to wait until the FIFO is empty before the
 	 * HW can go idle. So we get here once again with empty FIFO and disable
 	 * the interrupt and RPM in __stop_tx()
 	 */
 	if (status & (UART_LSR_DR | UART_LSR_BI)) {
 		if (up->dma)
-			dma_err = serial8250_rx_dma(up, iir);
+			dma_err = up->dma->rx_dma(up, iir);
 		if (!up->dma || dma_err)
 			status = serial8250_rx_chars(up, status);
 	}
 	serial8250_modem_status(up);
-	if (!up->dma && (status & UART_LSR_THRE))
+	if ((!up->dma || (up->dma && up->dma->tx_err)) &&
+	    (status & UART_LSR_THRE))
 		serial8250_tx_chars(up);
 	spin_unlock_irqrestore(&port->lock, flags);
 }
 static void
-serial8250_set_ldisc(struct uart_port *port, int new)
+serial8250_set_ldisc(struct uart_port *port, struct ktermios *termios)
 {
-	if (new == N_PPS) {
+	if (termios->c_line == N_PPS) {
 		port->flags |= UPF_HARDPPS_CD;
+		spin_lock_irq(&port->lock);
 		serial8250_enable_ms(port);
-	} else
+		spin_unlock_irq(&port->lock);
+	} else {
 		port->flags &= ~UPF_HARDPPS_CD;
+		if (!UART_ENABLE_MS(port, termios->c_cflag)) {
+			spin_lock_irq(&port->lock);
+			serial8250_disable_ms(port);
+			spin_unlock_irq(&port->lock);
+		}
+	}
 }
 static unsigned int serial8250_port_size(struct uart_8250_port *pt)
 {
-	if (pt->port.iotype == UPIO_AU)
+	if (pt->port.iotype == UPIO_AU) {
+		if (pt->port.type == PORT_RT2880)
+			return 0x100;
 		return 0x1000;
+	}
 	if (is_omap1_8250(pt))
 		return 0x16 << pt->port.regshift;
 	return 0;
 }
-static int serial8250_ioctl(struct uart_port *port, unsigned int cmd,
-			   unsigned long arg)
-{
-	struct uart_8250_port *up =
-		container_of(port, struct uart_8250_port, port);
-	int ret;
-	struct serial_rs485 rs485_config;
-	if (!up->rs485_config)
-		return -ENOIOCTLCMD;
-	switch (cmd) {
-	case TIOCSRS485:
-		if (copy_from_user(&rs485_config, (void __user *)arg,
-				   sizeof(rs485_config)))
-			return -EFAULT;
-		ret = up->rs485_config(up, &rs485_config);
-		if (ret)
-			return ret;
-		memcpy(&up->rs485, &rs485_config, sizeof(rs485_config));
-		return 0;
-	case TIOCGRS485:
-		if (copy_to_user((void __user *)arg, &up->rs485,
-				 sizeof(up->rs485)))
-			return -EFAULT;
-		return 0;
-	default:
-		break;
-	}
-	return -ENOIOCTLCMD;
-}
 static const char *
 serial8250_type(struct uart_port *port)
 {
 	.request_port	= serial8250_request_port,
 	.config_port	= serial8250_config_port,
 	.verify_port	= serial8250_verify_port,
-	.ioctl		= serial8250_ioctl,
 #ifdef CONFIG_CONSOLE_POLL
 	.poll_get_char = serial8250_get_poll_char,
 	.poll_put_char = serial8250_put_poll_char,
 	serial8250_rpm_get(up);
-	if (port->sysrq || oops_in_progress)
+	if (port->sysrq)
+		locked = 0;
+	else if (oops_in_progress)
 		locked = spin_trylock_irqsave(&port->lock, flags);
 	else
 		spin_lock_irqsave(&port->lock, flags);
 	serial8250_rpm_put(up);
 }
-static int __init serial8250_console_setup(struct console *co, char *options)
+static int serial8250_console_setup(struct console *co, char *options)
 {
 	struct uart_port *port;
 	int baud = 9600;
 		uart->port.fifosize	= up->port.fifosize;
 		uart->tx_loadsz		= up->tx_loadsz;
 		uart->capabilities	= up->capabilities;
-		uart->rs485_config	= up->rs485_config;
-		uart->rs485		= up->rs485;
 		uart->port.throttle	= up->port.throttle;
 		uart->port.unthrottle	= up->port.unthrottle;
+		uart->port.rs485_config	= up->port.rs485_config;
+		uart->port.rs485	= up->port.rs485;
 		/* Take tx_loadsz from fifosize if it wasn't set separately */
 		if (uart->port.fifosize && !uart->tx_loadsz)
 			uart->dl_read = up->dl_read;
 		if (up->dl_write)
 			uart->dl_write = up->dl_write;
-		if (up->dma)
+		if (up->dma) {
 			uart->dma = up->dma;
+			if (!uart->dma->tx_dma)
+				uart->dma->tx_dma = serial8250_tx_dma;
+			if (!uart->dma->rx_dma)
+				uart->dma->rx_dma = serial8250_rx_dma;
+		}
 		if (serial8250_isa_config != NULL)
 			serial8250_isa_config(0, &uart->port,

drivers/tty/serial/8250/8250_dma.c+25−14

@@ -21,6 +21,7 @@ static void __dma_tx_complete(void *param) · 20 unmodified lines
21	struct uart_8250_dma *dma = p->dma;	21	struct uart_8250_dma *dma = p->dma;
22	struct circ_buf *xmit = &p->port.state->xmit;	22	struct circ_buf *xmit = &p->port.state->xmit;
23	unsigned long flags;	23	unsigned long flags;
		24	int ret;
24		25
25	dma_sync_single_for_cpu(dma->txchan->device->dev, dma->tx_addr,	26	dma_sync_single_for_cpu(dma->txchan->device->dev, dma->tx_addr,
26	UART_XMIT_SIZE, DMA_TO_DEVICE);	27	UART_XMIT_SIZE, DMA_TO_DEVICE);
@@ -36,8 +37,11 @@ static void __dma_tx_complete(void *param) · 9 unmodified lines
36	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)	37	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
37	uart_write_wakeup(&p->port);	38	uart_write_wakeup(&p->port);
38		39
39	if (!uart_circ_empty(xmit) && !uart_tx_stopped(&p->port))	40	ret = serial8250_tx_dma(p);
40	serial8250_tx_dma(p);	41	if (ret) {
		42	p->ier \|= UART_IER_THRI;
		43	serial_port_out(&p->port, UART_IER, p->ier);
		44	}
41		45
42	spin_unlock_irqrestore(&p->port.lock, flags);	46	spin_unlock_irqrestore(&p->port.lock, flags);
43	}	47	}
@@ -53,6 +57,7 @@ static void __dma_rx_complete(void *param) · 9 unmodified lines
53	dma_sync_single_for_cpu(dma->rxchan->device->dev, dma->rx_addr,	57	dma_sync_single_for_cpu(dma->rxchan->device->dev, dma->rx_addr,
54	dma->rx_size, DMA_FROM_DEVICE);	58	dma->rx_size, DMA_FROM_DEVICE);
55		59
		60	dma->rx_running = 0;
56	dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state);	61	dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state);
57	dmaengine_terminate_all(dma->rxchan);	62	dmaengine_terminate_all(dma->rxchan);
58		63
@@ -69,6 +74,7 @@ int serial8250_tx_dma(struct uart_8250_port *p) · 10 unmodified lines
69	struct uart_8250_dma *dma = p->dma;	74	struct uart_8250_dma *dma = p->dma;
70	struct circ_buf *xmit = &p->port.state->xmit;	75	struct circ_buf *xmit = &p->port.state->xmit;
71	struct dma_async_tx_descriptor *desc;	76	struct dma_async_tx_descriptor *desc;
		77	int ret;
72		78
73	if (uart_tx_stopped(&p->port) \|\| dma->tx_running \|\|	79	if (uart_tx_stopped(&p->port) \|\| dma->tx_running \|\|
74	uart_circ_empty(xmit))	80	uart_circ_empty(xmit))
@@ -80,11 +86,12 @@ int serial8250_tx_dma(struct uart_8250_port *p) · 5 unmodified lines
80	dma->tx_addr + xmit->tail,	86	dma->tx_addr + xmit->tail,
81	dma->tx_size, DMA_MEM_TO_DEV,	87	dma->tx_size, DMA_MEM_TO_DEV,
82	DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);	88	DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);
83	if (!desc)	89	if (!desc) {
84	return -EBUSY;	90	ret = -EBUSY;
		91	goto err;
		92	}
85		93
86	dma->tx_running = 1;	94	dma->tx_running = 1;
87
88	desc->callback = __dma_tx_complete;	95	desc->callback = __dma_tx_complete;
89	desc->callback_param = p;	96	desc->callback_param = p;
90		97
@@ -94,19 +101,23 @@ int serial8250_tx_dma(struct uart_8250_port *p) · 3 unmodified lines
94	UART_XMIT_SIZE, DMA_TO_DEVICE);	101	UART_XMIT_SIZE, DMA_TO_DEVICE);
95		102
96	dma_async_issue_pending(dma->txchan);	103	dma_async_issue_pending(dma->txchan);
97		104	if (dma->tx_err) {
		105	dma->tx_err = 0;
		106	if (p->ier & UART_IER_THRI) {
		107	p->ier &= ~UART_IER_THRI;
		108	serial_out(p, UART_IER, p->ier);
		109	}
		110	}
98	return 0;	111	return 0;
		112	err:
		113	dma->tx_err = 1;
		114	return ret;
99	}	115	}
100	EXPORT_SYMBOL_GPL(serial8250_tx_dma);
101		116
102	int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir)	117	int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
103	{	118	{
104	struct uart_8250_dma *dma = p->dma;	119	struct uart_8250_dma *dma = p->dma;
105	struct dma_async_tx_descriptor *desc;	120	struct dma_async_tx_descriptor *desc;
106	struct dma_tx_state state;
107	int dma_status;
108
109	dma_status = dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state);
110		121
111	switch (iir & 0x3f) {	122	switch (iir & 0x3f) {
112	case UART_IIR_RLSI:	123	case UART_IIR_RLSI:
@@ -117,7 +128,7 @@ int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir) · 4 unmodified lines
117	* If RCVR FIFO trigger level was not reached, complete the	128	* If RCVR FIFO trigger level was not reached, complete the
118	* transfer and let 8250_core copy the remaining data.	129	* transfer and let 8250_core copy the remaining data.
119	*/	130	*/
120	if (dma_status == DMA_IN_PROGRESS) {	131	if (dma->rx_running) {
121	dmaengine_pause(dma->rxchan);	132	dmaengine_pause(dma->rxchan);
122	__dma_rx_complete(p);	133	__dma_rx_complete(p);
123	}	134	}
@@ -126,7 +137,7 @@ int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir) · 2 unmodified lines
126	break;	137	break;
127	}	138	}
128		139
129	if (dma_status)	140	if (dma->rx_running)
130	return 0;	141	return 0;
131		142
132	desc = dmaengine_prep_slave_single(dma->rxchan, dma->rx_addr,	143	desc = dmaengine_prep_slave_single(dma->rxchan, dma->rx_addr,
@@ -135,6 +146,7 @@ int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir) · 2 unmodified lines
135	if (!desc)	146	if (!desc)
136	return -EBUSY;	147	return -EBUSY;
137		148
		149	dma->rx_running = 1;
138	desc->callback = __dma_rx_complete;	150	desc->callback = __dma_rx_complete;
139	desc->callback_param = p;	151	desc->callback_param = p;
140		152
@@ -147,7 +159,6 @@ int serial8250_rx_dma(struct uart_8250_port *p, unsigned int iir) · 6 unmodified lines
147		159
148	return 0;	160	return 0;
149	}	161	}
150	EXPORT_SYMBOL_GPL(serial8250_rx_dma);
151		162
152	int serial8250_request_dma(struct uart_8250_port *p)	163	int serial8250_request_dma(struct uart_8250_port *p)
153	{	164	{

drivers/tty/serial/8250/8250_dw.c+55−14

@@ -122,13 +122,44 @@ static unsigned int dw8250_serial_in(struct uart_port *p, int offset) · 121 unmodified lines
122	return dw8250_modify_msr(p, offset, value);	122	return dw8250_modify_msr(p, offset, value);
123	}	123	}
124		124
125	/* Read Back (rb) version to ensure register access ording. */	125	#ifdef CONFIG_64BIT
126	static void dw8250_serial_out_rb(struct uart_port *p, int offset, int value)	126	static unsigned int dw8250_serial_inq(struct uart_port *p, int offset)
127	{	127	{
128	dw8250_serial_out(p, offset, value);	128	unsigned int value;
129	dw8250_serial_in(p, UART_LCR);	129
		130	value = (u8)__raw_readq(p->membase + (offset << p->regshift));
		131
		132	return dw8250_modify_msr(p, offset, value);
130	}	133	}
131		134
		135	static void dw8250_serial_outq(struct uart_port *p, int offset, int value)
		136	{
		137	struct dw8250_data *d = p->private_data;
		138
		139	if (offset == UART_MCR)
		140	d->last_mcr = value;
		141
		142	value &= 0xff;
		143	__raw_writeq(value, p->membase + (offset << p->regshift));
		144	/* Read back to ensure register write ordering. */
		145	__raw_readq(p->membase + (UART_LCR << p->regshift));
		146
		147	/* Make sure LCR write wasn't ignored */
		148	if (offset == UART_LCR) {
		149	int tries = 1000;
		150	while (tries--) {
		151	unsigned int lcr = p->serial_in(p, UART_LCR);
		152	if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
		153	return;
		154	dw8250_force_idle(p);
		155	__raw_writeq(value & 0xff,
		156	p->membase + (UART_LCR << p->regshift));
		157	}
		158	dev_err(p->dev, "Couldn't set LCR to %d\n", value);
		159	}
		160	}
		161	#endif /* CONFIG_64BIT */
		162
132	static void dw8250_serial_out32(struct uart_port *p, int offset, int value)	163	static void dw8250_serial_out32(struct uart_port *p, int offset, int value)
133	{	164	{
134	struct dw8250_data *d = p->private_data;	165	struct dw8250_data *d = p->private_data;
@@ -258,22 +289,19 @@ static int dw8250_probe_of(struct uart_port *p, · 123 unmodified lines
258	struct uart_8250_port *up = up_to_u8250p(p);	289	struct uart_8250_port *up = up_to_u8250p(p);
259	u32 val;	290	u32 val;
260	bool has_ucv = true;	291	bool has_ucv = true;
		292	int id;
261		293
		294	#ifdef CONFIG_64BIT
262	if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) {	295	if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) {
263	#ifdef __BIG_ENDIAN	296	p->serial_in = dw8250_serial_inq;
264	/*	297	p->serial_out = dw8250_serial_outq;
265	* Low order bits of these 64-bit registers, when
266	* accessed as a byte, are 7 bytes further down in the
267	* address space in big endian mode.
268	*/
269	p->membase += 7;
270	#endif
271	p->serial_out = dw8250_serial_out_rb;
272	p->flags = UPF_SKIP_TEST \| UPF_SHARE_IRQ \| UPF_FIXED_TYPE;	298	p->flags = UPF_SKIP_TEST \| UPF_SHARE_IRQ \| UPF_FIXED_TYPE;
273	p->type = PORT_OCTEON;	299	p->type = PORT_OCTEON;
274	data->usr_reg = 0x27;	300	data->usr_reg = 0x27;
275	has_ucv = false;	301	has_ucv = false;
276	} else if (!of_property_read_u32(np, "reg-io-width", &val)) {	302	} else
		303	#endif
		304	if (!of_property_read_u32(np, "reg-io-width", &val)) {
277	switch (val) {	305	switch (val) {
278	case 1:	306	case 1:
279	break;	307	break;
@@ -290,9 +318,22 @@ static int dw8250_probe_of(struct uart_port *p, · 10 unmodified lines
290	if (has_ucv)	318	if (has_ucv)
291	dw8250_setup_port(up);	319	dw8250_setup_port(up);
292		320
		321	/* if we have a valid fifosize, try hooking up DMA here */
		322	if (p->fifosize) {
		323	up->dma = &data->dma;
		324
		325	up->dma->rxconf.src_maxburst = p->fifosize / 4;
		326	up->dma->txconf.dst_maxburst = p->fifosize / 4;
		327	}
		328
293	if (!of_property_read_u32(np, "reg-shift", &val))	329	if (!of_property_read_u32(np, "reg-shift", &val))
294	p->regshift = val;	330	p->regshift = val;
295		331
		332	/* get index of serial line, if found in DT aliases */
		333	id = of_alias_get_id(np, "serial");
		334	if (id >= 0)
		335	p->line = id;
		336
296	/* clock got configured through clk api, all done */	337	/* clock got configured through clk api, all done */
297	if (p->uartclk)	338	if (p->uartclk)
298	return 0;	339	return 0;

drivers/tty/serial/8250/8250_em.c+1−3

 	}
 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
-	if (!priv) {
+	if (!priv)
-		dev_err(&pdev->dev, "unable to allocate private data\n");
 		return -ENOMEM;
-	}
 	priv->sclk = devm_clk_get(&pdev->dev, "sclk");
 	if (IS_ERR(priv->sclk)) {

drivers/tty/serial/8250/8250_fintek.c+5−3

 	return 0;
 }
-static int fintek_8250_rs4850_config(struct uart_8250_port *uart,
+static int fintek_8250_rs485_config(struct uart_port *port,
 			      struct serial_rs485 *rs485)
 {
 	uint8_t config = 0;
-	int index = fintek_8250_get_index(uart->port.iobase);
+	int index = fintek_8250_get_index(port->iobase);
 	if (index < 0)
 		return -EINVAL;
 	outb(config, DATA_PORT);
 	fintek_8250_exit_key();
+	port->rs485 = *rs485;
 	return 0;
 }
 	uart.port.irq = pnp_irq(dev, 0);
 	uart.port.iobase = pnp_port_start(dev, 0);
 	uart.port.iotype = UPIO_PORT;
-	uart.rs485_config = fintek_8250_rs4850_config;
+	uart.port.rs485_config = fintek_8250_rs485_config;
 	uart.port.flags |= UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
 	if (pnp_irq_flags(dev, 0) & IORESOURCE_IRQ_SHAREABLE)

drivers/tty/serial/8250/8250_hp300.c+0−4

 /*
  * Parse the bootinfo to find descriptions for headless console and
  * debug serial ports and register them with the 8250 driver.
- * This function should be called before serial_console_init() is called
- * to make sure the serial console will be available for use. IA-64 kernel
- * calls this function from setup_arch() after the EFI and ACPI tables have
- * been parsed.
  */
 int __init hp300_setup_serial_console(void)
 {

drivers/tty/serial/8250/8250_mtk.c+2−2

@@ -74,14 +74,14 @@ mtk8250_set_termios(struct uart_port port, struct ktermios termios, · 73 unmodified lines
74	/* Set to next lower baudrate supported */	74	/* Set to next lower baudrate supported */
75	if ((baud == 500000) \|\| (baud == 576000))	75	if ((baud == 500000) \|\| (baud == 576000))
76	baud = 460800;	76	baud = 460800;
77	quot = DIV_ROUND_CLOSEST(port->uartclk, 4 * baud);	77	quot = DIV_ROUND_UP(port->uartclk, 4 * baud);
78	} else {	78	} else {
79	serial_port_out(port, UART_MTK_HIGHS, 0x3);	79	serial_port_out(port, UART_MTK_HIGHS, 0x3);
80		80
81	/* Set to highest baudrate supported */	81	/* Set to highest baudrate supported */
82	if (baud >= 1152000)	82	if (baud >= 1152000)
83	baud = 921600;	83	baud = 921600;
84	quot = (port->uartclk / (256 * baud)) + 1;	84	quot = DIV_ROUND_UP(port->uartclk, 256 * baud);
85	}	85	}
86		86
87	/*	87	/*

drivers/tty/serial/8250/8250_omap.c+1281−0

@@ -0,0 +1,1281 @@
	1	/*
	2	* 8250-core based driver for the OMAP internal UART
	3	*
	4	* based on omap-serial.c, Copyright (C) 2010 Texas Instruments.
	5	*
	6	* Copyright (C) 2014 Sebastian Andrzej Siewior
	7	*
	8	*/
	9
	10	#include <linux/device.h>
	11	#include <linux/io.h>
	12	#include <linux/module.h>
	13	#include <linux/serial_8250.h>
	14	#include <linux/serial_core.h>
	15	#include <linux/serial_reg.h>
	16	#include <linux/tty_flip.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/slab.h>
	19	#include <linux/of.h>
	20	#include <linux/of_gpio.h>
	21	#include <linux/of_irq.h>
	22	#include <linux/delay.h>
	23	#include <linux/pm_runtime.h>
	24	#include <linux/console.h>
	25	#include <linux/pm_qos.h>
	26	#include <linux/dma-mapping.h>
	27
	28	#include "8250.h"
	29
	30	#define DEFAULT_CLK_SPEED 48000000
	31
	32	#define UART_ERRATA_i202_MDR1_ACCESS (1 << 0)
	33	#define OMAP_UART_WER_HAS_TX_WAKEUP (1 << 1)
	34	#define OMAP_DMA_TX_KICK (1 << 2)
	35
	36	#define OMAP_UART_FCR_RX_TRIG 6
	37	#define OMAP_UART_FCR_TX_TRIG 4
	38
	39	/* SCR register bitmasks */
	40	#define OMAP_UART_SCR_RX_TRIG_GRANU1_MASK (1 << 7)
	41	#define OMAP_UART_SCR_TX_TRIG_GRANU1_MASK (1 << 6)
	42	#define OMAP_UART_SCR_TX_EMPTY (1 << 3)
	43	#define OMAP_UART_SCR_DMAMODE_MASK (3 << 1)
	44	#define OMAP_UART_SCR_DMAMODE_1 (1 << 1)
	45	#define OMAP_UART_SCR_DMAMODE_CTL (1 << 0)
	46
	47	/* MVR register bitmasks */
	48	#define OMAP_UART_MVR_SCHEME_SHIFT 30
	49	#define OMAP_UART_LEGACY_MVR_MAJ_MASK 0xf0
	50	#define OMAP_UART_LEGACY_MVR_MAJ_SHIFT 4
	51	#define OMAP_UART_LEGACY_MVR_MIN_MASK 0x0f
	52	#define OMAP_UART_MVR_MAJ_MASK 0x700
	53	#define OMAP_UART_MVR_MAJ_SHIFT 8
	54	#define OMAP_UART_MVR_MIN_MASK 0x3f
	55
	56	#define UART_TI752_TLR_TX 0
	57	#define UART_TI752_TLR_RX 4
	58
	59	#define TRIGGER_TLR_MASK(x) ((x & 0x3c) >> 2)
	60	#define TRIGGER_FCR_MASK(x) (x & 3)
	61
	62	/* Enable XON/XOFF flow control on output */
	63	#define OMAP_UART_SW_TX 0x08
	64	/* Enable XON/XOFF flow control on input */
	65	#define OMAP_UART_SW_RX 0x02
	66
	67	#define OMAP_UART_WER_MOD_WKUP 0x7f
	68	#define OMAP_UART_TX_WAKEUP_EN (1 << 7)
	69
	70	#define TX_TRIGGER 1
	71	#define RX_TRIGGER 48
	72
	73	#define OMAP_UART_TCR_RESTORE(x) ((x / 4) << 4)
	74	#define OMAP_UART_TCR_HALT(x) ((x / 4) << 0)
	75
	76	#define UART_BUILD_REVISION(x, y) (((x) << 8) \| (y))
	77
	78	#define OMAP_UART_REV_46 0x0406
	79	#define OMAP_UART_REV_52 0x0502
	80	#define OMAP_UART_REV_63 0x0603
	81
	82	struct omap8250_priv {
	83	int line;
	84	u8 habit;
	85	u8 mdr1;
	86	u8 efr;
	87	u8 scr;
	88	u8 wer;
	89	u8 xon;
	90	u8 xoff;
	91	u8 delayed_restore;
	92	u16 quot;
	93
	94	bool is_suspending;
	95	int wakeirq;
	96	int wakeups_enabled;
	97	u32 latency;
	98	u32 calc_latency;
	99	struct pm_qos_request pm_qos_request;
	100	struct work_struct qos_work;
	101	struct uart_8250_dma omap8250_dma;
	102	};
	103
	104	static u32 uart_read(struct uart_8250_port *up, u32 reg)
	105	{
	106	return readl(up->port.membase + (reg << up->port.regshift));
	107	}
	108
	109	/*
	110	* Work Around for Errata i202 (2430, 3430, 3630, 4430 and 4460)
	111	* The access to uart register after MDR1 Access
	112	* causes UART to corrupt data.
	113	*
	114	* Need a delay =
	115	* 5 L4 clock cycles + 5 UART functional clock cycle (@48MHz = ~0.2uS)
	116	* give 10 times as much
	117	*/
	118	static void omap_8250_mdr1_errataset(struct uart_8250_port *up,
	119	struct omap8250_priv *priv)
	120	{
	121	u8 timeout = 255;
	122	u8 old_mdr1;
	123
	124	old_mdr1 = serial_in(up, UART_OMAP_MDR1);
	125	if (old_mdr1 == priv->mdr1)
	126	return;
	127
	128	serial_out(up, UART_OMAP_MDR1, priv->mdr1);
	129	udelay(2);
	130	serial_out(up, UART_FCR, up->fcr \| UART_FCR_CLEAR_XMIT \|
	131	UART_FCR_CLEAR_RCVR);
	132	/*
	133	* Wait for FIFO to empty: when empty, RX_FIFO_E bit is 0 and
	134	* TX_FIFO_E bit is 1.
	135	*/
	136	while (UART_LSR_THRE != (serial_in(up, UART_LSR) &
	137	(UART_LSR_THRE \| UART_LSR_DR))) {
	138	timeout--;
	139	if (!timeout) {
	140	/* Should never happen. we warn and carry on */
	141	dev_crit(up->port.dev, "Errata i202: timedout %x\n",
	142	serial_in(up, UART_LSR));
	143	break;
	144	}
	145	udelay(1);
	146	}
	147	}
	148
	149	static void omap_8250_get_divisor(struct uart_port *port, unsigned int baud,
	150	struct omap8250_priv *priv)
	151	{
	152	unsigned int uartclk = port->uartclk;
	153	unsigned int div_13, div_16;
	154	unsigned int abs_d13, abs_d16;
	155
	156	/*
	157	* Old custom speed handling.
	158	*/
	159	if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST) {
	160	priv->quot = port->custom_divisor & 0xffff;
	161	/*
	162	* I assume that nobody is using this. But hey, if somebody
	163	* would like to specify the divisor _and_ the mode then the
	164	* driver is ready and waiting for it.
	165	*/
	166	if (port->custom_divisor & (1 << 16))
	167	priv->mdr1 = UART_OMAP_MDR1_13X_MODE;
	168	else
	169	priv->mdr1 = UART_OMAP_MDR1_16X_MODE;
	170	return;
	171	}
	172	div_13 = DIV_ROUND_CLOSEST(uartclk, 13 * baud);
	173	div_16 = DIV_ROUND_CLOSEST(uartclk, 16 * baud);
	174
	175	if (!div_13)
	176	div_13 = 1;
	177	if (!div_16)
	178	div_16 = 1;
	179
	180	abs_d13 = abs(baud - uartclk / 13 / div_13);
	181	abs_d16 = abs(baud - uartclk / 16 / div_16);
	182
	183	if (abs_d13 >= abs_d16) {
	184	priv->mdr1 = UART_OMAP_MDR1_16X_MODE;
	185	priv->quot = div_16;
	186	} else {
	187	priv->mdr1 = UART_OMAP_MDR1_13X_MODE;
	188	priv->quot = div_13;
	189	}
	190	}
	191
	192	static void omap8250_update_scr(struct uart_8250_port *up,
	193	struct omap8250_priv *priv)
	194	{
	195	u8 old_scr;
	196
	197	old_scr = serial_in(up, UART_OMAP_SCR);
	198	if (old_scr == priv->scr)
	199	return;
	200
	201	/*
	202	* The manual recommends not to enable the DMA mode selector in the SCR
	203	* (instead of the FCR) register _and_ selecting the DMA mode as one
	204	* register write because this may lead to malfunction.
	205	*/
	206	if (priv->scr & OMAP_UART_SCR_DMAMODE_MASK)
	207	serial_out(up, UART_OMAP_SCR,
	208	priv->scr & ~OMAP_UART_SCR_DMAMODE_MASK);
	209	serial_out(up, UART_OMAP_SCR, priv->scr);
	210	}
	211
	212	static void omap8250_restore_regs(struct uart_8250_port *up)
	213	{
	214	struct omap8250_priv *priv = up->port.private_data;
	215	struct uart_8250_dma *dma = up->dma;
	216
	217	if (dma && dma->tx_running) {
	218	/*
	219	* TCSANOW requests the change to occur immediately however if
	220	* we have a TX-DMA operation in progress then it has been
	221	* observed that it might stall and never complete. Therefore we
	222	* delay DMA completes to prevent this hang from happen.
	223	*/
	224	priv->delayed_restore = 1;
	225	return;
	226	}
	227
	228	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
	229	serial_out(up, UART_EFR, UART_EFR_ECB);
	230
	231	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
	232	serial_out(up, UART_MCR, UART_MCR_TCRTLR);
	233	serial_out(up, UART_FCR, up->fcr);
	234
	235	omap8250_update_scr(up, priv);
	236
	237	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
	238
	239	serial_out(up, UART_TI752_TCR, OMAP_UART_TCR_RESTORE(16) \|
	240	OMAP_UART_TCR_HALT(52));
	241	serial_out(up, UART_TI752_TLR,
	242	TRIGGER_TLR_MASK(TX_TRIGGER) << UART_TI752_TLR_TX \|
	243	TRIGGER_TLR_MASK(RX_TRIGGER) << UART_TI752_TLR_RX);
	244
	245	serial_out(up, UART_LCR, 0);
	246
	247	/* drop TCR + TLR access, we setup XON/XOFF later */
	248	serial_out(up, UART_MCR, up->mcr);
	249	serial_out(up, UART_IER, up->ier);
	250
	251	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
	252	serial_dl_write(up, priv->quot);
	253
	254	serial_out(up, UART_EFR, priv->efr);
	255
	256	/* Configure flow control */
	257	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
	258	serial_out(up, UART_XON1, priv->xon);
	259	serial_out(up, UART_XOFF1, priv->xoff);
	260
	261	serial_out(up, UART_LCR, up->lcr);
	262	/* need mode A for FCR */
	263	if (priv->habit & UART_ERRATA_i202_MDR1_ACCESS)
	264	omap_8250_mdr1_errataset(up, priv);
	265	else
	266	serial_out(up, UART_OMAP_MDR1, priv->mdr1);
	267	up->port.ops->set_mctrl(&up->port, up->port.mctrl);
	268	}
	269
	270	/*
	271	* OMAP can use "CLK / (16 or 13) / div" for baud rate. And then we have have
	272	* some differences in how we want to handle flow control.
	273	*/
	274	static void omap_8250_set_termios(struct uart_port *port,
	275	struct ktermios *termios,
	276	struct ktermios *old)
	277	{
	278	struct uart_8250_port *up =
	279	container_of(port, struct uart_8250_port, port);
	280	struct omap8250_priv *priv = up->port.private_data;
	281	unsigned char cval = 0;
	282	unsigned int baud;
	283
	284	switch (termios->c_cflag & CSIZE) {
	285	case CS5:
	286	cval = UART_LCR_WLEN5;
	287	break;
	288	case CS6:
	289	cval = UART_LCR_WLEN6;
	290	break;
	291	case CS7:
	292	cval = UART_LCR_WLEN7;
	293	break;
	294	default:
	295	case CS8:
	296	cval = UART_LCR_WLEN8;
	297	break;
	298	}
	299
	300	if (termios->c_cflag & CSTOPB)
	301	cval \|= UART_LCR_STOP;
	302	if (termios->c_cflag & PARENB)
	303	cval \|= UART_LCR_PARITY;
	304	if (!(termios->c_cflag & PARODD))
	305	cval \|= UART_LCR_EPAR;
	306	if (termios->c_cflag & CMSPAR)
	307	cval \|= UART_LCR_SPAR;
	308
	309	/*
	310	* Ask the core to calculate the divisor for us.
	311	*/
	312	baud = uart_get_baud_rate(port, termios, old,
	313	port->uartclk / 16 / 0xffff,
	314	port->uartclk / 13);
	315	omap_8250_get_divisor(port, baud, priv);
	316
	317	/*
	318	* Ok, we're now changing the port state. Do it with
	319	* interrupts disabled.
	320	*/
	321	pm_runtime_get_sync(port->dev);
	322	spin_lock_irq(&port->lock);
	323
	324	/*
	325	* Update the per-port timeout.
	326	*/
	327	uart_update_timeout(port, termios->c_cflag, baud);
	328
	329	up->port.read_status_mask = UART_LSR_OE \| UART_LSR_THRE \| UART_LSR_DR;
	330	if (termios->c_iflag & INPCK)
	331	up->port.read_status_mask \|= UART_LSR_FE \| UART_LSR_PE;
	332	if (termios->c_iflag & (IGNBRK \| PARMRK))
	333	up->port.read_status_mask \|= UART_LSR_BI;
	334
	335	/*
	336	* Characters to ignore
	337	*/
	338	up->port.ignore_status_mask = 0;
	339	if (termios->c_iflag & IGNPAR)
	340	up->port.ignore_status_mask \|= UART_LSR_PE \| UART_LSR_FE;
	341	if (termios->c_iflag & IGNBRK) {
	342	up->port.ignore_status_mask \|= UART_LSR_BI;
	343	/*
	344	* If we're ignoring parity and break indicators,
	345	* ignore overruns too (for real raw support).
	346	*/
	347	if (termios->c_iflag & IGNPAR)
	348	up->port.ignore_status_mask \|= UART_LSR_OE;
	349	}
	350
	351	/*
	352	* ignore all characters if CREAD is not set
	353	*/
	354	if ((termios->c_cflag & CREAD) == 0)
	355	up->port.ignore_status_mask \|= UART_LSR_DR;
	356
	357	/*
	358	* Modem status interrupts
	359	*/
	360	up->ier &= ~UART_IER_MSI;
	361	if (UART_ENABLE_MS(&up->port, termios->c_cflag))
	362	up->ier \|= UART_IER_MSI;
	363
	364	up->lcr = cval;
	365	/* Up to here it was mostly serial8250_do_set_termios() */
	366
	367	/*
	368	* We enable TRIG_GRANU for RX and TX and additionaly we set
	369	* SCR_TX_EMPTY bit. The result is the following:
	370	* - RX_TRIGGER amount of bytes in the FIFO will cause an interrupt.
	371	* - less than RX_TRIGGER number of bytes will also cause an interrupt
	372	* once the UART decides that there no new bytes arriving.
	373	* - Once THRE is enabled, the interrupt will be fired once the FIFO is
	374	* empty - the trigger level is ignored here.
	375	*
	376	* Once DMA is enabled:
	377	* - UART will assert the TX DMA line once there is room for TX_TRIGGER
	378	* bytes in the TX FIFO. On each assert the DMA engine will move
	379	* TX_TRIGGER bytes into the FIFO.
	380	* - UART will assert the RX DMA line once there are RX_TRIGGER bytes in
	381	* the FIFO and move RX_TRIGGER bytes.
	382	* This is because threshold and trigger values are the same.
	383	*/
	384	up->fcr = UART_FCR_ENABLE_FIFO;
	385	up->fcr \|= TRIGGER_FCR_MASK(TX_TRIGGER) << OMAP_UART_FCR_TX_TRIG;
	386	up->fcr \|= TRIGGER_FCR_MASK(RX_TRIGGER) << OMAP_UART_FCR_RX_TRIG;
	387
	388	priv->scr = OMAP_UART_SCR_RX_TRIG_GRANU1_MASK \| OMAP_UART_SCR_TX_EMPTY \|
	389	OMAP_UART_SCR_TX_TRIG_GRANU1_MASK;
	390
	391	if (up->dma)
	392	priv->scr \|= OMAP_UART_SCR_DMAMODE_1 \|
	393	OMAP_UART_SCR_DMAMODE_CTL;
	394
	395	priv->xon = termios->c_cc[VSTART];
	396	priv->xoff = termios->c_cc[VSTOP];
	397
	398	priv->efr = 0;
	399	up->mcr &= ~(UART_MCR_RTS \| UART_MCR_XONANY);
	400	if (termios->c_cflag & CRTSCTS && up->port.flags & UPF_HARD_FLOW) {
	401	/* Enable AUTORTS and AUTOCTS */
	402	priv->efr \|= UART_EFR_CTS \| UART_EFR_RTS;
	403
	404	/* Ensure MCR RTS is asserted */
	405	up->mcr \|= UART_MCR_RTS;
	406	} else if (up->port.flags & UPF_SOFT_FLOW) {
	407	/*
	408	* IXON Flag:
	409	* Enable XON/XOFF flow control on input.
	410	* Receiver compares XON1, XOFF1.
	411	*/
	412	if (termios->c_iflag & IXON)
	413	priv->efr \|= OMAP_UART_SW_RX;
	414
	415	/*
	416	* IXOFF Flag:
	417	* Enable XON/XOFF flow control on output.
	418	* Transmit XON1, XOFF1
	419	*/
	420	if (termios->c_iflag & IXOFF)
	421	priv->efr \|= OMAP_UART_SW_TX;
	422
	423	/*
	424	* IXANY Flag:
	425	* Enable any character to restart output.
	426	* Operation resumes after receiving any
	427	* character after recognition of the XOFF character
	428	*/
	429	if (termios->c_iflag & IXANY)
	430	up->mcr \|= UART_MCR_XONANY;
	431	}
	432	omap8250_restore_regs(up);
	433
	434	spin_unlock_irq(&up->port.lock);
	435	pm_runtime_mark_last_busy(port->dev);
	436	pm_runtime_put_autosuspend(port->dev);
	437
	438	/* calculate wakeup latency constraint */
	439	priv->calc_latency = USEC_PER_SEC * 64 * 8 / baud;
	440	priv->latency = priv->calc_latency;
	441
	442	schedule_work(&priv->qos_work);
	443
	444	/* Don't rewrite B0 */
	445	if (tty_termios_baud_rate(termios))
	446	tty_termios_encode_baud_rate(termios, baud, baud);
	447	}
	448
	449	/* same as 8250 except that we may have extra flow bits set in EFR */
	450	static void omap_8250_pm(struct uart_port *port, unsigned int state,
	451	unsigned int oldstate)
	452	{
	453	struct uart_8250_port *up =
	454	container_of(port, struct uart_8250_port, port);
	455	struct omap8250_priv *priv = up->port.private_data;
	456
	457	pm_runtime_get_sync(port->dev);
	458	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
	459	serial_out(up, UART_EFR, priv->efr \| UART_EFR_ECB);
	460	serial_out(up, UART_LCR, 0);
	461
	462	serial_out(up, UART_IER, (state != 0) ? UART_IERX_SLEEP : 0);
	463	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
	464	serial_out(up, UART_EFR, priv->efr);
	465	serial_out(up, UART_LCR, 0);
	466
	467	pm_runtime_mark_last_busy(port->dev);
	468	pm_runtime_put_autosuspend(port->dev);
	469	}
	470
	471	static void omap_serial_fill_features_erratas(struct uart_8250_port *up,
	472	struct omap8250_priv *priv)
	473	{
	474	u32 mvr, scheme;
	475	u16 revision, major, minor;
	476
	477	mvr = uart_read(up, UART_OMAP_MVER);
	478
	479	/* Check revision register scheme */
	480	scheme = mvr >> OMAP_UART_MVR_SCHEME_SHIFT;
	481
	482	switch (scheme) {
	483	case 0: /* Legacy Scheme: OMAP2/3 */
	484	/* MINOR_REV[0:4], MAJOR_REV[4:7] */
	485	major = (mvr & OMAP_UART_LEGACY_MVR_MAJ_MASK) >>
	486	OMAP_UART_LEGACY_MVR_MAJ_SHIFT;
	487	minor = (mvr & OMAP_UART_LEGACY_MVR_MIN_MASK);
	488	break;
	489	case 1:
	490	/* New Scheme: OMAP4+ */
	491	/* MINOR_REV[0:5], MAJOR_REV[8:10] */
	492	major = (mvr & OMAP_UART_MVR_MAJ_MASK) >>
	493	OMAP_UART_MVR_MAJ_SHIFT;
	494	minor = (mvr & OMAP_UART_MVR_MIN_MASK);
	495	break;
	496	default:
	497	dev_warn(up->port.dev,
	498	"Unknown revision, defaulting to highest\n");
	499	/* highest possible revision */
	500	major = 0xff;
	501	minor = 0xff;
	502	}
	503	/* normalize revision for the driver */
	504	revision = UART_BUILD_REVISION(major, minor);
	505
	506	switch (revision) {
	507	case OMAP_UART_REV_46:
	508	priv->habit = UART_ERRATA_i202_MDR1_ACCESS;
	509	break;
	510	case OMAP_UART_REV_52:
	511	priv->habit = UART_ERRATA_i202_MDR1_ACCESS \|
	512	OMAP_UART_WER_HAS_TX_WAKEUP;
	513	break;
	514	case OMAP_UART_REV_63:
	515	priv->habit = UART_ERRATA_i202_MDR1_ACCESS \|
	516	OMAP_UART_WER_HAS_TX_WAKEUP;
	517	break;
	518	default:
	519	break;
	520	}
	521	}
	522
	523	static void omap8250_uart_qos_work(struct work_struct *work)
	524	{
	525	struct omap8250_priv *priv;
	526
	527	priv = container_of(work, struct omap8250_priv, qos_work);
	528	pm_qos_update_request(&priv->pm_qos_request, priv->latency);
	529	}
	530
	531	static irqreturn_t omap_wake_irq(int irq, void *dev_id)
	532	{
	533	struct uart_port *port = dev_id;
	534	int ret;
	535
	536	ret = port->handle_irq(port);
	537	if (ret)
	538	return IRQ_HANDLED;
	539	return IRQ_NONE;
	540	}
	541
	542	static int omap_8250_startup(struct uart_port *port)
	543	{
	544	struct uart_8250_port *up =
	545	container_of(port, struct uart_8250_port, port);
	546	struct omap8250_priv *priv = port->private_data;
	547
	548	int ret;
	549
	550	if (priv->wakeirq) {
	551	ret = request_irq(priv->wakeirq, omap_wake_irq,
	552	port->irqflags, "uart wakeup irq", port);
	553	if (ret)
	554	return ret;
	555	disable_irq(priv->wakeirq);
	556	}
	557
	558	pm_runtime_get_sync(port->dev);
	559
	560	ret = serial8250_do_startup(port);
	561	if (ret)
	562	goto err;
	563
	564	#ifdef CONFIG_PM_RUNTIME
	565	up->capabilities \|= UART_CAP_RPM;
	566	#endif
	567
	568	/* Enable module level wake up */
	569	priv->wer = OMAP_UART_WER_MOD_WKUP;
	570	if (priv->habit & OMAP_UART_WER_HAS_TX_WAKEUP)
	571	priv->wer \|= OMAP_UART_TX_WAKEUP_EN;
	572	serial_out(up, UART_OMAP_WER, priv->wer);
	573
	574	if (up->dma)
	575	up->dma->rx_dma(up, 0);
	576
	577	pm_runtime_mark_last_busy(port->dev);
	578	pm_runtime_put_autosuspend(port->dev);
	579	return 0;
	580	err:
	581	pm_runtime_mark_last_busy(port->dev);
	582	pm_runtime_put_autosuspend(port->dev);
	583	if (priv->wakeirq)
	584	free_irq(priv->wakeirq, port);
	585	return ret;
	586	}
	587
	588	static void omap_8250_shutdown(struct uart_port *port)
	589	{
	590	struct uart_8250_port *up =
	591	container_of(port, struct uart_8250_port, port);
	592	struct omap8250_priv *priv = port->private_data;
	593
	594	flush_work(&priv->qos_work);
	595	if (up->dma)
	596	up->dma->rx_dma(up, UART_IIR_RX_TIMEOUT);
	597
	598	pm_runtime_get_sync(port->dev);
	599
	600	serial_out(up, UART_OMAP_WER, 0);
	601	serial8250_do_shutdown(port);
	602
	603	pm_runtime_mark_last_busy(port->dev);
	604	pm_runtime_put_autosuspend(port->dev);
	605
	606	if (priv->wakeirq)
	607	free_irq(priv->wakeirq, port);
	608	}
	609
	610	static void omap_8250_throttle(struct uart_port *port)
	611	{
	612	unsigned long flags;
	613	struct uart_8250_port *up =
	614	container_of(port, struct uart_8250_port, port);
	615
	616	pm_runtime_get_sync(port->dev);
	617
	618	spin_lock_irqsave(&port->lock, flags);
	619	up->ier &= ~(UART_IER_RLSI \| UART_IER_RDI);
	620	serial_out(up, UART_IER, up->ier);
	621	spin_unlock_irqrestore(&port->lock, flags);
	622
	623	pm_runtime_mark_last_busy(port->dev);
	624	pm_runtime_put_autosuspend(port->dev);
	625	}
	626
	627	static void omap_8250_unthrottle(struct uart_port *port)
	628	{
	629	unsigned long flags;
	630	struct uart_8250_port *up =
	631	container_of(port, struct uart_8250_port, port);
	632
	633	pm_runtime_get_sync(port->dev);
	634
	635	spin_lock_irqsave(&port->lock, flags);
	636	up->ier \|= UART_IER_RLSI \| UART_IER_RDI;
	637	serial_out(up, UART_IER, up->ier);
	638	spin_unlock_irqrestore(&port->lock, flags);
	639
	640	pm_runtime_mark_last_busy(port->dev);
	641	pm_runtime_put_autosuspend(port->dev);
	642	}
	643
	644	#ifdef CONFIG_SERIAL_8250_DMA
	645	static int omap_8250_rx_dma(struct uart_8250_port *p, unsigned int iir);
	646
	647	static void __dma_rx_do_complete(struct uart_8250_port *p, bool error)
	648	{
	649	struct uart_8250_dma *dma = p->dma;
	650	struct tty_port *tty_port = &p->port.state->port;
	651	struct dma_tx_state state;
	652	int count;
	653
	654	dma_sync_single_for_cpu(dma->rxchan->device->dev, dma->rx_addr,
	655	dma->rx_size, DMA_FROM_DEVICE);
	656
	657	dma->rx_running = 0;
	658	dmaengine_tx_status(dma->rxchan, dma->rx_cookie, &state);
	659	dmaengine_terminate_all(dma->rxchan);
	660
	661	count = dma->rx_size - state.residue;
	662
	663	tty_insert_flip_string(tty_port, dma->rx_buf, count);
	664	p->port.icount.rx += count;
	665	if (!error)
	666	omap_8250_rx_dma(p, 0);
	667
	668	tty_flip_buffer_push(tty_port);
	669	}
	670
	671	static void __dma_rx_complete(void *param)
	672	{
	673	__dma_rx_do_complete(param, false);
	674	}
	675
	676	static int omap_8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
	677	{
	678	struct uart_8250_dma *dma = p->dma;
	679	struct dma_async_tx_descriptor *desc;
	680
	681	switch (iir & 0x3f) {
	682	case UART_IIR_RLSI:
	683	/* 8250_core handles errors and break interrupts */
	684	if (dma->rx_running) {
	685	dmaengine_pause(dma->rxchan);
	686	__dma_rx_do_complete(p, true);
	687	}
	688	return -EIO;
	689	case UART_IIR_RX_TIMEOUT:
	690	/*
	691	* If RCVR FIFO trigger level was not reached, complete the
	692	* transfer and let 8250_core copy the remaining data.
	693	*/
	694	if (dma->rx_running) {
	695	dmaengine_pause(dma->rxchan);
	696	__dma_rx_do_complete(p, true);
	697	}
	698	return -ETIMEDOUT;
	699	case UART_IIR_RDI:
	700	/*
	701	* The OMAP UART is a special BEAST. If we receive RDI we _have_
	702	* a DMA transfer programmed but it didn't work. One reason is
	703	* that we were too slow and there were too many bytes in the
	704	* FIFO, the UART counted wrong and never kicked the DMA engine
	705	* to do anything. That means once we receive RDI on OMAP then
	706	* the DMA won't do anything soon so we have to cancel the DMA
	707	* transfer and purge the FIFO manually.
	708	*/
	709	if (dma->rx_running) {
	710	dmaengine_pause(dma->rxchan);
	711	__dma_rx_do_complete(p, true);
	712	}
	713	return -ETIMEDOUT;
	714
	715	default:
	716	break;
	717	}
	718
	719	if (dma->rx_running)
	720	return 0;
	721
	722	desc = dmaengine_prep_slave_single(dma->rxchan, dma->rx_addr,
	723	dma->rx_size, DMA_DEV_TO_MEM,
	724	DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);
	725	if (!desc)
	726	return -EBUSY;
	727
	728	dma->rx_running = 1;
	729	desc->callback = __dma_rx_complete;
	730	desc->callback_param = p;
	731
	732	dma->rx_cookie = dmaengine_submit(desc);
	733
	734	dma_sync_single_for_device(dma->rxchan->device->dev, dma->rx_addr,
	735	dma->rx_size, DMA_FROM_DEVICE);
	736
	737	dma_async_issue_pending(dma->rxchan);
	738	return 0;
	739	}
	740
	741	static int omap_8250_tx_dma(struct uart_8250_port *p);
	742
	743	static void omap_8250_dma_tx_complete(void *param)
	744	{
	745	struct uart_8250_port *p = param;
	746	struct uart_8250_dma *dma = p->dma;
	747	struct circ_buf *xmit = &p->port.state->xmit;
	748	unsigned long flags;
	749	bool en_thri = false;
	750	struct omap8250_priv *priv = p->port.private_data;
	751
	752	dma_sync_single_for_cpu(dma->txchan->device->dev, dma->tx_addr,
	753	UART_XMIT_SIZE, DMA_TO_DEVICE);
	754
	755	spin_lock_irqsave(&p->port.lock, flags);
	756
	757	dma->tx_running = 0;
	758
	759	xmit->tail += dma->tx_size;
	760	xmit->tail &= UART_XMIT_SIZE - 1;
	761	p->port.icount.tx += dma->tx_size;
	762
	763	if (priv->delayed_restore) {
	764	priv->delayed_restore = 0;
	765	omap8250_restore_regs(p);
	766	}
	767
	768	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
	769	uart_write_wakeup(&p->port);
	770
	771	if (!uart_circ_empty(xmit) && !uart_tx_stopped(&p->port)) {
	772	int ret;
	773
	774	ret = omap_8250_tx_dma(p);
	775	if (ret)
	776	en_thri = true;
	777
	778	} else if (p->capabilities & UART_CAP_RPM) {
	779	en_thri = true;
	780	}
	781
	782	if (en_thri) {
	783	dma->tx_err = 1;
	784	p->ier \|= UART_IER_THRI;
	785	serial_port_out(&p->port, UART_IER, p->ier);
	786	}
	787
	788	spin_unlock_irqrestore(&p->port.lock, flags);
	789	}
	790
	791	static int omap_8250_tx_dma(struct uart_8250_port *p)
	792	{
	793	struct uart_8250_dma *dma = p->dma;
	794	struct omap8250_priv *priv = p->port.private_data;
	795	struct circ_buf *xmit = &p->port.state->xmit;
	796	struct dma_async_tx_descriptor *desc;
	797	unsigned int skip_byte = 0;
	798	int ret;
	799
	800	if (dma->tx_running)
	801	return 0;
	802	if (uart_tx_stopped(&p->port) \|\| uart_circ_empty(xmit)) {
	803
	804	/*
	805	* Even if no data, we need to return an error for the two cases
	806	* below so serial8250_tx_chars() is invoked and properly clears
	807	* THRI and/or runtime suspend.
	808	*/
	809	if (dma->tx_err \|\| p->capabilities & UART_CAP_RPM) {
	810	ret = -EBUSY;
	811	goto err;
	812	}
	813	if (p->ier & UART_IER_THRI) {
	814	p->ier &= ~UART_IER_THRI;
	815	serial_out(p, UART_IER, p->ier);
	816	}
	817	return 0;
	818	}
	819
	820	dma->tx_size = CIRC_CNT_TO_END(xmit->head, xmit->tail, UART_XMIT_SIZE);
	821	if (priv->habit & OMAP_DMA_TX_KICK) {
	822	u8 tx_lvl;
	823
	824	/*
	825	* We need to put the first byte into the FIFO in order to start
	826	* the DMA transfer. For transfers smaller than four bytes we
	827	* don't bother doing DMA at all. It seem not matter if there
	828	* are still bytes in the FIFO from the last transfer (in case
	829	* we got here directly from omap_8250_dma_tx_complete()). Bytes
	830	* leaving the FIFO seem not to trigger the DMA transfer. It is
	831	* really the byte that we put into the FIFO.
	832	* If the FIFO is already full then we most likely got here from
	833	* omap_8250_dma_tx_complete(). And this means the DMA engine
	834	* just completed its work. We don't have to wait the complete
	835	* 86us at 115200,8n1 but around 60us (not to mention lower
	836	* baudrates). So in that case we take the interrupt and try
	837	* again with an empty FIFO.
	838	*/
	839	tx_lvl = serial_in(p, UART_OMAP_TX_LVL);
	840	if (tx_lvl == p->tx_loadsz) {
	841	ret = -EBUSY;
	842	goto err;
	843	}
	844	if (dma->tx_size < 4) {
	845	ret = -EINVAL;
	846	goto err;
	847	}
	848	skip_byte = 1;
	849	}
	850
	851	desc = dmaengine_prep_slave_single(dma->txchan,
	852	dma->tx_addr + xmit->tail + skip_byte,
	853	dma->tx_size - skip_byte, DMA_MEM_TO_DEV,
	854	DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);
	855	if (!desc) {
	856	ret = -EBUSY;
	857	goto err;
	858	}
	859
	860	dma->tx_running = 1;
	861
	862	desc->callback = omap_8250_dma_tx_complete;
	863	desc->callback_param = p;
	864
	865	dma->tx_cookie = dmaengine_submit(desc);
	866
	867	dma_sync_single_for_device(dma->txchan->device->dev, dma->tx_addr,
	868	UART_XMIT_SIZE, DMA_TO_DEVICE);
	869
	870	dma_async_issue_pending(dma->txchan);
	871	if (dma->tx_err)
	872	dma->tx_err = 0;
	873
	874	if (p->ier & UART_IER_THRI) {
	875	p->ier &= ~UART_IER_THRI;
	876	serial_out(p, UART_IER, p->ier);
	877	}
	878	if (skip_byte)
	879	serial_out(p, UART_TX, xmit->buf[xmit->tail]);
	880	return 0;
	881	err:
	882	dma->tx_err = 1;
	883	return ret;
	884	}
	885
	886	/*
	887	* This is mostly serial8250_handle_irq(). We have a slightly different DMA
	888	* hoook for RX/TX and need different logic for them in the ISR. Therefore we
	889	* use the default routine in the non-DMA case and this one for with DMA.
	890	*/
	891	static int omap_8250_dma_handle_irq(struct uart_port *port)
	892	{
	893	struct uart_8250_port *up = up_to_u8250p(port);
	894	unsigned char status;
	895	unsigned long flags;
	896	u8 iir;
	897	int dma_err = 0;
	898
	899	serial8250_rpm_get(up);
	900
	901	iir = serial_port_in(port, UART_IIR);
	902	if (iir & UART_IIR_NO_INT) {
	903	serial8250_rpm_put(up);
	904	return 0;
	905	}
	906
	907	spin_lock_irqsave(&port->lock, flags);
	908
	909	status = serial_port_in(port, UART_LSR);
	910
	911	if (status & (UART_LSR_DR \| UART_LSR_BI)) {
	912
	913	dma_err = omap_8250_rx_dma(up, iir);
	914	if (dma_err) {
	915	status = serial8250_rx_chars(up, status);
	916	omap_8250_rx_dma(up, 0);
	917	}
	918	}
	919	serial8250_modem_status(up);
	920	if (status & UART_LSR_THRE && up->dma->tx_err) {
	921	if (uart_tx_stopped(&up->port) \|\|
	922	uart_circ_empty(&up->port.state->xmit)) {
	923	up->dma->tx_err = 0;
	924	serial8250_tx_chars(up);
	925	} else {
	926	/*
	927	* try again due to an earlier failer which
	928	* might have been resolved by now.
	929	*/
	930	dma_err = omap_8250_tx_dma(up);
	931	if (dma_err)
	932	serial8250_tx_chars(up);
	933	}
	934	}
	935
	936	spin_unlock_irqrestore(&port->lock, flags);
	937	serial8250_rpm_put(up);
	938	return 1;
	939	}
	940
	941	static bool the_no_dma_filter_fn(struct dma_chan chan, void param)
	942	{
	943	return false;
	944	}
	945
	946	#else
	947
	948	static inline int omap_8250_rx_dma(struct uart_8250_port *p, unsigned int iir)
	949	{
	950	return -EINVAL;
	951	}
	952	#endif
	953
	954	static int omap8250_probe(struct platform_device *pdev)
	955	{
	956	struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	957	struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	958	struct omap8250_priv *priv;
	959	struct uart_8250_port up;
	960	int ret;
	961	void __iomem *membase;
	962
	963	if (!regs \|\| !irq) {
	964	dev_err(&pdev->dev, "missing registers or irq\n");
	965	return -EINVAL;
	966	}
	967
	968	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	969	if (!priv)
	970	return -ENOMEM;
	971
	972	membase = devm_ioremap_nocache(&pdev->dev, regs->start,
	973	resource_size(regs));
	974	if (!membase)
	975	return -ENODEV;
	976
	977	memset(&up, 0, sizeof(up));
	978	up.port.dev = &pdev->dev;
	979	up.port.mapbase = regs->start;
	980	up.port.membase = membase;
	981	up.port.irq = irq->start;
	982	/*
	983	* It claims to be 16C750 compatible however it is a little different.
	984	* It has EFR and has no FCR7_64byte bit. The AFE (which it claims to
	985	* have) is enabled via EFR instead of MCR. The type is set here 8250
	986	* just to get things going. UNKNOWN does not work for a few reasons and
	987	* we don't need our own type since we don't use 8250's set_termios()
	988	* or pm callback.
	989	*/
	990	up.port.type = PORT_8250;
	991	up.port.iotype = UPIO_MEM;
	992	up.port.flags = UPF_FIXED_PORT \| UPF_FIXED_TYPE \| UPF_SOFT_FLOW \|
	993	UPF_HARD_FLOW;
	994	up.port.private_data = priv;
	995
	996	up.port.regshift = 2;
	997	up.port.fifosize = 64;
	998	up.tx_loadsz = 64;
	999	up.capabilities = UART_CAP_FIFO;
	1000	#ifdef CONFIG_PM_RUNTIME
	1001	/*
	1002	* PM_RUNTIME is mostly transparent. However to do it right we need to a
	1003	* TX empty interrupt before we can put the device to auto idle. So if
	1004	* PM_RUNTIME is not enabled we don't add that flag and can spare that
	1005	* one extra interrupt in the TX path.
	1006	*/
	1007	up.capabilities \|= UART_CAP_RPM;
	1008	#endif
	1009	up.port.set_termios = omap_8250_set_termios;
	1010	up.port.pm = omap_8250_pm;
	1011	up.port.startup = omap_8250_startup;
	1012	up.port.shutdown = omap_8250_shutdown;
	1013	up.port.throttle = omap_8250_throttle;
	1014	up.port.unthrottle = omap_8250_unthrottle;
	1015
	1016	if (pdev->dev.of_node) {
	1017	ret = of_alias_get_id(pdev->dev.of_node, "serial");
	1018
	1019	of_property_read_u32(pdev->dev.of_node, "clock-frequency",
	1020	&up.port.uartclk);
	1021	priv->wakeirq = irq_of_parse_and_map(pdev->dev.of_node, 1);
	1022	} else {
	1023	ret = pdev->id;
	1024	}
	1025	if (ret < 0) {
	1026	dev_err(&pdev->dev, "failed to get alias/pdev id\n");
	1027	return ret;
	1028	}
	1029	up.port.line = ret;
	1030
	1031	if (!up.port.uartclk) {
	1032	up.port.uartclk = DEFAULT_CLK_SPEED;
	1033	dev_warn(&pdev->dev,
	1034	"No clock speed specified: using default: %d\n",
	1035	DEFAULT_CLK_SPEED);
	1036	}
	1037
	1038	priv->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
	1039	priv->calc_latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
	1040	pm_qos_add_request(&priv->pm_qos_request, PM_QOS_CPU_DMA_LATENCY,
	1041	priv->latency);
	1042	INIT_WORK(&priv->qos_work, omap8250_uart_qos_work);
	1043
	1044	device_init_wakeup(&pdev->dev, true);
	1045	pm_runtime_use_autosuspend(&pdev->dev);
	1046	pm_runtime_set_autosuspend_delay(&pdev->dev, -1);
	1047
	1048	pm_runtime_irq_safe(&pdev->dev);
	1049	pm_runtime_enable(&pdev->dev);
	1050
	1051	pm_runtime_get_sync(&pdev->dev);
	1052
	1053	omap_serial_fill_features_erratas(&up, priv);
	1054	#ifdef CONFIG_SERIAL_8250_DMA
	1055	if (pdev->dev.of_node) {
	1056	/*
	1057	* Oh DMA support. If there are no DMA properties in the DT then
	1058	* we will fall back to a generic DMA channel which does not
	1059	* really work here. To ensure that we do not get a generic DMA
	1060	* channel assigned, we have the the_no_dma_filter_fn() here.
	1061	* To avoid "failed to request DMA" messages we check for DMA
	1062	* properties in DT.
	1063	*/
	1064	ret = of_property_count_strings(pdev->dev.of_node, "dma-names");
	1065	if (ret == 2) {
	1066	up.dma = &priv->omap8250_dma;
	1067	up.port.handle_irq = omap_8250_dma_handle_irq;
	1068	priv->omap8250_dma.fn = the_no_dma_filter_fn;
	1069	priv->omap8250_dma.tx_dma = omap_8250_tx_dma;
	1070	priv->omap8250_dma.rx_dma = omap_8250_rx_dma;
	1071	priv->omap8250_dma.rx_size = RX_TRIGGER;
	1072	priv->omap8250_dma.rxconf.src_maxburst = RX_TRIGGER;
	1073	priv->omap8250_dma.txconf.dst_maxburst = TX_TRIGGER;
	1074
	1075	if (of_machine_is_compatible("ti,am33xx"))
	1076	priv->habit \|= OMAP_DMA_TX_KICK;
	1077	}
	1078	}
	1079	#endif
	1080	ret = serial8250_register_8250_port(&up);
	1081	if (ret < 0) {
	1082	dev_err(&pdev->dev, "unable to register 8250 port\n");
	1083	goto err;
	1084	}
	1085	priv->line = ret;
	1086	platform_set_drvdata(pdev, priv);
	1087	pm_runtime_mark_last_busy(&pdev->dev);
	1088	pm_runtime_put_autosuspend(&pdev->dev);
	1089	return 0;
	1090	err:
	1091	pm_runtime_put(&pdev->dev);
	1092	pm_runtime_disable(&pdev->dev);
	1093	return ret;
	1094	}
	1095
	1096	static int omap8250_remove(struct platform_device *pdev)
	1097	{
	1098	struct omap8250_priv *priv = platform_get_drvdata(pdev);
	1099
	1100	pm_runtime_put_sync(&pdev->dev);
	1101	pm_runtime_disable(&pdev->dev);
	1102	serial8250_unregister_port(priv->line);
	1103	pm_qos_remove_request(&priv->pm_qos_request);
	1104	device_init_wakeup(&pdev->dev, false);
	1105	return 0;
	1106	}
	1107
	1108	#if defined(CONFIG_PM_SLEEP) \|\| defined(CONFIG_PM_RUNTIME)
	1109
	1110	static inline void omap8250_enable_wakeirq(struct omap8250_priv *priv,
	1111	bool enable)
	1112	{
	1113	if (!priv->wakeirq)
	1114	return;
	1115
	1116	if (enable)
	1117	enable_irq(priv->wakeirq);
	1118	else
	1119	disable_irq_nosync(priv->wakeirq);
	1120	}
	1121
	1122	static void omap8250_enable_wakeup(struct omap8250_priv *priv,
	1123	bool enable)
	1124	{
	1125	if (enable == priv->wakeups_enabled)
	1126	return;
	1127
	1128	omap8250_enable_wakeirq(priv, enable);
	1129	priv->wakeups_enabled = enable;
	1130	}
	1131	#endif
	1132
	1133	#ifdef CONFIG_PM_SLEEP
	1134	static int omap8250_prepare(struct device *dev)
	1135	{
	1136	struct omap8250_priv *priv = dev_get_drvdata(dev);
	1137
	1138	if (!priv)
	1139	return 0;
	1140	priv->is_suspending = true;
	1141	return 0;
	1142	}
	1143
	1144	static void omap8250_complete(struct device *dev)
	1145	{
	1146	struct omap8250_priv *priv = dev_get_drvdata(dev);
	1147
	1148	if (!priv)
	1149	return;
	1150	priv->is_suspending = false;
	1151	}
	1152
	1153	static int omap8250_suspend(struct device *dev)
	1154	{
	1155	struct omap8250_priv *priv = dev_get_drvdata(dev);
	1156
	1157	serial8250_suspend_port(priv->line);
	1158	flush_work(&priv->qos_work);
	1159
	1160	if (device_may_wakeup(dev))
	1161	omap8250_enable_wakeup(priv, true);
	1162	else
	1163	omap8250_enable_wakeup(priv, false);
	1164	return 0;
	1165	}
	1166
	1167	static int omap8250_resume(struct device *dev)
	1168	{
	1169	struct omap8250_priv *priv = dev_get_drvdata(dev);
	1170
	1171	if (device_may_wakeup(dev))
	1172	omap8250_enable_wakeup(priv, false);
	1173
	1174	serial8250_resume_port(priv->line);
	1175	return 0;
	1176	}
	1177	#else
	1178	#define omap8250_prepare NULL
	1179	#define omap8250_complete NULL
	1180	#endif
	1181
	1182	#ifdef CONFIG_PM_RUNTIME
	1183	static int omap8250_lost_context(struct uart_8250_port *up)
	1184	{
	1185	u32 val;
	1186
	1187	val = serial_in(up, UART_OMAP_MDR1);
	1188	/*
	1189	* If we lose context, then MDR1 is set to its reset value which is
	1190	* UART_OMAP_MDR1_DISABLE. After set_termios() we set it either to 13x
	1191	* or 16x but never to disable again.
	1192	*/
	1193	if (val == UART_OMAP_MDR1_DISABLE)
	1194	return 1;
	1195	return 0;
	1196	}
	1197
	1198	static int omap8250_runtime_suspend(struct device *dev)
	1199	{
	1200	struct omap8250_priv *priv = dev_get_drvdata(dev);
	1201	struct uart_8250_port *up;
	1202
	1203	up = serial8250_get_port(priv->line);
	1204	/*
	1205	* When using 'no_console_suspend', the console UART must not be
	1206	* suspended. Since driver suspend is managed by runtime suspend,
	1207	* preventing runtime suspend (by returning error) will keep device
	1208	* active during suspend.
	1209	*/
	1210	if (priv->is_suspending && !console_suspend_enabled) {
	1211	if (uart_console(&up->port))
	1212	return -EBUSY;
	1213	}
	1214
	1215	omap8250_enable_wakeup(priv, true);
	1216	if (up->dma)
	1217	omap_8250_rx_dma(up, UART_IIR_RX_TIMEOUT);
	1218
	1219	priv->latency = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE;
	1220	schedule_work(&priv->qos_work);
	1221
	1222	return 0;
	1223	}
	1224
	1225	static int omap8250_runtime_resume(struct device *dev)
	1226	{
	1227	struct omap8250_priv *priv = dev_get_drvdata(dev);
	1228	struct uart_8250_port *up;
	1229	int loss_cntx;
	1230
	1231	/* In case runtime-pm tries this before we are setup */
	1232	if (!priv)
	1233	return 0;
	1234
	1235	up = serial8250_get_port(priv->line);
	1236	omap8250_enable_wakeup(priv, false);
	1237	loss_cntx = omap8250_lost_context(up);
	1238
	1239	if (loss_cntx)
	1240	omap8250_restore_regs(up);
	1241
	1242	if (up->dma)
	1243	omap_8250_rx_dma(up, 0);
	1244
	1245	priv->latency = priv->calc_latency;
	1246	schedule_work(&priv->qos_work);
	1247	return 0;
	1248	}
	1249	#endif
	1250
	1251	static const struct dev_pm_ops omap8250_dev_pm_ops = {
	1252	SET_SYSTEM_SLEEP_PM_OPS(omap8250_suspend, omap8250_resume)
	1253	SET_RUNTIME_PM_OPS(omap8250_runtime_suspend,
	1254	omap8250_runtime_resume, NULL)
	1255	.prepare = omap8250_prepare,
	1256	.complete = omap8250_complete,
	1257	};
	1258
	1259	static const struct of_device_id omap8250_dt_ids[] = {
	1260	{ .compatible = "ti,omap2-uart" },
	1261	{ .compatible = "ti,omap3-uart" },
	1262	{ .compatible = "ti,omap4-uart" },
	1263	{},
	1264	};
	1265	MODULE_DEVICE_TABLE(of, omap8250_dt_ids);
	1266
	1267	static struct platform_driver omap8250_platform_driver = {
	1268	.driver = {
	1269	.name = "omap8250",
	1270	.pm = &omap8250_dev_pm_ops,
	1271	.of_match_table = omap8250_dt_ids,
	1272	.owner = THIS_MODULE,
	1273	},
	1274	.probe = omap8250_probe,
	1275	.remove = omap8250_remove,
	1276	};
	1277	module_platform_driver(omap8250_platform_driver);
	1278
	1279	MODULE_AUTHOR("Sebastian Andrzej Siewior");
	1280	MODULE_DESCRIPTION("OMAP 8250 Driver");
	1281	MODULE_LICENSE("GPL v2");

drivers/tty/serial/8250/8250_pci.c+153−45

 	   int bar, int offset, int regshift)
 {
 	struct pci_dev *dev = priv->dev;
-	unsigned long base, len;
 	if (bar >= PCI_NUM_BAR_RESOURCES)
 		return -EINVAL;
-	base = pci_resource_start(dev, bar);
 	if (pci_resource_flags(dev, bar) & IORESOURCE_MEM) {
-		len =  pci_resource_len(dev, bar);
 		if (!priv->remapped_bar[bar])
-			priv->remapped_bar[bar] = ioremap_nocache(base, len);
+			priv->remapped_bar[bar] = pci_ioremap_bar(dev, bar);
 		if (!priv->remapped_bar[bar])
 			return -ENOMEM;
 		port->port.iotype = UPIO_MEM;
 		port->port.iobase = 0;
-		port->port.mapbase = base + offset;
+		port->port.mapbase = pci_resource_start(dev, bar) + offset;
 		port->port.membase = priv->remapped_bar[bar] + offset;
 		port->port.regshift = regshift;
 	} else {
 		port->port.iotype = UPIO_PORT;
-		port->port.iobase = base + offset;
+		port->port.iobase = pci_resource_start(dev, bar) + offset;
 		port->port.mapbase = 0;
 		port->port.membase = NULL;
 		port->port.regshift = 0;
 static void pci_ni8420_exit(struct pci_dev *dev)
 {
 	void __iomem *p;
-	unsigned long base, len;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		return;
 	}
-	base = pci_resource_start(dev, bar);
+	p = pci_ioremap_bar(dev, bar);
-	len =  pci_resource_len(dev, bar);
-	p = ioremap_nocache(base, len);
 	if (p == NULL)
 		return;
 static void pci_ni8430_exit(struct pci_dev *dev)
 {
 	void __iomem *p;
-	unsigned long base, len;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		return;
 	}
-	base = pci_resource_start(dev, bar);
+	p = pci_ioremap_bar(dev, bar);
-	len =  pci_resource_len(dev, bar);
-	p = ioremap_nocache(base, len);
 	if (p == NULL)
 		return;
 static int pci_ni8420_init(struct pci_dev *dev)
 {
 	void __iomem *p;
-	unsigned long base, len;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		return 0;
 	}
-	base = pci_resource_start(dev, bar);
+	p = pci_ioremap_bar(dev, bar);
-	len =  pci_resource_len(dev, bar);
-	p = ioremap_nocache(base, len);
 	if (p == NULL)
 		return -ENOMEM;
 static int pci_ni8430_init(struct pci_dev *dev)
 {
 	void __iomem *p;
-	unsigned long base, len;
+	struct pci_bus_region region;
 	u32 device_window;
 	unsigned int bar = 0;
 		return 0;
 	}
-	base = pci_resource_start(dev, bar);
+	p = pci_ioremap_bar(dev, bar);
-	len =  pci_resource_len(dev, bar);
-	p = ioremap_nocache(base, len);
 	if (p == NULL)
 		return -ENOMEM;
-	/* Set device window address and size in BAR0 */
+	/*
-	device_window = ((base + MITE_IOWBSR1_WIN_OFFSET) & 0xffffff00)
+	 * Set device window address and size in BAR0, while acknowledging that
+	 * the resource structure may contain a translated address that differs
+	 * from the address the device responds to.
+	 */
+	pcibios_resource_to_bus(dev->bus, &region, &dev->resource[bar]);
+	device_window = ((region.start + MITE_IOWBSR1_WIN_OFFSET) & 0xffffff00)
 	                | MITE_IOWBSR1_WENAB | MITE_IOWBSR1_WSIZE;
 	writel(device_window, p + MITE_IOWBSR1);
 		 const struct pciserial_board *board,
 		 struct uart_8250_port *port, int idx)
 {
+	struct pci_dev *dev = priv->dev;
 	void __iomem *p;
-	unsigned long base, len;
 	unsigned int bar, offset = board->first_offset;
 	if (idx >= board->num_ports)
 	bar = FL_GET_BASE(board->flags);
 	offset += idx * board->uart_offset;
-	base = pci_resource_start(priv->dev, bar);
+	p = pci_ioremap_bar(dev, bar);
-	len =  pci_resource_len(priv->dev, bar);
+	if (!p)
-	p = ioremap_nocache(base, len);
+		return -ENOMEM;
 	/* enable the transceiver */
 	writeb(readb(p + offset + NI8430_PORTCON) | NI8430_PORTCON_TXVR_ENABLE,
 	release_region(ioport, ITE_887x_IOSIZE);
 }
+/*
+ * EndRun Technologies.
+ * Determine the number of ports available on the device.
+ */
+#define PCI_VENDOR_ID_ENDRUN			0x7401
+#define PCI_DEVICE_ID_ENDRUN_1588	0xe100
+static int pci_endrun_init(struct pci_dev *dev)
+{
+	u8 __iomem *p;
+	unsigned long deviceID;
+	unsigned int  number_uarts = 0;
+	/* EndRun device is all 0xexxx */
+	if (dev->vendor == PCI_VENDOR_ID_ENDRUN &&
+		(dev->device & 0xf000) != 0xe000)
+		return 0;
+	p = pci_iomap(dev, 0, 5);
+	if (p == NULL)
+		return -ENOMEM;
+	deviceID = ioread32(p);
+	/* EndRun device */
+	if (deviceID == 0x07000200) {
+		number_uarts = ioread8(p + 4);
+		dev_dbg(&dev->dev,
+			"%d ports detected on EndRun PCI Express device\n",
+			number_uarts);
+	}
+	pci_iounmap(dev, p);
+	return number_uarts;
+}
 /*
  * Oxford Semiconductor Inc.
  * Check that device is part of the Tornado range of devices, then determine
 	unsigned long iobase;
 	unsigned long ciobase = 0;
 	u8 config_base;
+	u32 bar_data[3];
 	/*
-	 * We are supposed to be able to read these from the PCI config space,
+	 * Find each UARTs offset in PCI configuraion space
-	 * but the values there don't seem to match what we need to use, so
-	 * just use these hard-coded values for now, as they are correct.
 	 */
 	switch (idx) {
-	case 0: iobase = 0xe000; config_base = 0x40; break;
+	case 0:
-	case 1: iobase = 0xe008; config_base = 0x48; break;
+		config_base = 0x40;
-	case 2: iobase = 0xe010; config_base = 0x50; break;
+		break;
-	case 3: iobase = 0xe018; config_base = 0x58; break;
+	case 1:
-	case 4: iobase = 0xe020; config_base = 0x60; break;
+		config_base = 0x48;
-	case 5: iobase = 0xe028; config_base = 0x68; break;
+		break;
-	case 6: iobase = 0xe030; config_base = 0x70; break;
+	case 2:
-	case 7: iobase = 0xe038; config_base = 0x78; break;
+		config_base = 0x50;
-	case 8: iobase = 0xe040; config_base = 0x80; break;
+		break;
-	case 9: iobase = 0xe048; config_base = 0x88; break;
+	case 3:
-	case 10: iobase = 0xe050; config_base = 0x90; break;
+		config_base = 0x58;
-	case 11: iobase = 0xe058; config_base = 0x98; break;
+		break;
+	case 4:
+		config_base = 0x60;
+		break;
+	case 5:
+		config_base = 0x68;
+		break;
+	case 6:
+		config_base = 0x70;
+		break;
+	case 7:
+		config_base = 0x78;
+		break;
+	case 8:
+		config_base = 0x80;
+		break;
+	case 9:
+		config_base = 0x88;
+		break;
+	case 10:
+		config_base = 0x90;
+		break;
+	case 11:
+		config_base = 0x98;
+		break;
 	default:
 		/* Unknown number of ports, get out of here */
 		return -EINVAL;
 		ciobase = (int)(base + (0x8 * idx));
 	}
+	/* Get the io address dispatch from the BIOS */
+	pci_read_config_dword(pdev, 0x24, &bar_data[0]);
+	pci_read_config_dword(pdev, 0x20, &bar_data[1]);
+	pci_read_config_dword(pdev, 0x1c, &bar_data[2]);
+	/* Calculate Real IO Port */
+	iobase = (bar_data[idx/4] & 0xffffffe0) + (idx % 4) * 8;
 	dev_dbg(&pdev->dev, "%s: idx=%d iobase=0x%lx ciobase=0x%lx config_base=0x%2x\n",
 		__func__, idx, iobase, ciobase, config_base);
 	return pci_default_setup(priv, board, port, idx);
 }
+static int
+pci_wch_ch382_setup(struct serial_private *priv,
+                    const struct pciserial_board *board,
+                    struct uart_8250_port *port, int idx)
+{
+	port->port.flags |= UPF_FIXED_TYPE;
+	port->port.type = PORT_16850;
+	return pci_default_setup(priv, board, port, idx);
+}
 #define PCI_VENDOR_ID_SBSMODULARIO	0x124B
 #define PCI_SUBVENDOR_ID_SBSMODULARIO	0x124B
 #define PCI_DEVICE_ID_OCTPRO		0x0001
 #define PCI_VENDOR_ID_SUNIX		0x1fd4
 #define PCI_DEVICE_ID_SUNIX_1999	0x1999
+#define PCIE_VENDOR_ID_WCH		0x1c00
+#define PCIE_DEVICE_ID_WCH_CH382_2S1P	0x3250
 /* Unknown vendors/cards - this should not be in linux/pci_ids.h */
 #define PCI_SUBDEVICE_ID_UNKNOWN_0x1584	0x1584
 		.init		= pci_netmos_init,
 		.setup		= pci_netmos_9900_setup,
 	},
+	/*
+	 * EndRun Technologies
+	*/
+	{
+		.vendor		= PCI_VENDOR_ID_ENDRUN,
+		.device		= PCI_ANY_ID,
+		.subvendor	= PCI_ANY_ID,
+		.subdevice	= PCI_ANY_ID,
+		.init		= pci_endrun_init,
+		.setup		= pci_default_setup,
+	},
 	/*
 	 * For Oxford Semiconductor Tornado based devices
 	 */
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_wch_ch353_setup,
 	},
+	/* WCH CH382 2S1P card (16750 clone) */
+	{
+		.vendor         = PCIE_VENDOR_ID_WCH,
+		.device         = PCIE_DEVICE_ID_WCH_CH382_2S1P,
+		.subvendor      = PCI_ANY_ID,
+		.subdevice      = PCI_ANY_ID,
+		.setup          = pci_wch_ch382_setup,
+	},
 	/*
 	 * ASIX devices with FIFO bug
 	 */
 	pbn_panacom2,
 	pbn_panacom4,
 	pbn_plx_romulus,
+	pbn_endrun_2_4000000,
 	pbn_oxsemi,
 	pbn_oxsemi_1_4000000,
 	pbn_oxsemi_2_4000000,
 		.first_offset	= 0x03,
 	},
+	/*
+	 * EndRun Technologies
+	* Uses the size of PCI Base region 0 to
+	* signal now many ports are available
+	* 2 port 952 Uart support
+	*/
+	[pbn_endrun_2_4000000] = {
+		.flags		= FL_BASE0,
+		.num_ports	= 2,
+		.base_baud	= 4000000,
+		.uart_offset	= 0x200,
+		.first_offset	= 0x1000,
+	},
 	/*
 	 * This board uses the size of PCI Base region 0 to
 	 * signal now many ports are available
 	/* multi-io cards handled by parport_serial */
 	{ PCI_DEVICE(0x4348, 0x7053), }, /* WCH CH353 2S1P */
 	{ PCI_DEVICE(0x4348, 0x5053), }, /* WCH CH353 1S1P */
+	{ PCI_DEVICE(0x1c00, 0x3250), }, /* WCH CH382 2S1P */
 };
 /*
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_ROMULUS,
 		0x10b5, 0x106a, 0, 0,
 		pbn_plx_romulus },
+	/*
+	* EndRun Technologies. PCI express device range.
+	*    EndRun PTP/1588 has 2 Native UARTs.
+	*/
+	{	PCI_VENDOR_ID_ENDRUN, PCI_DEVICE_ID_ENDRUN_1588,
+		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+		pbn_endrun_2_4000000 },
 	/*
 	 * Quatech cards. These actually have configurable clocks but for
 	 * now we just use the default.

drivers/tty/serial/8250/Kconfig+10−1

 config SERIAL_8250_RT288X
 	bool "Ralink RT288x/RT305x/RT3662/RT3883 serial port support"
-	depends on SERIAL_8250 && (SOC_RT288X || SOC_RT305X || SOC_RT3883)
+	depends on SERIAL_8250 && (SOC_RT288X || SOC_RT305X || SOC_RT3883 || SOC_MT7620)
 	help
 	  If you have a Ralink RT288x/RT305x SoC based board and want to use the
 	  serial port, say Y to this option. The driver can handle up to 2 serial
 	  ports. If unsure, say N.
+config SERIAL_8250_OMAP
+	tristate "Support for OMAP internal UART (8250 based driver)"
+	depends on SERIAL_8250 && ARCH_OMAP2PLUS
+	help
+	  If you have a machine based on an Texas Instruments OMAP CPU you
+	  can enable its onboard serial ports by enabling this option.
+	  This driver uses ttyS instead of ttyO.
 config SERIAL_8250_FINTEK
 	tristate "Support for Fintek F81216A LPC to 4 UART"
 	depends on SERIAL_8250 && PNP

drivers/tty/serial/8250/Makefile+1−0

@@ -20,5 +20,6 @@ obj-$(CONFIG_SERIAL_8250_HUB6) += 8250_hub6.o · 19 unmodified lines
20	obj-$(CONFIG_SERIAL_8250_FSL) += 8250_fsl.o	20	obj-$(CONFIG_SERIAL_8250_FSL) += 8250_fsl.o
21	obj-$(CONFIG_SERIAL_8250_DW) += 8250_dw.o	21	obj-$(CONFIG_SERIAL_8250_DW) += 8250_dw.o
22	obj-$(CONFIG_SERIAL_8250_EM) += 8250_em.o	22	obj-$(CONFIG_SERIAL_8250_EM) += 8250_em.o
		23	obj-$(CONFIG_SERIAL_8250_OMAP) += 8250_omap.o
23	obj-$(CONFIG_SERIAL_8250_FINTEK) += 8250_fintek.o	24	obj-$(CONFIG_SERIAL_8250_FINTEK) += 8250_fintek.o
24	obj-$(CONFIG_SERIAL_8250_MT6577) += 8250_mtk.o	25	obj-$(CONFIG_SERIAL_8250_MT6577) += 8250_mtk.o

drivers/tty/serial/Kconfig+14−10

 	  a console on a serial port, say Y.  Otherwise, say N.
 config SERIAL_JSM
-	tristate "Digi International NEO PCI Support"
+	tristate "Digi International NEO and Classic PCI Support"
 	depends on PCI
 	select SERIAL_CORE
 	help
-	  This is a driver for Digi International's Neo series
+	  This is a driver for Digi International's Neo and Classic series
 	  of cards which provide multiple serial ports. You would need
 	  something like this to connect more than two modems to your Linux
 	  box, for instance in order to become a dial-in server. This driver
 	Add support for UART controller on timberdale.
 config SERIAL_BCM63XX
-	tristate "bcm63xx serial port support"
+	tristate "Broadcom BCM63xx/BCM33xx UART support"
 	select SERIAL_CORE
-	depends on BCM63XX
+	depends on MIPS || ARM || COMPILE_TEST
 	help
-	  If you have a bcm63xx CPU, you can enable its onboard
+	  This enables the driver for the onchip UART core found on
-	  serial port by enabling this options.
+	  the following chipsets:
-          To compile this driver as a module, choose M here: the
+	    BCM33xx (cable modem)
-          module will be called bcm963xx_uart.
+	    BCM63xx/BCM63xxx (DSL)
+	    BCM68xx (PON)
+	    BCM7xxx (STB) - DOCSIS console
 config SERIAL_BCM63XX_CONSOLE
-	bool "Console on bcm63xx serial port"
+	bool "Console on BCM63xx serial port"
 	depends on SERIAL_BCM63XX=y
 	select SERIAL_CORE_CONSOLE
+	select SERIAL_EARLYCON
 	help
-	  If you have enabled the serial port on the bcm63xx CPU
+	  If you have enabled the serial port on the BCM63xx CPU
 	  you can make it the console by answering Y to this option.
 config SERIAL_GRLIB_GAISLER_APBUART
 	depends on ARCH_MXS
 	tristate "MXS AUART support"
 	select SERIAL_CORE
+	select SERIAL_MCTRL_GPIO if GPIOLIB
 	help
 	  This driver supports the MXS Application UART (AUART) port.

drivers/tty/serial/amba-pl010.c+45−15

 static void pl010_stop_tx(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int cr;
 	cr = readb(uap->port.membase + UART010_CR);
 static void pl010_start_tx(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int cr;
 	cr = readb(uap->port.membase + UART010_CR);
 static void pl010_stop_rx(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int cr;
 	cr = readb(uap->port.membase + UART010_CR);
 	writel(cr, uap->port.membase + UART010_CR);
 }
-static void pl010_enable_ms(struct uart_port *port)
+static void pl010_disable_ms(struct uart_port *port)
 {
 	struct uart_amba_port *uap = (struct uart_amba_port *)port;
 	unsigned int cr;
+	cr = readb(uap->port.membase + UART010_CR);
+	cr &= ~UART010_CR_MSIE;
+	writel(cr, uap->port.membase + UART010_CR);
+}
+static void pl010_enable_ms(struct uart_port *port)
+{
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
+	unsigned int cr;
 	cr = readb(uap->port.membase + UART010_CR);
 	cr |= UART010_CR_MSIE;
 	writel(cr, uap->port.membase + UART010_CR);
 static unsigned int pl010_tx_empty(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int status = readb(uap->port.membase + UART01x_FR);
 	return status & UART01x_FR_BUSY ? 0 : TIOCSER_TEMT;
 }
 static unsigned int pl010_get_mctrl(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int result = 0;
 	unsigned int status;
 static void pl010_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	if (uap->data)
 		uap->data->set_mctrl(uap->dev, uap->port.membase, mctrl);
 static void pl010_break_ctl(struct uart_port *port, int break_state)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned long flags;
 	unsigned int lcr_h;
 static int pl010_startup(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	int retval;
 	/*
 static void pl010_shutdown(struct uart_port *port)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	/*
 	 * Free the interrupt
 pl010_set_termios(struct uart_port *port, struct ktermios *termios,
 		     struct ktermios *old)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int lcr_h, old_cr;
 	unsigned long flags;
 	unsigned int baud, quot;
 	spin_unlock_irqrestore(&uap->port.lock, flags);
 }
-static void pl010_set_ldisc(struct uart_port *port, int new)
+static void pl010_set_ldisc(struct uart_port *port, struct ktermios *termios)
 {
-	if (new == N_PPS) {
+	if (termios->c_line == N_PPS) {
 		port->flags |= UPF_HARDPPS_CD;
+		spin_lock_irq(&port->lock);
 		pl010_enable_ms(port);
-	} else
+		spin_unlock_irq(&port->lock);
+	} else {
 		port->flags &= ~UPF_HARDPPS_CD;
+		if (!UART_ENABLE_MS(port, termios->c_cflag)) {
+			spin_lock_irq(&port->lock);
+			pl010_disable_ms(port);
+			spin_unlock_irq(&port->lock);
+		}
+	}
 }
 static const char *pl010_type(struct uart_port *port)
 static void pl010_console_putchar(struct uart_port *port, int ch)
 {
-	struct uart_amba_port *uap = (struct uart_amba_port *)port;
+	struct uart_amba_port *uap =
+		container_of(port, struct uart_amba_port, port);
 	unsigned int status;
 	do {

drivers/tty/serial/amba-pl011.c+43−5

@@ -246,6 +246,7 @@ static int pl011_sgbuf_init(struct dma_chan chan, struct pl011_sgbuf sg, · 245 unmodified lines
246	sg_set_page(&sg->sg, phys_to_page(dma_addr),	246	sg_set_page(&sg->sg, phys_to_page(dma_addr),
247	PL011_DMA_BUFFER_SIZE, offset_in_page(dma_addr));	247	PL011_DMA_BUFFER_SIZE, offset_in_page(dma_addr));
248	sg_dma_address(&sg->sg) = dma_addr;	248	sg_dma_address(&sg->sg) = dma_addr;
		249	sg_dma_len(&sg->sg) = PL011_DMA_BUFFER_SIZE;
249		250
250	return 0;	251	return 0;
251	}	252	}
@@ -321,10 +322,26 @@ static void pl011_dma_probe_initcall(struct device dev, struct uart_amba_port · 69 unmodified lines
321	.src_maxburst = uap->fifosize >> 2,	322	.src_maxburst = uap->fifosize >> 2,
322	.device_fc = false,	323	.device_fc = false,
323	};	324	};
		325	struct dma_slave_caps caps;
324		326
		327	/*
		328	* Some DMA controllers provide information on their capabilities.
		329	* If the controller does, check for suitable residue processing
		330	* otherwise assime all is well.
		331	*/
		332	if (0 == dma_get_slave_caps(chan, &caps)) {
		333	if (caps.residue_granularity ==
		334	DMA_RESIDUE_GRANULARITY_DESCRIPTOR) {
		335	dma_release_channel(chan);
		336	dev_info(uap->port.dev,
		337	"RX DMA disabled - no residue processing\n");
		338	return;
		339	}
		340	}
325	dmaengine_slave_config(chan, &rx_conf);	341	dmaengine_slave_config(chan, &rx_conf);
326	uap->dmarx.chan = chan;	342	uap->dmarx.chan = chan;
327		343
		344	uap->dmarx.auto_poll_rate = false;
328	if (plat && plat->dma_rx_poll_enable) {	345	if (plat && plat->dma_rx_poll_enable) {
329	/* Set poll rate if specified. */	346	/* Set poll rate if specified. */
330	if (plat->dma_rx_poll_rate) {	347	if (plat->dma_rx_poll_rate) {
@@ -345,9 +362,24 @@ static void pl011_dma_probe_initcall(struct device dev, struct uart_amba_port · 14 unmodified lines
345	plat->dma_rx_poll_timeout;	362	plat->dma_rx_poll_timeout;
346	else	363	else
347	uap->dmarx.poll_timeout = 3000;	364	uap->dmarx.poll_timeout = 3000;
348	} else	365	} else if (!plat && dev->of_node) {
349	uap->dmarx.auto_poll_rate = false;	366	uap->dmarx.auto_poll_rate = of_property_read_bool(
350		367	dev->of_node, "auto-poll");
		368	if (uap->dmarx.auto_poll_rate) {
		369	u32 x;
		370
		371	if (0 == of_property_read_u32(dev->of_node,
		372	"poll-rate-ms", &x))
		373	uap->dmarx.poll_rate = x;
		374	else
		375	uap->dmarx.poll_rate = 100;
		376	if (0 == of_property_read_u32(dev->of_node,
		377	"poll-timeout-ms", &x))
		378	uap->dmarx.poll_timeout = x;
		379	else
		380	uap->dmarx.poll_timeout = 3000;
		381	}
		382	}
351	dev_info(uap->port.dev, "DMA channel RX %s\n",	383	dev_info(uap->port.dev, "DMA channel RX %s\n",
352	dma_chan_name(uap->dmarx.chan));	384	dma_chan_name(uap->dmarx.chan));
353	}	385	}
@@ -501,7 +533,11 @@ static int pl011_dma_tx_refill(struct uart_amba_port *uap) · 147 unmodified lines
501	memcpy(&dmatx->buf[0], &xmit->buf[xmit->tail], count);	533	memcpy(&dmatx->buf[0], &xmit->buf[xmit->tail], count);
502	else {	534	else {
503	size_t first = UART_XMIT_SIZE - xmit->tail;	535	size_t first = UART_XMIT_SIZE - xmit->tail;
504	size_t second = xmit->head;	536	size_t second;
		537
		538	if (first > count)
		539	first = count;
		540	second = count - first;
505		541
506	memcpy(&dmatx->buf[0], &xmit->buf[xmit->tail], first);	542	memcpy(&dmatx->buf[0], &xmit->buf[xmit->tail], first);
507	if (second)	543	if (second)
@@ -988,7 +1024,7 @@ static void pl011_dma_startup(struct uart_amba_port *uap) · 480 unmodified lines
988	if (!uap->dmatx.chan)	1024	if (!uap->dmatx.chan)
989	return;	1025	return;
990		1026
991	uap->dmatx.buf = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL);	1027	uap->dmatx.buf = kmalloc(PL011_DMA_BUFFER_SIZE, GFP_KERNEL \| __GFP_DMA);
992	if (!uap->dmatx.buf) {	1028	if (!uap->dmatx.buf) {
993	dev_err(uap->port.dev, "no memory for DMA TX buffer\n");	1029	dev_err(uap->port.dev, "no memory for DMA TX buffer\n");
994	uap->port.fifosize = uap->fifosize;	1030	uap->port.fifosize = uap->fifosize;
@@ -1689,6 +1725,8 @@ static void pl011_shutdown(struct uart_port *port) · 694 unmodified lines
1689	plat->exit();	1725	plat->exit();
1690	}	1726	}
1691		1727
		1728	if (uap->port.ops->flush_buffer)
		1729	uap->port.ops->flush_buffer(port);
1692	}	1730	}
1693		1731
1694	static void	1732	static void

drivers/tty/serial/ar933x_uart.c+20−10

 static unsigned int ar933x_uart_tx_empty(struct uart_port *port)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	unsigned long flags;
 	unsigned int rdata;
 static void ar933x_uart_start_tx(struct uart_port *port)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	ar933x_uart_start_tx_interrupt(up);
 }
 static void ar933x_uart_stop_tx(struct uart_port *port)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	ar933x_uart_stop_tx_interrupt(up);
 }
 static void ar933x_uart_stop_rx(struct uart_port *port)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	up->ier &= ~AR933X_UART_INT_RX_VALID;
 	ar933x_uart_write(up, AR933X_UART_INT_EN_REG, up->ier);
 static void ar933x_uart_break_ctl(struct uart_port *port, int break_state)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	unsigned long flags;
 	spin_lock_irqsave(&up->port.lock, flags);
 				    struct ktermios *new,
 				    struct ktermios *old)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	unsigned int cs;
 	unsigned long flags;
 	unsigned int baud, scale, step;
 static int ar933x_uart_startup(struct uart_port *port)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	unsigned long flags;
 	int ret;
 static void ar933x_uart_shutdown(struct uart_port *port)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	/* Disable all interrupts */
 	up->ier = 0;
 static int ar933x_uart_verify_port(struct uart_port *port,
 				   struct serial_struct *ser)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	if (ser->type != PORT_UNKNOWN &&
 	    ser->type != PORT_AR933X)
 static void ar933x_uart_console_putchar(struct uart_port *port, int ch)
 {
-	struct ar933x_uart_port *up = (struct ar933x_uart_port *) port;
+	struct ar933x_uart_port *up =
+		container_of(port, struct ar933x_uart_port, port);
 	ar933x_uart_wait_xmitr(up);
 	ar933x_uart_putc(up, ch);

drivers/tty/serial/atmel_serial.c+110−120

@@ -167,7 +167,6 @@ struct atmel_uart_port { · 166 unmodified lines
167		167
168	struct circ_buf rx_ring;	168	struct circ_buf rx_ring;
169		169
170	struct serial_rs485 rs485; /* rs485 settings */
171	struct mctrl_gpios *gpios;	170	struct mctrl_gpios *gpios;
172	int gpio_irq[UART_GPIO_MAX];	171	int gpio_irq[UART_GPIO_MAX];
173	unsigned int tx_done_mask;	172	unsigned int tx_done_mask;
@@ -290,13 +289,11 @@ static unsigned int atmel_get_lines_status(struct uart_port *port) · 116 unmodified lines
290	}	289	}
291		290
292	/* Enable or disable the rs485 support */	291	/* Enable or disable the rs485 support */
293	void atmel_config_rs485(struct uart_port port, struct serial_rs485 rs485conf)	292	static int atmel_config_rs485(struct uart_port *port,
		293	struct serial_rs485 *rs485conf)
294	{	294	{
295	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);	295	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
296	unsigned int mode;	296	unsigned int mode;
297	unsigned long flags;
298
299	spin_lock_irqsave(&port->lock, flags);
300		297
301	/* Disable interrupts */	298	/* Disable interrupts */
302	UART_PUT_IDR(port, atmel_port->tx_done_mask);	299	UART_PUT_IDR(port, atmel_port->tx_done_mask);
@@ -306,7 +303,7 @@ void atmel_config_rs485(struct uart_port port, struct serial_rs485 rs485conf) · 3 unmodified lines
306	/* Resetting serial mode to RS232 (0x0) */	303	/* Resetting serial mode to RS232 (0x0) */
307	mode &= ~ATMEL_US_USMODE;	304	mode &= ~ATMEL_US_USMODE;
308		305
309	atmel_port->rs485 = *rs485conf;	306	port->rs485 = *rs485conf;
310		307
311	if (rs485conf->flags & SER_RS485_ENABLED) {	308	if (rs485conf->flags & SER_RS485_ENABLED) {
312	dev_dbg(port->dev, "Setting UART to RS485\n");	309	dev_dbg(port->dev, "Setting UART to RS485\n");
@@ -327,8 +324,7 @@ void atmel_config_rs485(struct uart_port port, struct serial_rs485 rs485conf) · 14 unmodified lines
327	/* Enable interrupts */	324	/* Enable interrupts */
328	UART_PUT_IER(port, atmel_port->tx_done_mask);	325	UART_PUT_IER(port, atmel_port->tx_done_mask);
329		326
330	spin_unlock_irqrestore(&port->lock, flags);	327	return 0;
331
332	}	328	}
333		329
334	/*	330	/*
@@ -372,11 +368,10 @@ static void atmel_set_mctrl(struct uart_port *port, u_int mctrl) · 37 unmodified lines
372	/* Resetting serial mode to RS232 (0x0) */	368	/* Resetting serial mode to RS232 (0x0) */
373	mode &= ~ATMEL_US_USMODE;	369	mode &= ~ATMEL_US_USMODE;
374		370
375	if (atmel_port->rs485.flags & SER_RS485_ENABLED) {	371	if (port->rs485.flags & SER_RS485_ENABLED) {
376	dev_dbg(port->dev, "Setting UART to RS485\n");	372	dev_dbg(port->dev, "Setting UART to RS485\n");
377	if ((atmel_port->rs485.delay_rts_after_send) > 0)	373	if ((port->rs485.delay_rts_after_send) > 0)
378	UART_PUT_TTGR(port,	374	UART_PUT_TTGR(port, port->rs485.delay_rts_after_send);
379	atmel_port->rs485.delay_rts_after_send);
380	mode \|= ATMEL_US_USMODE_RS485;	375	mode \|= ATMEL_US_USMODE_RS485;
381	} else {	376	} else {
382	dev_dbg(port->dev, "Setting UART to RS232\n");	377	dev_dbg(port->dev, "Setting UART to RS232\n");
@@ -423,8 +418,8 @@ static void atmel_stop_tx(struct uart_port *port) · 40 unmodified lines
423	/* Disable interrupts */	418	/* Disable interrupts */
424	UART_PUT_IDR(port, atmel_port->tx_done_mask);	419	UART_PUT_IDR(port, atmel_port->tx_done_mask);
425		420
426	if ((atmel_port->rs485.flags & SER_RS485_ENABLED) &&	421	if ((port->rs485.flags & SER_RS485_ENABLED) &&
427	!(atmel_port->rs485.flags & SER_RS485_RX_DURING_TX))	422	!(port->rs485.flags & SER_RS485_RX_DURING_TX))
428	atmel_start_rx(port);	423	atmel_start_rx(port);
429	}	424	}
430		425
@@ -441,8 +436,8 @@ static void atmel_start_tx(struct uart_port *port) · 10 unmodified lines
441	really need this.*/	436	really need this.*/
442	return;	437	return;
443		438
444	if ((atmel_port->rs485.flags & SER_RS485_ENABLED) &&	439	if ((port->rs485.flags & SER_RS485_ENABLED) &&
445	!(atmel_port->rs485.flags & SER_RS485_RX_DURING_TX))	440	!(port->rs485.flags & SER_RS485_RX_DURING_TX))
446	atmel_stop_rx(port);	441	atmel_stop_rx(port);
447		442
448	/* re-enable PDC transmit */	443	/* re-enable PDC transmit */
@@ -807,7 +802,7 @@ static void atmel_tx_dma(struct uart_port *port) · 358 unmodified lines
807	atmel_port->cookie_tx = dmaengine_submit(desc);	802	atmel_port->cookie_tx = dmaengine_submit(desc);
808		803
809	} else {	804	} else {
810	if (atmel_port->rs485.flags & SER_RS485_ENABLED) {	805	if (port->rs485.flags & SER_RS485_ENABLED) {
811	/* DMA done, stop TX, start RX for RS485 */	806	/* DMA done, stop TX, start RX for RS485 */
812	atmel_start_rx(port);	807	atmel_start_rx(port);
813	}	808	}
@@ -862,9 +857,8 @@ static int atmel_prepare_tx_dma(struct uart_port *port) · 48 unmodified lines
862	config.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;	857	config.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
863	config.dst_addr = port->mapbase + ATMEL_US_THR;	858	config.dst_addr = port->mapbase + ATMEL_US_THR;
864		859
865	ret = dmaengine_device_control(atmel_port->chan_tx,	860	ret = dmaengine_slave_config(atmel_port->chan_tx,
866	DMA_SLAVE_CONFIG,	861	&config);
867	(unsigned long)&config);
868	if (ret) {	862	if (ret) {
869	dev_err(port->dev, "DMA tx slave configuration failed\n");	863	dev_err(port->dev, "DMA tx slave configuration failed\n");
870	goto chan_err;	864	goto chan_err;
@@ -880,32 +874,6 @@ chan_err: · 9 unmodified lines
880	return -EINVAL;	874	return -EINVAL;
881	}	875	}
882		876
883	static void atmel_flip_buffer_rx_dma(struct uart_port *port,
884	char *buf, size_t count)
885	{
886	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
887	struct tty_port *tport = &port->state->port;
888
889	dma_sync_sg_for_cpu(port->dev,
890	&atmel_port->sg_rx,
891	1,
892	DMA_DEV_TO_MEM);
893
894	tty_insert_flip_string(tport, buf, count);
895
896	dma_sync_sg_for_device(port->dev,
897	&atmel_port->sg_rx,
898	1,
899	DMA_DEV_TO_MEM);
900	/*
901	* Drop the lock here since it might end up calling
902	* uart_start(), which takes the lock.
903	*/
904	spin_unlock(&port->lock);
905	tty_flip_buffer_push(tport);
906	spin_lock(&port->lock);
907	}
908
909	static void atmel_complete_rx_dma(void *arg)	877	static void atmel_complete_rx_dma(void *arg)
910	{	878	{
911	struct uart_port *port = arg;	879	struct uart_port *port = arg;
@@ -934,11 +902,12 @@ static void atmel_release_rx_dma(struct uart_port *port) · 22 unmodified lines
934	static void atmel_rx_from_dma(struct uart_port *port)	902	static void atmel_rx_from_dma(struct uart_port *port)
935	{	903	{
936	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);	904	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
		905	struct tty_port *tport = &port->state->port;
937	struct circ_buf *ring = &atmel_port->rx_ring;	906	struct circ_buf *ring = &atmel_port->rx_ring;
938	struct dma_chan *chan = atmel_port->chan_rx;	907	struct dma_chan *chan = atmel_port->chan_rx;
939	struct dma_tx_state state;	908	struct dma_tx_state state;
940	enum dma_status dmastat;	909	enum dma_status dmastat;
941	size_t pending, count;	910	size_t count;
942		911
943		912
944	/* Reset the UART timeout early so that we don't miss one */	913	/* Reset the UART timeout early so that we don't miss one */
@@ -953,27 +922,68 @@ static void atmel_rx_from_dma(struct uart_port *port) · 8 unmodified lines
953	tasklet_schedule(&atmel_port->tasklet);	922	tasklet_schedule(&atmel_port->tasklet);
954	return;	923	return;
955	}	924	}
956	/* current transfer size should no larger than dma buffer */	925
957	pending = sg_dma_len(&atmel_port->sg_rx) - state.residue;	926	/* CPU claims ownership of RX DMA buffer */
958	BUG_ON(pending > sg_dma_len(&atmel_port->sg_rx));	927	dma_sync_sg_for_cpu(port->dev,
		928	&atmel_port->sg_rx,
		929	1,
		930	DMA_DEV_TO_MEM);
959		931
960	/*	932	/*
961	* This will take the chars we have so far,	933	* ring->head points to the end of data already written by the DMA.
962	* ring->head will record the transfer size, only new bytes come	934	* ring->tail points to the beginning of data to be read by the
963	* will insert into the framework.	935	* framework.
		936	* The current transfer size should not be larger than the dma buffer
		937	* length.
964	*/	938	*/
965	if (pending > ring->head) {	939	ring->head = sg_dma_len(&atmel_port->sg_rx) - state.residue;
966	count = pending - ring->head;	940	BUG_ON(ring->head > sg_dma_len(&atmel_port->sg_rx));
		941	/*
		942	* At this point ring->head may point to the first byte right after the
		943	* last byte of the dma buffer:
		944	* 0 <= ring->head <= sg_dma_len(&atmel_port->sg_rx)
		945	*
		946	* However ring->tail must always points inside the dma buffer:
		947	* 0 <= ring->tail <= sg_dma_len(&atmel_port->sg_rx) - 1
		948	*
		949	* Since we use a ring buffer, we have to handle the case
		950	* where head is lower than tail. In such a case, we first read from
		951	* tail to the end of the buffer then reset tail.
		952	*/
		953	if (ring->head < ring->tail) {
		954	count = sg_dma_len(&atmel_port->sg_rx) - ring->tail;
		955
		956	tty_insert_flip_string(tport, ring->buf + ring->tail, count);
		957	ring->tail = 0;
		958	port->icount.rx += count;
		959	}
967		960
968	atmel_flip_buffer_rx_dma(port, ring->buf + ring->head, count);	961	/* Finally we read data from tail to head */
		962	if (ring->tail < ring->head) {
		963	count = ring->head - ring->tail;
969		964
970	ring->head += count;	965	tty_insert_flip_string(tport, ring->buf + ring->tail, count);
971	if (ring->head == sg_dma_len(&atmel_port->sg_rx))	966	/* Wrap ring->head if needed */
		967	if (ring->head >= sg_dma_len(&atmel_port->sg_rx))
972	ring->head = 0;	968	ring->head = 0;
973		969	ring->tail = ring->head;
974	port->icount.rx += count;	970	port->icount.rx += count;
975	}	971	}
976		972
		973	/* USART retreives ownership of RX DMA buffer */
		974	dma_sync_sg_for_device(port->dev,
		975	&atmel_port->sg_rx,
		976	1,
		977	DMA_DEV_TO_MEM);
		978
		979	/*
		980	* Drop the lock here since it might end up calling
		981	* uart_start(), which takes the lock.
		982	*/
		983	spin_unlock(&port->lock);
		984	tty_flip_buffer_push(tport);
		985	spin_lock(&port->lock);
		986
977	UART_PUT_IER(port, ATMEL_US_TIMEOUT);	987	UART_PUT_IER(port, ATMEL_US_TIMEOUT);
978	}	988	}
979		989
@@ -1026,9 +1036,8 @@ static int atmel_prepare_rx_dma(struct uart_port *port) · 46 unmodified lines
1026	config.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;	1036	config.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
1027	config.src_addr = port->mapbase + ATMEL_US_RHR;	1037	config.src_addr = port->mapbase + ATMEL_US_RHR;
1028		1038
1029	ret = dmaengine_device_control(atmel_port->chan_rx,	1039	ret = dmaengine_slave_config(atmel_port->chan_rx,
1030	DMA_SLAVE_CONFIG,	1040	&config);
1031	(unsigned long)&config);
1032	if (ret) {	1041	if (ret) {
1033	dev_err(port->dev, "DMA rx slave configuration failed\n");	1042	dev_err(port->dev, "DMA rx slave configuration failed\n");
1034	goto chan_err;	1043	goto chan_err;
@@ -1240,8 +1249,8 @@ static void atmel_tx_pdc(struct uart_port *port) · 205 unmodified lines
1240	/* Enable interrupts */	1249	/* Enable interrupts */
1241	UART_PUT_IER(port, atmel_port->tx_done_mask);	1250	UART_PUT_IER(port, atmel_port->tx_done_mask);
1242	} else {	1251	} else {
1243	if ((atmel_port->rs485.flags & SER_RS485_ENABLED) &&	1252	if ((port->rs485.flags & SER_RS485_ENABLED) &&
1244	!(atmel_port->rs485.flags & SER_RS485_RX_DURING_TX)) {	1253	!(port->rs485.flags & SER_RS485_RX_DURING_TX)) {
1245	/* DMA done, stop TX, start RX for RS485 */	1254	/* DMA done, stop TX, start RX for RS485 */
1246	atmel_start_rx(port);	1255	atmel_start_rx(port);
1247	}	1256	}
@@ -1552,7 +1561,7 @@ static int atmel_init_property(struct atmel_uart_port *atmel_port, · 304 unmodified lines
1552	return 0;	1561	return 0;
1553	}	1562	}
1554		1563
1555	static void atmel_init_rs485(struct atmel_uart_port *atmel_port,	1564	static void atmel_init_rs485(struct uart_port *port,
1556	struct platform_device *pdev)	1565	struct platform_device *pdev)
1557	{	1566	{
1558	struct device_node *np = pdev->dev.of_node;	1567	struct device_node *np = pdev->dev.of_node;
@@ -1563,7 +1572,7 @@ static void atmel_init_rs485(struct atmel_uart_port *atmel_port, · 4 unmodified lines
1563	/* rs485 properties */	1572	/* rs485 properties */
1564	if (of_property_read_u32_array(np, "rs485-rts-delay",	1573	if (of_property_read_u32_array(np, "rs485-rts-delay",
1565	rs485_delay, 2) == 0) {	1574	rs485_delay, 2) == 0) {
1566	struct serial_rs485 *rs485conf = &atmel_port->rs485;	1575	struct serial_rs485 *rs485conf = &port->rs485;
1567		1576
1568	rs485conf->delay_rts_before_send = rs485_delay[0];	1577	rs485conf->delay_rts_before_send = rs485_delay[0];
1569	rs485conf->delay_rts_after_send = rs485_delay[1];	1578	rs485conf->delay_rts_after_send = rs485_delay[1];
@@ -1577,7 +1586,7 @@ static void atmel_init_rs485(struct atmel_uart_port *atmel_port, · 7 unmodified lines
1577	rs485conf->flags \|= SER_RS485_ENABLED;	1586	rs485conf->flags \|= SER_RS485_ENABLED;
1578	}	1587	}
1579	} else {	1588	} else {
1580	atmel_port->rs485 = pdata->rs485;	1589	port->rs485 = pdata->rs485;
1581	}	1590	}
1582		1591
1583	}	1592	}
@@ -1801,6 +1810,20 @@ free_irq: · 217 unmodified lines
1801	return retval;	1810	return retval;
1802	}	1811	}
1803		1812
		1813	/*
		1814	* Flush any TX data submitted for DMA. Called when the TX circular
		1815	* buffer is reset.
		1816	*/
		1817	static void atmel_flush_buffer(struct uart_port *port)
		1818	{
		1819	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
		1820
		1821	if (atmel_use_pdc_tx(port)) {
		1822	UART_PUT_TCR(port, 0);
		1823	atmel_port->pdc_tx.ofs = 0;
		1824	}
		1825	}
		1826
1804	/*	1827	/*
1805	* Disable the port	1828	* Disable the port
1806	*/	1829	*/
@@ -1852,20 +1875,8 @@ static void atmel_shutdown(struct uart_port *port) · 45 unmodified lines
1852	atmel_free_gpio_irq(port);	1875	atmel_free_gpio_irq(port);
1853		1876
1854	atmel_port->ms_irq_enabled = false;	1877	atmel_port->ms_irq_enabled = false;
1855	}
1856		1878
1857	/*	1879	atmel_flush_buffer(port);
1858	* Flush any TX data submitted for DMA. Called when the TX circular
1859	* buffer is reset.
1860	*/
1861	static void atmel_flush_buffer(struct uart_port *port)
1862	{
1863	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
1864
1865	if (atmel_use_pdc_tx(port)) {
1866	UART_PUT_TCR(port, 0);
1867	atmel_port->pdc_tx.ofs = 0;
1868	}
1869	}	1880	}
1870		1881
1871	/*	1882	/*
@@ -1911,7 +1922,6 @@ static void atmel_set_termios(struct uart_port port, struct ktermios termios, · 39 unmodified lines
1911	{	1922	{
1912	unsigned long flags;	1923	unsigned long flags;
1913	unsigned int mode, imr, quot, baud;	1924	unsigned int mode, imr, quot, baud;
1914	struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
1915		1925
1916	/* Get current mode register */	1926	/* Get current mode register */
1917	mode = UART_GET_MR(port) & ~(ATMEL_US_USCLKS \| ATMEL_US_CHRL	1927	mode = UART_GET_MR(port) & ~(ATMEL_US_USCLKS \| ATMEL_US_CHRL
@@ -2013,10 +2023,9 @@ static void atmel_set_termios(struct uart_port port, struct ktermios termios, · 95 unmodified lines
2013	/* Resetting serial mode to RS232 (0x0) */	2023	/* Resetting serial mode to RS232 (0x0) */
2014	mode &= ~ATMEL_US_USMODE;	2024	mode &= ~ATMEL_US_USMODE;
2015		2025
2016	if (atmel_port->rs485.flags & SER_RS485_ENABLED) {	2026	if (port->rs485.flags & SER_RS485_ENABLED) {
2017	if ((atmel_port->rs485.delay_rts_after_send) > 0)	2027	if ((port->rs485.delay_rts_after_send) > 0)
2018	UART_PUT_TTGR(port,	2028	UART_PUT_TTGR(port, port->rs485.delay_rts_after_send);
2019	atmel_port->rs485.delay_rts_after_send);
2020	mode \|= ATMEL_US_USMODE_RS485;	2029	mode \|= ATMEL_US_USMODE_RS485;
2021	}	2030	}
2022		2031
@@ -2040,13 +2049,20 @@ static void atmel_set_termios(struct uart_port port, struct ktermios termios, · 17 unmodified lines
2040	spin_unlock_irqrestore(&port->lock, flags);	2049	spin_unlock_irqrestore(&port->lock, flags);
2041	}	2050	}
2042		2051
2043	static void atmel_set_ldisc(struct uart_port *port, int new)	2052	static void atmel_set_ldisc(struct uart_port port, struct ktermios termios)
2044	{	2053	{
2045	if (new == N_PPS) {	2054	if (termios->c_line == N_PPS) {
2046	port->flags \|= UPF_HARDPPS_CD;	2055	port->flags \|= UPF_HARDPPS_CD;
		2056	spin_lock_irq(&port->lock);
2047	atmel_enable_ms(port);	2057	atmel_enable_ms(port);
		2058	spin_unlock_irq(&port->lock);
2048	} else {	2059	} else {
2049	port->flags &= ~UPF_HARDPPS_CD;	2060	port->flags &= ~UPF_HARDPPS_CD;
		2061	if (!UART_ENABLE_MS(port, termios->c_cflag)) {
		2062	spin_lock_irq(&port->lock);
		2063	atmel_disable_ms(port);
		2064	spin_unlock_irq(&port->lock);
		2065	}
2050	}	2066	}
2051	}	2067	}
2052		2068
@@ -2148,35 +2164,6 @@ static void atmel_poll_put_char(struct uart_port *port, unsigned char ch) · 95 unmodified lines
2148	}	2164	}
2149	#endif	2165	#endif
2150		2166
2151	static int
2152	atmel_ioctl(struct uart_port *port, unsigned int cmd, unsigned long arg)
2153	{
2154	struct serial_rs485 rs485conf;
2155
2156	switch (cmd) {
2157	case TIOCSRS485:
2158	if (copy_from_user(&rs485conf, (struct serial_rs485 *) arg,
2159	sizeof(rs485conf)))
2160	return -EFAULT;
2161
2162	atmel_config_rs485(port, &rs485conf);
2163	break;
2164
2165	case TIOCGRS485:
2166	if (copy_to_user((struct serial_rs485 *) arg,
2167	&(to_atmel_uart_port(port)->rs485),
2168	sizeof(rs485conf)))
2169	return -EFAULT;
2170	break;
2171
2172	default:
2173	return -ENOIOCTLCMD;
2174	}
2175	return 0;
2176	}
2177
2178
2179
2180	static struct uart_ops atmel_pops = {	2167	static struct uart_ops atmel_pops = {
2181	.tx_empty = atmel_tx_empty,	2168	.tx_empty = atmel_tx_empty,
2182	.set_mctrl = atmel_set_mctrl,	2169	.set_mctrl = atmel_set_mctrl,
@@ -2197,7 +2184,6 @@ static struct uart_ops atmel_pops = { · 14 unmodified lines
2197	.config_port = atmel_config_port,	2184	.config_port = atmel_config_port,
2198	.verify_port = atmel_verify_port,	2185	.verify_port = atmel_verify_port,
2199	.pm = atmel_serial_pm,	2186	.pm = atmel_serial_pm,
2200	.ioctl = atmel_ioctl,
2201	#ifdef CONFIG_CONSOLE_POLL	2187	#ifdef CONFIG_CONSOLE_POLL
2202	.poll_get_char = atmel_poll_get_char,	2188	.poll_get_char = atmel_poll_get_char,
2203	.poll_put_char = atmel_poll_put_char,	2189	.poll_put_char = atmel_poll_put_char,
@@ -2217,7 +2203,7 @@ static int atmel_init_port(struct atmel_uart_port *atmel_port, · 13 unmodified lines
2217	if (!atmel_init_property(atmel_port, pdev))	2203	if (!atmel_init_property(atmel_port, pdev))
2218	atmel_set_ops(port);	2204	atmel_set_ops(port);
2219		2205
2220	atmel_init_rs485(atmel_port, pdev);	2206	atmel_init_rs485(port, pdev);
2221		2207
2222	port->iotype = UPIO_MEM;	2208	port->iotype = UPIO_MEM;
2223	port->flags = UPF_BOOT_AUTOCONF;	2209	port->flags = UPF_BOOT_AUTOCONF;
@@ -2226,6 +2212,7 @@ static int atmel_init_port(struct atmel_uart_port *atmel_port, · 2 unmodified lines
2226	port->dev = &pdev->dev;	2212	port->dev = &pdev->dev;
2227	port->mapbase = pdev->resource[0].start;	2213	port->mapbase = pdev->resource[0].start;
2228	port->irq = pdev->resource[1].start;	2214	port->irq = pdev->resource[1].start;
		2215	port->rs485_config = atmel_config_rs485;
2229		2216
2230	tasklet_init(&atmel_port->tasklet, atmel_tasklet_func,	2217	tasklet_init(&atmel_port->tasklet, atmel_tasklet_func,
2231	(unsigned long)port);	2218	(unsigned long)port);
@@ -2260,7 +2247,7 @@ static int atmel_init_port(struct atmel_uart_port *atmel_port, · 28 unmodified lines
2260	}	2247	}
2261		2248
2262	/* Use TXEMPTY for interrupt when rs485 else TXRDY or ENDTX\|TXBUFE */	2249	/* Use TXEMPTY for interrupt when rs485 else TXRDY or ENDTX\|TXBUFE */
2263	if (atmel_port->rs485.flags & SER_RS485_ENABLED)	2250	if (port->rs485.flags & SER_RS485_ENABLED)
2264	atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;	2251	atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;
2265	else if (atmel_use_pdc_tx(port)) {	2252	else if (atmel_use_pdc_tx(port)) {
2266	port->fifosize = PDC_BUFFER_SIZE;	2253	port->fifosize = PDC_BUFFER_SIZE;
@@ -2541,6 +2528,7 @@ static int atmel_serial_probe(struct platform_device *pdev) · 274 unmodified lines
2541	struct atmel_uart_data *pdata = dev_get_platdata(&pdev->dev);	2528	struct atmel_uart_data *pdata = dev_get_platdata(&pdev->dev);
2542	void *data;	2529	void *data;
2543	int ret = -ENODEV;	2530	int ret = -ENODEV;
		2531	bool rs485_enabled;
2544		2532
2545	BUILD_BUG_ON(ATMEL_SERIAL_RINGSIZE & (ATMEL_SERIAL_RINGSIZE - 1));	2533	BUILD_BUG_ON(ATMEL_SERIAL_RINGSIZE & (ATMEL_SERIAL_RINGSIZE - 1));
2546		2534
@@ -2588,6 +2576,8 @@ static int atmel_serial_probe(struct platform_device *pdev) · 41 unmodified lines
2588	port->rx_ring.buf = data;	2576	port->rx_ring.buf = data;
2589	}	2577	}
2590		2578
		2579	rs485_enabled = port->uart.rs485.flags & SER_RS485_ENABLED;
		2580
2591	ret = uart_add_one_port(&atmel_uart, &port->uart);	2581	ret = uart_add_one_port(&atmel_uart, &port->uart);
2592	if (ret)	2582	if (ret)
2593	goto err_add_port;	2583	goto err_add_port;
@@ -2606,7 +2596,7 @@ static int atmel_serial_probe(struct platform_device *pdev) · 12 unmodified lines
2606	device_init_wakeup(&pdev->dev, 1);	2596	device_init_wakeup(&pdev->dev, 1);
2607	platform_set_drvdata(pdev, port);	2597	platform_set_drvdata(pdev, port);
2608		2598
2609	if (port->rs485.flags & SER_RS485_ENABLED) {	2599	if (rs485_enabled) {
2610	UART_PUT_MR(&port->uart, ATMEL_US_USMODE_NORMAL);	2600	UART_PUT_MR(&port->uart, ATMEL_US_USMODE_NORMAL);
2611	UART_PUT_CR(&port->uart, ATMEL_US_RTSEN);	2601	UART_PUT_CR(&port->uart, ATMEL_US_RTSEN);
2612	}	2602	}

drivers/tty/serial/bcm63xx_uart.c+33−22

  */
 static int bcm_uart_request_port(struct uart_port *port)
 {
-	unsigned int size;
+	/* UARTs always present */
-	size = UART_REG_SIZE;
-	if (!request_mem_region(port->mapbase, size, "bcm63xx")) {
-		dev_err(port->dev, "Memory region busy\n");
-		return -EBUSY;
-	}
-	port->membase = ioremap(port->mapbase, size);
-	if (!port->membase) {
-		dev_err(port->dev, "Unable to map registers\n");
-		release_mem_region(port->mapbase, size);
-		return -EBUSY;
-	}
 	return 0;
 }
  */
 static void bcm_uart_release_port(struct uart_port *port)
 {
-	release_mem_region(port->mapbase, UART_REG_SIZE);
+	/* Nothing to release ... */
-	iounmap(port->membase);
 }
 /*
 console_initcall(bcm63xx_console_init);
+static void bcm_early_write(struct console *con, const char *s, unsigned n)
+{
+	struct earlycon_device *dev = con->data;
+	uart_console_write(&dev->port, s, n, bcm_console_putchar);
+	wait_for_xmitr(&dev->port);
+}
+static int __init bcm_early_console_setup(struct earlycon_device *device,
+					  const char *opt)
+{
+	if (!device->port.membase)
+		return -ENODEV;
+	device->con->write = bcm_early_write;
+	return 0;
+}
+OF_EARLYCON_DECLARE(bcm63xx_uart, "brcm,bcm6345-uart", bcm_early_console_setup);
 #define BCM63XX_CONSOLE	(&bcm63xx_console)
 #else
 #define BCM63XX_CONSOLE	NULL
 	if (pdev->id < 0 || pdev->id >= BCM63XX_NR_UARTS)
 		return -EINVAL;
-	if (ports[pdev->id].membase)
+	port = &ports[pdev->id];
+	if (port->membase)
 		return -EBUSY;
+	memset(port, 0, sizeof(*port));
 	res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res_mem)
 		return -ENODEV;
+	port->mapbase = res_mem->start;
+	port->membase = devm_ioremap_resource(&pdev->dev, res_mem);
+	if (IS_ERR(port->membase))
+		return PTR_ERR(port->membase);
 	res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 	if (!res_irq)
 		return -ENODEV;
-	clk = clk_get(&pdev->dev, "periph");
+	clk = pdev->dev.of_node ? of_clk_get(pdev->dev.of_node, 0) :
+				  clk_get(&pdev->dev, "periph");
 	if (IS_ERR(clk))
 		return -ENODEV;
-	port = &ports[pdev->id];
-	memset(port, 0, sizeof(*port));
 	port->iotype = UPIO_MEM;
-	port->mapbase = res_mem->start;
 	port->irq = res_irq->start;
 	port->ops = &bcm_uart_ops;
 	port->flags = UPF_BOOT_AUTOCONF;
 module_exit(bcm_uart_exit);
 MODULE_AUTHOR("Maxime Bizon <mbizon@freebox.fr>");
-MODULE_DESCRIPTION("Broadcom 63<xx integrated uart driver");
+MODULE_DESCRIPTION("Broadcom 63xx integrated uart driver");
 MODULE_LICENSE("GPL");

drivers/tty/serial/bfin_sport_uart.c+3−2

 		up->csize = 5;
 		break;
 	default:
-		pr_warning("requested word length not supported\n");
+		pr_warn("requested word length not supported\n");
+		break;
 	}
 	if (termios->c_cflag & CSTOPB) {
 		up->stopb = 1;
 	}
 	if (termios->c_cflag & PARENB) {
-		pr_warning("PAREN bits is not supported yet\n");
+		pr_warn("PAREN bit is not supported yet\n");
 		/* up->parib = 1; */
 	}

drivers/tty/serial/bfin_uart.c+3−2

  * Enable the IrDA function if tty->ldisc.num is N_IRDA.
  * In other cases, disable IrDA function.
  */
-static void bfin_serial_set_ldisc(struct uart_port *port, int ld)
+static void bfin_serial_set_ldisc(struct uart_port *port,
+				  struct ktermios *termios)
 {
 	struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 	unsigned int val;
-	switch (ld) {
+	switch (termios->c_line) {
 	case N_IRDA:
 		val = UART_GET_GCTL(uart);
 		val |= (UMOD_IRDA | RPOLC);

drivers/tty/serial/clps711x.c+3−2

 	writel(ubrlcr, port->membase + UBRLCR_OFFSET);
 }
-static void uart_clps711x_set_ldisc(struct uart_port *port, int ld)
+static void uart_clps711x_set_ldisc(struct uart_port *port,
+				    struct ktermios *termios)
 {
 	if (!port->line) {
 		struct clps711x_port *s = dev_get_drvdata(port->dev);
 		regmap_update_bits(s->syscon, SYSCON_OFFSET, SYSCON1_SIREN,
-				   (ld == N_IRDA) ? SYSCON1_SIREN : 0);
+				   (termios->c_line == N_IRDA) ? SYSCON1_SIREN : 0);
 	}
 }

drivers/tty/serial/cpm_uart/cpm_uart_core.c+32−16

 */
 static unsigned int cpm_uart_tx_empty(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	cbd_t __iomem *bdp = pinfo->tx_bd_base;
 	int ret = 0;
 static void cpm_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	if (pinfo->gpios[GPIO_RTS] >= 0)
 		gpio_set_value(pinfo->gpios[GPIO_RTS], !(mctrl & TIOCM_RTS));
 static unsigned int cpm_uart_get_mctrl(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	unsigned int mctrl = TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
 	if (pinfo->gpios[GPIO_CTS] >= 0) {
  */
 static void cpm_uart_stop_tx(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	smc_t __iomem *smcp = pinfo->smcp;
 	scc_t __iomem *sccp = pinfo->sccp;
  */
 static void cpm_uart_start_tx(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	smc_t __iomem *smcp = pinfo->smcp;
 	scc_t __iomem *sccp = pinfo->sccp;
  */
 static void cpm_uart_stop_rx(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	smc_t __iomem *smcp = pinfo->smcp;
 	scc_t __iomem *sccp = pinfo->sccp;
  */
 static void cpm_uart_break_ctl(struct uart_port *port, int break_state)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	pr_debug("CPM uart[%d]:break ctrl, break_state: %d\n", port->line,
 		break_state);
 	unsigned char ch;
 	u8 *cp;
 	struct tty_port *tport = &port->state->port;
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	cbd_t __iomem *bdp;
 	u16 status;
 	unsigned int flg;
 static int cpm_uart_startup(struct uart_port *port)
 {
 	int retval;
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	pr_debug("CPM uart[%d]:startup\n", port->line);
  */
 static void cpm_uart_shutdown(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	pr_debug("CPM uart[%d]:shutdown\n", port->line);
 	unsigned long flags;
 	u16 cval, scval, prev_mode;
 	int bits, sbits;
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	smc_t __iomem *smcp = pinfo->smcp;
 	scc_t __iomem *sccp = pinfo->sccp;
 	int maxidl;
 	cbd_t __iomem *bdp;
 	u8 *p;
 	int count;
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	struct circ_buf *xmit = &port->state->xmit;
 	/* Handle xon/xoff */
  */
 static int cpm_uart_request_port(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	int ret;
 	pr_debug("CPM uart[%d]:request port\n", port->line);
 static void cpm_uart_release_port(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	if (!(pinfo->flags & FLAG_CONSOLE))
 		cpm_uart_freebuf(pinfo);
 static int cpm_get_poll_char(struct uart_port *port)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	if (!serial_polled) {
 		serial_polled = 1;
 static void cpm_put_poll_char(struct uart_port *port,
 			 unsigned char c)
 {
-	struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
+	struct uart_cpm_port *pinfo =
+		container_of(port, struct uart_cpm_port, port);
 	static char ch[2];
 	ch[0] = (char)c;

drivers/tty/serial/crisv10.c+0−12

 		return;
 	}
 	info->port.flags |= ASYNC_CLOSING;
-	/*
-	 * Save the termios structure, since this port may have
-	 * separate termios for callout and dialin.
-	 */
-	if (info->port.flags & ASYNC_NORMAL_ACTIVE)
-		info->normal_termios = tty->termios;
 	/*
 	 * Now we wait for the transmit buffer to clear; and we notify
 	 * the line discipline to only process XON/XOFF characters.
 		return retval;
 	}
-	if ((info->port.count == 1) && (info->port.flags & ASYNC_SPLIT_TERMIOS)) {
-		tty->termios = info->normal_termios;
-		change_speed(info);
-	}
 #ifdef SERIAL_DEBUG_OPEN
 	printk("rs_open ttyS%d successful...\n", info->line);
 #endif
 		info->custom_divisor = 0;
 		info->x_char = 0;
 		info->event = 0;
-		info->normal_termios = driver->init_termios;
 		info->xmit.buf = NULL;
 		info->xmit.tail = info->xmit.head = 0;
 		info->first_recv_buffer = info->last_recv_buffer = NULL;

drivers/tty/serial/crisv10.h+0−1

@@ -98,7 +98,6 @@ struct e100_serial { · 97 unmodified lines
98		98
99	struct work_struct work;	99	struct work_struct work;
100	struct async_icount icount; /* error-statistics etc.*/	100	struct async_icount icount; /* error-statistics etc.*/
101	struct ktermios normal_termios;
102		101
103	unsigned long char_time_usec; /* The time for 1 char, in usecs */	102	unsigned long char_time_usec; /* The time for 1 char, in usecs */
104	unsigned long flush_time_usec; /* How often we should flush */	103	unsigned long flush_time_usec; /* How often we should flush */

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

@@ -98,7 +98,7 @@ static int __init parse_options(struct earlycon_device *device, · 97 unmodified lines
98	strlcpy(device->options, options, length);	98	strlcpy(device->options, options, length);
99	}	99	}
100		100
101	if (mmio \|\| mmio32)	101	if (port->iotype == UPIO_MEM \|\| port->iotype == UPIO_MEM32)
102	pr_info("Early serial console at MMIO%s 0x%llx (options '%s')\n",	102	pr_info("Early serial console at MMIO%s 0x%llx (options '%s')\n",
103	mmio32 ? "32" : "",	103	mmio32 ? "32" : "",
104	(unsigned long long)port->mapbase,	104	(unsigned long long)port->mapbase,

drivers/tty/serial/fsl_lpuart.c+17−8

 	}
 	sport->port.line = ret;
 	sport->lpuart32 = of_device_is_compatible(np, "fsl,ls1021a-lpuart");
-	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-	if (!res)
-		return -ENODEV;
-	sport->port.mapbase = res->start;
+	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	sport->port.membase = devm_ioremap_resource(&pdev->dev, res);
 	if (IS_ERR(sport->port.membase))
 		return PTR_ERR(sport->port.membase);
+	sport->port.mapbase = res->start;
 	sport->port.dev = &pdev->dev;
 	sport->port.type = PORT_LPUART;
 	sport->port.iotype = UPIO_MEM;
 static int lpuart_resume(struct device *dev)
 {
 	struct lpuart_port *sport = dev_get_drvdata(dev);
+	unsigned long temp;
+	if (sport->lpuart32) {
+		lpuart32_setup_watermark(sport);
+		temp = lpuart32_read(sport->port.membase + UARTCTRL);
+		temp |= (UARTCTRL_RIE | UARTCTRL_TIE | UARTCTRL_RE |
+			 UARTCTRL_TE | UARTCTRL_ILIE);
+		lpuart32_write(temp, sport->port.membase + UARTCTRL);
+	} else {
+		lpuart_setup_watermark(sport);
+		temp = readb(sport->port.membase + UARTCR2);
+		temp |= (UARTCR2_RIE | UARTCR2_TIE | UARTCR2_RE | UARTCR2_TE);
+		writeb(temp, sport->port.membase + UARTCR2);
+	}
 	uart_resume_port(&lpuart_reg, &sport->port);
 static int __init lpuart_serial_init(void)
 {
-	int ret;
+	int ret = uart_register_driver(&lpuart_reg);
-	pr_info("serial: Freescale lpuart driver\n");
-	ret = uart_register_driver(&lpuart_reg);
 	if (ret)
 		return ret;

drivers/tty/serial/icom.c+3−1

@@ -1550,8 +1550,10 @@ static int icom_probe(struct pci_dev *dev, · 1549 unmodified lines
1550		1550
1551	icom_adapter->base_addr = pci_ioremap_bar(dev, 0);	1551	icom_adapter->base_addr = pci_ioremap_bar(dev, 0);
1552		1552
1553	if (!icom_adapter->base_addr)	1553	if (!icom_adapter->base_addr) {
		1554	retval = -ENOMEM;
1554	goto probe_exit1;	1555	goto probe_exit1;
		1556	}
1555		1557
1556	/* save off irq and request irq line */	1558	/* save off irq and request irq line */
1557	if ( (retval = request_irq(dev->irq, icom_interrupt,	1559	if ( (retval = request_irq(dev->irq, icom_interrupt,

drivers/tty/serial/imx.c+75−78

 /*
  * Save and restore functions for UCR1, UCR2 and UCR3 registers
  */
-#if defined(CONFIG_CONSOLE_POLL) || defined(CONFIG_SERIAL_IMX_CONSOLE)
+#if defined(CONFIG_SERIAL_IMX_CONSOLE)
 static void imx_port_ucrs_save(struct uart_port *port,
 			       struct imx_port_ucrs *ucr)
 {
 	sport->rx_buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
 	if (!sport->rx_buf) {
-		dev_err(dev, "cannot alloc DMA buffer.\n");
 		ret = -ENOMEM;
 		goto err;
 	}
 	retval = clk_prepare_enable(sport->clk_per);
 	if (retval)
-		goto error_out1;
+		return retval;
 	retval = clk_prepare_enable(sport->clk_ipg);
 	if (retval) {
 		clk_disable_unprepare(sport->clk_per);
-		goto error_out1;
+		return retval;
 	}
 	imx_setup_ufcr(sport, 0);
 	while (!(readl(sport->port.membase + UCR2) & UCR2_SRST) && (--i > 0))
 		udelay(1);
-	/*
-	 * Allocate the IRQ(s) i.MX1 has three interrupts whereas later
-	 * chips only have one interrupt.
-	 */
-	if (sport->txirq > 0) {
-		retval = request_irq(sport->rxirq, imx_rxint, 0,
-				     dev_name(port->dev), sport);
-		if (retval)
-			goto error_out1;
-		retval = request_irq(sport->txirq, imx_txint, 0,
-				     dev_name(port->dev), sport);
-		if (retval)
-			goto error_out2;
-		/* do not use RTS IRQ on IrDA */
-		if (!USE_IRDA(sport)) {
-			retval = request_irq(sport->rtsirq, imx_rtsint, 0,
-					     dev_name(port->dev), sport);
-			if (retval)
-				goto error_out3;
-		}
-	} else {
-		retval = request_irq(sport->port.irq, imx_int, 0,
-				     dev_name(port->dev), sport);
-		if (retval) {
-			free_irq(sport->port.irq, sport);
-			goto error_out1;
-		}
-	}
 	spin_lock_irqsave(&sport->port.lock, flags);
 	/*
 	 * Finally, clear and enable interrupts
 	}
 	return 0;
-error_out3:
-	if (sport->txirq)
-		free_irq(sport->txirq, sport);
-error_out2:
-	if (sport->rxirq)
-		free_irq(sport->rxirq, sport);
-error_out1:
-	return retval;
 }
 static void imx_shutdown(struct uart_port *port)
 	 */
 	del_timer_sync(&sport->timer);
-	/*
-	 * Free the interrupts
-	 */
-	if (sport->txirq > 0) {
-		if (!USE_IRDA(sport))
-			free_irq(sport->rtsirq, sport);
-		free_irq(sport->txirq, sport);
-		free_irq(sport->rxirq, sport);
-	} else
-		free_irq(sport->port.irq, sport);
 	/*
 	 * Disable all interrupts, port and break condition.
 	 */
 }
 #if defined(CONFIG_CONSOLE_POLL)
+static int imx_poll_init(struct uart_port *port)
+{
+	struct imx_port *sport = (struct imx_port *)port;
+	unsigned long flags;
+	unsigned long temp;
+	int retval;
+	retval = clk_prepare_enable(sport->clk_ipg);
+	if (retval)
+		return retval;
+	retval = clk_prepare_enable(sport->clk_per);
+	if (retval)
+		clk_disable_unprepare(sport->clk_ipg);
+	imx_setup_ufcr(sport, 0);
+	spin_lock_irqsave(&sport->port.lock, flags);
+	temp = readl(sport->port.membase + UCR1);
+	if (is_imx1_uart(sport))
+		temp |= IMX1_UCR1_UARTCLKEN;
+	temp |= UCR1_UARTEN | UCR1_RRDYEN;
+	temp &= ~(UCR1_TXMPTYEN | UCR1_RTSDEN);
+	writel(temp, sport->port.membase + UCR1);
+	temp = readl(sport->port.membase + UCR2);
+	temp |= UCR2_RXEN;
+	writel(temp, sport->port.membase + UCR2);
+	spin_unlock_irqrestore(&sport->port.lock, flags);
+	return 0;
+}
 static int imx_poll_get_char(struct uart_port *port)
 {
-	if (!(readl(port->membase + USR2) & USR2_RDR))
+	if (!(readl_relaxed(port->membase + USR2) & USR2_RDR))
 		return NO_POLL_CHAR;
-	return readl(port->membase + URXD0) & URXD_RX_DATA;
+	return readl_relaxed(port->membase + URXD0) & URXD_RX_DATA;
 }
 static void imx_poll_put_char(struct uart_port *port, unsigned char c)
 {
-	struct imx_port_ucrs old_ucr;
 	unsigned int status;
-	/* save control registers */
-	imx_port_ucrs_save(port, &old_ucr);
-	/* disable interrupts */
-	writel(UCR1_UARTEN, port->membase + UCR1);
-	writel(old_ucr.ucr2 & ~(UCR2_ATEN | UCR2_RTSEN | UCR2_ESCI),
-	       port->membase + UCR2);
-	writel(old_ucr.ucr3 & ~(UCR3_DCD | UCR3_RI | UCR3_DTREN),
-	       port->membase + UCR3);
 	/* drain */
 	do {
-		status = readl(port->membase + USR1);
+		status = readl_relaxed(port->membase + USR1);
 	} while (~status & USR1_TRDY);
 	/* write */
-	writel(c, port->membase + URTX0);
+	writel_relaxed(c, port->membase + URTX0);
 	/* flush */
 	do {
-		status = readl(port->membase + USR2);
+		status = readl_relaxed(port->membase + USR2);
 	} while (~status & USR2_TXDC);
-	/* restore control registers */
-	imx_port_ucrs_restore(port, &old_ucr);
 }
 #endif
 	.config_port	= imx_config_port,
 	.verify_port	= imx_verify_port,
 #if defined(CONFIG_CONSOLE_POLL)
+	.poll_init      = imx_poll_init,
 	.poll_get_char  = imx_poll_get_char,
 	.poll_put_char  = imx_poll_put_char,
 #endif
 	sport->port.uartclk = clk_get_rate(sport->clk_per);
+	/*
+	 * Allocate the IRQ(s) i.MX1 has three interrupts whereas later
+	 * chips only have one interrupt.
+	 */
+	if (sport->txirq > 0) {
+		ret = devm_request_irq(&pdev->dev, sport->rxirq, imx_rxint, 0,
+				       dev_name(&pdev->dev), sport);
+		if (ret)
+			return ret;
+		ret = devm_request_irq(&pdev->dev, sport->txirq, imx_txint, 0,
+				       dev_name(&pdev->dev), sport);
+		if (ret)
+			return ret;
+		/* do not use RTS IRQ on IrDA */
+		if (!USE_IRDA(sport)) {
+			ret = devm_request_irq(&pdev->dev, sport->rtsirq,
+					       imx_rtsint, 0,
+					       dev_name(&pdev->dev), sport);
+			if (ret)
+				return ret;
+		}
+	} else {
+		ret = devm_request_irq(&pdev->dev, sport->port.irq, imx_int, 0,
+				       dev_name(&pdev->dev), sport);
+		if (ret)
+			return ret;
+	}
 	imx_ports[sport->port.line] = sport;
 	platform_set_drvdata(pdev, sport);
 static int __init imx_serial_init(void)
 {
-	int ret;
+	int ret = uart_register_driver(&imx_reg);
-	pr_info("Serial: IMX driver\n");
-	ret = uart_register_driver(&imx_reg);
 	if (ret)
 		return ret;

drivers/tty/serial/ip22zilog.c+12−6

 /* The port lock is held and interrupts are disabled.  */
 static void ip22zilog_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct uart_ip22zilog_port *up = (struct uart_ip22zilog_port *) port;
+	struct uart_ip22zilog_port *up =
+		container_of(port, struct uart_ip22zilog_port, port);
 	struct zilog_channel *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char set_bits, clear_bits;
 /* The port lock is held and interrupts are disabled.  */
 static void ip22zilog_stop_tx(struct uart_port *port)
 {
-	struct uart_ip22zilog_port *up = (struct uart_ip22zilog_port *) port;
+	struct uart_ip22zilog_port *up =
+		container_of(port, struct uart_ip22zilog_port, port);
 	up->flags |= IP22ZILOG_FLAG_TX_STOPPED;
 }
 /* The port lock is held and interrupts are disabled.  */
 static void ip22zilog_start_tx(struct uart_port *port)
 {
-	struct uart_ip22zilog_port *up = (struct uart_ip22zilog_port *) port;
+	struct uart_ip22zilog_port *up =
+		container_of(port, struct uart_ip22zilog_port, port);
 	struct zilog_channel *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char status;
 /* The port lock is held.  */
 static void ip22zilog_enable_ms(struct uart_port *port)
 {
-	struct uart_ip22zilog_port *up = (struct uart_ip22zilog_port *) port;
+	struct uart_ip22zilog_port *up =
+		container_of(port, struct uart_ip22zilog_port, port);
 	struct zilog_channel *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char new_reg;
 /* The port lock is not held.  */
 static void ip22zilog_break_ctl(struct uart_port *port, int break_state)
 {
-	struct uart_ip22zilog_port *up = (struct uart_ip22zilog_port *) port;
+	struct uart_ip22zilog_port *up =
+		container_of(port, struct uart_ip22zilog_port, port);
 	struct zilog_channel *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char set_bits, clear_bits, new_reg;
 	unsigned long flags;
 ip22zilog_set_termios(struct uart_port *port, struct ktermios *termios,
 		      struct ktermios *old)
 {
-	struct uart_ip22zilog_port *up = (struct uart_ip22zilog_port *) port;
+	struct uart_ip22zilog_port *up =
+		container_of(port, struct uart_ip22zilog_port, port);
 	unsigned long flags;
 	int baud, brg;

drivers/tty/serial/jsm/Makefile+1−1

@@ -4,5 +4,5 @@ · 3 unmodified lines
4		4
5	obj-$(CONFIG_SERIAL_JSM) += jsm.o	5	obj-$(CONFIG_SERIAL_JSM) += jsm.o
6		6
7	jsm-objs := jsm_driver.o jsm_neo.o jsm_tty.o	7	jsm-objs := jsm_driver.o jsm_neo.o jsm_tty.o jsm_cls.o
8		8

drivers/tty/serial/jsm/jsm.h+79−22

  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  * PURPOSE.  See the GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
- * MA  02111-1307, USA.
- *
  * Contact Information:
  * Scott H Kilau <Scott_Kilau@digi.com>
  * Wendy Xiong   <wendyx@us.ibm.com>
 #define MAX_STOPS_SENT	5
 /* Board ids */
+#define PCI_DEVICE_ID_CLASSIC_4		0x0028
+#define PCI_DEVICE_ID_CLASSIC_8		0x0029
+#define PCI_DEVICE_ID_CLASSIC_4_422	0x00D0
+#define PCI_DEVICE_ID_CLASSIC_8_422	0x00D1
 #define PCI_DEVICE_ID_NEO_4             0x00B0
 #define PCI_DEVICE_ID_NEO_1_422         0x00CC
 #define PCI_DEVICE_ID_NEO_1_422_485     0x00CD
  ************************************************************************/
 struct board_ops {
 	irq_handler_t intr;
-	void (*uart_init) (struct jsm_channel *ch);
+	void (*uart_init)(struct jsm_channel *ch);
-	void (*uart_off) (struct jsm_channel *ch);
+	void (*uart_off)(struct jsm_channel *ch);
-	void (*param) (struct jsm_channel *ch);
+	void (*param)(struct jsm_channel *ch);
-	void (*assert_modem_signals) (struct jsm_channel *ch);
+	void (*assert_modem_signals)(struct jsm_channel *ch);
-	void (*flush_uart_write) (struct jsm_channel *ch);
+	void (*flush_uart_write)(struct jsm_channel *ch);
-	void (*flush_uart_read) (struct jsm_channel *ch);
+	void (*flush_uart_read)(struct jsm_channel *ch);
-	void (*disable_receiver) (struct jsm_channel *ch);
+	void (*disable_receiver)(struct jsm_channel *ch);
-	void (*enable_receiver) (struct jsm_channel *ch);
+	void (*enable_receiver)(struct jsm_channel *ch);
-	void (*send_break) (struct jsm_channel *ch);
+	void (*send_break)(struct jsm_channel *ch);
-	void (*clear_break) (struct jsm_channel *ch, int);
+	void (*clear_break)(struct jsm_channel *ch);
-	void (*send_start_character) (struct jsm_channel *ch);
+	void (*send_start_character)(struct jsm_channel *ch);
-	void (*send_stop_character) (struct jsm_channel *ch);
+	void (*send_stop_character)(struct jsm_channel *ch);
-	void (*copy_data_from_queue_to_uart) (struct jsm_channel *ch);
+	void (*copy_data_from_queue_to_uart)(struct jsm_channel *ch);
-	u32 (*get_uart_bytes_left) (struct jsm_channel *ch);
+	u32 (*get_uart_bytes_left)(struct jsm_channel *ch);
-	void (*send_immediate_char) (struct jsm_channel *ch, unsigned char);
+	void (*send_immediate_char)(struct jsm_channel *ch, unsigned char);
 };
 #define CH_LOOPBACK 0x2000		/* Channel is in lookback mode	*/
 #define CH_BAUD0	0x08000		/* Used for checking B0 transitions */
-/* Our Read/Error/Write queue sizes */
+/* Our Read/Error queue sizes */
 #define RQUEUEMASK	0x1FFF		/* 8 K - 1 */
 #define EQUEUEMASK	0x1FFF		/* 8 K - 1 */
 #define RQUEUESIZE	(RQUEUEMASK + 1)
 	u8		ch_mostat;	/* FEP output modem status	*/
 	u8		ch_mistat;	/* FEP input modem status	*/
-	struct neo_uart_struct __iomem *ch_neo_uart;	/* Pointer to the "mapped" UART struct */
+	/* Pointers to the "mapped" UART structs */
+	struct neo_uart_struct __iomem *ch_neo_uart; /* NEO card */
+	struct cls_uart_struct __iomem *ch_cls_uart; /* Classic card */
 	u8		ch_cached_lsr;	/* Cached value of the LSR register */
 	u8		*ch_rqueue;	/* Our read queue buffer - malloc'ed */
 	u64		ch_xoff_sends;	/* Count of xoffs transmitted */
 };
+/************************************************************************
+ * Per channel/port Classic UART structures				*
+ ************************************************************************
+ *		Base Structure Entries Usage Meanings to Host		*
+ *									*
+ *	W = read write		R = read only				*
+ *			U = Unused.					*
+ ************************************************************************/
+struct cls_uart_struct {
+	u8 txrx;	/* WR  RHR/THR - Holding Reg */
+	u8 ier;		/* WR  IER - Interrupt Enable Reg */
+	u8 isr_fcr;	/* WR  ISR/FCR - Interrupt Status Reg/Fifo Control Reg*/
+	u8 lcr;		/* WR  LCR - Line Control Reg */
+	u8 mcr;		/* WR  MCR - Modem Control Reg */
+	u8 lsr;		/* WR  LSR - Line Status Reg */
+	u8 msr;		/* WR  MSR - Modem Status Reg */
+	u8 spr;		/* WR  SPR - Scratch Pad Reg */
+};
+/* Where to read the interrupt register (8bits) */
+#define UART_CLASSIC_POLL_ADDR_OFFSET	0x40
+#define UART_EXAR654_ENHANCED_REGISTER_SET 0xBF
+#define UART_16654_FCR_TXTRIGGER_8	0x0
+#define UART_16654_FCR_TXTRIGGER_16	0x10
+#define UART_16654_FCR_TXTRIGGER_32	0x20
+#define UART_16654_FCR_TXTRIGGER_56	0x30
+#define UART_16654_FCR_RXTRIGGER_8	0x0
+#define UART_16654_FCR_RXTRIGGER_16	0x40
+#define UART_16654_FCR_RXTRIGGER_56	0x80
+#define UART_16654_FCR_RXTRIGGER_60	0xC0
+#define UART_IIR_CTSRTS			0x20	/* Received CTS/RTS change of state */
+#define UART_IIR_RDI_TIMEOUT		0x0C    /* Receiver data TIMEOUT */
+/*
+ * These are the EXTENDED definitions for the Exar 654's Interrupt
+ * Enable Register.
+ */
+#define UART_EXAR654_EFR_ECB      0x10    /* Enhanced control bit */
+#define UART_EXAR654_EFR_IXON     0x2     /* Receiver compares Xon1/Xoff1 */
+#define UART_EXAR654_EFR_IXOFF    0x8     /* Transmit Xon1/Xoff1 */
+#define UART_EXAR654_EFR_RTSDTR   0x40    /* Auto RTS/DTR Flow Control Enable */
+#define UART_EXAR654_EFR_CTSDSR   0x80    /* Auto CTS/DSR Flow COntrol Enable */
+#define UART_EXAR654_XOFF_DETECT  0x1     /* Indicates whether chip saw an incoming XOFF char  */
+#define UART_EXAR654_XON_DETECT   0x2     /* Indicates whether chip saw an incoming XON char */
+#define UART_EXAR654_IER_XOFF     0x20    /* Xoff Interrupt Enable */
+#define UART_EXAR654_IER_RTSDTR   0x40    /* Output Interrupt Enable */
+#define UART_EXAR654_IER_CTSDSR   0x80    /* Input Interrupt Enable */
 /************************************************************************
  * Per channel/port NEO UART structure					*
  */
 extern struct	uart_driver jsm_uart_driver;
 extern struct	board_ops jsm_neo_ops;
+extern struct	board_ops jsm_cls_ops;
 extern int	jsm_debug;
 /*************************************************************************

drivers/tty/serial/jsm/jsm_cls.c+982−0

@@ -0,0 +1,982 @@
	1	/*
	2	* Copyright 2003 Digi International (www.digi.com)
	3	* Scott H Kilau <Scott_Kilau at digi dot com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2, or (at your option)
	8	* any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
	12	* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
	13	* PURPOSE. See the GNU General Public License for more details.
	14	*
	15	* NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE!
	16	*
	17	* This is shared code between Digi's CVS archive and the
	18	* Linux Kernel sources.
	19	* Changing the source just for reformatting needlessly breaks
	20	* our CVS diff history.
	21	*
	22	* Send any bug fixes/changes to: Eng.Linux at digi dot com.
	23	* Thank you.
	24	*
	25	*/
	26
	27	#include <linux/delay.h> /* For udelay */
	28	#include <linux/io.h> /* For read[bwl]/write[bwl] */
	29	#include <linux/serial.h> /* For struct async_serial */
	30	#include <linux/serial_reg.h> /* For the various UART offsets */
	31	#include <linux/pci.h>
	32	#include <linux/tty.h>
	33
	34	#include "jsm.h" /* Driver main header file */
	35
	36	static struct {
	37	unsigned int rate;
	38	unsigned int cflag;
	39	} baud_rates[] = {
	40	{ 921600, B921600 },
	41	{ 460800, B460800 },
	42	{ 230400, B230400 },
	43	{ 115200, B115200 },
	44	{ 57600, B57600 },
	45	{ 38400, B38400 },
	46	{ 19200, B19200 },
	47	{ 9600, B9600 },
	48	{ 4800, B4800 },
	49	{ 2400, B2400 },
	50	{ 1200, B1200 },
	51	{ 600, B600 },
	52	{ 300, B300 },
	53	{ 200, B200 },
	54	{ 150, B150 },
	55	{ 134, B134 },
	56	{ 110, B110 },
	57	{ 75, B75 },
	58	{ 50, B50 },
	59	};
	60
	61	static void cls_set_cts_flow_control(struct jsm_channel *ch)
	62	{
	63	u8 lcrb = readb(&ch->ch_cls_uart->lcr);
	64	u8 ier = readb(&ch->ch_cls_uart->ier);
	65	u8 isr_fcr = 0;
	66
	67	/*
	68	* The Enhanced Register Set may only be accessed when
	69	* the Line Control Register is set to 0xBFh.
	70	*/
	71	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	72
	73	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	74
	75	/* Turn on CTS flow control, turn off IXON flow control */
	76	isr_fcr \|= (UART_EXAR654_EFR_ECB \| UART_EXAR654_EFR_CTSDSR);
	77	isr_fcr &= ~(UART_EXAR654_EFR_IXON);
	78
	79	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	80
	81	/* Write old LCR value back out, which turns enhanced access off */
	82	writeb(lcrb, &ch->ch_cls_uart->lcr);
	83
	84	/*
	85	* Enable interrupts for CTS flow, turn off interrupts for
	86	* received XOFF chars
	87	*/
	88	ier \|= (UART_EXAR654_IER_CTSDSR);
	89	ier &= ~(UART_EXAR654_IER_XOFF);
	90	writeb(ier, &ch->ch_cls_uart->ier);
	91
	92	/* Set the usual FIFO values */
	93	writeb((UART_FCR_ENABLE_FIFO), &ch->ch_cls_uart->isr_fcr);
	94
	95	writeb((UART_FCR_ENABLE_FIFO \| UART_16654_FCR_RXTRIGGER_56 \|
	96	UART_16654_FCR_TXTRIGGER_16 \| UART_FCR_CLEAR_RCVR),
	97	&ch->ch_cls_uart->isr_fcr);
	98
	99	ch->ch_t_tlevel = 16;
	100	}
	101
	102	static void cls_set_ixon_flow_control(struct jsm_channel *ch)
	103	{
	104	u8 lcrb = readb(&ch->ch_cls_uart->lcr);
	105	u8 ier = readb(&ch->ch_cls_uart->ier);
	106	u8 isr_fcr = 0;
	107
	108	/*
	109	* The Enhanced Register Set may only be accessed when
	110	* the Line Control Register is set to 0xBFh.
	111	*/
	112	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	113
	114	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	115
	116	/* Turn on IXON flow control, turn off CTS flow control */
	117	isr_fcr \|= (UART_EXAR654_EFR_ECB \| UART_EXAR654_EFR_IXON);
	118	isr_fcr &= ~(UART_EXAR654_EFR_CTSDSR);
	119
	120	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	121
	122	/* Now set our current start/stop chars while in enhanced mode */
	123	writeb(ch->ch_startc, &ch->ch_cls_uart->mcr);
	124	writeb(0, &ch->ch_cls_uart->lsr);
	125	writeb(ch->ch_stopc, &ch->ch_cls_uart->msr);
	126	writeb(0, &ch->ch_cls_uart->spr);
	127
	128	/* Write old LCR value back out, which turns enhanced access off */
	129	writeb(lcrb, &ch->ch_cls_uart->lcr);
	130
	131	/*
	132	* Disable interrupts for CTS flow, turn on interrupts for
	133	* received XOFF chars
	134	*/
	135	ier &= ~(UART_EXAR654_IER_CTSDSR);
	136	ier \|= (UART_EXAR654_IER_XOFF);
	137	writeb(ier, &ch->ch_cls_uart->ier);
	138
	139	/* Set the usual FIFO values */
	140	writeb((UART_FCR_ENABLE_FIFO), &ch->ch_cls_uart->isr_fcr);
	141
	142	writeb((UART_FCR_ENABLE_FIFO \| UART_16654_FCR_RXTRIGGER_16 \|
	143	UART_16654_FCR_TXTRIGGER_16 \| UART_FCR_CLEAR_RCVR),
	144	&ch->ch_cls_uart->isr_fcr);
	145	}
	146
	147	static void cls_set_no_output_flow_control(struct jsm_channel *ch)
	148	{
	149	u8 lcrb = readb(&ch->ch_cls_uart->lcr);
	150	u8 ier = readb(&ch->ch_cls_uart->ier);
	151	u8 isr_fcr = 0;
	152
	153	/*
	154	* The Enhanced Register Set may only be accessed when
	155	* the Line Control Register is set to 0xBFh.
	156	*/
	157	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	158
	159	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	160
	161	/* Turn off IXON flow control, turn off CTS flow control */
	162	isr_fcr \|= (UART_EXAR654_EFR_ECB);
	163	isr_fcr &= ~(UART_EXAR654_EFR_CTSDSR \| UART_EXAR654_EFR_IXON);
	164
	165	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	166
	167	/* Write old LCR value back out, which turns enhanced access off */
	168	writeb(lcrb, &ch->ch_cls_uart->lcr);
	169
	170	/*
	171	* Disable interrupts for CTS flow, turn off interrupts for
	172	* received XOFF chars
	173	*/
	174	ier &= ~(UART_EXAR654_IER_CTSDSR);
	175	ier &= ~(UART_EXAR654_IER_XOFF);
	176	writeb(ier, &ch->ch_cls_uart->ier);
	177
	178	/* Set the usual FIFO values */
	179	writeb((UART_FCR_ENABLE_FIFO), &ch->ch_cls_uart->isr_fcr);
	180
	181	writeb((UART_FCR_ENABLE_FIFO \| UART_16654_FCR_RXTRIGGER_16 \|
	182	UART_16654_FCR_TXTRIGGER_16 \| UART_FCR_CLEAR_RCVR),
	183	&ch->ch_cls_uart->isr_fcr);
	184
	185	ch->ch_r_watermark = 0;
	186	ch->ch_t_tlevel = 16;
	187	ch->ch_r_tlevel = 16;
	188	}
	189
	190	static void cls_set_rts_flow_control(struct jsm_channel *ch)
	191	{
	192	u8 lcrb = readb(&ch->ch_cls_uart->lcr);
	193	u8 ier = readb(&ch->ch_cls_uart->ier);
	194	u8 isr_fcr = 0;
	195
	196	/*
	197	* The Enhanced Register Set may only be accessed when
	198	* the Line Control Register is set to 0xBFh.
	199	*/
	200	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	201
	202	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	203
	204	/* Turn on RTS flow control, turn off IXOFF flow control */
	205	isr_fcr \|= (UART_EXAR654_EFR_ECB \| UART_EXAR654_EFR_RTSDTR);
	206	isr_fcr &= ~(UART_EXAR654_EFR_IXOFF);
	207
	208	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	209
	210	/* Write old LCR value back out, which turns enhanced access off */
	211	writeb(lcrb, &ch->ch_cls_uart->lcr);
	212
	213	/* Enable interrupts for RTS flow */
	214	ier \|= (UART_EXAR654_IER_RTSDTR);
	215	writeb(ier, &ch->ch_cls_uart->ier);
	216
	217	/* Set the usual FIFO values */
	218	writeb((UART_FCR_ENABLE_FIFO), &ch->ch_cls_uart->isr_fcr);
	219
	220	writeb((UART_FCR_ENABLE_FIFO \| UART_16654_FCR_RXTRIGGER_56 \|
	221	UART_16654_FCR_TXTRIGGER_16 \| UART_FCR_CLEAR_RCVR),
	222	&ch->ch_cls_uart->isr_fcr);
	223
	224	ch->ch_r_watermark = 4;
	225	ch->ch_r_tlevel = 8;
	226	}
	227
	228	static void cls_set_ixoff_flow_control(struct jsm_channel *ch)
	229	{
	230	u8 lcrb = readb(&ch->ch_cls_uart->lcr);
	231	u8 ier = readb(&ch->ch_cls_uart->ier);
	232	u8 isr_fcr = 0;
	233
	234	/*
	235	* The Enhanced Register Set may only be accessed when
	236	* the Line Control Register is set to 0xBFh.
	237	*/
	238	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	239
	240	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	241
	242	/* Turn on IXOFF flow control, turn off RTS flow control */
	243	isr_fcr \|= (UART_EXAR654_EFR_ECB \| UART_EXAR654_EFR_IXOFF);
	244	isr_fcr &= ~(UART_EXAR654_EFR_RTSDTR);
	245
	246	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	247
	248	/* Now set our current start/stop chars while in enhanced mode */
	249	writeb(ch->ch_startc, &ch->ch_cls_uart->mcr);
	250	writeb(0, &ch->ch_cls_uart->lsr);
	251	writeb(ch->ch_stopc, &ch->ch_cls_uart->msr);
	252	writeb(0, &ch->ch_cls_uart->spr);
	253
	254	/* Write old LCR value back out, which turns enhanced access off */
	255	writeb(lcrb, &ch->ch_cls_uart->lcr);
	256
	257	/* Disable interrupts for RTS flow */
	258	ier &= ~(UART_EXAR654_IER_RTSDTR);
	259	writeb(ier, &ch->ch_cls_uart->ier);
	260
	261	/* Set the usual FIFO values */
	262	writeb((UART_FCR_ENABLE_FIFO), &ch->ch_cls_uart->isr_fcr);
	263
	264	writeb((UART_FCR_ENABLE_FIFO \| UART_16654_FCR_RXTRIGGER_16 \|
	265	UART_16654_FCR_TXTRIGGER_16 \| UART_FCR_CLEAR_RCVR),
	266	&ch->ch_cls_uart->isr_fcr);
	267	}
	268
	269	static void cls_set_no_input_flow_control(struct jsm_channel *ch)
	270	{
	271	u8 lcrb = readb(&ch->ch_cls_uart->lcr);
	272	u8 ier = readb(&ch->ch_cls_uart->ier);
	273	u8 isr_fcr = 0;
	274
	275	/*
	276	* The Enhanced Register Set may only be accessed when
	277	* the Line Control Register is set to 0xBFh.
	278	*/
	279	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	280
	281	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	282
	283	/* Turn off IXOFF flow control, turn off RTS flow control */
	284	isr_fcr \|= (UART_EXAR654_EFR_ECB);
	285	isr_fcr &= ~(UART_EXAR654_EFR_RTSDTR \| UART_EXAR654_EFR_IXOFF);
	286
	287	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	288
	289	/* Write old LCR value back out, which turns enhanced access off */
	290	writeb(lcrb, &ch->ch_cls_uart->lcr);
	291
	292	/* Disable interrupts for RTS flow */
	293	ier &= ~(UART_EXAR654_IER_RTSDTR);
	294	writeb(ier, &ch->ch_cls_uart->ier);
	295
	296	/* Set the usual FIFO values */
	297	writeb((UART_FCR_ENABLE_FIFO), &ch->ch_cls_uart->isr_fcr);
	298
	299	writeb((UART_FCR_ENABLE_FIFO \| UART_16654_FCR_RXTRIGGER_16 \|
	300	UART_16654_FCR_TXTRIGGER_16 \| UART_FCR_CLEAR_RCVR),
	301	&ch->ch_cls_uart->isr_fcr);
	302
	303	ch->ch_t_tlevel = 16;
	304	ch->ch_r_tlevel = 16;
	305	}
	306
	307	/*
	308	* cls_clear_break.
	309	* Determines whether its time to shut off break condition.
	310	*
	311	* No locks are assumed to be held when calling this function.
	312	* channel lock is held and released in this function.
	313	*/
	314	static void cls_clear_break(struct jsm_channel *ch)
	315	{
	316	unsigned long lock_flags;
	317
	318	spin_lock_irqsave(&ch->ch_lock, lock_flags);
	319
	320	/* Turn break off, and unset some variables */
	321	if (ch->ch_flags & CH_BREAK_SENDING) {
	322	u8 temp = readb(&ch->ch_cls_uart->lcr);
	323
	324	writeb((temp & ~UART_LCR_SBC), &ch->ch_cls_uart->lcr);
	325
	326	ch->ch_flags &= ~(CH_BREAK_SENDING);
	327	jsm_dbg(IOCTL, &ch->ch_bd->pci_dev,
	328	"clear break Finishing UART_LCR_SBC! finished: %lx\n",
	329	jiffies);
	330	}
	331	spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
	332	}
	333
	334	static void cls_disable_receiver(struct jsm_channel *ch)
	335	{
	336	u8 tmp = readb(&ch->ch_cls_uart->ier);
	337
	338	tmp &= ~(UART_IER_RDI);
	339	writeb(tmp, &ch->ch_cls_uart->ier);
	340	}
	341
	342	static void cls_enable_receiver(struct jsm_channel *ch)
	343	{
	344	u8 tmp = readb(&ch->ch_cls_uart->ier);
	345
	346	tmp \|= (UART_IER_RDI);
	347	writeb(tmp, &ch->ch_cls_uart->ier);
	348	}
	349
	350	/* Make the UART raise any of the output signals we want up */
	351	static void cls_assert_modem_signals(struct jsm_channel *ch)
	352	{
	353	if (!ch)
	354	return;
	355
	356	writeb(ch->ch_mostat, &ch->ch_cls_uart->mcr);
	357	}
	358
	359	static void cls_copy_data_from_uart_to_queue(struct jsm_channel *ch)
	360	{
	361	int qleft = 0;
	362	u8 linestatus = 0;
	363	u8 error_mask = 0;
	364	u16 head;
	365	u16 tail;
	366	unsigned long flags;
	367
	368	if (!ch)
	369	return;
	370
	371	spin_lock_irqsave(&ch->ch_lock, flags);
	372
	373	/* cache head and tail of queue */
	374	head = ch->ch_r_head & RQUEUEMASK;
	375	tail = ch->ch_r_tail & RQUEUEMASK;
	376
	377	/* Get our cached LSR */
	378	linestatus = ch->ch_cached_lsr;
	379	ch->ch_cached_lsr = 0;
	380
	381	/* Store how much space we have left in the queue */
	382	qleft = tail - head - 1;
	383	if (qleft < 0)
	384	qleft += RQUEUEMASK + 1;
	385
	386	/*
	387	* Create a mask to determine whether we should
	388	* insert the character (if any) into our queue.
	389	*/
	390	if (ch->ch_c_iflag & IGNBRK)
	391	error_mask \|= UART_LSR_BI;
	392
	393	while (1) {
	394	/*
	395	* Grab the linestatus register, we need to
	396	* check to see if there is any data to read
	397	*/
	398	linestatus = readb(&ch->ch_cls_uart->lsr);
	399
	400	/* Break out if there is no data to fetch */
	401	if (!(linestatus & UART_LSR_DR))
	402	break;
	403
	404	/*
	405	* Discard character if we are ignoring the error mask
	406	* which in this case is the break signal.
	407	*/
	408	if (linestatus & error_mask) {
	409	u8 discard;
	410
	411	linestatus = 0;
	412	discard = readb(&ch->ch_cls_uart->txrx);
	413	continue;
	414	}
	415
	416	/*
	417	* If our queue is full, we have no choice but to drop some
	418	* data. The assumption is that HWFLOW or SWFLOW should have
	419	* stopped things way way before we got to this point.
	420	*
	421	* I decided that I wanted to ditch the oldest data first,
	422	* I hope thats okay with everyone? Yes? Good.
	423	*/
	424	while (qleft < 1) {
	425	tail = (tail + 1) & RQUEUEMASK;
	426	ch->ch_r_tail = tail;
	427	ch->ch_err_overrun++;
	428	qleft++;
	429	}
	430
	431	ch->ch_equeue[head] = linestatus & (UART_LSR_BI \| UART_LSR_PE
	432	\| UART_LSR_FE);
	433	ch->ch_rqueue[head] = readb(&ch->ch_cls_uart->txrx);
	434
	435	qleft--;
	436
	437	if (ch->ch_equeue[head] & UART_LSR_PE)
	438	ch->ch_err_parity++;
	439	if (ch->ch_equeue[head] & UART_LSR_BI)
	440	ch->ch_err_break++;
	441	if (ch->ch_equeue[head] & UART_LSR_FE)
	442	ch->ch_err_frame++;
	443
	444	/* Add to, and flip head if needed */
	445	head = (head + 1) & RQUEUEMASK;
	446	ch->ch_rxcount++;
	447	}
	448
	449	/*
	450	* Write new final heads to channel structure.
	451	*/
	452	ch->ch_r_head = head & RQUEUEMASK;
	453	ch->ch_e_head = head & EQUEUEMASK;
	454
	455	spin_unlock_irqrestore(&ch->ch_lock, flags);
	456	}
	457
	458	static void cls_copy_data_from_queue_to_uart(struct jsm_channel *ch)
	459	{
	460	u16 tail;
	461	int n;
	462	int qlen;
	463	u32 len_written = 0;
	464	struct circ_buf *circ;
	465
	466	if (!ch)
	467	return;
	468
	469	circ = &ch->uart_port.state->xmit;
	470
	471	/* No data to write to the UART */
	472	if (uart_circ_empty(circ))
	473	return;
	474
	475	/* If port is "stopped", don't send any data to the UART */
	476	if ((ch->ch_flags & CH_STOP) \|\| (ch->ch_flags & CH_BREAK_SENDING))
	477	return;
	478
	479	/* We have to do it this way, because of the EXAR TXFIFO count bug. */
	480	if (!(ch->ch_flags & (CH_TX_FIFO_EMPTY \| CH_TX_FIFO_LWM)))
	481	return;
	482
	483	n = 32;
	484
	485	/* cache tail of queue */
	486	tail = circ->tail & (UART_XMIT_SIZE - 1);
	487	qlen = uart_circ_chars_pending(circ);
	488
	489	/* Find minimum of the FIFO space, versus queue length */
	490	n = min(n, qlen);
	491
	492	while (n > 0) {
	493	writeb(circ->buf[tail], &ch->ch_cls_uart->txrx);
	494	tail = (tail + 1) & (UART_XMIT_SIZE - 1);
	495	n--;
	496	ch->ch_txcount++;
	497	len_written++;
	498	}
	499
	500	/* Update the final tail */
	501	circ->tail = tail & (UART_XMIT_SIZE - 1);
	502
	503	if (len_written > ch->ch_t_tlevel)
	504	ch->ch_flags &= ~(CH_TX_FIFO_EMPTY \| CH_TX_FIFO_LWM);
	505
	506	if (uart_circ_empty(circ))
	507	uart_write_wakeup(&ch->uart_port);
	508	}
	509
	510	static void cls_parse_modem(struct jsm_channel *ch, u8 signals)
	511	{
	512	u8 msignals = signals;
	513
	514	jsm_dbg(MSIGS, &ch->ch_bd->pci_dev,
	515	"neo_parse_modem: port: %d msignals: %x\n",
	516	ch->ch_portnum, msignals);
	517
	518	/*
	519	* Scrub off lower bits.
	520	* They signify delta's, which I don't care about
	521	* Keep DDCD and DDSR though
	522	*/
	523	msignals &= 0xf8;
	524
	525	if (msignals & UART_MSR_DDCD)
	526	uart_handle_dcd_change(&ch->uart_port, msignals & UART_MSR_DCD);
	527	if (msignals & UART_MSR_DDSR)
	528	uart_handle_dcd_change(&ch->uart_port, msignals & UART_MSR_CTS);
	529
	530	if (msignals & UART_MSR_DCD)
	531	ch->ch_mistat \|= UART_MSR_DCD;
	532	else
	533	ch->ch_mistat &= ~UART_MSR_DCD;
	534
	535	if (msignals & UART_MSR_DSR)
	536	ch->ch_mistat \|= UART_MSR_DSR;
	537	else
	538	ch->ch_mistat &= ~UART_MSR_DSR;
	539
	540	if (msignals & UART_MSR_RI)
	541	ch->ch_mistat \|= UART_MSR_RI;
	542	else
	543	ch->ch_mistat &= ~UART_MSR_RI;
	544
	545	if (msignals & UART_MSR_CTS)
	546	ch->ch_mistat \|= UART_MSR_CTS;
	547	else
	548	ch->ch_mistat &= ~UART_MSR_CTS;
	549
	550	jsm_dbg(MSIGS, &ch->ch_bd->pci_dev,
	551	"Port: %d DTR: %d RTS: %d CTS: %d DSR: %d " "RI: %d CD: %d\n",
	552	ch->ch_portnum,
	553	!!((ch->ch_mistat \| ch->ch_mostat) & UART_MCR_DTR),
	554	!!((ch->ch_mistat \| ch->ch_mostat) & UART_MCR_RTS),
	555	!!((ch->ch_mistat \| ch->ch_mostat) & UART_MSR_CTS),
	556	!!((ch->ch_mistat \| ch->ch_mostat) & UART_MSR_DSR),
	557	!!((ch->ch_mistat \| ch->ch_mostat) & UART_MSR_RI),
	558	!!((ch->ch_mistat \| ch->ch_mostat) & UART_MSR_DCD));
	559	}
	560
	561	/* Parse the ISR register for the specific port */
	562	static inline void cls_parse_isr(struct jsm_board *brd, uint port)
	563	{
	564	struct jsm_channel *ch;
	565	u8 isr = 0;
	566	unsigned long flags;
	567
	568	/*
	569	* No need to verify board pointer, it was already
	570	* verified in the interrupt routine.
	571	*/
	572
	573	if (port > brd->nasync)
	574	return;
	575
	576	ch = brd->channels[port];
	577	if (!ch)
	578	return;
	579
	580	/* Here we try to figure out what caused the interrupt to happen */
	581	while (1) {
	582	isr = readb(&ch->ch_cls_uart->isr_fcr);
	583
	584	/* Bail if no pending interrupt on port */
	585	if (isr & UART_IIR_NO_INT)
	586	break;
	587
	588	/* Receive Interrupt pending */
	589	if (isr & (UART_IIR_RDI \| UART_IIR_RDI_TIMEOUT)) {
	590	/* Read data from uart -> queue */
	591	cls_copy_data_from_uart_to_queue(ch);
	592	jsm_check_queue_flow_control(ch);
	593	}
	594
	595	/* Transmit Hold register empty pending */
	596	if (isr & UART_IIR_THRI) {
	597	/* Transfer data (if any) from Write Queue -> UART. */
	598	spin_lock_irqsave(&ch->ch_lock, flags);
	599	ch->ch_flags \|= (CH_TX_FIFO_EMPTY \| CH_TX_FIFO_LWM);
	600	spin_unlock_irqrestore(&ch->ch_lock, flags);
	601	cls_copy_data_from_queue_to_uart(ch);
	602	}
	603
	604	/*
	605	* CTS/RTS change of state:
	606	* Don't need to do anything, the cls_parse_modem
	607	* below will grab the updated modem signals.
	608	*/
	609
	610	/* Parse any modem signal changes */
	611	cls_parse_modem(ch, readb(&ch->ch_cls_uart->msr));
	612	}
	613	}
	614
	615	/* Channel lock MUST be held before calling this function! */
	616	static void cls_flush_uart_write(struct jsm_channel *ch)
	617	{
	618	u8 tmp = 0;
	619	u8 i = 0;
	620
	621	if (!ch)
	622	return;
	623
	624	writeb((UART_FCR_ENABLE_FIFO \| UART_FCR_CLEAR_XMIT),
	625	&ch->ch_cls_uart->isr_fcr);
	626
	627	for (i = 0; i < 10; i++) {
	628	/* Check to see if the UART feels it completely flushed FIFO */
	629	tmp = readb(&ch->ch_cls_uart->isr_fcr);
	630	if (tmp & UART_FCR_CLEAR_XMIT) {
	631	jsm_dbg(IOCTL, &ch->ch_bd->pci_dev,
	632	"Still flushing TX UART... i: %d\n", i);
	633	udelay(10);
	634	} else
	635	break;
	636	}
	637
	638	ch->ch_flags \|= (CH_TX_FIFO_EMPTY \| CH_TX_FIFO_LWM);
	639	}
	640
	641	/* Channel lock MUST be held before calling this function! */
	642	static void cls_flush_uart_read(struct jsm_channel *ch)
	643	{
	644	if (!ch)
	645	return;
	646
	647	/*
	648	* For complete POSIX compatibility, we should be purging the
	649	* read FIFO in the UART here.
	650	*
	651	* However, clearing the read FIFO (UART_FCR_CLEAR_RCVR) also
	652	* incorrectly flushes write data as well as just basically trashing the
	653	* FIFO.
	654	*
	655	* Presumably, this is a bug in this UART.
	656	*/
	657
	658	udelay(10);
	659	}
	660
	661	static void cls_send_start_character(struct jsm_channel *ch)
	662	{
	663	if (!ch)
	664	return;
	665
	666	if (ch->ch_startc != __DISABLED_CHAR) {
	667	ch->ch_xon_sends++;
	668	writeb(ch->ch_startc, &ch->ch_cls_uart->txrx);
	669	}
	670	}
	671
	672	static void cls_send_stop_character(struct jsm_channel *ch)
	673	{
	674	if (!ch)
	675	return;
	676
	677	if (ch->ch_stopc != __DISABLED_CHAR) {
	678	ch->ch_xoff_sends++;
	679	writeb(ch->ch_stopc, &ch->ch_cls_uart->txrx);
	680	}
	681	}
	682
	683	/*
	684	* cls_param()
	685	* Send any/all changes to the line to the UART.
	686	*/
	687	static void cls_param(struct jsm_channel *ch)
	688	{
	689	u8 lcr = 0;
	690	u8 uart_lcr = 0;
	691	u8 ier = 0;
	692	u32 baud = 9600;
	693	int quot = 0;
	694	struct jsm_board *bd;
	695	int i;
	696	unsigned int cflag;
	697
	698	bd = ch->ch_bd;
	699	if (!bd)
	700	return;
	701
	702	/*
	703	* If baud rate is zero, flush queues, and set mval to drop DTR.
	704	*/
	705	if ((ch->ch_c_cflag & (CBAUD)) == 0) {
	706	ch->ch_r_head = 0;
	707	ch->ch_r_tail = 0;
	708	ch->ch_e_head = 0;
	709	ch->ch_e_tail = 0;
	710
	711	cls_flush_uart_write(ch);
	712	cls_flush_uart_read(ch);
	713
	714	/* The baudrate is B0 so all modem lines are to be dropped. */
	715	ch->ch_flags \|= (CH_BAUD0);
	716	ch->ch_mostat &= ~(UART_MCR_RTS \| UART_MCR_DTR);
	717	cls_assert_modem_signals(ch);
	718	return;
	719	}
	720
	721	cflag = C_BAUD(ch->uart_port.state->port.tty);
	722	baud = 9600;
	723	for (i = 0; i < ARRAY_SIZE(baud_rates); i++) {
	724	if (baud_rates[i].cflag == cflag) {
	725	baud = baud_rates[i].rate;
	726	break;
	727	}
	728	}
	729
	730	if (ch->ch_flags & CH_BAUD0)
	731	ch->ch_flags &= ~(CH_BAUD0);
	732
	733	if (ch->ch_c_cflag & PARENB)
	734	lcr \|= UART_LCR_PARITY;
	735
	736	if (!(ch->ch_c_cflag & PARODD))
	737	lcr \|= UART_LCR_EPAR;
	738
	739	/*
	740	* Not all platforms support mark/space parity,
	741	* so this will hide behind an ifdef.
	742	*/
	743	#ifdef CMSPAR
	744	if (ch->ch_c_cflag & CMSPAR)
	745	lcr \|= UART_LCR_SPAR;
	746	#endif
	747
	748	if (ch->ch_c_cflag & CSTOPB)
	749	lcr \|= UART_LCR_STOP;
	750
	751	switch (ch->ch_c_cflag & CSIZE) {
	752	case CS5:
	753	lcr \|= UART_LCR_WLEN5;
	754	break;
	755	case CS6:
	756	lcr \|= UART_LCR_WLEN6;
	757	break;
	758	case CS7:
	759	lcr \|= UART_LCR_WLEN7;
	760	break;
	761	case CS8:
	762	default:
	763	lcr \|= UART_LCR_WLEN8;
	764	break;
	765	}
	766
	767	ier = readb(&ch->ch_cls_uart->ier);
	768	uart_lcr = readb(&ch->ch_cls_uart->lcr);
	769
	770	quot = ch->ch_bd->bd_dividend / baud;
	771
	772	if (quot != 0) {
	773	writeb(UART_LCR_DLAB, &ch->ch_cls_uart->lcr);
	774	writeb((quot & 0xff), &ch->ch_cls_uart->txrx);
	775	writeb((quot >> 8), &ch->ch_cls_uart->ier);
	776	writeb(lcr, &ch->ch_cls_uart->lcr);
	777	}
	778
	779	if (uart_lcr != lcr)
	780	writeb(lcr, &ch->ch_cls_uart->lcr);
	781
	782	if (ch->ch_c_cflag & CREAD)
	783	ier \|= (UART_IER_RDI \| UART_IER_RLSI);
	784
	785	ier \|= (UART_IER_THRI \| UART_IER_MSI);
	786
	787	writeb(ier, &ch->ch_cls_uart->ier);
	788
	789	if (ch->ch_c_cflag & CRTSCTS)
	790	cls_set_cts_flow_control(ch);
	791	else if (ch->ch_c_iflag & IXON) {
	792	/*
	793	* If start/stop is set to disable,
	794	* then we should disable flow control.
	795	*/
	796	if ((ch->ch_startc == __DISABLED_CHAR) \|\|
	797	(ch->ch_stopc == __DISABLED_CHAR))
	798	cls_set_no_output_flow_control(ch);
	799	else
	800	cls_set_ixon_flow_control(ch);
	801	} else
	802	cls_set_no_output_flow_control(ch);
	803
	804	if (ch->ch_c_cflag & CRTSCTS)
	805	cls_set_rts_flow_control(ch);
	806	else if (ch->ch_c_iflag & IXOFF) {
	807	/*
	808	* If start/stop is set to disable,
	809	* then we should disable flow control.
	810	*/
	811	if ((ch->ch_startc == __DISABLED_CHAR) \|\|
	812	(ch->ch_stopc == __DISABLED_CHAR))
	813	cls_set_no_input_flow_control(ch);
	814	else
	815	cls_set_ixoff_flow_control(ch);
	816	} else
	817	cls_set_no_input_flow_control(ch);
	818
	819	cls_assert_modem_signals(ch);
	820
	821	/* get current status of the modem signals now */
	822	cls_parse_modem(ch, readb(&ch->ch_cls_uart->msr));
	823	}
	824
	825	/*
	826	* cls_intr()
	827	*
	828	* Classic specific interrupt handler.
	829	*/
	830	static irqreturn_t cls_intr(int irq, void *voidbrd)
	831	{
	832	struct jsm_board *brd = voidbrd;
	833	unsigned long lock_flags;
	834	unsigned char uart_poll;
	835	uint i = 0;
	836
	837	/* Lock out the slow poller from running on this board. */
	838	spin_lock_irqsave(&brd->bd_intr_lock, lock_flags);
	839
	840	/*
	841	* Check the board's global interrupt offset to see if we
	842	* acctually do have an interrupt pending on us.
	843	*/
	844	uart_poll = readb(brd->re_map_membase + UART_CLASSIC_POLL_ADDR_OFFSET);
	845
	846	jsm_dbg(INTR, &brd->pci_dev, "%s:%d uart_poll: %x\n",
	847	__FILE__, __LINE__, uart_poll);
	848
	849	if (!uart_poll) {
	850	jsm_dbg(INTR, &brd->pci_dev,
	851	"Kernel interrupted to me, but no pending interrupts...\n");
	852	spin_unlock_irqrestore(&brd->bd_intr_lock, lock_flags);
	853	return IRQ_NONE;
	854	}
	855
	856	/* At this point, we have at least SOMETHING to service, dig further. */
	857
	858	/* Parse each port to find out what caused the interrupt */
	859	for (i = 0; i < brd->nasync; i++)
	860	cls_parse_isr(brd, i);
	861
	862	spin_unlock_irqrestore(&brd->bd_intr_lock, lock_flags);
	863
	864	return IRQ_HANDLED;
	865	}
	866
	867	/* Inits UART */
	868	static void cls_uart_init(struct jsm_channel *ch)
	869	{
	870	unsigned char lcrb = readb(&ch->ch_cls_uart->lcr);
	871	unsigned char isr_fcr = 0;
	872
	873	writeb(0, &ch->ch_cls_uart->ier);
	874
	875	/*
	876	* The Enhanced Register Set may only be accessed when
	877	* the Line Control Register is set to 0xBFh.
	878	*/
	879	writeb(UART_EXAR654_ENHANCED_REGISTER_SET, &ch->ch_cls_uart->lcr);
	880
	881	isr_fcr = readb(&ch->ch_cls_uart->isr_fcr);
	882
	883	/* Turn on Enhanced/Extended controls */
	884	isr_fcr \|= (UART_EXAR654_EFR_ECB);
	885
	886	writeb(isr_fcr, &ch->ch_cls_uart->isr_fcr);
	887
	888	/* Write old LCR value back out, which turns enhanced access off */
	889	writeb(lcrb, &ch->ch_cls_uart->lcr);
	890
	891	/* Clear out UART and FIFO */
	892	readb(&ch->ch_cls_uart->txrx);
	893
	894	writeb((UART_FCR_ENABLE_FIFO\|UART_FCR_CLEAR_RCVR\|UART_FCR_CLEAR_XMIT),
	895	&ch->ch_cls_uart->isr_fcr);
	896	udelay(10);
	897
	898	ch->ch_flags \|= (CH_FIFO_ENABLED \| CH_TX_FIFO_EMPTY \| CH_TX_FIFO_LWM);
	899
	900	readb(&ch->ch_cls_uart->lsr);
	901	readb(&ch->ch_cls_uart->msr);
	902	}
	903
	904	/*
	905	* Turns off UART.
	906	*/
	907	static void cls_uart_off(struct jsm_channel *ch)
	908	{
	909	/* Stop all interrupts from accurring. */
	910	writeb(0, &ch->ch_cls_uart->ier);
	911	}
	912
	913	/*
	914	* cls_get_uarts_bytes_left.
	915	* Returns 0 is nothing left in the FIFO, returns 1 otherwise.
	916	*
	917	* The channel lock MUST be held by the calling function.
	918	*/
	919	static u32 cls_get_uart_bytes_left(struct jsm_channel *ch)
	920	{
	921	u8 left = 0;
	922	u8 lsr = readb(&ch->ch_cls_uart->lsr);
	923
	924	/* Determine whether the Transmitter is empty or not */
	925	if (!(lsr & UART_LSR_TEMT))
	926	left = 1;
	927	else {
	928	ch->ch_flags \|= (CH_TX_FIFO_EMPTY \| CH_TX_FIFO_LWM);
	929	left = 0;
	930	}
	931
	932	return left;
	933	}
	934
	935	/*
	936	* cls_send_break.
	937	* Starts sending a break thru the UART.
	938	*
	939	* The channel lock MUST be held by the calling function.
	940	*/
	941	static void cls_send_break(struct jsm_channel *ch)
	942	{
	943	/* Tell the UART to start sending the break */
	944	if (!(ch->ch_flags & CH_BREAK_SENDING)) {
	945	u8 temp = readb(&ch->ch_cls_uart->lcr);
	946
	947	writeb((temp \| UART_LCR_SBC), &ch->ch_cls_uart->lcr);
	948	ch->ch_flags \|= (CH_BREAK_SENDING);
	949	}
	950	}
	951
	952	/*
	953	* cls_send_immediate_char.
	954	* Sends a specific character as soon as possible to the UART,
	955	* jumping over any bytes that might be in the write queue.
	956	*
	957	* The channel lock MUST be held by the calling function.
	958	*/
	959	static void cls_send_immediate_char(struct jsm_channel *ch, unsigned char c)
	960	{
	961	writeb(c, &ch->ch_cls_uart->txrx);
	962	}
	963
	964	struct board_ops jsm_cls_ops = {
	965	.intr = cls_intr,
	966	.uart_init = cls_uart_init,
	967	.uart_off = cls_uart_off,
	968	.param = cls_param,
	969	.assert_modem_signals = cls_assert_modem_signals,
	970	.flush_uart_write = cls_flush_uart_write,
	971	.flush_uart_read = cls_flush_uart_read,
	972	.disable_receiver = cls_disable_receiver,
	973	.enable_receiver = cls_enable_receiver,
	974	.send_break = cls_send_break,
	975	.clear_break = cls_clear_break,
	976	.send_start_character = cls_send_start_character,
	977	.send_stop_character = cls_send_stop_character,
	978	.copy_data_from_queue_to_uart = cls_copy_data_from_queue_to_uart,
	979	.get_uart_bytes_left = cls_get_uart_bytes_left,
	980	.send_immediate_char = cls_send_immediate_char
	981	};
	982

drivers/tty/serial/jsm/jsm_driver.c+120−36

  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  * PURPOSE.  See the GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
- * MA  02111-1307, USA.
- *
  * Contact Information:
  * Scott H Kilau <Scott_Kilau@digi.com>
  * Wendy Xiong   <wendyx@us.ibm.com>
 #include "jsm.h"
 MODULE_AUTHOR("Digi International, http://www.digi.com");
-MODULE_DESCRIPTION("Driver for the Digi International "
+MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
-		   "Neo PCI based product line");
 MODULE_LICENSE("GPL");
 MODULE_SUPPORTED_DEVICE("jsm");
 };
 static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
-                                       pci_channel_state_t state);
+					pci_channel_state_t state);
 static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev);
 static void jsm_io_resume(struct pci_dev *pdev);
 {
 	int rc = 0;
 	struct jsm_board *brd;
-	static int adapter_count = 0;
+	static int adapter_count;
 	rc = pci_enable_device(pdev);
 	if (rc) {
 		goto out_disable_device;
 	}
-	brd = kzalloc(sizeof(struct jsm_board), GFP_KERNEL);
+	brd = kzalloc(sizeof(*brd), GFP_KERNEL);
 	if (!brd) {
-		dev_err(&pdev->dev,
-			"memory allocation for board structure failed\n");
 		rc = -ENOMEM;
 		goto out_release_regions;
 	}
 	brd->pci_dev = pdev;
 	switch (pdev->device) {
 	case PCI_DEVICE_ID_NEO_2DB9:
 	case PCI_DEVICE_ID_NEO_2DB9PRI:
 	case PCI_DEVICE_ID_NEO_2RJ45:
 		brd->maxports = 2;
 		break;
+	case PCI_DEVICE_ID_CLASSIC_4:
+	case PCI_DEVICE_ID_CLASSIC_4_422:
 	case PCI_DEVICE_ID_NEO_4:
 	case PCIE_DEVICE_ID_NEO_4:
 	case PCIE_DEVICE_ID_NEO_4RJ45:
 		brd->maxports = 4;
 		break;
+	case PCI_DEVICE_ID_CLASSIC_8:
+	case PCI_DEVICE_ID_CLASSIC_8_422:
 	case PCI_DEVICE_ID_DIGI_NEO_8:
 	case PCIE_DEVICE_ID_NEO_8:
 	case PCIE_DEVICE_ID_NEO_8RJ45:
 	brd->irq = pdev->irq;
-	jsm_dbg(INIT, &brd->pci_dev, "jsm_found_board - NEO adapter\n");
+	switch (pdev->device) {
+	case PCI_DEVICE_ID_CLASSIC_4:
+	case PCI_DEVICE_ID_CLASSIC_4_422:
+	case PCI_DEVICE_ID_CLASSIC_8:
+	case PCI_DEVICE_ID_CLASSIC_8_422:
+		jsm_dbg(INIT, &brd->pci_dev,
+			"jsm_found_board - Classic adapter\n");
+		/*
+		 * For PCI ClassicBoards
+		 * PCI Local Address (.i.e. "resource" number) space
+		 * 0	PLX Memory Mapped Config
+		 * 1	PLX I/O Mapped Config
+		 * 2	I/O Mapped UARTs and Status
+		 * 3	Memory Mapped VPD
+		 * 4	Memory Mapped UARTs and Status
+		 */
+		/* Get the PCI Base Address Registers */
+		brd->membase = pci_resource_start(pdev, 4);
+		brd->membase_end = pci_resource_end(pdev, 4);
+		if (brd->membase & 0x1)
+			brd->membase &= ~0x3;
+		else
+			brd->membase &= ~0xF;
+		brd->iobase = pci_resource_start(pdev, 1);
+		brd->iobase_end = pci_resource_end(pdev, 1);
+		brd->iobase = ((unsigned int)(brd->iobase)) & 0xFFFE;
+		/* Assign the board_ops struct */
+		brd->bd_ops = &jsm_cls_ops;
+		brd->bd_uart_offset = 0x8;
+		brd->bd_dividend = 921600;
+		brd->re_map_membase = ioremap(brd->membase,
+						pci_resource_len(pdev, 4));
+		if (!brd->re_map_membase) {
+			dev_err(&pdev->dev,
+				"Card has no PCI Memory resources, failing board.\n");
+			rc = -ENOMEM;
+			goto out_kfree_brd;
+		}
+		/*
+		 * Enable Local Interrupt 1			(0x1),
+		 * Local Interrupt 1 Polarity Active high	(0x2),
+		 * Enable PCI interrupt				(0x43)
+		 */
+		outb(0x43, brd->iobase + 0x4c);
+		break;
+	case PCI_DEVICE_ID_NEO_2DB9:
+	case PCI_DEVICE_ID_NEO_2DB9PRI:
+	case PCI_DEVICE_ID_NEO_2RJ45:
+	case PCI_DEVICE_ID_NEO_2RJ45PRI:
+	case PCI_DEVICE_ID_NEO_2_422_485:
+	case PCI_DEVICE_ID_NEO_4:
+	case PCIE_DEVICE_ID_NEO_4:
+	case PCIE_DEVICE_ID_NEO_4RJ45:
+	case PCIE_DEVICE_ID_NEO_4_IBM:
+	case PCI_DEVICE_ID_DIGI_NEO_8:
+	case PCIE_DEVICE_ID_NEO_8:
+	case PCIE_DEVICE_ID_NEO_8RJ45:
+		jsm_dbg(INIT, &brd->pci_dev, "jsm_found_board - NEO adapter\n");
-	/* get the PCI Base Address Registers */
+		/* get the PCI Base Address Registers */
-	brd->membase	= pci_resource_start(pdev, 0);
+		brd->membase	= pci_resource_start(pdev, 0);
-	brd->membase_end = pci_resource_end(pdev, 0);
+		brd->membase_end = pci_resource_end(pdev, 0);
-	if (brd->membase & 1)
+		if (brd->membase & 1)
-		brd->membase &= ~3;
+			brd->membase &= ~0x3;
-	else
+		else
-		brd->membase &= ~15;
+			brd->membase &= ~0xF;
-	/* Assign the board_ops struct */
+		/* Assign the board_ops struct */
-	brd->bd_ops = &jsm_neo_ops;
+		brd->bd_ops = &jsm_neo_ops;
-	brd->bd_uart_offset = 0x200;
+		brd->bd_uart_offset = 0x200;
-	brd->bd_dividend = 921600;
+		brd->bd_dividend = 921600;
-	brd->re_map_membase = ioremap(brd->membase, pci_resource_len(pdev, 0));
+		brd->re_map_membase = ioremap(brd->membase,
-	if (!brd->re_map_membase) {
+						pci_resource_len(pdev, 0));
-		dev_err(&pdev->dev,
+		if (!brd->re_map_membase) {
-			"card has no PCI Memory resources, "
+			dev_err(&pdev->dev,
-			"failing board.\n");
+				"Card has no PCI Memory resources, failing board.\n");
-		rc = -ENOMEM;
+			rc = -ENOMEM;
-		goto out_kfree_brd;
+			goto out_kfree_brd;
+		}
+		break;
+	default:
+		return -ENXIO;
 	}
-	rc = request_irq(brd->irq, brd->bd_ops->intr,
+	rc = request_irq(brd->irq, brd->bd_ops->intr, IRQF_SHARED, "JSM", brd);
-			IRQF_SHARED, "JSM", brd);
 	if (rc) {
-		printk(KERN_WARNING "Failed to hook IRQ %d\n",brd->irq);
+		dev_warn(&pdev->dev, "Failed to hook IRQ %d\n", brd->irq);
 		goto out_iounmap;
 	}
 	}
 	/* Log the information about the board */
-	dev_info(&pdev->dev, "board %d: Digi Neo (rev %d), irq %d\n",
+	dev_info(&pdev->dev, "board %d: Digi Classic/Neo (rev %d), irq %d\n",
 			adapter_count, brd->rev, brd->irq);
 	pci_set_drvdata(pdev, brd);
 	struct jsm_board *brd = pci_get_drvdata(pdev);
 	int i = 0;
+	switch (pdev->device) {
+	case PCI_DEVICE_ID_CLASSIC_4:
+	case PCI_DEVICE_ID_CLASSIC_4_422:
+	case PCI_DEVICE_ID_CLASSIC_8:
+	case PCI_DEVICE_ID_CLASSIC_8_422:
+		/* Tell card not to interrupt anymore. */
+		outb(0x0, brd->iobase + 0x4c);
+		break;
+	default:
+		break;
+	}
 	jsm_remove_uart_port(brd);
 	free_irq(brd->irq, brd);
 	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4), 0, 0, 11 },
 	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4RJ45), 0, 0, 12 },
 	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_8RJ45), 0, 0, 13 },
+	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_4), 0, 0, 14 },
+	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_4_422), 0, 0, 15 },
+	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_8), 0, 0, 16 },
+	{ PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_8_422), 0, 0, 17 },
 	{ 0, }
 };
 MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);

drivers/tty/serial/jsm/jsm_neo.c+14−22

  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  * PURPOSE.  See the GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
- * MA  02111-1307, USA.
- *
  * Contact Information:
  * Scott H Kilau <Scott_Kilau@digi.com>
  * Wendy Xiong   <wendyx@us.ibm.com>
 		/* Check to see if the UART feels it completely flushed the FIFO. */
 		tmp = readb(&ch->ch_neo_uart->isr_fcr);
-		if (tmp & 4) {
+		if (tmp & UART_FCR_CLEAR_XMIT) {
 			jsm_dbg(IOCTL, &ch->ch_bd->pci_dev,
 				"Still flushing TX UART... i: %d\n", i);
 			udelay(10);
 /*
  * No locks are assumed to be held when calling this function.
  */
-static void neo_clear_break(struct jsm_channel *ch, int force)
+static void neo_clear_break(struct jsm_channel *ch)
 {
 	unsigned long lock_flags;
 		lcr |= UART_LCR_STOP;
 	switch (ch->ch_c_cflag & CSIZE) {
-		case CS5:
+	case CS5:
-			lcr |= UART_LCR_WLEN5;
+		lcr |= UART_LCR_WLEN5;
-			break;
-		case CS6:
-			lcr |= UART_LCR_WLEN6;
-			break;
-		case CS7:
-			lcr |= UART_LCR_WLEN7;
-			break;
-		case CS8:
-		default:
-			lcr |= UART_LCR_WLEN8;
 		break;
+	case CS6:
+		lcr |= UART_LCR_WLEN6;
+		break;
+	case CS7:
+		lcr |= UART_LCR_WLEN7;
+		break;
+	case CS8:
+	default:
+		lcr |= UART_LCR_WLEN8;
+	break;
 	}
 	ier = readb(&ch->ch_neo_uart->ier);
 	uart_lcr = readb(&ch->ch_neo_uart->lcr);
-	if (baud == 0)
-		baud = 9600;
 	quot = ch->ch_bd->bd_dividend / baud;
 	if (quot != 0) {

drivers/tty/serial/jsm/jsm_tty.c+23−16

  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  * PURPOSE.  See the GNU General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
- * MA  02111-1307, USA.
- *
  * Contact Information:
  * Scott H Kilau <Scott_Kilau@digi.com>
  * Ananda Venkatarman <mansarov@us.ibm.com>
 static unsigned int jsm_tty_get_mctrl(struct uart_port *port)
 {
 	int result;
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
  */
 static void jsm_tty_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
 static void jsm_tty_start_tx(struct uart_port *port)
 {
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
 static void jsm_tty_stop_tx(struct uart_port *port)
 {
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	jsm_dbg(IOCTL, &channel->ch_bd->pci_dev, "start\n");
 static void jsm_tty_send_xchar(struct uart_port *port, char ch)
 {
 	unsigned long lock_flags;
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	struct ktermios *termios;
 	spin_lock_irqsave(&port->lock, lock_flags);
 static void jsm_tty_stop_rx(struct uart_port *port)
 {
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	channel->ch_bd->bd_ops->disable_receiver(channel);
 }
 static void jsm_tty_break(struct uart_port *port, int break_state)
 {
 	unsigned long lock_flags;
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	spin_lock_irqsave(&port->lock, lock_flags);
 	if (break_state == -1)
 		channel->ch_bd->bd_ops->send_break(channel);
 	else
-		channel->ch_bd->bd_ops->clear_break(channel, 0);
+		channel->ch_bd->bd_ops->clear_break(channel);
 	spin_unlock_irqrestore(&port->lock, lock_flags);
 }
 static int jsm_tty_open(struct uart_port *port)
 {
 	struct jsm_board *brd;
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	struct ktermios *termios;
 	/* Get board pointer from our array of majors we have allocated */
 {
 	struct jsm_board *bd;
 	struct ktermios *ts;
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	jsm_dbg(CLOSE, &channel->ch_bd->pci_dev, "start\n");
 				 struct ktermios *old_termios)
 {
 	unsigned long lock_flags;
-	struct jsm_channel *channel = (struct jsm_channel *)port;
+	struct jsm_channel *channel =
+		container_of(port, struct jsm_channel, uart_port);
 	spin_lock_irqsave(&port->lock, lock_flags);
 	channel->ch_c_cflag	= termios->c_cflag;
 		if (brd->bd_uart_offset == 0x200)
 			ch->ch_neo_uart =  vaddr + (brd->bd_uart_offset * i);
+		else
+			ch->ch_cls_uart =  vaddr + (brd->bd_uart_offset * i);
 		ch->ch_bd = brd;
 		ch->ch_portnum = i;

drivers/tty/serial/lantiq.c+3−1

 static void
 lqasc_release_port(struct uart_port *port)
 {
+	struct platform_device *pdev = to_platform_device(port->dev);
 	if (port->flags & UPF_IOREMAP) {
-		iounmap(port->membase);
+		devm_iounmap(&pdev->dev, port->membase);
 		port->membase = NULL;
 	}
 }

drivers/tty/serial/m32r_sio.c+28−14

 static void m32r_sio_stop_tx(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	if (up->ier & UART_IER_THRI) {
 		up->ier &= ~UART_IER_THRI;
 static void m32r_sio_start_tx(struct uart_port *port)
 {
 #ifdef CONFIG_SERIAL_M32R_PLDSIO
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	struct circ_buf *xmit = &up->port.state->xmit;
 	if (!(up->ier & UART_IER_THRI)) {
 	}
 	while((serial_in(up, UART_LSR) & UART_EMPTY) != UART_EMPTY);
 #else
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	if (!(up->ier & UART_IER_THRI)) {
 		up->ier |= UART_IER_THRI;
 static void m32r_sio_stop_rx(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	up->ier &= ~UART_IER_RLSI;
 	up->port.read_status_mask &= ~UART_LSR_DR;
 static void m32r_sio_enable_ms(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	up->ier |= UART_IER_MSI;
 	serial_out(up, UART_IER, up->ier);
 static unsigned int m32r_sio_tx_empty(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	unsigned long flags;
 	unsigned int ret;
 static int m32r_sio_startup(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	int retval;
 	sio_init();
 static void m32r_sio_shutdown(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	/*
 	 * Disable interrupts from this port
 static void m32r_sio_set_termios(struct uart_port *port,
 	struct ktermios *termios, struct ktermios *old)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	unsigned char cval = 0;
 	unsigned long flags;
 	unsigned int baud, quot;
 static void m32r_sio_pm(struct uart_port *port, unsigned int state,
 	unsigned int oldstate)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	if (up->pm)
 		up->pm(port, state, oldstate);
 static void m32r_sio_release_port(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	unsigned long start, offset = 0, size = 0;
 	size <<= up->port.regshift;
 static int m32r_sio_request_port(struct uart_port *port)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	struct resource *res = NULL;
 	int ret = 0;
 static void m32r_sio_config_port(struct uart_port *port, int unused)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	unsigned long flags;
 	spin_lock_irqsave(&up->port.lock, flags);
 static void m32r_sio_console_putchar(struct uart_port *port, int ch)
 {
-	struct uart_sio_port *up = (struct uart_sio_port *)port;
+	struct uart_sio_port *up =
+		container_of(port, struct uart_sio_port, port);
 	wait_for_xmitr(up);
 	sio_out(up, SIOTXB, ch);

drivers/tty/serial/max310x.c+31−46

@@ -346,10 +346,13 @@ static int max3109_detect(struct device *dev) · 345 unmodified lines
346	unsigned int val = 0;	346	unsigned int val = 0;
347	int ret;	347	int ret;
348		348
349	ret = regmap_read(s->regmap, MAX310X_REVID_REG, &val);	349	ret = regmap_write(s->regmap, MAX310X_GLOBALCMD_REG,
		350	MAX310X_EXTREG_ENBL);
350	if (ret)	351	if (ret)
351	return ret;	352	return ret;
352		353
		354	regmap_read(s->regmap, MAX310X_REVID_EXTREG, &val);
		355	regmap_write(s->regmap, MAX310X_GLOBALCMD_REG, MAX310X_EXTREG_DSBL);
353	if (((val & MAX310x_REV_MASK) != MAX3109_REV_ID)) {	356	if (((val & MAX310x_REV_MASK) != MAX3109_REV_ID)) {
354	dev_err(dev,	357	dev_err(dev,
355	"%s ID 0x%02x does not match\n", s->devtype->name, val);	358	"%s ID 0x%02x does not match\n", s->devtype->name, val);
@@ -874,55 +877,37 @@ static void max310x_set_termios(struct uart_port *port, · 518 unmodified lines
874	uart_update_timeout(port, termios->c_cflag, baud);	877	uart_update_timeout(port, termios->c_cflag, baud);
875	}	878	}
876		879
877	static int max310x_ioctl(struct uart_port *port, unsigned int cmd,	880	static int max310x_rs485_config(struct uart_port *port,
878	unsigned long arg)	881	struct serial_rs485 *rs485)
879	{	882	{
880	#if defined(TIOCSRS485) && defined(TIOCGRS485)
881	struct serial_rs485 rs485;
882	unsigned int val;	883	unsigned int val;
883		884
884	switch (cmd) {	885	if (rs485->delay_rts_before_send > 0x0f \|\|
885	case TIOCSRS485:	886	rs485->delay_rts_after_send > 0x0f)
886	if (copy_from_user(&rs485, (void __user *)arg, sizeof(rs485)))	887	return -ERANGE;
887	return -EFAULT;	888
888	if (rs485.delay_rts_before_send > 0x0f \|\|	889	val = (rs485->delay_rts_before_send << 4) \|
889	rs485.delay_rts_after_send > 0x0f)	890	rs485->delay_rts_after_send;
890	return -ERANGE;	891	max310x_port_write(port, MAX310X_HDPIXDELAY_REG, val);
891	val = (rs485.delay_rts_before_send << 4) \|	892	if (rs485->flags & SER_RS485_ENABLED) {
892	rs485.delay_rts_after_send;	893	max310x_port_update(port, MAX310X_MODE1_REG,
893	max310x_port_write(port, MAX310X_HDPIXDELAY_REG, val);	894	MAX310X_MODE1_TRNSCVCTRL_BIT,
894	if (rs485.flags & SER_RS485_ENABLED) {	895	MAX310X_MODE1_TRNSCVCTRL_BIT);
895	max310x_port_update(port, MAX310X_MODE1_REG,	896	max310x_port_update(port, MAX310X_MODE2_REG,
896	MAX310X_MODE1_TRNSCVCTRL_BIT,	897	MAX310X_MODE2_ECHOSUPR_BIT,
897	MAX310X_MODE1_TRNSCVCTRL_BIT);	898	MAX310X_MODE2_ECHOSUPR_BIT);
898	max310x_port_update(port, MAX310X_MODE2_REG,	899	} else {
899	MAX310X_MODE2_ECHOSUPR_BIT,	900	max310x_port_update(port, MAX310X_MODE1_REG,
900	MAX310X_MODE2_ECHOSUPR_BIT);	901	MAX310X_MODE1_TRNSCVCTRL_BIT, 0);
901	} else {	902	max310x_port_update(port, MAX310X_MODE2_REG,
902	max310x_port_update(port, MAX310X_MODE1_REG,	903	MAX310X_MODE2_ECHOSUPR_BIT, 0);
903	MAX310X_MODE1_TRNSCVCTRL_BIT, 0);
904	max310x_port_update(port, MAX310X_MODE2_REG,
905	MAX310X_MODE2_ECHOSUPR_BIT, 0);
906	}
907	return 0;
908	case TIOCGRS485:
909	memset(&rs485, 0, sizeof(rs485));
910	val = max310x_port_read(port, MAX310X_MODE1_REG);
911	rs485.flags = (val & MAX310X_MODE1_TRNSCVCTRL_BIT) ?
912	SER_RS485_ENABLED : 0;
913	rs485.flags \|= SER_RS485_RTS_ON_SEND;
914	val = max310x_port_read(port, MAX310X_HDPIXDELAY_REG);
915	rs485.delay_rts_before_send = val >> 4;
916	rs485.delay_rts_after_send = val & 0x0f;
917	if (copy_to_user((void __user *)arg, &rs485, sizeof(rs485)))
918	return -EFAULT;
919	return 0;
920	default:
921	break;
922	}	904	}
923	#endif
924		905
925	return -ENOIOCTLCMD;	906	rs485->flags &= SER_RS485_RTS_ON_SEND \| SER_RS485_ENABLED;
		907	memset(rs485->padding, 0, sizeof(rs485->padding));
		908	port->rs485 = *rs485;
		909
		910	return 0;
926	}	911	}
927		912
928	static int max310x_startup(struct uart_port *port)	913	static int max310x_startup(struct uart_port *port)
@@ -1017,7 +1002,6 @@ static const struct uart_ops max310x_ops = { · 88 unmodified lines
1017	.release_port = max310x_null_void,	1002	.release_port = max310x_null_void,
1018	.config_port = max310x_config_port,	1003	.config_port = max310x_config_port,
1019	.verify_port = max310x_verify_port,	1004	.verify_port = max310x_verify_port,
1020	.ioctl = max310x_ioctl,
1021	};	1005	};
1022		1006
1023	static int __maybe_unused max310x_suspend(struct device *dev)	1007	static int __maybe_unused max310x_suspend(struct device *dev)
@@ -1218,6 +1202,7 @@ static int max310x_probe(struct device dev, struct max310x_devtype devtype, · 194 unmodified lines
1218	s->p[i].port.iobase = i * 0x20;	1202	s->p[i].port.iobase = i * 0x20;
1219	s->p[i].port.membase = (void __iomem *)~0;	1203	s->p[i].port.membase = (void __iomem *)~0;
1220	s->p[i].port.uartclk = uartclk;	1204	s->p[i].port.uartclk = uartclk;
		1205	s->p[i].port.rs485_config = max310x_rs485_config;
1221	s->p[i].port.ops = &max310x_ops;	1206	s->p[i].port.ops = &max310x_ops;
1222	/* Disable all interrupts */	1207	/* Disable all interrupts */
1223	max310x_port_write(&s->p[i].port, MAX310X_IRQEN_REG, 0);	1208	max310x_port_write(&s->p[i].port, MAX310X_IRQEN_REG, 0);

drivers/tty/serial/mcf.c+8−34

 	struct uart_port	port;
 	unsigned int		sigs;		/* Local copy of line sigs */
 	unsigned char		imr;		/* Local IMR mirror */
-	struct serial_rs485	rs485;		/* RS485 settings */
 };
 /****************************************************************************/
 {
 	struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
-	if (pp->rs485.flags & SER_RS485_ENABLED) {
+	if (port->rs485.flags & SER_RS485_ENABLED) {
 		/* Enable Transmitter */
 		writeb(MCFUART_UCR_TXENABLE, port->membase + MCFUART_UCR);
 		/* Manually assert RTS */
 		mr2 |= MCFUART_MR2_TXCTS;
 	}
-	if (pp->rs485.flags & SER_RS485_ENABLED) {
+	spin_lock_irqsave(&port->lock, flags);
+	if (port->rs485.flags & SER_RS485_ENABLED) {
 		dev_dbg(port->dev, "Setting UART to RS485\n");
 		mr2 |= MCFUART_MR2_TXRTS;
 	}
-	spin_lock_irqsave(&port->lock, flags);
 	uart_update_timeout(port, termios->c_cflag, baud);
 	writeb(MCFUART_UCR_CMDRESETRX, port->membase + MCFUART_UCR);
 	writeb(MCFUART_UCR_CMDRESETTX, port->membase + MCFUART_UCR);
 		pp->imr &= ~MCFUART_UIR_TXREADY;
 		writeb(pp->imr, port->membase + MCFUART_UIMR);
 		/* Disable TX to negate RTS automatically */
-		if (pp->rs485.flags & SER_RS485_ENABLED)
+		if (port->rs485.flags & SER_RS485_ENABLED)
 			writeb(MCFUART_UCR_TXDISABLE,
 				port->membase + MCFUART_UCR);
 	}
 /****************************************************************************/
 /* Enable or disable the RS485 support */
-static void mcf_config_rs485(struct uart_port *port, struct serial_rs485 *rs485)
+static int mcf_config_rs485(struct uart_port *port, struct serial_rs485 *rs485)
 {
 	struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
-	unsigned long flags;
 	unsigned char mr1, mr2;
-	spin_lock_irqsave(&port->lock, flags);
 	/* Get mode registers */
 	mr1 = readb(port->membase + MCFUART_UMR);
 	mr2 = readb(port->membase + MCFUART_UMR);
 	}
 	writeb(mr1, port->membase + MCFUART_UMR);
 	writeb(mr2, port->membase + MCFUART_UMR);
-	pp->rs485 = *rs485;
+	port->rs485 = *rs485;
-	spin_unlock_irqrestore(&port->lock, flags);
-}
-static int mcf_ioctl(struct uart_port *port, unsigned int cmd,
-		unsigned long arg)
-{
-	switch (cmd) {
-	case TIOCSRS485: {
-		struct serial_rs485 rs485;
-		if (copy_from_user(&rs485, (struct serial_rs485 *)arg,
-				sizeof(struct serial_rs485)))
-			return -EFAULT;
-		mcf_config_rs485(port, &rs485);
-		break;
-	}
-	case TIOCGRS485: {
-		struct mcf_uart *pp = container_of(port, struct mcf_uart, port);
-		if (copy_to_user((struct serial_rs485 *)arg, &pp->rs485,
-				sizeof(struct serial_rs485)))
-			return -EFAULT;
-		break;
-	}
-	default:
-		return -ENOIOCTLCMD;
-	}
 	return 0;
 }
 	.release_port	= mcf_release_port,
 	.config_port	= mcf_config_port,
 	.verify_port	= mcf_verify_port,
-	.ioctl		= mcf_ioctl,
 };
 static struct mcf_uart mcf_ports[4];
 		port->irq = platp[i].irq;
 		port->uartclk = MCF_BUSCLK;
 		port->flags = UPF_BOOT_AUTOCONF;
+		port->rs485_config = mcf_config_rs485;
 		port->ops = &mcf_uart_ops;
 	}
 		port->uartclk = MCF_BUSCLK;
 		port->ops = &mcf_uart_ops;
 		port->flags = UPF_BOOT_AUTOCONF;
+		port->rs485_config = mcf_config_rs485;
 		uart_add_one_port(&mcf_driver, port);
 	}

drivers/tty/serial/men_z135_uart.c+1−0

@@ -809,6 +809,7 @@ static void men_z135_remove(struct mcb_device *mdev) · 808 unmodified lines
809		809
810	static const struct mcb_device_id men_z135_ids[] = {	810	static const struct mcb_device_id men_z135_ids[] = {
811	{ .device = 0x87 },	811	{ .device = 0x87 },
		812	{ }
812	};	813	};
813	MODULE_DEVICE_TABLE(mcb, men_z135_ids);	814	MODULE_DEVICE_TABLE(mcb, men_z135_ids);
814		815

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

@@ -1371,7 +1371,7 @@ static void hsu_global_init(void) · 1370 unmodified lines
1371	hsu->iolen = 0x1000;	1371	hsu->iolen = 0x1000;
1372		1372
1373	if (!(request_mem_region(hsu->paddr, hsu->iolen, "HSU global")))	1373	if (!(request_mem_region(hsu->paddr, hsu->iolen, "HSU global")))
1374	pr_warning("HSU: error in request mem region\n");	1374	pr_warn("HSU: error in request mem region\n");
1375		1375
1376	hsu->reg = ioremap_nocache((unsigned long)hsu->paddr, hsu->iolen);	1376	hsu->reg = ioremap_nocache((unsigned long)hsu->paddr, hsu->iolen);
1377	if (!hsu->reg) {	1377	if (!hsu->reg) {

drivers/tty/serial/mpsc.c+26−13

  */
 static uint mpsc_tx_empty(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	ulong iflags;
 	uint rc;
 static uint mpsc_get_mctrl(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	u32 mflags, status;
 	status = (pi->mirror_regs) ? pi->MPSC_CHR_10_m
 static void mpsc_stop_tx(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	pr_debug("mpsc_stop_tx[%d]\n", port->line);
 static void mpsc_start_tx(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	unsigned long iflags;
 	spin_lock_irqsave(&pi->tx_lock, iflags);
 static void mpsc_stop_rx(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	pr_debug("mpsc_stop_rx[%d]: Stopping...\n", port->line);
 static void mpsc_break_ctl(struct uart_port *port, int ctl)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	ulong	flags;
 	u32	v;
 static int mpsc_startup(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	u32 flag = 0;
 	int rc;
 static void mpsc_shutdown(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	pr_debug("mpsc_shutdown[%d]: Shutting down MPSC\n", port->line);
 static void mpsc_set_termios(struct uart_port *port, struct ktermios *termios,
 		 struct ktermios *old)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	u32 baud;
 	ulong flags;
 	u32 chr_bits, stop_bits, par;
 static void mpsc_release_port(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	if (pi->ready) {
 		mpsc_uninit_rings(pi);
 static int mpsc_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	int rc = 0;
 	pr_debug("mpsc_verify_port[%d]: Verifying port data\n", pi->port.line);
 static int mpsc_get_poll_char(struct uart_port *port)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	struct mpsc_rx_desc *rxre;
 	u32	cmdstat, bytes_in, i;
 	u8	*bp;
 static void mpsc_put_poll_char(struct uart_port *port,
 			 unsigned char c)
 {
-	struct mpsc_port_info *pi = (struct mpsc_port_info *)port;
+	struct mpsc_port_info *pi =
+		container_of(port, struct mpsc_port_info, port);
 	u32 data;
 	data = readl(pi->mpsc_base + MPSC_MPCR);

drivers/tty/serial/mrst_max3110.c+12−15

  *    interrupt for a low speed UART device
  */
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #ifdef CONFIG_MAGIC_SYSRQ
 #define SUPPORT_SYSRQ
 #endif
 #include "mrst_max3110.h"
-#define PR_FMT	"mrst_max3110: "
 #define UART_TX_NEEDED 1
 #define CON_TX_NEEDED  2
 #define BIT_IRQ_PENDING    3
 	*obuf = out;
 	ret = max3110_write_then_read(max, obuf, ibuf, 2, 1);
 	if (ret) {
-		pr_warning(PR_FMT "%s(): get err msg %d when sending 0x%x\n",
+		pr_warn("%s: get err msg %d when sending 0x%x\n",
-				__func__, ret, out);
+			__func__, ret, out);
 		goto exit;
 	}
 	blen = M3110_RX_FIFO_DEPTH * sizeof(u16);
 	buf = kzalloc(blen * 2, GFP_KERNEL | GFP_DMA);
-	if (!buf) {
+	if (!buf)
-		pr_warning(PR_FMT "%s(): fail to alloc dma buffer\n", __func__);
 		return 0;
-	}
 	/* tx/rx always have the same length */
 	obuf = buf;
 	int parity = 'n';
 	int flow = 'n';
-	pr_info(PR_FMT "setting up console\n");
+	pr_info("setting up console\n");
 	if (co->index == -1)
 		co->index = 0;
 	if (!max) {
-		pr_err(PR_FMT "pmax is NULL, return");
+		pr_err("pmax is NULL, return\n");
 		return -ENODEV;
 	}
 			ret = max3110_write_then_read(max, obuf, ibuf, blen, 0);
 			if (ret)
-				pr_warning(PR_FMT "%s(): get err msg %d\n",
+				pr_warn("%s: get err msg %d\n", __func__, ret);
-						__func__, ret);
 			receive_chars(max, ibuf, len);
 	int ret = 0;
 	struct circ_buf *xmit = &max->con_xmit;
-	pr_info(PR_FMT "start main thread\n");
+	pr_info("start main thread\n");
 	do {
 		wait_event_interruptible(*wq,
 {
 	struct uart_max3110 *max = _max;
-	pr_info(PR_FMT "start read thread\n");
+	pr_info("start read thread\n");
 	do {
 		/*
 		 * If can't acquire the mutex, it means the main thread
 	int ret = 0;
 	if (port->line != 0) {
-		pr_err(PR_FMT "uart port startup failed\n");
+		pr_err("uart port startup failed\n");
 		return -1;
 	}
 		if (IS_ERR(max->read_thread)) {
 			ret = PTR_ERR(max->read_thread);
 			max->read_thread = NULL;
-			pr_err(PR_FMT "Can't create read thread!\n");
+			pr_err("Can't create read thread!\n");
 			return ret;
 		}
 	}

drivers/tty/serial/msm_serial.c+58−53

@@ -54,6 +54,7 @@ struct msm_port { · 53 unmodified lines
54	unsigned int imr;	54	unsigned int imr;
55	int is_uartdm;	55	int is_uartdm;
56	unsigned int old_snap_state;	56	unsigned int old_snap_state;
		57	bool break_detected;
57	};	58	};
58		59
59	static inline void wait_for_xmitr(struct uart_port *port)	60	static inline void wait_for_xmitr(struct uart_port *port)
@@ -126,23 +127,38 @@ static void handle_rx_dm(struct uart_port *port, unsigned int misr) · 66 unmodified lines
126		127
127	while (count > 0) {	128	while (count > 0) {
128	unsigned char buf[4];	129	unsigned char buf[4];
		130	int sysrq, r_count, i;
129		131
130	sr = msm_read(port, UART_SR);	132	sr = msm_read(port, UART_SR);
131	if ((sr & UART_SR_RX_READY) == 0) {	133	if ((sr & UART_SR_RX_READY) == 0) {
132	msm_port->old_snap_state -= count;	134	msm_port->old_snap_state -= count;
133	break;	135	break;
134	}	136	}
		137
135	ioread32_rep(port->membase + UARTDM_RF, buf, 1);	138	ioread32_rep(port->membase + UARTDM_RF, buf, 1);
136	if (sr & UART_SR_RX_BREAK) {	139	r_count = min_t(int, count, sizeof(buf));
137	port->icount.brk++;
138	if (uart_handle_break(port))
139	continue;
140	} else if (sr & UART_SR_PAR_FRAME_ERR)
141	port->icount.frame++;
142		140
143	/* TODO: handle sysrq */	141	for (i = 0; i < r_count; i++) {
144	tty_insert_flip_string(tport, buf, min(count, 4));	142	char flag = TTY_NORMAL;
145	count -= 4;	143
		144	if (msm_port->break_detected && buf[i] == 0) {
		145	port->icount.brk++;
		146	flag = TTY_BREAK;
		147	msm_port->break_detected = false;
		148	if (uart_handle_break(port))
		149	continue;
		150	}
		151
		152	if (!(port->read_status_mask & UART_SR_RX_BREAK))
		153	flag = TTY_NORMAL;
		154
		155	spin_unlock(&port->lock);
		156	sysrq = uart_handle_sysrq_char(port, buf[i]);
		157	spin_lock(&port->lock);
		158	if (!sysrq)
		159	tty_insert_flip_char(tport, buf[i], flag);
		160	}
		161	count -= r_count;
146	}	162	}
147		163
148	spin_unlock(&port->lock);	164	spin_unlock(&port->lock);
@@ -174,6 +190,7 @@ static void handle_rx(struct uart_port *port) · 25 unmodified lines
174	while ((sr = msm_read(port, UART_SR)) & UART_SR_RX_READY) {	190	while ((sr = msm_read(port, UART_SR)) & UART_SR_RX_READY) {
175	unsigned int c;	191	unsigned int c;
176	char flag = TTY_NORMAL;	192	char flag = TTY_NORMAL;
		193	int sysrq;
177		194
178	c = msm_read(port, UART_RF);	195	c = msm_read(port, UART_RF);
179		196
@@ -195,7 +212,10 @@ static void handle_rx(struct uart_port *port) · 15 unmodified lines
195	else if (sr & UART_SR_PAR_FRAME_ERR)	212	else if (sr & UART_SR_PAR_FRAME_ERR)
196	flag = TTY_FRAME;	213	flag = TTY_FRAME;
197		214
198	if (!uart_handle_sysrq_char(port, c))	215	spin_unlock(&port->lock);
		216	sysrq = uart_handle_sysrq_char(port, c);
		217	spin_lock(&port->lock);
		218	if (!sysrq)
199	tty_insert_flip_char(tport, c, flag);	219	tty_insert_flip_char(tport, c, flag);
200	}	220	}
201		221
@@ -287,6 +307,11 @@ static irqreturn_t msm_irq(int irq, void *dev_id) · 85 unmodified lines
287	misr = msm_read(port, UART_MISR);	307	misr = msm_read(port, UART_MISR);
288	msm_write(port, 0, UART_IMR); /* disable interrupt */	308	msm_write(port, 0, UART_IMR); /* disable interrupt */
289		309
		310	if (misr & UART_IMR_RXBREAK_START) {
		311	msm_port->break_detected = true;
		312	msm_write(port, UART_CR_CMD_RESET_RXBREAK_START, UART_CR);
		313	}
		314
290	if (misr & (UART_IMR_RXLEV \| UART_IMR_RXSTALE)) {	315	if (misr & (UART_IMR_RXLEV \| UART_IMR_RXSTALE)) {
291	if (msm_port->is_uartdm)	316	if (msm_port->is_uartdm)
292	handle_rx_dm(port, misr);	317	handle_rx_dm(port, misr);
@@ -402,9 +427,6 @@ static int msm_set_baud_rate(struct uart_port *port, unsigned int baud) · 109 unmodified lines
402		427
403	entry = msm_find_best_baud(port, baud);	428	entry = msm_find_best_baud(port, baud);
404		429
405	if (msm_port->is_uartdm)
406	msm_write(port, UART_CR_CMD_RESET_RX, UART_CR);
407
408	msm_write(port, entry->code, UART_CSR);	430	msm_write(port, entry->code, UART_CSR);
409		431
410	/* RX stale watermark */	432	/* RX stale watermark */
@@ -421,6 +443,18 @@ static int msm_set_baud_rate(struct uart_port *port, unsigned int baud) · 10 unmodified lines
421	/* set TX watermark */	443	/* set TX watermark */
422	msm_write(port, 10, UART_TFWR);	444	msm_write(port, 10, UART_TFWR);
423		445
		446	msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
		447	msm_reset(port);
		448
		449	/* Enable RX and TX */
		450	msm_write(port, UART_CR_TX_ENABLE \| UART_CR_RX_ENABLE, UART_CR);
		451
		452	/* turn on RX and CTS interrupts */
		453	msm_port->imr = UART_IMR_RXLEV \| UART_IMR_RXSTALE \|
		454	UART_IMR_CURRENT_CTS \| UART_IMR_RXBREAK_START;
		455
		456	msm_write(port, msm_port->imr, UART_IMR);
		457
424	if (msm_port->is_uartdm) {	458	if (msm_port->is_uartdm) {
425	msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);	459	msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
426	msm_write(port, 0xFFFFFF, UARTDM_DMRX);	460	msm_write(port, 0xFFFFFF, UARTDM_DMRX);
@@ -467,40 +501,6 @@ static int msm_startup(struct uart_port *port) · 40 unmodified lines
467	data \|= UART_MR1_AUTO_RFR_LEVEL1 & (rfr_level << 2);	501	data \|= UART_MR1_AUTO_RFR_LEVEL1 & (rfr_level << 2);
468	data \|= UART_MR1_AUTO_RFR_LEVEL0 & rfr_level;	502	data \|= UART_MR1_AUTO_RFR_LEVEL0 & rfr_level;
469	msm_write(port, data, UART_MR1);	503	msm_write(port, data, UART_MR1);
470
471	/* make sure that RXSTALE count is non-zero */
472	data = msm_read(port, UART_IPR);
473	if (unlikely(!data)) {
474	data \|= UART_IPR_RXSTALE_LAST;
475	data \|= UART_IPR_STALE_LSB;
476	msm_write(port, data, UART_IPR);
477	}
478
479	data = 0;
480	if (!port->cons \|\| (port->cons && !(port->cons->flags & CON_ENABLED))) {
481	msm_write(port, UART_CR_CMD_PROTECTION_EN, UART_CR);
482	msm_reset(port);
483	data = UART_CR_TX_ENABLE;
484	}
485
486	data \|= UART_CR_RX_ENABLE;
487	msm_write(port, data, UART_CR); /* enable TX & RX */
488
489	/* Make sure IPR is not 0 to start with*/
490	if (msm_port->is_uartdm)
491	msm_write(port, UART_IPR_STALE_LSB, UART_IPR);
492
493	/* turn on RX and CTS interrupts */
494	msm_port->imr = UART_IMR_RXLEV \| UART_IMR_RXSTALE \|
495	UART_IMR_CURRENT_CTS;
496
497	if (msm_port->is_uartdm) {
498	msm_write(port, 0xFFFFFF, UARTDM_DMRX);
499	msm_write(port, UART_CR_CMD_RESET_STALE_INT, UART_CR);
500	msm_write(port, UART_CR_CMD_STALE_EVENT_ENABLE, UART_CR);
501	}
502
503	msm_write(port, msm_port->imr, UART_IMR);
504	return 0;	504	return 0;
505	}	505	}
506		506
@@ -1044,17 +1044,22 @@ static int msm_serial_probe(struct platform_device *pdev) · 537 unmodified lines
1044	struct resource *resource;	1044	struct resource *resource;
1045	struct uart_port *port;	1045	struct uart_port *port;
1046	const struct of_device_id *id;	1046	const struct of_device_id *id;
1047	int irq;	1047	int irq, line;
		1048
		1049	if (pdev->dev.of_node)
		1050	line = of_alias_get_id(pdev->dev.of_node, "serial");
		1051	else
		1052	line = pdev->id;
1048		1053
1049	if (pdev->id == -1)	1054	if (line < 0)
1050	pdev->id = atomic_inc_return(&msm_uart_next_id) - 1;	1055	line = atomic_inc_return(&msm_uart_next_id) - 1;
1051		1056
1052	if (unlikely(pdev->id < 0 \|\| pdev->id >= UART_NR))	1057	if (unlikely(line < 0 \|\| line >= UART_NR))
1053	return -ENXIO;	1058	return -ENXIO;
1054		1059
1055	dev_info(&pdev->dev, "msm_serial: detected port #%d\n", pdev->id);	1060	dev_info(&pdev->dev, "msm_serial: detected port #%d\n", line);
1056		1061
1057	port = get_port_from_line(pdev->id);	1062	port = get_port_from_line(line);
1058	port->dev = &pdev->dev;	1063	port->dev = &pdev->dev;
1059	msm_port = UART_TO_MSM(port);	1064	msm_port = UART_TO_MSM(port);
1060		1065

drivers/tty/serial/msm_serial.h+2−0

 #define UART_CR_TX_ENABLE		(1 << 2)
 #define UART_CR_RX_DISABLE		(1 << 1)
 #define UART_CR_RX_ENABLE		(1 << 0)
+#define UART_CR_CMD_RESET_RXBREAK_START	((1 << 11) | (2 << 4))
 #define UART_IMR		0x0014
 #define UART_IMR_TXLEV		(1 << 0)
 #define UART_IMR_RXLEV		(1 << 4)
 #define UART_IMR_DELTA_CTS	(1 << 5)
 #define UART_IMR_CURRENT_CTS	(1 << 6)
+#define UART_IMR_RXBREAK_START	(1 << 10)
 #define UART_IPR_RXSTALE_LAST		0x20
 #define UART_IPR_STALE_LSB		0x1F

drivers/tty/serial/mxs-auart.c+233−17

@@ -14,6 +14,10 @@ · 13 unmodified lines
14	* http://www.gnu.org/copyleft/gpl.html	14	* http://www.gnu.org/copyleft/gpl.html
15	*/	15	*/
16		16
		17	#if defined(CONFIG_SERIAL_MXS_AUART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
		18	#define SUPPORT_SYSRQ
		19	#endif
		20
17	#include <linux/kernel.h>	21	#include <linux/kernel.h>
18	#include <linux/errno.h>	22	#include <linux/errno.h>
19	#include <linux/init.h>	23	#include <linux/init.h>
@@ -38,6 +42,12 @@ · 18 unmodified lines
38		42
39	#include <asm/cacheflush.h>	43	#include <asm/cacheflush.h>
40		44
		45	#include <linux/gpio.h>
		46	#include <linux/gpio/consumer.h>
		47	#include <linux/err.h>
		48	#include <linux/irq.h>
		49	#include "serial_mctrl_gpio.h"
		50
41	#define MXS_AUART_PORTS 5	51	#define MXS_AUART_PORTS 5
42	#define MXS_AUART_FIFO_SIZE 16	52	#define MXS_AUART_FIFO_SIZE 16
43		53
@@ -139,7 +149,7 @@ struct mxs_auart_port { · 95 unmodified lines
139	#define MXS_AUART_DMA_RX_READY 3 /* bit 3 */	149	#define MXS_AUART_DMA_RX_READY 3 /* bit 3 */
140	#define MXS_AUART_RTSCTS 4 /* bit 4 */	150	#define MXS_AUART_RTSCTS 4 /* bit 4 */
141	unsigned long flags;	151	unsigned long flags;
142	unsigned int ctrl;	152	unsigned int mctrl_prev;
143	enum mxs_auart_type devtype;	153	enum mxs_auart_type devtype;
144		154
145	unsigned int irq;	155	unsigned int irq;
@@ -155,6 +165,10 @@ struct mxs_auart_port { · 9 unmodified lines
155	struct scatterlist rx_sgl;	165	struct scatterlist rx_sgl;
156	struct dma_chan *rx_dma_chan;	166	struct dma_chan *rx_dma_chan;
157	void *rx_dma_buf;	167	void *rx_dma_buf;
		168
		169	struct mctrl_gpios *gpios;
		170	int gpio_irq[UART_GPIO_MAX];
		171	bool ms_irq_enabled;
158	};	172	};
159		173
160	static struct platform_device_id mxs_auart_devtype[] = {	174	static struct platform_device_id mxs_auart_devtype[] = {
@@ -414,25 +428,102 @@ static void mxs_auart_set_mctrl(struct uart_port *u, unsigned mctrl) · 253 unmodified lines
414	ctrl \|= AUART_CTRL2_RTS;	428	ctrl \|= AUART_CTRL2_RTS;
415	}	429	}
416		430
417	s->ctrl = mctrl;
418	writel(ctrl, u->membase + AUART_CTRL2);	431	writel(ctrl, u->membase + AUART_CTRL2);
		432
		433	mctrl_gpio_set(s->gpios, mctrl);
		434	}
		435
		436	#define MCTRL_ANY_DELTA (TIOCM_RI \| TIOCM_DSR \| TIOCM_CD \| TIOCM_CTS)
		437	static u32 mxs_auart_modem_status(struct mxs_auart_port *s, u32 mctrl)
		438	{
		439	u32 mctrl_diff;
		440
		441	mctrl_diff = mctrl ^ s->mctrl_prev;
		442	s->mctrl_prev = mctrl;
		443	if (mctrl_diff & MCTRL_ANY_DELTA && s->ms_irq_enabled &&
		444	s->port.state != NULL) {
		445	if (mctrl_diff & TIOCM_RI)
		446	s->port.icount.rng++;
		447	if (mctrl_diff & TIOCM_DSR)
		448	s->port.icount.dsr++;
		449	if (mctrl_diff & TIOCM_CD)
		450	uart_handle_dcd_change(&s->port, mctrl & TIOCM_CD);
		451	if (mctrl_diff & TIOCM_CTS)
		452	uart_handle_cts_change(&s->port, mctrl & TIOCM_CTS);
		453
		454	wake_up_interruptible(&s->port.state->port.delta_msr_wait);
		455	}
		456	return mctrl;
419	}	457	}
420		458
421	static u32 mxs_auart_get_mctrl(struct uart_port *u)	459	static u32 mxs_auart_get_mctrl(struct uart_port *u)
422	{	460	{
423	struct mxs_auart_port *s = to_auart_port(u);	461	struct mxs_auart_port *s = to_auart_port(u);
424	u32 stat = readl(u->membase + AUART_STAT);	462	u32 stat = readl(u->membase + AUART_STAT);
425	int ctrl2 = readl(u->membase + AUART_CTRL2);	463	u32 mctrl = 0;
426	u32 mctrl = s->ctrl;
427		464
428	mctrl &= ~TIOCM_CTS;
429	if (stat & AUART_STAT_CTS)	465	if (stat & AUART_STAT_CTS)
430	mctrl \|= TIOCM_CTS;	466	mctrl \|= TIOCM_CTS;
431		467
432	if (ctrl2 & AUART_CTRL2_RTS)	468	return mctrl_gpio_get(s->gpios, &mctrl);
433	mctrl \|= TIOCM_RTS;	469	}
		470
		471	/*
		472	* Enable modem status interrupts
		473	*/
		474	static void mxs_auart_enable_ms(struct uart_port *port)
		475	{
		476	struct mxs_auart_port *s = to_auart_port(port);
434		477
435	return mctrl;	478	/*
		479	* Interrupt should not be enabled twice
		480	*/
		481	if (s->ms_irq_enabled)
		482	return;
		483
		484	s->ms_irq_enabled = true;
		485
		486	if (s->gpio_irq[UART_GPIO_CTS] >= 0)
		487	enable_irq(s->gpio_irq[UART_GPIO_CTS]);
		488	/* TODO: enable AUART_INTR_CTSMIEN otherwise */
		489
		490	if (s->gpio_irq[UART_GPIO_DSR] >= 0)
		491	enable_irq(s->gpio_irq[UART_GPIO_DSR]);
		492
		493	if (s->gpio_irq[UART_GPIO_RI] >= 0)
		494	enable_irq(s->gpio_irq[UART_GPIO_RI]);
		495
		496	if (s->gpio_irq[UART_GPIO_DCD] >= 0)
		497	enable_irq(s->gpio_irq[UART_GPIO_DCD]);
		498	}
		499
		500	/*
		501	* Disable modem status interrupts
		502	*/
		503	static void mxs_auart_disable_ms(struct uart_port *port)
		504	{
		505	struct mxs_auart_port *s = to_auart_port(port);
		506
		507	/*
		508	* Interrupt should not be disabled twice
		509	*/
		510	if (!s->ms_irq_enabled)
		511	return;
		512
		513	s->ms_irq_enabled = false;
		514
		515	if (s->gpio_irq[UART_GPIO_CTS] >= 0)
		516	disable_irq(s->gpio_irq[UART_GPIO_CTS]);
		517	/* TODO: disable AUART_INTR_CTSMIEN otherwise */
		518
		519	if (s->gpio_irq[UART_GPIO_DSR] >= 0)
		520	disable_irq(s->gpio_irq[UART_GPIO_DSR]);
		521
		522	if (s->gpio_irq[UART_GPIO_RI] >= 0)
		523	disable_irq(s->gpio_irq[UART_GPIO_RI]);
		524
		525	if (s->gpio_irq[UART_GPIO_DCD] >= 0)
		526	disable_irq(s->gpio_irq[UART_GPIO_DCD]);
436	}	527	}
437		528
438	static int mxs_auart_dma_prep_rx(struct mxs_auart_port *s);	529	static int mxs_auart_dma_prep_rx(struct mxs_auart_port *s);
@@ -560,6 +651,10 @@ err_out: · 121 unmodified lines
560		651
561	}	652	}
562		653
		654	#define RTS_AT_AUART() IS_ERR_OR_NULL(mctrl_gpio_to_gpiod(s->gpios, \
		655	UART_GPIO_RTS))
		656	#define CTS_AT_AUART() IS_ERR_OR_NULL(mctrl_gpio_to_gpiod(s->gpios, \
		657	UART_GPIO_CTS))
563	static void mxs_auart_settermios(struct uart_port *u,	658	static void mxs_auart_settermios(struct uart_port *u,
564	struct ktermios *termios,	659	struct ktermios *termios,
565	struct ktermios *old)	660	struct ktermios *old)
@@ -636,6 +731,7 @@ static void mxs_auart_settermios(struct uart_port *u, · 70 unmodified lines
636	ctrl \|= AUART_LINECTRL_STP2;	731	ctrl \|= AUART_LINECTRL_STP2;
637		732
638	/* figure out the hardware flow control settings */	733	/* figure out the hardware flow control settings */
		734	ctrl2 &= ~(AUART_CTRL2_CTSEN \| AUART_CTRL2_RTSEN);
639	if (cflag & CRTSCTS) {	735	if (cflag & CRTSCTS) {
640	/*	736	/*
641	* The DMA has a bug(see errata:2836) in mx23.	737	* The DMA has a bug(see errata:2836) in mx23.
@@ -650,9 +746,11 @@ static void mxs_auart_settermios(struct uart_port *u, · 8 unmodified lines
650	ctrl2 \|= AUART_CTRL2_TXDMAE \| AUART_CTRL2_RXDMAE	746	ctrl2 \|= AUART_CTRL2_TXDMAE \| AUART_CTRL2_RXDMAE
651	\| AUART_CTRL2_DMAONERR;	747	\| AUART_CTRL2_DMAONERR;
652	}	748	}
653	ctrl2 \|= AUART_CTRL2_CTSEN \| AUART_CTRL2_RTSEN;	749	/* Even if RTS is GPIO line RTSEN can be enabled because
654	} else {	750	* the pinctrl configuration decides about RTS pin function */
655	ctrl2 &= ~(AUART_CTRL2_CTSEN \| AUART_CTRL2_RTSEN);	751	ctrl2 \|= AUART_CTRL2_RTSEN;
		752	if (CTS_AT_AUART())
		753	ctrl2 \|= AUART_CTRL2_CTSEN;
656	}	754	}
657		755
658	/* set baud rate */	756	/* set baud rate */
@@ -678,12 +776,30 @@ static void mxs_auart_settermios(struct uart_port *u, · 19 unmodified lines
678	dev_err(s->dev, "We can not start up the DMA.\n");	776	dev_err(s->dev, "We can not start up the DMA.\n");
679	}	777	}
680	}	778	}
		779
		780	/* CTS flow-control and modem-status interrupts */
		781	if (UART_ENABLE_MS(u, termios->c_cflag))
		782	mxs_auart_enable_ms(u);
		783	else
		784	mxs_auart_disable_ms(u);
		785	}
		786
		787	static void mxs_auart_set_ldisc(struct uart_port *port,
		788	struct ktermios *termios)
		789	{
		790	if (termios->c_line == N_PPS) {
		791	port->flags \|= UPF_HARDPPS_CD;
		792	mxs_auart_enable_ms(port);
		793	} else {
		794	port->flags &= ~UPF_HARDPPS_CD;
		795	}
681	}	796	}
682		797
683	static irqreturn_t mxs_auart_irq_handle(int irq, void *context)	798	static irqreturn_t mxs_auart_irq_handle(int irq, void *context)
684	{	799	{
685	u32 istat;	800	u32 istat;
686	struct mxs_auart_port *s = context;	801	struct mxs_auart_port *s = context;
		802	u32 mctrl_temp = s->mctrl_prev;
687	u32 stat = readl(s->port.membase + AUART_STAT);	803	u32 stat = readl(s->port.membase + AUART_STAT);
688		804
689	istat = readl(s->port.membase + AUART_INTR);	805	istat = readl(s->port.membase + AUART_INTR);
@@ -695,8 +811,20 @@ static irqreturn_t mxs_auart_irq_handle(int irq, void *context) · 5 unmodified lines
695	\| AUART_INTR_CTSMIS),	811	\| AUART_INTR_CTSMIS),
696	s->port.membase + AUART_INTR_CLR);	812	s->port.membase + AUART_INTR_CLR);
697		813
		814	/*
		815	* Dealing with GPIO interrupt
		816	*/
		817	if (irq == s->gpio_irq[UART_GPIO_CTS] \|\|
		818	irq == s->gpio_irq[UART_GPIO_DCD] \|\|
		819	irq == s->gpio_irq[UART_GPIO_DSR] \|\|
		820	irq == s->gpio_irq[UART_GPIO_RI])
		821	mxs_auart_modem_status(s,
		822	mctrl_gpio_get(s->gpios, &mctrl_temp));
		823
698	if (istat & AUART_INTR_CTSMIS) {	824	if (istat & AUART_INTR_CTSMIS) {
699	uart_handle_cts_change(&s->port, stat & AUART_STAT_CTS);	825	if (CTS_AT_AUART() && s->ms_irq_enabled)
		826	uart_handle_cts_change(&s->port,
		827	stat & AUART_STAT_CTS);
700	writel(AUART_INTR_CTSMIS,	828	writel(AUART_INTR_CTSMIS,
701	s->port.membase + AUART_INTR_CLR);	829	s->port.membase + AUART_INTR_CLR);
702	istat &= ~AUART_INTR_CTSMIS;	830	istat &= ~AUART_INTR_CTSMIS;
@@ -757,6 +885,10 @@ static int mxs_auart_startup(struct uart_port *u) · 54 unmodified lines
757	*/	885	*/
758	writel(AUART_LINECTRL_FEN, u->membase + AUART_LINECTRL_SET);	886	writel(AUART_LINECTRL_FEN, u->membase + AUART_LINECTRL_SET);
759		887
		888	/* get initial status of modem lines */
		889	mctrl_gpio_get(s->gpios, &s->mctrl_prev);
		890
		891	s->ms_irq_enabled = false;
760	return 0;	892	return 0;
761	}	893	}
762		894
@@ -764,6 +896,8 @@ static void mxs_auart_shutdown(struct uart_port *u) · 1 unmodified line
764	{	896	{
765	struct mxs_auart_port *s = to_auart_port(u);	897	struct mxs_auart_port *s = to_auart_port(u);
766		898
		899	mxs_auart_disable_ms(u);
		900
767	if (auart_dma_enabled(s))	901	if (auart_dma_enabled(s))
768	mxs_auart_dma_exit(s);	902	mxs_auart_dma_exit(s);
769		903
@@ -779,10 +913,11 @@ static void mxs_auart_shutdown(struct uart_port *u) · 9 unmodified lines
779		913
780	static unsigned int mxs_auart_tx_empty(struct uart_port *u)	914	static unsigned int mxs_auart_tx_empty(struct uart_port *u)
781	{	915	{
782	if (readl(u->membase + AUART_STAT) & AUART_STAT_TXFE)	916	if ((readl(u->membase + AUART_STAT) &
		917	(AUART_STAT_TXFE \| AUART_STAT_BUSY)) == AUART_STAT_TXFE)
783	return TIOCSER_TEMT;	918	return TIOCSER_TEMT;
784	else	919
785	return 0;	920	return 0;
786	}	921	}
787		922
788	static void mxs_auart_start_tx(struct uart_port *u)	923	static void mxs_auart_start_tx(struct uart_port *u)
@@ -820,12 +955,14 @@ static struct uart_ops mxs_auart_ops = { · 31 unmodified lines
820	.start_tx = mxs_auart_start_tx,	955	.start_tx = mxs_auart_start_tx,
821	.stop_tx = mxs_auart_stop_tx,	956	.stop_tx = mxs_auart_stop_tx,
822	.stop_rx = mxs_auart_stop_rx,	957	.stop_rx = mxs_auart_stop_rx,
		958	.enable_ms = mxs_auart_enable_ms,
823	.break_ctl = mxs_auart_break_ctl,	959	.break_ctl = mxs_auart_break_ctl,
824	.set_mctrl = mxs_auart_set_mctrl,	960	.set_mctrl = mxs_auart_set_mctrl,
825	.get_mctrl = mxs_auart_get_mctrl,	961	.get_mctrl = mxs_auart_get_mctrl,
826	.startup = mxs_auart_startup,	962	.startup = mxs_auart_startup,
827	.shutdown = mxs_auart_shutdown,	963	.shutdown = mxs_auart_shutdown,
828	.set_termios = mxs_auart_settermios,	964	.set_termios = mxs_auart_settermios,
		965	.set_ldisc = mxs_auart_set_ldisc,
829	.type = mxs_auart_type,	966	.type = mxs_auart_type,
830	.release_port = mxs_auart_release_port,	967	.release_port = mxs_auart_release_port,
831	.request_port = mxs_auart_request_port,	968	.request_port = mxs_auart_request_port,
@@ -1020,6 +1157,71 @@ static int serial_mxs_probe_dt(struct mxs_auart_port *s, · 188 unmodified lines
1020	return 0;	1157	return 0;
1021	}	1158	}
1022		1159
		1160	static bool mxs_auart_init_gpios(struct mxs_auart_port s, struct device dev)
		1161	{
		1162	enum mctrl_gpio_idx i;
		1163	struct gpio_desc *gpiod;
		1164
		1165	s->gpios = mctrl_gpio_init(dev, 0);
		1166	if (IS_ERR_OR_NULL(s->gpios))
		1167	return false;
		1168
		1169	/* Block (enabled before) DMA option if RTS or CTS is GPIO line */
		1170	if (!RTS_AT_AUART() \|\| !CTS_AT_AUART()) {
		1171	if (test_bit(MXS_AUART_RTSCTS, &s->flags))
		1172	dev_warn(dev,
		1173	"DMA and flow control via gpio may cause some problems. DMA disabled!\n");
		1174	clear_bit(MXS_AUART_RTSCTS, &s->flags);
		1175	}
		1176
		1177	for (i = 0; i < UART_GPIO_MAX; i++) {
		1178	gpiod = mctrl_gpio_to_gpiod(s->gpios, i);
		1179	if (gpiod && (gpiod_get_direction(gpiod) == GPIOF_DIR_IN))
		1180	s->gpio_irq[i] = gpiod_to_irq(gpiod);
		1181	else
		1182	s->gpio_irq[i] = -EINVAL;
		1183	}
		1184
		1185	return true;
		1186	}
		1187
		1188	static void mxs_auart_free_gpio_irq(struct mxs_auart_port *s)
		1189	{
		1190	enum mctrl_gpio_idx i;
		1191
		1192	for (i = 0; i < UART_GPIO_MAX; i++)
		1193	if (s->gpio_irq[i] >= 0)
		1194	free_irq(s->gpio_irq[i], s);
		1195	}
		1196
		1197	static int mxs_auart_request_gpio_irq(struct mxs_auart_port *s)
		1198	{
		1199	int *irq = s->gpio_irq;
		1200	enum mctrl_gpio_idx i;
		1201	int err = 0;
		1202
		1203	for (i = 0; (i < UART_GPIO_MAX) && !err; i++) {
		1204	if (irq[i] < 0)
		1205	continue;
		1206
		1207	irq_set_status_flags(irq[i], IRQ_NOAUTOEN);
		1208	err = request_irq(irq[i], mxs_auart_irq_handle,
		1209	IRQ_TYPE_EDGE_BOTH, dev_name(s->dev), s);
		1210	if (err)
		1211	dev_err(s->dev, "%s - Can't get %d irq\n",
		1212	__func__, irq[i]);
		1213	}
		1214
		1215	/*
		1216	* If something went wrong, rollback.
		1217	*/
		1218	while (err && (--i >= 0))
		1219	if (irq[i] >= 0)
		1220	free_irq(irq[i], s);
		1221
		1222	return err;
		1223	}
		1224
1023	static int mxs_auart_probe(struct platform_device *pdev)	1225	static int mxs_auart_probe(struct platform_device *pdev)
1024	{	1226	{
1025	const struct of_device_id *of_id =	1227	const struct of_device_id *of_id =
@@ -1067,7 +1269,7 @@ static int mxs_auart_probe(struct platform_device *pdev) · 41 unmodified lines
1067	s->port.type = PORT_IMX;	1269	s->port.type = PORT_IMX;
1068	s->port.dev = s->dev = &pdev->dev;	1270	s->port.dev = s->dev = &pdev->dev;
1069		1271
1070	s->ctrl = 0;	1272	s->mctrl_prev = 0;
1071		1273
1072	s->irq = platform_get_irq(pdev, 0);	1274	s->irq = platform_get_irq(pdev, 0);
1073	s->port.irq = s->irq;	1275	s->port.irq = s->irq;
@@ -1077,13 +1279,24 @@ static int mxs_auart_probe(struct platform_device *pdev) · 3 unmodified lines
1077		1279
1078	platform_set_drvdata(pdev, s);	1280	platform_set_drvdata(pdev, s);
1079		1281
		1282	if (!mxs_auart_init_gpios(s, &pdev->dev))
		1283	dev_err(&pdev->dev,
		1284	"Failed to initialize GPIOs. The serial port may not work as expected\n");
		1285
		1286	/*
		1287	* Get the GPIO lines IRQ
		1288	*/
		1289	ret = mxs_auart_request_gpio_irq(s);
		1290	if (ret)
		1291	goto out_free_irq;
		1292
1080	auart_port[s->port.line] = s;	1293	auart_port[s->port.line] = s;
1081		1294
1082	mxs_auart_reset(&s->port);	1295	mxs_auart_reset(&s->port);
1083		1296
1084	ret = uart_add_one_port(&auart_driver, &s->port);	1297	ret = uart_add_one_port(&auart_driver, &s->port);
1085	if (ret)	1298	if (ret)
1086	goto out_free_irq;	1299	goto out_free_gpio_irq;
1087		1300
1088	version = readl(s->port.membase + AUART_VERSION);	1301	version = readl(s->port.membase + AUART_VERSION);
1089	dev_info(&pdev->dev, "Found APPUART %d.%d.%d\n",	1302	dev_info(&pdev->dev, "Found APPUART %d.%d.%d\n",
@@ -1092,6 +1305,8 @@ static int mxs_auart_probe(struct platform_device *pdev) · 2 unmodified lines
1092		1305
1093	return 0;	1306	return 0;
1094		1307
		1308	out_free_gpio_irq:
		1309	mxs_auart_free_gpio_irq(s);
1095	out_free_irq:	1310	out_free_irq:
1096	auart_port[pdev->id] = NULL;	1311	auart_port[pdev->id] = NULL;
1097	free_irq(s->irq, s);	1312	free_irq(s->irq, s);
@@ -1111,6 +1326,7 @@ static int mxs_auart_remove(struct platform_device *pdev) · 13 unmodified lines
1111		1326
1112	auart_port[pdev->id] = NULL;	1327	auart_port[pdev->id] = NULL;
1113		1328
		1329	mxs_auart_free_gpio_irq(s);
1114	clk_put(s->clk);	1330	clk_put(s->clk);
1115	free_irq(s->irq, s);	1331	free_irq(s->irq, s);
1116	kfree(s);	1332	kfree(s);

drivers/tty/serial/of_serial.c+74−1

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	* 2 of the License, or (at your option) any later version.	9	* 2 of the License, or (at your option) any later version.
10	*	10	*
11	*/	11	*/
		12	#include <linux/console.h>
12	#include <linux/module.h>	13	#include <linux/module.h>
13	#include <linux/slab.h>	14	#include <linux/slab.h>
14	#include <linux/delay.h>	15	#include <linux/delay.h>
@@ -129,8 +130,15 @@ static int of_platform_serial_setup(struct platform_device *ofdev, · 114 unmodified lines
129		130
130	port->dev = &ofdev->dev;	131	port->dev = &ofdev->dev;
131		132
132	if (type == PORT_TEGRA)	133	switch (type) {
		134	case PORT_TEGRA:
133	port->handle_break = tegra_serial_handle_break;	135	port->handle_break = tegra_serial_handle_break;
		136	break;
		137
		138	case PORT_RT2880:
		139	port->iotype = UPIO_AU;
		140	break;
		141	}
134		142
135	return 0;	143	return 0;
136	out:	144	out:
@@ -240,6 +248,70 @@ static int of_platform_serial_remove(struct platform_device *ofdev) · 103 unmodified lines
240	return 0;	248	return 0;
241	}	249	}
242		250
		251	#ifdef CONFIG_PM_SLEEP
		252	#ifdef CONFIG_SERIAL_8250
		253	static void of_serial_suspend_8250(struct of_serial_info *info)
		254	{
		255	struct uart_8250_port *port8250 = serial8250_get_port(info->line);
		256	struct uart_port *port = &port8250->port;
		257
		258	serial8250_suspend_port(info->line);
		259	if (info->clk && (!uart_console(port) \|\| console_suspend_enabled))
		260	clk_disable_unprepare(info->clk);
		261	}
		262
		263	static void of_serial_resume_8250(struct of_serial_info *info)
		264	{
		265	struct uart_8250_port *port8250 = serial8250_get_port(info->line);
		266	struct uart_port *port = &port8250->port;
		267
		268	if (info->clk && (!uart_console(port) \|\| console_suspend_enabled))
		269	clk_prepare_enable(info->clk);
		270
		271	serial8250_resume_port(info->line);
		272	}
		273	#else
		274	static inline void of_serial_suspend_8250(struct of_serial_info *info)
		275	{
		276	}
		277
		278	static inline void of_serial_resume_8250(struct of_serial_info *info)
		279	{
		280	}
		281	#endif
		282
		283	static int of_serial_suspend(struct device *dev)
		284	{
		285	struct of_serial_info *info = dev_get_drvdata(dev);
		286
		287	switch (info->type) {
		288	case PORT_8250 ... PORT_MAX_8250:
		289	of_serial_suspend_8250(info);
		290	break;
		291	default:
		292	break;
		293	}
		294
		295	return 0;
		296	}
		297
		298	static int of_serial_resume(struct device *dev)
		299	{
		300	struct of_serial_info *info = dev_get_drvdata(dev);
		301
		302	switch (info->type) {
		303	case PORT_8250 ... PORT_MAX_8250:
		304	of_serial_resume_8250(info);
		305	break;
		306	default:
		307	break;
		308	}
		309
		310	return 0;
		311	}
		312	#endif
		313	static SIMPLE_DEV_PM_OPS(of_serial_pm_ops, of_serial_suspend, of_serial_resume);
		314
243	/*	315	/*
244	* A few common types, add more as needed.	316	* A few common types, add more as needed.
245	*/	317	*/
@@ -252,6 +324,7 @@ static struct of_device_id of_platform_serial_table[] = { · 6 unmodified lines
252	{ .compatible = "ns16850", .data = (void *)PORT_16850, },	324	{ .compatible = "ns16850", .data = (void *)PORT_16850, },
253	{ .compatible = "nvidia,tegra20-uart", .data = (void *)PORT_TEGRA, },	325	{ .compatible = "nvidia,tegra20-uart", .data = (void *)PORT_TEGRA, },
254	{ .compatible = "nxp,lpc3220-uart", .data = (void *)PORT_LPC3220, },	326	{ .compatible = "nxp,lpc3220-uart", .data = (void *)PORT_LPC3220, },
		327	{ .compatible = "ralink,rt2880-uart", .data = (void *)PORT_RT2880, },
255	{ .compatible = "altr,16550-FIFO32",	328	{ .compatible = "altr,16550-FIFO32",
256	.data = (void *)PORT_ALTR_16550_F32, },	329	.data = (void *)PORT_ALTR_16550_F32, },
257	{ .compatible = "altr,16550-FIFO64",	330	{ .compatible = "altr,16550-FIFO64",

drivers/tty/serial/omap-serial.c+35−58

 #include <dt-bindings/gpio/gpio.h>
-#define OMAP_MAX_HSUART_PORTS	6
+#define OMAP_MAX_HSUART_PORTS	10
 #define UART_BUILD_REVISION(x, y)	(((x) << 8) | (y))
 	u8			wakeups_enabled;
 	u32			features;
-	struct serial_rs485	rs485;
 	int			rts_gpio;
 	struct pm_qos_request	pm_qos_request;
 	pm_runtime_get_sync(up->dev);
 	/* Handle RS-485 */
-	if (up->rs485.flags & SER_RS485_ENABLED) {
+	if (port->rs485.flags & SER_RS485_ENABLED) {
 		if (up->scr & OMAP_UART_SCR_TX_EMPTY) {
 			/* THR interrupt is fired when both TX FIFO and TX
 			 * shift register are empty. This means there's nothing
 			 */
 			up->scr &= ~OMAP_UART_SCR_TX_EMPTY;
 			serial_out(up, UART_OMAP_SCR, up->scr);
-			res = (up->rs485.flags & SER_RS485_RTS_AFTER_SEND) ? 1 : 0;
+			res = (port->rs485.flags & SER_RS485_RTS_AFTER_SEND) ?
+				1 : 0;
 			if (gpio_get_value(up->rts_gpio) != res) {
-				if (up->rs485.delay_rts_after_send > 0)
+				if (port->rs485.delay_rts_after_send > 0)
-					mdelay(up->rs485.delay_rts_after_send);
+					mdelay(
+					port->rs485.delay_rts_after_send);
 				gpio_set_value(up->rts_gpio, res);
 			}
 		} else {
 		serial_out(up, UART_IER, up->ier);
 	}
-	if ((up->rs485.flags & SER_RS485_ENABLED) &&
+	if ((port->rs485.flags & SER_RS485_ENABLED) &&
-	    !(up->rs485.flags & SER_RS485_RX_DURING_TX)) {
+	    !(port->rs485.flags & SER_RS485_RX_DURING_TX)) {
 		/*
 		 * Empty the RX FIFO, we are not interested in anything
 		 * received during the half-duplex transmission.
 	pm_runtime_get_sync(up->dev);
 	/* Handle RS-485 */
-	if (up->rs485.flags & SER_RS485_ENABLED) {
+	if (port->rs485.flags & SER_RS485_ENABLED) {
 		/* Fire THR interrupts when FIFO is below trigger level */
 		up->scr &= ~OMAP_UART_SCR_TX_EMPTY;
 		serial_out(up, UART_OMAP_SCR, up->scr);
 		/* if rts not already enabled */
-		res = (up->rs485.flags & SER_RS485_RTS_ON_SEND) ? 1 : 0;
+		res = (port->rs485.flags & SER_RS485_RTS_ON_SEND) ? 1 : 0;
 		if (gpio_get_value(up->rts_gpio) != res) {
 			gpio_set_value(up->rts_gpio, res);
-			if (up->rs485.delay_rts_before_send > 0)
+			if (port->rs485.delay_rts_before_send > 0)
-				mdelay(up->rs485.delay_rts_before_send);
+				mdelay(port->rs485.delay_rts_before_send);
 		}
 	}
-	if ((up->rs485.flags & SER_RS485_ENABLED) &&
+	if ((port->rs485.flags & SER_RS485_ENABLED) &&
-	    !(up->rs485.flags & SER_RS485_RX_DURING_TX))
+	    !(port->rs485.flags & SER_RS485_RX_DURING_TX))
 		serial_omap_stop_rx(port);
 	serial_omap_enable_ier_thri(up);
 #endif
 /* Enable or disable the rs485 support */
-static void
+static int
 serial_omap_config_rs485(struct uart_port *port, struct serial_rs485 *rs485conf)
 {
 	struct uart_omap_port *up = to_uart_omap_port(port);
-	unsigned long flags;
 	unsigned int mode;
 	int val;
 	pm_runtime_get_sync(up->dev);
-	spin_lock_irqsave(&up->port.lock, flags);
 	/* Disable interrupts from this port */
 	mode = up->ier;
 	serial_out(up, UART_IER, 0);
 	/* store new config */
-	up->rs485 = *rs485conf;
+	port->rs485 = *rs485conf;
 	/*
 	 * Just as a precaution, only allow rs485
 	 */
 	if (gpio_is_valid(up->rts_gpio)) {
 		/* enable / disable rts */
-		val = (up->rs485.flags & SER_RS485_ENABLED) ?
+		val = (port->rs485.flags & SER_RS485_ENABLED) ?
 			SER_RS485_RTS_AFTER_SEND : SER_RS485_RTS_ON_SEND;
-		val = (up->rs485.flags & val) ? 1 : 0;
+		val = (port->rs485.flags & val) ? 1 : 0;
 		gpio_set_value(up->rts_gpio, val);
 	} else
-		up->rs485.flags &= ~SER_RS485_ENABLED;
+		port->rs485.flags &= ~SER_RS485_ENABLED;
 	/* Enable interrupts */
 	up->ier = mode;
 	/* If RS-485 is disabled, make sure the THR interrupt is fired when
 	 * TX FIFO is below the trigger level.
 	 */
-	if (!(up->rs485.flags & SER_RS485_ENABLED) &&
+	if (!(port->rs485.flags & SER_RS485_ENABLED) &&
 	    (up->scr & OMAP_UART_SCR_TX_EMPTY)) {
 		up->scr &= ~OMAP_UART_SCR_TX_EMPTY;
 		serial_out(up, UART_OMAP_SCR, up->scr);
 	}
-	spin_unlock_irqrestore(&up->port.lock, flags);
 	pm_runtime_mark_last_busy(up->dev);
 	pm_runtime_put_autosuspend(up->dev);
-}
-static int
-serial_omap_ioctl(struct uart_port *port, unsigned int cmd, unsigned long arg)
-{
-	struct serial_rs485 rs485conf;
-	switch (cmd) {
-	case TIOCSRS485:
-		if (copy_from_user(&rs485conf, (void __user *) arg,
-					sizeof(rs485conf)))
-			return -EFAULT;
-		serial_omap_config_rs485(port, &rs485conf);
-		break;
-	case TIOCGRS485:
-		if (copy_to_user((void __user *) arg,
-					&(to_uart_omap_port(port)->rs485),
-					sizeof(rs485conf)))
-			return -EFAULT;
-		break;
-	default:
-		return -ENOIOCTLCMD;
-	}
 	return 0;
 }
 static struct uart_ops serial_omap_pops = {
 	.tx_empty	= serial_omap_tx_empty,
 	.set_mctrl	= serial_omap_set_mctrl,
 	.request_port	= serial_omap_request_port,
 	.config_port	= serial_omap_config_port,
 	.verify_port	= serial_omap_verify_port,
-	.ioctl		= serial_omap_ioctl,
 #ifdef CONFIG_CONSOLE_POLL
 	.poll_put_char  = serial_omap_poll_put_char,
 	.poll_get_char  = serial_omap_poll_get_char,
 static int serial_omap_probe_rs485(struct uart_omap_port *up,
 				   struct device_node *np)
 {
-	struct serial_rs485 *rs485conf = &up->rs485;
+	struct serial_rs485 *rs485conf = &up->port.rs485;
 	u32 rs485_delay[2];
 	enum of_gpio_flags flags;
 	int ret;
 	up->port.ops = &serial_omap_pops;
 	if (pdev->dev.of_node)
-		up->port.line = of_alias_get_id(pdev->dev.of_node, "serial");
+		ret = of_alias_get_id(pdev->dev.of_node, "serial");
 	else
-		up->port.line = pdev->id;
+		ret = pdev->id;
-	if (up->port.line < 0) {
+	if (ret < 0) {
 		dev_err(&pdev->dev, "failed to get alias/pdev id, errno %d\n",
-								up->port.line);
+			ret);
-		ret = -ENODEV;
+		goto err_port_line;
+	}
+	up->port.line = ret;
+	if (up->port.line >= OMAP_MAX_HSUART_PORTS) {
+		dev_err(&pdev->dev, "uart ID %d >  MAX %d.\n", up->port.line,
+			OMAP_MAX_HSUART_PORTS);
+		ret = -ENXIO;
 		goto err_port_line;
 	}
 	up->port.membase = base;
 	up->port.flags = omap_up_info->flags;
 	up->port.uartclk = omap_up_info->uartclk;
+	up->port.rs485_config = serial_omap_config_rs485;
 	if (!up->port.uartclk) {
 		up->port.uartclk = DEFAULT_CLK_SPEED;
 		dev_warn(&pdev->dev,
 	pm_runtime_disable(&pdev->dev);
 err_rs485:
 err_port_line:
-	dev_err(&pdev->dev, "[UART%d]: failure [%s]: %d\n",
-				pdev->id, __func__, ret);
 	return ret;
 }

drivers/tty/serial/pmac_zilog.c+6−3

 static int pmz_poll_get_char(struct uart_port *port)
 {
-	struct uart_pmac_port *uap = (struct uart_pmac_port *)port;
+	struct uart_pmac_port *uap =
+		container_of(port, struct uart_pmac_port, port);
 	int tries = 2;
 	while (tries) {
 static void pmz_poll_put_char(struct uart_port *port, unsigned char c)
 {
-	struct uart_pmac_port *uap = (struct uart_pmac_port *)port;
+	struct uart_pmac_port *uap =
+		container_of(port, struct uart_pmac_port, port);
 	/* Wait for the transmit buffer to empty. */
 	while ((read_zsreg(uap, R0) & Tx_BUF_EMP) == 0)
 static void pmz_console_putchar(struct uart_port *port, int ch)
 {
-	struct uart_pmac_port *uap = (struct uart_pmac_port *)port;
+	struct uart_pmac_port *uap =
+		container_of(port, struct uart_pmac_port, port);
 	/* Wait for the transmit buffer to empty. */
 	while ((read_zsreg(uap, R0) & Tx_BUF_EMP) == 0)

drivers/tty/serial/pnx8xxx_uart.c+32−16

  */
 static void pnx8xxx_stop_tx(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	u32 ien;
 	/* Disable TX intr */
  */
 static void pnx8xxx_start_tx(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	u32 ien;
 	/* Clear all pending TX intr */
  */
 static void pnx8xxx_stop_rx(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	u32 ien;
 	/* Disable RX intr */
  */
 static void pnx8xxx_enable_ms(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	mod_timer(&sport->timer, jiffies);
 }
  */
 static unsigned int pnx8xxx_tx_empty(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	return serial_in(sport, PNX8XXX_FIFO) & PNX8XXX_UART_FIFO_TXFIFO_STA ? 0 : TIOCSER_TEMT;
 }
 static unsigned int pnx8xxx_get_mctrl(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	unsigned int mctrl = TIOCM_DSR;
 	unsigned int msr;
  */
 static void pnx8xxx_break_ctl(struct uart_port *port, int break_state)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	unsigned long flags;
 	unsigned int lcr;
 static int pnx8xxx_startup(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	int retval;
 	/*
 static void pnx8xxx_shutdown(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	int lcr;
 	/*
 pnx8xxx_set_termios(struct uart_port *port, struct ktermios *termios,
 		   struct ktermios *old)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	unsigned long flags;
 	unsigned int lcr_fcr, old_ien, baud, quot;
 	unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8;
 static const char *pnx8xxx_type(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	return sport->port.type == PORT_PNX8XXX ? "PNX8XXX" : NULL;
 }
  */
 static void pnx8xxx_release_port(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	release_mem_region(sport->port.mapbase, UART_PORT_SIZE);
 }
  */
 static int pnx8xxx_request_port(struct uart_port *port)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	return request_mem_region(sport->port.mapbase, UART_PORT_SIZE,
 			"pnx8xxx-uart") != NULL ? 0 : -EBUSY;
 }
  */
 static void pnx8xxx_config_port(struct uart_port *port, int flags)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	if (flags & UART_CONFIG_TYPE &&
 	    pnx8xxx_request_port(&sport->port) == 0)
 static int
 pnx8xxx_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port,	port);
 	int ret = 0;
 	if (ser->type != PORT_UNKNOWN && ser->type != PORT_PNX8XXX)
 static void pnx8xxx_console_putchar(struct uart_port *port, int ch)
 {
-	struct pnx8xxx_port *sport = (struct pnx8xxx_port *)port;
+	struct pnx8xxx_port *sport =
+		container_of(port, struct pnx8xxx_port, port);
 	int status;
 	do {

drivers/tty/serial/pxa.c+3−0

 	}
 }
+/* should hold up->port.lock */
 static inline void check_modem_status(struct uart_pxa_port *up)
 {
 	int status;
 	iir = serial_in(up, UART_IIR);
 	if (iir & UART_IIR_NO_INT)
 		return IRQ_NONE;
+	spin_lock(&up->port.lock);
 	lsr = serial_in(up, UART_LSR);
 	if (lsr & UART_LSR_DR)
 		receive_chars(up, &lsr);
 	check_modem_status(up);
 	if (lsr & UART_LSR_THRE)
 		transmit_chars(up);
+	spin_unlock(&up->port.lock);
 	return IRQ_HANDLED;
 }

drivers/tty/serial/sa1100.c+30−15

  */
 static void sa1100_stop_tx(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	u32 utcr3;
 	utcr3 = UART_GET_UTCR3(sport);
  */
 static void sa1100_start_tx(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	u32 utcr3;
 	utcr3 = UART_GET_UTCR3(sport);
  */
 static void sa1100_stop_rx(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	u32 utcr3;
 	utcr3 = UART_GET_UTCR3(sport);
  */
 static void sa1100_enable_ms(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	mod_timer(&sport->timer, jiffies);
 }
  */
 static unsigned int sa1100_tx_empty(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	return UART_GET_UTSR1(sport) & UTSR1_TBY ? 0 : TIOCSER_TEMT;
 }
  */
 static void sa1100_break_ctl(struct uart_port *port, int break_state)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	unsigned long flags;
 	unsigned int utcr3;
 static int sa1100_startup(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	int retval;
 	/*
 static void sa1100_shutdown(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	/*
 	 * Stop our timer.
 sa1100_set_termios(struct uart_port *port, struct ktermios *termios,
 		   struct ktermios *old)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	unsigned long flags;
 	unsigned int utcr0, old_utcr3, baud, quot;
 	unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8;
 static const char *sa1100_type(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	return sport->port.type == PORT_SA1100 ? "SA1100" : NULL;
 }
  */
 static void sa1100_release_port(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	release_mem_region(sport->port.mapbase, UART_PORT_SIZE);
 }
  */
 static int sa1100_request_port(struct uart_port *port)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	return request_mem_region(sport->port.mapbase, UART_PORT_SIZE,
 			"sa11x0-uart") != NULL ? 0 : -EBUSY;
  */
 static void sa1100_config_port(struct uart_port *port, int flags)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	if (flags & UART_CONFIG_TYPE &&
 	    sa1100_request_port(&sport->port) == 0)
 static int
 sa1100_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	int ret = 0;
 	if (ser->type != PORT_UNKNOWN && ser->type != PORT_SA1100)
 #ifdef CONFIG_SERIAL_SA1100_CONSOLE
 static void sa1100_console_putchar(struct uart_port *port, int ch)
 {
-	struct sa1100_port *sport = (struct sa1100_port *)port;
+	struct sa1100_port *sport =
+		container_of(port, struct sa1100_port, port);
 	while (!(UART_GET_UTSR1(sport) & UTSR1_TNF))
 		barrier();

drivers/tty/serial/samsung.c+38−52

@@ -199,12 +199,14 @@ static void s3c24xx_serial_stop_rx(struct uart_port *port) · 198 unmodified lines
199	}	199	}
200	}	200	}
201		201
202	static inline struct s3c24xx_uart_info s3c24xx_port_to_info(struct uart_port port)	202	static inline struct s3c24xx_uart_info
		203	s3c24xx_port_to_info(struct uart_port port)
203	{	204	{
204	return to_ourport(port)->info;	205	return to_ourport(port)->info;
205	}	206	}
206		207
207	static inline struct s3c2410_uartcfg s3c24xx_port_to_cfg(struct uart_port port)	208	static inline struct s3c2410_uartcfg
		209	s3c24xx_port_to_cfg(struct uart_port port)
208	{	210	{
209	struct s3c24xx_uart_port *ourport;	211	struct s3c24xx_uart_port *ourport;
210		212
@@ -237,7 +239,7 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id) · 26 unmodified lines
237	struct uart_port *port = &ourport->port;	239	struct uart_port *port = &ourport->port;
238	unsigned int ufcon, ch, flag, ufstat, uerstat;	240	unsigned int ufcon, ch, flag, ufstat, uerstat;
239	unsigned long flags;	241	unsigned long flags;
240	int max_count = 64;	242	int max_count = port->fifosize;
241		243
242	spin_lock_irqsave(&port->lock, flags);	244	spin_lock_irqsave(&port->lock, flags);
243		245
@@ -311,14 +313,14 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id) · 67 unmodified lines
311	uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,	313	uart_insert_char(port, uerstat, S3C2410_UERSTAT_OVERRUN,
312	ch, flag);	314	ch, flag);
313		315
314	ignore_char:	316	ignore_char:
315	continue;	317	continue;
316	}	318	}
317		319
318	spin_unlock_irqrestore(&port->lock, flags);	320	spin_unlock_irqrestore(&port->lock, flags);
319	tty_flip_buffer_push(&port->state->port);	321	tty_flip_buffer_push(&port->state->port);
320		322
321	out:	323	out:
322	return IRQ_HANDLED;	324	return IRQ_HANDLED;
323	}	325	}
324		326
@@ -328,7 +330,7 @@ static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id) · 3 unmodified lines
328	struct uart_port *port = &ourport->port;	330	struct uart_port *port = &ourport->port;
329	struct circ_buf *xmit = &port->state->xmit;	331	struct circ_buf *xmit = &port->state->xmit;
330	unsigned long flags;	332	unsigned long flags;
331	int count = 256;	333	int count = port->fifosize;
332		334
333	spin_lock_irqsave(&port->lock, flags);	335	spin_lock_irqsave(&port->lock, flags);
334		336
@@ -368,7 +370,7 @@ static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id) · 33 unmodified lines
368	if (uart_circ_empty(xmit))	370	if (uart_circ_empty(xmit))
369	s3c24xx_serial_stop_tx(port);	371	s3c24xx_serial_stop_tx(port);
370		372
371	out:	373	out:
372	spin_unlock_irqrestore(&port->lock, flags);	374	spin_unlock_irqrestore(&port->lock, flags);
373	return IRQ_HANDLED;	375	return IRQ_HANDLED;
374	}	376	}
@@ -519,7 +521,7 @@ static int s3c24xx_serial_startup(struct uart_port *port) · 144 unmodified lines
519		521
520	return ret;	522	return ret;
521		523
522	err:	524	err:
523	s3c24xx_serial_shutdown(port);	525	s3c24xx_serial_shutdown(port);
524	return ret;	526	return ret;
525	}	527	}
@@ -559,11 +561,15 @@ static void s3c24xx_serial_pm(struct uart_port *port, unsigned int level, · 33 unmodified lines
559	unsigned int old)	561	unsigned int old)
560	{	562	{
561	struct s3c24xx_uart_port *ourport = to_ourport(port);	563	struct s3c24xx_uart_port *ourport = to_ourport(port);
		564	int timeout = 10000;
562		565
563	ourport->pm_level = level;	566	ourport->pm_level = level;
564		567
565	switch (level) {	568	switch (level) {
566	case 3:	569	case 3:
		570	while (--timeout && !s3c24xx_serial_txempty_nofifo(port))
		571	udelay(100);
		572
567	if (!IS_ERR(ourport->baudclk))	573	if (!IS_ERR(ourport->baudclk))
568	clk_disable_unprepare(ourport->baudclk);	574	clk_disable_unprepare(ourport->baudclk);
569		575
@@ -841,8 +847,8 @@ static void s3c24xx_serial_set_termios(struct uart_port *port, · 271 unmodified lines
841	*/	847	*/
842	port->read_status_mask = S3C2410_UERSTAT_OVERRUN;	848	port->read_status_mask = S3C2410_UERSTAT_OVERRUN;
843	if (termios->c_iflag & INPCK)	849	if (termios->c_iflag & INPCK)
844	port->read_status_mask \|= S3C2410_UERSTAT_FRAME \| S3C2410_UERSTAT_PARITY;	850	port->read_status_mask \|= S3C2410_UERSTAT_FRAME \|
845		851	S3C2410_UERSTAT_PARITY;
846	/*	852	/*
847	* Which character status flags should we ignore?	853	* Which character status flags should we ignore?
848	*/	854	*/
@@ -969,10 +975,13 @@ static struct uart_driver s3c24xx_uart_drv = { · 120 unmodified lines
969	.minor = S3C24XX_SERIAL_MINOR,	975	.minor = S3C24XX_SERIAL_MINOR,
970	};	976	};
971		977
972	static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS] = {	978	#define __PORT_LOCK_UNLOCKED(i) \
		979	__SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[i].port.lock)
		980	static struct s3c24xx_uart_port
		981	s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS] = {
973	[0] = {	982	[0] = {
974	.port = {	983	.port = {
975	.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),	984	.lock = __PORT_LOCK_UNLOCKED(0),
976	.iotype = UPIO_MEM,	985	.iotype = UPIO_MEM,
977	.uartclk = 0,	986	.uartclk = 0,
978	.fifosize = 16,	987	.fifosize = 16,
@@ -983,7 +992,7 @@ static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS · 4 unmodified lines
983	},	992	},
984	[1] = {	993	[1] = {
985	.port = {	994	.port = {
986	.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[1].port.lock),	995	.lock = __PORT_LOCK_UNLOCKED(1),
987	.iotype = UPIO_MEM,	996	.iotype = UPIO_MEM,
988	.uartclk = 0,	997	.uartclk = 0,
989	.fifosize = 16,	998	.fifosize = 16,
@@ -996,7 +1005,7 @@ static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS · 6 unmodified lines
996		1005
997	[2] = {	1006	[2] = {
998	.port = {	1007	.port = {
999	.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[2].port.lock),	1008	.lock = __PORT_LOCK_UNLOCKED(2),
1000	.iotype = UPIO_MEM,	1009	.iotype = UPIO_MEM,
1001	.uartclk = 0,	1010	.uartclk = 0,
1002	.fifosize = 16,	1011	.fifosize = 16,
@@ -1009,7 +1018,7 @@ static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS · 6 unmodified lines
1009	#if CONFIG_SERIAL_SAMSUNG_UARTS > 3	1018	#if CONFIG_SERIAL_SAMSUNG_UARTS > 3
1010	[3] = {	1019	[3] = {
1011	.port = {	1020	.port = {
1012	.lock = __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[3].port.lock),	1021	.lock = __PORT_LOCK_UNLOCKED(3),
1013	.iotype = UPIO_MEM,	1022	.iotype = UPIO_MEM,
1014	.uartclk = 0,	1023	.uartclk = 0,
1015	.fifosize = 16,	1024	.fifosize = 16,
@@ -1020,6 +1029,7 @@ static struct s3c24xx_uart_port s3c24xx_serial_ports[CONFIG_SERIAL_SAMSUNG_UARTS · 4 unmodified lines
1020	}	1029	}
1021	#endif	1030	#endif
1022	};	1031	};
		1032	#undef __PORT_LOCK_UNLOCKED
1023		1033
1024	/* s3c24xx_serial_resetport	1034	/* s3c24xx_serial_resetport
1025	*	1035	*
@@ -1102,11 +1112,12 @@ static int s3c24xx_serial_cpufreq_transition(struct notifier_block *nb, · 76 unmodified lines
1102	s3c24xx_serial_set_termios(uport, termios, NULL);	1112	s3c24xx_serial_set_termios(uport, termios, NULL);
1103	}	1113	}
1104		1114
1105	exit:	1115	exit:
1106	return 0;	1116	return 0;
1107	}	1117	}
1108		1118
1109	static inline int s3c24xx_serial_cpufreq_register(struct s3c24xx_uart_port *port)	1119	static inline int
		1120	s3c24xx_serial_cpufreq_register(struct s3c24xx_uart_port *port)
1110	{	1121	{
1111	port->freq_transition.notifier_call = s3c24xx_serial_cpufreq_transition;	1122	port->freq_transition.notifier_call = s3c24xx_serial_cpufreq_transition;
1112		1123
@@ -1114,19 +1125,22 @@ static inline int s3c24xx_serial_cpufreq_register(struct s3c24xx_uart_port *port · 1 unmodified line
1114	CPUFREQ_TRANSITION_NOTIFIER);	1125	CPUFREQ_TRANSITION_NOTIFIER);
1115	}	1126	}
1116		1127
1117	static inline void s3c24xx_serial_cpufreq_deregister(struct s3c24xx_uart_port *port)	1128	static inline void
		1129	s3c24xx_serial_cpufreq_deregister(struct s3c24xx_uart_port *port)
1118	{	1130	{
1119	cpufreq_unregister_notifier(&port->freq_transition,	1131	cpufreq_unregister_notifier(&port->freq_transition,
1120	CPUFREQ_TRANSITION_NOTIFIER);	1132	CPUFREQ_TRANSITION_NOTIFIER);
1121	}	1133	}
1122		1134
1123	#else	1135	#else
1124	static inline int s3c24xx_serial_cpufreq_register(struct s3c24xx_uart_port *port)	1136	static inline int
		1137	s3c24xx_serial_cpufreq_register(struct s3c24xx_uart_port *port)
1125	{	1138	{
1126	return 0;	1139	return 0;
1127	}	1140	}
1128		1141
1129	static inline void s3c24xx_serial_cpufreq_deregister(struct s3c24xx_uart_port *port)	1142	static inline void
		1143	s3c24xx_serial_cpufreq_deregister(struct s3c24xx_uart_port *port)
1130	{	1144	{
1131	}	1145	}
1132	#endif	1146	#endif
@@ -1226,24 +1240,6 @@ static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport, · 93 unmodified lines
1226	return 0;	1240	return 0;
1227	}	1241	}
1228		1242
1229	#ifdef CONFIG_SAMSUNG_CLOCK
1230	static ssize_t s3c24xx_serial_show_clksrc(struct device *dev,
1231	struct device_attribute *attr,
1232	char *buf)
1233	{
1234	struct uart_port *port = s3c24xx_dev_to_port(dev);
1235	struct s3c24xx_uart_port *ourport = to_ourport(port);
1236
1237	if (IS_ERR(ourport->baudclk))
1238	return -EINVAL;
1239
1240	return snprintf(buf, PAGE_SIZE, "* %s\n",
1241	ourport->baudclk->name ?: "(null)");
1242	}
1243
1244	static DEVICE_ATTR(clock_source, S_IRUGO, s3c24xx_serial_show_clksrc, NULL);
1245	#endif
1246
1247	/* Device driver serial port probe */	1243	/* Device driver serial port probe */
1248		1244
1249	static const struct of_device_id s3c24xx_uart_dt_match[];	1245	static const struct of_device_id s3c24xx_uart_dt_match[];
@@ -1296,11 +1292,10 @@ static int s3c24xx_serial_probe(struct platform_device *pdev) · 46 unmodified lines
1296	of_property_read_u32(np,	1292	of_property_read_u32(np,
1297	"samsung,uart-fifosize", &ourport->port.fifosize);	1293	"samsung,uart-fifosize", &ourport->port.fifosize);
1298		1294
1299	if (!ourport->port.fifosize) {	1295	if (ourport->drv_data->fifosize[index])
1300	ourport->port.fifosize = (ourport->info->fifosize) ?	1296	ourport->port.fifosize = ourport->drv_data->fifosize[index];
1301	ourport->info->fifosize :	1297	else if (ourport->info->fifosize)
1302	ourport->drv_data->fifosize[index];	1298	ourport->port.fifosize = ourport->info->fifosize;
1303	}
1304		1299
1305	probe_index++;	1300	probe_index++;
1306		1301
@@ -1329,12 +1324,6 @@ static int s3c24xx_serial_probe(struct platform_device *pdev) · 22 unmodified lines
1329	*/	1324	*/
1330	clk_disable_unprepare(ourport->clk);	1325	clk_disable_unprepare(ourport->clk);
1331		1326
1332	#ifdef CONFIG_SAMSUNG_CLOCK
1333	ret = device_create_file(&pdev->dev, &dev_attr_clock_source);
1334	if (ret < 0)
1335	dev_err(&pdev->dev, "failed to add clock source attr.\n");
1336	#endif
1337
1338	ret = s3c24xx_serial_cpufreq_register(ourport);	1327	ret = s3c24xx_serial_cpufreq_register(ourport);
1339	if (ret < 0)	1328	if (ret < 0)
1340	dev_err(&pdev->dev, "failed to add cpufreq notifier\n");	1329	dev_err(&pdev->dev, "failed to add cpufreq notifier\n");
@@ -1348,9 +1337,6 @@ static int s3c24xx_serial_remove(struct platform_device *dev) · 7 unmodified lines
1348		1337
1349	if (port) {	1338	if (port) {
1350	s3c24xx_serial_cpufreq_deregister(to_ourport(port));	1339	s3c24xx_serial_cpufreq_deregister(to_ourport(port));
1351	#ifdef CONFIG_SAMSUNG_CLOCK
1352	device_remove_file(&dev->dev, &dev_attr_clock_source);
1353	#endif
1354	uart_remove_one_port(&s3c24xx_uart_drv, port);	1340	uart_remove_one_port(&s3c24xx_uart_drv, port);
1355	}	1341	}
1356		1342

drivers/tty/serial/sc16is7xx.c+12−45

 	struct uart_port		port;
 	struct work_struct		tx_work;
 	struct work_struct		md_work;
-	struct serial_rs485		rs485;
 };
 struct sc16is7xx_port {
 	struct circ_buf *xmit = &one->port.state->xmit;
 	/* handle rs485 */
-	if (one->rs485.flags & SER_RS485_ENABLED) {
+	if (port->rs485.flags & SER_RS485_ENABLED) {
 		/* do nothing if current tx not yet completed */
 		int lsr = sc16is7xx_port_read(port, SC16IS7XX_LSR_REG);
 		if (!(lsr & SC16IS7XX_LSR_TEMT_BIT))
 			return;
 		if (uart_circ_empty(xmit) &&
-		    (one->rs485.delay_rts_after_send > 0))
+		    (port->rs485.delay_rts_after_send > 0))
-			mdelay(one->rs485.delay_rts_after_send);
+			mdelay(port->rs485.delay_rts_after_send);
 	}
 	sc16is7xx_port_update(port, SC16IS7XX_IER_REG,
 	struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
 	/* handle rs485 */
-	if ((one->rs485.flags & SER_RS485_ENABLED) &&
+	if ((port->rs485.flags & SER_RS485_ENABLED) &&
-	    (one->rs485.delay_rts_before_send > 0)) {
+	    (port->rs485.delay_rts_before_send > 0)) {
-		mdelay(one->rs485.delay_rts_before_send);
+		mdelay(port->rs485.delay_rts_before_send);
 	}
 	if (!work_pending(&one->tx_work))
 	uart_update_timeout(port, termios->c_cflag, baud);
 }
-#if defined(TIOCSRS485) && defined(TIOCGRS485)
+static int sc16is7xx_config_rs485(struct uart_port *port,
-static void sc16is7xx_config_rs485(struct uart_port *port,
 				   struct serial_rs485 *rs485)
 {
-	struct sc16is7xx_one *one = to_sc16is7xx_one(port, port);
+	if (port->rs485.flags & SER_RS485_ENABLED)
-	one->rs485 = *rs485;
-	if (one->rs485.flags & SER_RS485_ENABLED) {
 		sc16is7xx_port_update(port, SC16IS7XX_EFCR_REG,
 				      SC16IS7XX_EFCR_AUTO_RS485_BIT,
 				      SC16IS7XX_EFCR_AUTO_RS485_BIT);
-	} else {
+	else
 		sc16is7xx_port_update(port, SC16IS7XX_EFCR_REG,
 				      SC16IS7XX_EFCR_AUTO_RS485_BIT,
 				      0);
-	}
+	port->rs485 = *rs485;
-}
-#endif
-static int sc16is7xx_ioctl(struct uart_port *port, unsigned int cmd,
-			   unsigned long arg)
-{
-#if defined(TIOCSRS485) && defined(TIOCGRS485)
-	struct serial_rs485 rs485;
-	switch (cmd) {
+	return 0;
-	case TIOCSRS485:
-		if (copy_from_user(&rs485, (void __user *)arg, sizeof(rs485)))
-			return -EFAULT;
-		sc16is7xx_config_rs485(port, &rs485);
-		return 0;
-	case TIOCGRS485:
-		if (copy_to_user((void __user *)arg,
-				 &(to_sc16is7xx_one(port, port)->rs485),
-				 sizeof(rs485)))
-			return -EFAULT;
-		return 0;
-	default:
-		break;
-	}
-#endif
-	return -ENOIOCTLCMD;
 }
 static int sc16is7xx_startup(struct uart_port *port)
 	.release_port	= sc16is7xx_null_void,
 	.config_port	= sc16is7xx_config_port,
 	.verify_port	= sc16is7xx_verify_port,
-	.ioctl		= sc16is7xx_ioctl,
 	.pm		= sc16is7xx_pm,
 };
 		s->p[i].port.flags	= UPF_FIXED_TYPE | UPF_LOW_LATENCY;
 		s->p[i].port.iotype	= UPIO_PORT;
 		s->p[i].port.uartclk	= freq;
+		s->p[i].port.rs485_config = sc16is7xx_config_rs485;
 		s->p[i].port.ops	= &sc16is7xx_ops;
 		/* Disable all interrupts */
 		sc16is7xx_port_write(&s->p[i].port, SC16IS7XX_IER_REG, 0);

drivers/tty/serial/serial-tegra.c+19−17

 	if (unlikely(lsr & TEGRA_UART_LSR_ANY)) {
 		if (lsr & UART_LSR_OE) {
 			/* Overrrun error */
-			flag |= TTY_OVERRUN;
+			flag = TTY_OVERRUN;
 			tup->uport.icount.overrun++;
 			dev_err(tup->uport.dev, "Got overrun errors\n");
 		} else if (lsr & UART_LSR_PE) {
 			/* Parity error */
-			flag |= TTY_PARITY;
+			flag = TTY_PARITY;
 			tup->uport.icount.parity++;
 			dev_err(tup->uport.dev, "Got Parity errors\n");
 		} else if (lsr & UART_LSR_FE) {
-			flag |= TTY_FRAME;
+			flag = TTY_FRAME;
 			tup->uport.icount.frame++;
 			dev_err(tup->uport.dev, "Got frame errors\n");
 		} else if (lsr & UART_LSR_BI) {
 	return ret;
 }
+/*
+ * Flush any TX data submitted for DMA and PIO. Called when the
+ * TX circular buffer is reset.
+ */
+static void tegra_uart_flush_buffer(struct uart_port *u)
+{
+	struct tegra_uart_port *tup = to_tegra_uport(u);
+	tup->tx_bytes = 0;
+	if (tup->tx_dma_chan)
+		dmaengine_terminate_all(tup->tx_dma_chan);
+	return;
+}
 static void tegra_uart_shutdown(struct uart_port *u)
 {
 	struct tegra_uart_port *tup = to_tegra_uport(u);
 	tegra_uart_dma_channel_free(tup, true);
 	tegra_uart_dma_channel_free(tup, false);
 	free_irq(u->irq, tup);
+	tegra_uart_flush_buffer(u);
 }
 static void tegra_uart_enable_ms(struct uart_port *u)
 	return;
 }
-/*
- * Flush any TX data submitted for DMA and PIO. Called when the
- * TX circular buffer is reset.
- */
-static void tegra_uart_flush_buffer(struct uart_port *u)
-{
-	struct tegra_uart_port *tup = to_tegra_uport(u);
-	tup->tx_bytes = 0;
-	if (tup->tx_dma_chan)
-		dmaengine_terminate_all(tup->tx_dma_chan);
-	return;
-}
 static const char *tegra_uart_type(struct uart_port *u)
 {
 	return TEGRA_UART_TYPE;

drivers/tty/serial/serial_core.c+89−27

 static int uart_dcd_enabled(struct uart_port *uport)
 {
-	return uport->status & UPSTAT_DCD_ENABLE;
+	return !!(uport->status & UPSTAT_DCD_ENABLE);
 }
 /*
 EXPORT_SYMBOL(uart_get_divisor);
-/* FIXME: Consistent locking policy */
+/* Caller holds port mutex */
 static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
 					struct ktermios *old_termios)
 {
 		count -= c;
 		ret += c;
 	}
+	__uart_start(tty);
 	spin_unlock_irqrestore(&port->lock, flags);
-	uart_start(tty);
 	return ret;
 }
 {
 	struct uart_state *state = tty->driver_data;
 	struct uart_port *port = state->uart_port;
-	uint32_t mask = 0;
+	upf_t mask = 0;
 	if (I_IXOFF(tty))
 		mask |= UPF_SOFT_FLOW;
 {
 	struct uart_state *state = tty->driver_data;
 	struct uart_port *port = state->uart_port;
-	uint32_t mask = 0;
+	upf_t mask = 0;
 	if (I_IXOFF(tty))
 		mask |= UPF_SOFT_FLOW;
 	return 0;
 }
+static int uart_get_rs485_config(struct uart_port *port,
+			 struct serial_rs485 __user *rs485)
+{
+	unsigned long flags;
+	struct serial_rs485 aux;
+	spin_lock_irqsave(&port->lock, flags);
+	aux = port->rs485;
+	spin_unlock_irqrestore(&port->lock, flags);
+	if (copy_to_user(rs485, &aux, sizeof(aux)))
+		return -EFAULT;
+	return 0;
+}
+static int uart_set_rs485_config(struct uart_port *port,
+			 struct serial_rs485 __user *rs485_user)
+{
+	struct serial_rs485 rs485;
+	int ret;
+	unsigned long flags;
+	if (!port->rs485_config)
+		return -ENOIOCTLCMD;
+	if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user)))
+		return -EFAULT;
+	spin_lock_irqsave(&port->lock, flags);
+	ret = port->rs485_config(port, &rs485);
+	spin_unlock_irqrestore(&port->lock, flags);
+	if (ret)
+		return ret;
+	if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485)))
+		return -EFAULT;
+	return 0;
+}
 /*
  * Called via sys_ioctl.  We can use spin_lock_irq() here.
  */
 		break;
 	case TIOCSSERIAL:
+		down_write(&tty->termios_rwsem);
 		ret = uart_set_info_user(tty, state, uarg);
+		up_write(&tty->termios_rwsem);
 		break;
 	case TIOCSERCONFIG:
+		down_write(&tty->termios_rwsem);
 		ret = uart_do_autoconfig(tty, state);
+		up_write(&tty->termios_rwsem);
 		break;
 	case TIOCSERGWILD: /* obsolete */
 	 * All these rely on hardware being present and need to be
 	 * protected against the tty being hung up.
 	 */
 	switch (cmd) {
 	case TIOCSERGETLSR: /* Get line status register */
 		ret = uart_get_lsr_info(tty, state, uarg);
 		break;
+	case TIOCGRS485:
+		ret = uart_get_rs485_config(state->uart_port, uarg);
+		break;
+	case TIOCSRS485:
+		ret = uart_set_rs485_config(state->uart_port, uarg);
+		break;
 	default: {
 		struct uart_port *uport = state->uart_port;
 		if (uport->ops->ioctl)
 	struct uart_state *state = tty->driver_data;
 	struct uart_port *uport = state->uart_port;
-	if (uport->ops->set_ldisc)
+	if (uport->ops->set_ldisc) {
-		uport->ops->set_ldisc(uport, tty->termios.c_line);
+		mutex_lock(&state->port.mutex);
+		uport->ops->set_ldisc(uport, &tty->termios);
+		mutex_unlock(&state->port.mutex);
+	}
 }
 static void uart_set_termios(struct tty_struct *tty,
 		return;
 	}
+	mutex_lock(&state->port.mutex);
 	uart_change_speed(tty, state, old_termios);
+	mutex_unlock(&state->port.mutex);
 	/* reload cflag from termios; port driver may have overriden flags */
 	cflag = tty->termios.c_cflag;
 	struct uart_port *uport;
 	unsigned long flags;
-	if (!state)
+	if (!state) {
+		struct uart_driver *drv = tty->driver->driver_state;
+		state = drv->state + tty->index;
+		port = &state->port;
+		spin_lock_irq(&port->lock);
+		--port->count;
+		spin_unlock_irq(&port->lock);
 		return;
+	}
 	uport = state->uart_port;
 	port = &state->port;
 	mutex_lock(&port->mutex);
 	uart_shutdown(tty, state);
-	uart_flush_buffer(tty);
-	tty_ldisc_flush(tty);
 	tty_port_tty_set(port, NULL);
 	tty->closing = 0;
 	spin_lock_irqsave(&port->lock, flags);
 	if (port->blocked_open) {
 		spin_unlock_irqrestore(&port->lock, flags);
 		if (port->close_delay)
-			msleep_interruptible(
+			msleep_interruptible(jiffies_to_msecs(port->close_delay));
-					jiffies_to_msecs(port->close_delay));
 		spin_lock_irqsave(&port->lock, flags);
 	} else if (!uart_console(uport)) {
 		spin_unlock_irqrestore(&port->lock, flags);
 	wake_up_interruptible(&port->close_wait);
 	mutex_unlock(&port->mutex);
+	tty_ldisc_flush(tty);
 }
 static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
 	pr_debug("uart_open(%d) called\n", line);
+	spin_lock_irq(&port->lock);
+	++port->count;
+	spin_unlock_irq(&port->lock);
 	/*
 	 * We take the semaphore here to guarantee that we won't be re-entered
 	 * while allocating the state structure, or while we request any IRQs
 		goto end;
 	}
-	port->count++;
 	if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
 		retval = -ENXIO;
-		goto err_dec_count;
+		goto err_unlock;
 	}
-	/*
-	 * Once we set tty->driver_data here, we are guaranteed that
-	 * uart_close() will decrement the driver module use count.
-	 * Any failures from here onwards should not touch the count.
-	 */
 	tty->driver_data = state;
 	state->uart_port->state = state;
 	state->port.low_latency =
 end:
 	return retval;
-err_dec_count:
+err_unlock:
-	port->count--;
 	mutex_unlock(&port->mutex);
 	goto end;
 }
 		break;
 	case UPIO_MEM:
 	case UPIO_MEM32:
+	case UPIO_MEM32BE:
 	case UPIO_AU:
 	case UPIO_TSI:
 		snprintf(address, sizeof(address),
 		tty_port_init(port);
 		port->ops = &uart_port_ops;
-		port->close_delay     = HZ / 2;	/* .5 seconds */
-		port->closing_wait    = 30 * HZ;/* 30 seconds */
 	}
 	retval = tty_register_driver(normal);
 		goto out;
 	}
+	/* Link the port to the driver state table and vice versa */
 	state->uart_port = uport;
-	state->pm_state = UART_PM_STATE_UNDEFINED;
+	uport->state = state;
+	state->pm_state = UART_PM_STATE_UNDEFINED;
 	uport->cons = drv->cons;
-	uport->state = state;
 	/*
 	 * If this port is a console, then the spinlock is already
 		       (port1->hub6   == port2->hub6);
 	case UPIO_MEM:
 	case UPIO_MEM32:
+	case UPIO_MEM32BE:
 	case UPIO_AU:
 	case UPIO_TSI:
 		return (port1->mapbase == port2->mapbase);

drivers/tty/serial/sh-sci.c+1−4

 			err = DIV_ROUND_CLOSEST(freq, ((br + 1) * bps * sr *
 					       (1 << (2 * c + 1)) / 1000)) -
 					       1000;
-			if (err < 0)
-				continue;
 			/* Calc recv margin
 			 * M: Receive margin (%)
 			 * N: Ratio of bit rate to clock (N = sampling rate)
 			 */
 			recv_margin = abs((500 -
 					DIV_ROUND_CLOSEST(1000, sr << 1)) / 10);
-			if (min_err > err) {
+			if (abs(min_err) > abs(err)) {
 				min_err = err;
 				recv_max_margin = recv_margin;
 			} else if ((min_err == err) &&

drivers/tty/serial/sirfsoc_uart.c+27−7

 			      unsigned int oldstate)
 {
 	struct sirfsoc_uart_port *sirfport = to_sirfport(port);
-	if (!state)
+	if (!state) {
+		if (sirfport->is_bt_uart) {
+			clk_prepare_enable(sirfport->clk_noc);
+			clk_prepare_enable(sirfport->clk_general);
+		}
 		clk_prepare_enable(sirfport->clk);
-	else
+	} else {
 		clk_disable_unprepare(sirfport->clk);
+		if (sirfport->is_bt_uart) {
+			clk_disable_unprepare(sirfport->clk_general);
+			clk_disable_unprepare(sirfport->clk_noc);
+		}
+	}
 }
 static int sirfsoc_uart_startup(struct uart_port *port)
 	}
 	port->irq = res->start;
-	sirfport->clk = clk_get(&pdev->dev, NULL);
+	sirfport->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(sirfport->clk)) {
 		ret = PTR_ERR(sirfport->clk);
 		goto err;
 	}
 	port->uartclk = clk_get_rate(sirfport->clk);
+	if (of_device_is_compatible(pdev->dev.of_node, "sirf,marco-bt-uart")) {
+		sirfport->clk_general = devm_clk_get(&pdev->dev, "general");
+		if (IS_ERR(sirfport->clk_general)) {
+			ret = PTR_ERR(sirfport->clk_general);
+			goto err;
+		}
+		sirfport->clk_noc = devm_clk_get(&pdev->dev, "noc");
+		if (IS_ERR(sirfport->clk_noc)) {
+			ret = PTR_ERR(sirfport->clk_noc);
+			goto err;
+		}
+		sirfport->is_bt_uart = true;
+	} else
+		sirfport->is_bt_uart = false;
 	port->ops = &sirfsoc_uart_ops;
 	spin_lock_init(&port->lock);
 	ret = uart_add_one_port(&sirfsoc_uart_drv, port);
 	if (ret != 0) {
 		dev_err(&pdev->dev, "Cannot add UART port(%d).\n", pdev->id);
-		goto port_err;
+		goto err;
 	}
 	sirfport->rx_dma_chan = dma_request_slave_channel(port->dev, "rx");
 				sirfport->rx_dma_items[j].xmit.buf,
 				sirfport->rx_dma_items[j].dma_addr);
 	dma_release_channel(sirfport->rx_dma_chan);
-port_err:
-	clk_put(sirfport->clk);
 err:
 	return ret;
 }
 {
 	struct sirfsoc_uart_port *sirfport = platform_get_drvdata(pdev);
 	struct uart_port *port = &sirfport->port;
-	clk_put(sirfport->clk);
 	uart_remove_one_port(&sirfsoc_uart_drv, port);
 	if (sirfport->rx_dma_chan) {
 		int i;

drivers/tty/serial/sirfsoc_uart.h+4−0

 	struct uart_port		port;
 	struct clk			*clk;
+	/* UART6 for BT usage in A7DA platform need multi-clock source */
+	bool				is_bt_uart;
+	struct clk			*clk_general;
+	struct clk			*clk_noc;
 	/* for SiRFmarco, there are SET/CLR for UART_INT_EN */
 	bool				is_marco;
 	struct sirfsoc_uart_register	*uart_reg;

drivers/tty/serial/sunsab.c+24−12

 /* port->lock is not held.  */
 static unsigned int sunsab_tx_empty(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	int ret;
 	/* Do not need a lock for a state test like this.  */
 /* port->lock held by caller.  */
 static void sunsab_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	if (mctrl & TIOCM_RTS) {
 		up->cached_mode &= ~SAB82532_MODE_FRTS;
 /* port->lock is held by caller and interrupts are disabled.  */
 static unsigned int sunsab_get_mctrl(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	unsigned char val;
 	unsigned int result;
 /* port->lock held by caller.  */
 static void sunsab_stop_tx(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	up->interrupt_mask1 |= SAB82532_IMR1_XPR;
 	writeb(up->interrupt_mask1, &up->regs->w.imr1);
 /* port->lock held by caller.  */
 static void sunsab_start_tx(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	struct circ_buf *xmit = &up->port.state->xmit;
 	int i;
 /* port->lock is not held.  */
 static void sunsab_send_xchar(struct uart_port *port, char ch)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	unsigned long flags;
 	if (ch == __DISABLED_CHAR)
 /* port->lock held by caller.  */
 static void sunsab_stop_rx(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	up->interrupt_mask0 |= SAB82532_IMR0_TCD;
 	writeb(up->interrupt_mask1, &up->regs->w.imr0);
 /* port->lock is not held.  */
 static void sunsab_break_ctl(struct uart_port *port, int break_state)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	unsigned long flags;
 	unsigned char val;
 /* port->lock is not held.  */
 static int sunsab_startup(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	unsigned long flags;
 	unsigned char tmp;
 	int err = request_irq(up->port.irq, sunsab_interrupt,
 /* port->lock is not held.  */
 static void sunsab_shutdown(struct uart_port *port)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	unsigned long flags;
 	spin_lock_irqsave(&up->port.lock, flags);
 static void sunsab_set_termios(struct uart_port *port, struct ktermios *termios,
 			       struct ktermios *old)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	unsigned long flags;
 	unsigned int baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
 	unsigned int quot = uart_get_divisor(port, baud);
 static void sunsab_console_putchar(struct uart_port *port, int c)
 {
-	struct uart_sunsab_port *up = (struct uart_sunsab_port *)port;
+	struct uart_sunsab_port *up =
+		container_of(port, struct uart_sunsab_port, port);
 	sunsab_tec_wait(up);
 	writeb(c, &up->regs->w.tic);

drivers/tty/serial/sunsu.c+26−13

 static void sunsu_stop_tx(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	__stop_tx(up);
 static void sunsu_start_tx(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	if (!(up->ier & UART_IER_THRI)) {
 		up->ier |= UART_IER_THRI;
 static void sunsu_stop_rx(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	up->ier &= ~UART_IER_RLSI;
 	up->port.read_status_mask &= ~UART_LSR_DR;
 static void sunsu_enable_ms(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned long flags;
 	spin_lock_irqsave(&up->port.lock, flags);
 static unsigned int sunsu_tx_empty(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned long flags;
 	unsigned int ret;
 static unsigned int sunsu_get_mctrl(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned char status;
 	unsigned int ret;
 static void sunsu_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned char mcr = 0;
 	if (mctrl & TIOCM_RTS)
 static void sunsu_break_ctl(struct uart_port *port, int break_state)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned long flags;
 	spin_lock_irqsave(&up->port.lock, flags);
 static int sunsu_startup(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned long flags;
 	int retval;
 static void sunsu_shutdown(struct uart_port *port)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned long flags;
 	/*
 sunsu_change_speed(struct uart_port *port, unsigned int cflag,
 		   unsigned int iflag, unsigned int quot)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	unsigned char cval, fcr = 0;
 	unsigned long flags;
 static void sunsu_config_port(struct uart_port *port, int flags)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *) port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	if (flags & UART_CONFIG_TYPE) {
 		/*
 static void sunsu_console_putchar(struct uart_port *port, int ch)
 {
-	struct uart_sunsu_port *up = (struct uart_sunsu_port *)port;
+	struct uart_sunsu_port *up =
+		container_of(port, struct uart_sunsu_port, port);
 	wait_for_xmitr(up);
 	serial_out(up, UART_TX, ch);

drivers/tty/serial/sunzilog.c+16−8

 /* The port lock is held and interrupts are disabled.  */
 static void sunzilog_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	struct zilog_channel __iomem *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char set_bits, clear_bits;
 /* The port lock is held and interrupts are disabled.  */
 static void sunzilog_stop_tx(struct uart_port *port)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	up->flags |= SUNZILOG_FLAG_TX_STOPPED;
 }
 /* The port lock is held and interrupts are disabled.  */
 static void sunzilog_start_tx(struct uart_port *port)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	struct zilog_channel __iomem *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char status;
 /* The port lock is held.  */
 static void sunzilog_enable_ms(struct uart_port *port)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	struct zilog_channel __iomem *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char new_reg;
 /* The port lock is not held.  */
 static void sunzilog_break_ctl(struct uart_port *port, int break_state)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	struct zilog_channel __iomem *channel = ZILOG_CHANNEL_FROM_PORT(port);
 	unsigned char set_bits, clear_bits, new_reg;
 	unsigned long flags;
 sunzilog_set_termios(struct uart_port *port, struct ktermios *termios,
 		     struct ktermios *old)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	unsigned long flags;
 	int baud, brg;
 static int sunzilog_get_poll_char(struct uart_port *port)
 {
 	unsigned char ch, r1;
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *) port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	struct zilog_channel __iomem *channel
 		= ZILOG_CHANNEL_FROM_PORT(&up->port);
 static void sunzilog_put_poll_char(struct uart_port *port,
 			unsigned char ch)
 {
-	struct uart_sunzilog_port *up = (struct uart_sunzilog_port *)port;
+	struct uart_sunzilog_port *up =
+		container_of(port, struct uart_sunzilog_port, port);
 	sunzilog_putchar(&up->port, ch);
 }

drivers/tty/serial/timbuart.c+2−0

@@ -273,6 +273,8 @@ static void timbuart_shutdown(struct uart_port *port) · 272 unmodified lines
273	dev_dbg(port->dev, "%s\n", __func__);	273	dev_dbg(port->dev, "%s\n", __func__);
274	free_irq(port->irq, uart);	274	free_irq(port->irq, uart);
275	iowrite32(0, port->membase + TIMBUART_IER);	275	iowrite32(0, port->membase + TIMBUART_IER);
		276
		277	timbuart_flush_buffer(port);
276	}	278	}
277		279
278	static int get_bindex(int baud)	280	static int get_bindex(int baud)

drivers/tty/serial/xilinx_uartps.c+21−1

@@ -132,6 +132,15 @@ MODULE_PARM_DESC(rx_timeout, "Rx timeout, 1-255"); · 131 unmodified lines
132	/* Goes in read_status_mask for break detection as the HW doesn't do it*/	132	/* Goes in read_status_mask for break detection as the HW doesn't do it*/
133	#define CDNS_UART_IXR_BRK 0x80000000	133	#define CDNS_UART_IXR_BRK 0x80000000
134		134
		135	/*
		136	* Modem Control register:
		137	* The read/write Modem Control register controls the interface with the modem
		138	* or data set, or a peripheral device emulating a modem.
		139	*/
		140	#define CDNS_UART_MODEMCR_FCM 0x00000020 /* Automatic flow control mode */
		141	#define CDNS_UART_MODEMCR_RTS 0x00000002 /* Request to send output control */
		142	#define CDNS_UART_MODEMCR_DTR 0x00000001 /* Data Terminal Ready */
		143
135	/*	144	/*
136	* Channel Status Register:	145	* Channel Status Register:
137	* The channel status register (CSR) is provided to enable the control logic	146	* The channel status register (CSR) is provided to enable the control logic
@@ -915,7 +924,18 @@ static unsigned int cdns_uart_get_mctrl(struct uart_port *port) · 777 unmodified lines
915		924
916	static void cdns_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)	925	static void cdns_uart_set_mctrl(struct uart_port *port, unsigned int mctrl)
917	{	926	{
918	/* N/A */	927	u32 val;
		928
		929	val = cdns_uart_readl(CDNS_UART_MODEMCR_OFFSET);
		930
		931	val &= ~(CDNS_UART_MODEMCR_RTS \| CDNS_UART_MODEMCR_DTR);
		932
		933	if (mctrl & TIOCM_RTS)
		934	val \|= CDNS_UART_MODEMCR_RTS;
		935	if (mctrl & TIOCM_DTR)
		936	val \|= CDNS_UART_MODEMCR_DTR;
		937
		938	cdns_uart_writel(val, CDNS_UART_MODEMCR_OFFSET);
919	}	939	}
920		940
921	#ifdef CONFIG_CONSOLE_POLL	941	#ifdef CONFIG_CONSOLE_POLL

drivers/tty/tty_buffer.c+8−2

 /**
  *	tty_buffer_flush		-	flush full tty buffers
  *	@tty: tty to flush
+ *	@ld:  optional ldisc ptr (must be referenced)
  *
- *	flush all the buffers containing receive data.
+ *	flush all the buffers containing receive data. If ld != NULL,
+ *	flush the ldisc input buffer.
  *
  *	Locking: takes buffer lock to ensure single-threaded flip buffer
  *		 'consumer'
  */
-void tty_buffer_flush(struct tty_struct *tty)
+void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld)
 {
 	struct tty_port *port = tty->port;
 	struct tty_bufhead *buf = &port->buf;
 		buf->head = next;
 	}
 	buf->head->read = buf->head->commit;
+	if (ld && ld->ops->flush_buffer)
+		ld->ops->flush_buffer(tty);
 	atomic_dec(&buf->priority);
 	mutex_unlock(&buf->lock);
 }

drivers/tty/tty_io.c+223−217

@@ -153,8 +153,6 @@ static long tty_compat_ioctl(struct file *file, unsigned int cmd, · 152 unmodified lines
153	static int __tty_fasync(int fd, struct file *filp, int on);	153	static int __tty_fasync(int fd, struct file *filp, int on);
154	static int tty_fasync(int fd, struct file *filp, int on);	154	static int tty_fasync(int fd, struct file *filp, int on);
155	static void release_tty(struct tty_struct *tty, int idx);	155	static void release_tty(struct tty_struct *tty, int idx);
156	static void __proc_set_tty(struct task_struct tsk, struct tty_struct tty);
157	static void proc_set_tty(struct task_struct tsk, struct tty_struct tty);
158		156
159	/**	157	/**
160	* free_tty_struct - free a disused tty	158	* free_tty_struct - free a disused tty
@@ -169,8 +167,7 @@ void free_tty_struct(struct tty_struct *tty) · 8 unmodified lines
169	{	167	{
170	if (!tty)	168	if (!tty)
171	return;	169	return;
172	if (tty->dev)	170	put_device(tty->dev);
173	put_device(tty->dev);
174	kfree(tty->write_buf);	171	kfree(tty->write_buf);
175	tty->magic = 0xDEADDEAD;	172	tty->magic = 0xDEADDEAD;
176	kfree(tty);	173	kfree(tty);
@@ -277,6 +274,7 @@ int tty_paranoia_check(struct tty_struct tty, struct inode inode, · 100 unmodified lines
277	return 0;	274	return 0;
278	}	275	}
279		276
		277	/* Caller must hold tty_lock */
280	static int check_tty_count(struct tty_struct tty, const char routine)	278	static int check_tty_count(struct tty_struct tty, const char routine)
281	{	279	{
282	#ifdef CHECK_TTY_COUNT	280	#ifdef CHECK_TTY_COUNT
@@ -492,6 +490,78 @@ static const struct file_operations hung_up_tty_fops = { · 209 unmodified lines
492	static DEFINE_SPINLOCK(redirect_lock);	490	static DEFINE_SPINLOCK(redirect_lock);
493	static struct file *redirect;	491	static struct file *redirect;
494		492
		493
		494	void proc_clear_tty(struct task_struct *p)
		495	{
		496	unsigned long flags;
		497	struct tty_struct *tty;
		498	spin_lock_irqsave(&p->sighand->siglock, flags);
		499	tty = p->signal->tty;
		500	p->signal->tty = NULL;
		501	spin_unlock_irqrestore(&p->sighand->siglock, flags);
		502	tty_kref_put(tty);
		503	}
		504
		505	/**
		506	* proc_set_tty - set the controlling terminal
		507	*
		508	* Only callable by the session leader and only if it does not already have
		509	* a controlling terminal.
		510	*
		511	* Caller must hold: tty_lock()
		512	* a readlock on tasklist_lock
		513	* sighand lock
		514	*/
		515	static void __proc_set_tty(struct tty_struct *tty)
		516	{
		517	unsigned long flags;
		518
		519	spin_lock_irqsave(&tty->ctrl_lock, flags);
		520	/*
		521	* The session and fg pgrp references will be non-NULL if
		522	* tiocsctty() is stealing the controlling tty
		523	*/
		524	put_pid(tty->session);
		525	put_pid(tty->pgrp);
		526	tty->pgrp = get_pid(task_pgrp(current));
		527	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
		528	tty->session = get_pid(task_session(current));
		529	if (current->signal->tty) {
		530	printk(KERN_DEBUG "tty not NULL!!\n");
		531	tty_kref_put(current->signal->tty);
		532	}
		533	put_pid(current->signal->tty_old_pgrp);
		534	current->signal->tty = tty_kref_get(tty);
		535	current->signal->tty_old_pgrp = NULL;
		536	}
		537
		538	static void proc_set_tty(struct tty_struct *tty)
		539	{
		540	spin_lock_irq(&current->sighand->siglock);
		541	__proc_set_tty(tty);
		542	spin_unlock_irq(&current->sighand->siglock);
		543	}
		544
		545	struct tty_struct *get_current_tty(void)
		546	{
		547	struct tty_struct *tty;
		548	unsigned long flags;
		549
		550	spin_lock_irqsave(&current->sighand->siglock, flags);
		551	tty = tty_kref_get(current->signal->tty);
		552	spin_unlock_irqrestore(&current->sighand->siglock, flags);
		553	return tty;
		554	}
		555	EXPORT_SYMBOL_GPL(get_current_tty);
		556
		557	static void session_clear_tty(struct pid *session)
		558	{
		559	struct task_struct *p;
		560	do_each_pid_task(session, PIDTYPE_SID, p) {
		561	proc_clear_tty(p);
		562	} while_each_pid_task(session, PIDTYPE_SID, p);
		563	}
		564
495	/**	565	/**
496	* tty_wakeup - request more data	566	* tty_wakeup - request more data
497	* @tty: terminal	567	* @tty: terminal
@@ -620,9 +690,6 @@ static void __tty_hangup(struct tty_struct *tty, int exit_session) · 122 unmodified lines
620	return;	690	return;
621	}	691	}
622		692
623	/* some functions below drop BTM, so we need this bit */
624	set_bit(TTY_HUPPING, &tty->flags);
625
626	/* inuse_filps is protected by the single tty lock,	693	/* inuse_filps is protected by the single tty lock,
627	this really needs to change if we want to flush the	694	this really needs to change if we want to flush the
628	workqueue with the lock held */	695	workqueue with the lock held */
@@ -647,10 +714,6 @@ static void __tty_hangup(struct tty_struct *tty, int exit_session) · 18 unmodified lines
647	while (refs--)	714	while (refs--)
648	tty_kref_put(tty);	715	tty_kref_put(tty);
649		716
650	/*
651	* it drops BTM and thus races with reopen
652	* we protect the race by TTY_HUPPING
653	*/
654	tty_ldisc_hangup(tty);	717	tty_ldisc_hangup(tty);
655		718
656	spin_lock_irq(&tty->ctrl_lock);	719	spin_lock_irq(&tty->ctrl_lock);
@@ -682,8 +745,6 @@ static void __tty_hangup(struct tty_struct *tty, int exit_session) · 25 unmodified lines
682	* can't yet guarantee all that.	745	* can't yet guarantee all that.
683	*/	746	*/
684	set_bit(TTY_HUPPED, &tty->flags);	747	set_bit(TTY_HUPPED, &tty->flags);
685	clear_bit(TTY_HUPPING, &tty->flags);
686
687	tty_unlock(tty);	748	tty_unlock(tty);
688		749
689	if (f)	750	if (f)
@@ -792,14 +853,6 @@ int tty_hung_up_p(struct file *filp) · 102 unmodified lines
792		853
793	EXPORT_SYMBOL(tty_hung_up_p);	854	EXPORT_SYMBOL(tty_hung_up_p);
794		855
795	static void session_clear_tty(struct pid *session)
796	{
797	struct task_struct *p;
798	do_each_pid_task(session, PIDTYPE_SID, p) {
799	proc_clear_tty(p);
800	} while_each_pid_task(session, PIDTYPE_SID, p);
801	}
802
803	/**	856	/**
804	* disassociate_ctty - disconnect controlling tty	857	* disassociate_ctty - disconnect controlling tty
805	* @on_exit: true if exiting so need to "hang up" the session	858	* @on_exit: true if exiting so need to "hang up" the session
@@ -927,7 +980,7 @@ void __stop_tty(struct tty_struct *tty) · 121 unmodified lines
927	return;	980	return;
928	tty->stopped = 1;	981	tty->stopped = 1;
929	if (tty->ops->stop)	982	if (tty->ops->stop)
930	(tty->ops->stop)(tty);	983	tty->ops->stop(tty);
931	}	984	}
932		985
933	void stop_tty(struct tty_struct *tty)	986	void stop_tty(struct tty_struct *tty)
@@ -958,7 +1011,7 @@ void __start_tty(struct tty_struct *tty) · 24 unmodified lines
958	return;	1011	return;
959	tty->stopped = 0;	1012	tty->stopped = 0;
960	if (tty->ops->start)	1013	if (tty->ops->start)
961	(tty->ops->start)(tty);	1014	tty->ops->start(tty);
962	tty_wakeup(tty);	1015	tty_wakeup(tty);
963	}	1016	}
964		1017
@@ -1012,7 +1065,7 @@ static ssize_t tty_read(struct file file, char __user buf, size_t count, · 47 unmodified lines
1012	situation */	1065	situation */
1013	ld = tty_ldisc_ref_wait(tty);	1066	ld = tty_ldisc_ref_wait(tty);
1014	if (ld->ops->read)	1067	if (ld->ops->read)
1015	i = (ld->ops->read)(tty, file, buf, count);	1068	i = ld->ops->read(tty, file, buf, count);
1016	else	1069	else
1017	i = -EIO;	1070	i = -EIO;
1018	tty_ldisc_deref(ld);	1071	tty_ldisc_deref(ld);
@@ -1024,14 +1077,12 @@ static ssize_t tty_read(struct file file, char __user buf, size_t count, · 5 unmodified lines
1024	}	1077	}
1025		1078
1026	static void tty_write_unlock(struct tty_struct *tty)	1079	static void tty_write_unlock(struct tty_struct *tty)
1027	__releases(&tty->atomic_write_lock)
1028	{	1080	{
1029	mutex_unlock(&tty->atomic_write_lock);	1081	mutex_unlock(&tty->atomic_write_lock);
1030	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);	1082	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
1031	}	1083	}
1032		1084
1033	static int tty_write_lock(struct tty_struct *tty, int ndelay)	1085	static int tty_write_lock(struct tty_struct *tty, int ndelay)
1034	__acquires(&tty->atomic_write_lock)
1035	{	1086	{
1036	if (!mutex_trylock(&tty->atomic_write_lock)) {	1087	if (!mutex_trylock(&tty->atomic_write_lock)) {
1037	if (ndelay)	1088	if (ndelay)
@@ -1146,7 +1197,7 @@ void tty_write_message(struct tty_struct tty, char msg) · 108 unmodified lines
1146	if (tty) {	1197	if (tty) {
1147	mutex_lock(&tty->atomic_write_lock);	1198	mutex_lock(&tty->atomic_write_lock);
1148	tty_lock(tty);	1199	tty_lock(tty);
1149	if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {	1200	if (tty->ops->write && tty->count > 0) {
1150	tty_unlock(tty);	1201	tty_unlock(tty);
1151	tty->ops->write(tty, msg, strlen(msg));	1202	tty->ops->write(tty, msg, strlen(msg));
1152	} else	1203	} else
@@ -1293,19 +1344,24 @@ static ssize_t tty_line_name(struct tty_driver driver, int index, char p) · 140 unmodified lines
1293	* @driver: the driver for the tty	1344	* @driver: the driver for the tty
1294	* @idx: the minor number	1345	* @idx: the minor number
1295	*	1346	*
1296	* Return the tty, if found or ERR_PTR() otherwise.	1347	* Return the tty, if found. If not found, return NULL or ERR_PTR() if the
		1348	* driver lookup() method returns an error.
1297	*	1349	*
1298	* Locking: tty_mutex must be held. If tty is found, the mutex must	1350	* Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
1299	* be held until the 'fast-open' is also done. Will change once we
1300	* have refcounting in the driver and per driver locking
1301	*/	1351	*/
1302	static struct tty_struct tty_driver_lookup_tty(struct tty_driver driver,	1352	static struct tty_struct tty_driver_lookup_tty(struct tty_driver driver,
1303	struct inode *inode, int idx)	1353	struct inode *inode, int idx)
1304	{	1354	{
		1355	struct tty_struct *tty;
		1356
1305	if (driver->ops->lookup)	1357	if (driver->ops->lookup)
1306	return driver->ops->lookup(driver, inode, idx);	1358	tty = driver->ops->lookup(driver, inode, idx);
		1359	else
		1360	tty = driver->ttys[idx];
1307		1361
1308	return driver->ttys[idx];	1362	if (!IS_ERR(tty))
		1363	tty_kref_get(tty);
		1364	return tty;
1309	}	1365	}
1310		1366
1311	/**	1367	/**
@@ -1393,29 +1449,21 @@ void tty_driver_remove_tty(struct tty_driver driver, struct tty_struct tty) · 81 unmodified lines
1393	* @tty - the tty to open	1449	* @tty - the tty to open
1394	*	1450	*
1395	* Return 0 on success, -errno on error.	1451	* Return 0 on success, -errno on error.
		1452	* Re-opens on master ptys are not allowed and return -EIO.
1396	*	1453	*
1397	* Locking: tty_mutex must be held from the time the tty was found	1454	* Locking: Caller must hold tty_lock
1398	* till this open completes.
1399	*/	1455	*/
1400	static int tty_reopen(struct tty_struct *tty)	1456	static int tty_reopen(struct tty_struct *tty)
1401	{	1457	{
1402	struct tty_driver *driver = tty->driver;	1458	struct tty_driver *driver = tty->driver;
1403		1459
1404	if (test_bit(TTY_CLOSING, &tty->flags) \|\|	1460	if (!tty->count)
1405	test_bit(TTY_HUPPING, &tty->flags))
1406	return -EIO;	1461	return -EIO;
1407		1462
1408	if (driver->type == TTY_DRIVER_TYPE_PTY &&	1463	if (driver->type == TTY_DRIVER_TYPE_PTY &&
1409	driver->subtype == PTY_TYPE_MASTER) {	1464	driver->subtype == PTY_TYPE_MASTER)
1410	/*	1465	return -EIO;
1411	* special case for PTY masters: only one open permitted,
1412	* and the slave side open count is incremented as well.
1413	*/
1414	if (tty->count)
1415	return -EIO;
1416		1466
1417	tty->link->count++;
1418	}
1419	tty->count++;	1467	tty->count++;
1420		1468
1421	WARN_ON(!tty->ldisc);	1469	WARN_ON(!tty->ldisc);
@@ -1535,15 +1583,19 @@ void tty_free_termios(struct tty_struct *tty) · 113 unmodified lines
1535	EXPORT_SYMBOL(tty_free_termios);	1583	EXPORT_SYMBOL(tty_free_termios);
1536		1584
1537	/**	1585	/**
1538	* tty_flush_works - flush all works of a tty	1586	* tty_flush_works - flush all works of a tty/pty pair
1539	* @tty: tty device to flush works for	1587	* @tty: tty device to flush works for (or either end of a pty pair)
1540	*	1588	*
1541	* Sync flush all works belonging to @tty.	1589	* Sync flush all works belonging to @tty (and the 'other' tty).
1542	*/	1590	*/
1543	static void tty_flush_works(struct tty_struct *tty)	1591	static void tty_flush_works(struct tty_struct *tty)
1544	{	1592	{
1545	flush_work(&tty->SAK_work);	1593	flush_work(&tty->SAK_work);
1546	flush_work(&tty->hangup_work);	1594	flush_work(&tty->hangup_work);
		1595	if (tty->link) {
		1596	flush_work(&tty->link->SAK_work);
		1597	flush_work(&tty->link->hangup_work);
		1598	}
1547	}	1599	}
1548		1600
1549	/**	1601	/**
@@ -1635,8 +1687,7 @@ static void release_tty(struct tty_struct *tty, int idx) · 85 unmodified lines
1635	tty->link->port->itty = NULL;	1687	tty->link->port->itty = NULL;
1636	cancel_work_sync(&tty->port->buf.work);	1688	cancel_work_sync(&tty->port->buf.work);
1637		1689
1638	if (tty->link)	1690	tty_kref_put(tty->link);
1639	tty_kref_put(tty->link);
1640	tty_kref_put(tty);	1691	tty_kref_put(tty);
1641	}	1692	}
1642		1693
@@ -1649,8 +1700,7 @@ static void release_tty(struct tty_struct *tty, int idx) · 6 unmodified lines
1649	* Performs some paranoid checking before true release of the @tty.	1700	* Performs some paranoid checking before true release of the @tty.
1650	* This is a no-op unless TTY_PARANOIA_CHECK is defined.	1701	* This is a no-op unless TTY_PARANOIA_CHECK is defined.
1651	*/	1702	*/
1652	static int tty_release_checks(struct tty_struct tty, struct tty_struct o_tty,	1703	static int tty_release_checks(struct tty_struct *tty, int idx)
1653	int idx)
1654	{	1704	{
1655	#ifdef TTY_PARANOIA_CHECK	1705	#ifdef TTY_PARANOIA_CHECK
1656	if (idx < 0 \|\| idx >= tty->driver->num) {	1706	if (idx < 0 \|\| idx >= tty->driver->num) {
@@ -1669,6 +1719,8 @@ static int tty_release_checks(struct tty_struct tty, struct tty_struct o_tty, · 12 unmodified lines
1669	return -1;	1719	return -1;
1670	}	1720	}
1671	if (tty->driver->other) {	1721	if (tty->driver->other) {
		1722	struct tty_struct *o_tty = tty->link;
		1723
1672	if (o_tty != tty->driver->other->ttys[idx]) {	1724	if (o_tty != tty->driver->other->ttys[idx]) {
1673	printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",	1725	printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1674	__func__, idx, tty->name);	1726	__func__, idx, tty->name);
@@ -1705,8 +1757,8 @@ static int tty_release_checks(struct tty_struct tty, struct tty_struct o_tty, · 30 unmodified lines
1705	int tty_release(struct inode inode, struct file filp)	1757	int tty_release(struct inode inode, struct file filp)
1706	{	1758	{
1707	struct tty_struct *tty = file_tty(filp);	1759	struct tty_struct *tty = file_tty(filp);
1708	struct tty_struct *o_tty;	1760	struct tty_struct *o_tty = NULL;
1709	int pty_master, tty_closing, o_tty_closing, do_sleep;	1761	int do_sleep, final;
1710	int idx;	1762	int idx;
1711	char buf[64];	1763	char buf[64];
1712	long timeout = 0;	1764	long timeout = 0;
@@ -1721,12 +1773,11 @@ int tty_release(struct inode inode, struct file filp) · 8 unmodified lines
1721	__tty_fasync(-1, filp, 0);	1773	__tty_fasync(-1, filp, 0);
1722		1774
1723	idx = tty->index;	1775	idx = tty->index;
1724	pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	1776	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1725	tty->driver->subtype == PTY_TYPE_MASTER);	1777	tty->driver->subtype == PTY_TYPE_MASTER)
1726	/* Review: parallel close */	1778	o_tty = tty->link;
1727	o_tty = tty->link;
1728		1779
1729	if (tty_release_checks(tty, o_tty, idx)) {	1780	if (tty_release_checks(tty, idx)) {
1730	tty_unlock(tty);	1781	tty_unlock(tty);
1731	return 0;	1782	return 0;
1732	}	1783	}
@@ -1739,7 +1790,9 @@ int tty_release(struct inode inode, struct file filp) · 6 unmodified lines
1739	if (tty->ops->close)	1790	if (tty->ops->close)
1740	tty->ops->close(tty, filp);	1791	tty->ops->close(tty, filp);
1741		1792
1742	tty_unlock(tty);	1793	/* If tty is pty master, lock the slave pty (stable lock order) */
		1794	tty_lock_slave(o_tty);
		1795
1743	/*	1796	/*
1744	* Sanity check: if tty->count is going to zero, there shouldn't be	1797	* Sanity check: if tty->count is going to zero, there shouldn't be
1745	* any waiters on tty->read_wait or tty->write_wait. We test the	1798	* any waiters on tty->read_wait or tty->write_wait. We test the
@@ -1750,25 +1803,13 @@ int tty_release(struct inode inode, struct file filp) · 4 unmodified lines
1750	* The test for the o_tty closing is necessary, since the master and	1803	* The test for the o_tty closing is necessary, since the master and
1751	* slave sides may close in any order. If the slave side closes out	1804	* slave sides may close in any order. If the slave side closes out
1752	* first, its count will be one, since the master side holds an open.	1805	* first, its count will be one, since the master side holds an open.
1753	* Thus this test wouldn't be triggered at the time the slave closes,	1806	* Thus this test wouldn't be triggered at the time the slave closed,
1754	* so we do it now.	1807	* so we do it now.
1755	*
1756	* Note that it's possible for the tty to be opened again while we're
1757	* flushing out waiters. By recalculating the closing flags before
1758	* each iteration we avoid any problems.
1759	*/	1808	*/
1760	while (1) {	1809	while (1) {
1761	/* Guard against races with tty->count changes elsewhere and
1762	opens on /dev/tty */
1763
1764	mutex_lock(&tty_mutex);
1765	tty_lock_pair(tty, o_tty);
1766	tty_closing = tty->count <= 1;
1767	o_tty_closing = o_tty &&
1768	(o_tty->count <= (pty_master ? 1 : 0));
1769	do_sleep = 0;	1810	do_sleep = 0;
1770		1811
1771	if (tty_closing) {	1812	if (tty->count <= 1) {
1772	if (waitqueue_active(&tty->read_wait)) {	1813	if (waitqueue_active(&tty->read_wait)) {
1773	wake_up_poll(&tty->read_wait, POLLIN);	1814	wake_up_poll(&tty->read_wait, POLLIN);
1774	do_sleep++;	1815	do_sleep++;
@@ -1778,7 +1819,7 @@ int tty_release(struct inode inode, struct file filp) · 3 unmodified lines
1778	do_sleep++;	1819	do_sleep++;
1779	}	1820	}
1780	}	1821	}
1781	if (o_tty_closing) {	1822	if (o_tty && o_tty->count <= 1) {
1782	if (waitqueue_active(&o_tty->read_wait)) {	1823	if (waitqueue_active(&o_tty->read_wait)) {
1783	wake_up_poll(&o_tty->read_wait, POLLIN);	1824	wake_up_poll(&o_tty->read_wait, POLLIN);
1784	do_sleep++;	1825	do_sleep++;
@@ -1796,8 +1837,6 @@ int tty_release(struct inode inode, struct file filp) · 11 unmodified lines
1796	printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",	1837	printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1797	__func__, tty_name(tty, buf));	1838	__func__, tty_name(tty, buf));
1798	}	1839	}
1799	tty_unlock_pair(tty, o_tty);
1800	mutex_unlock(&tty_mutex);
1801	schedule_timeout_killable(timeout);	1840	schedule_timeout_killable(timeout);
1802	if (timeout < 120 * HZ)	1841	if (timeout < 120 * HZ)
1803	timeout = 2 * timeout + 1;	1842	timeout = 2 * timeout + 1;
@@ -1805,15 +1844,7 @@ int tty_release(struct inode inode, struct file filp) · 1 unmodified line
1805	timeout = MAX_SCHEDULE_TIMEOUT;	1844	timeout = MAX_SCHEDULE_TIMEOUT;
1806	}	1845	}
1807		1846
1808	/*	1847	if (o_tty) {
1809	* The closing flags are now consistent with the open counts on
1810	* both sides, and we've completed the last operation that could
1811	* block, so it's safe to proceed with closing.
1812	*
1813	* We must not drop the tty_mutex until we ensure that a further
1814	* entry into tty_open can not pick up this tty.
1815	*/
1816	if (pty_master) {
1817	if (--o_tty->count < 0) {	1848	if (--o_tty->count < 0) {
1818	printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",	1849	printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1819	__func__, o_tty->count, tty_name(o_tty, buf));	1850	__func__, o_tty->count, tty_name(o_tty, buf));
@@ -1840,21 +1871,11 @@ int tty_release(struct inode inode, struct file filp) · 20 unmodified lines
1840	/*	1871	/*
1841	* Perform some housekeeping before deciding whether to return.	1872	* Perform some housekeeping before deciding whether to return.
1842	*	1873	*
1843	* Set the TTY_CLOSING flag if this was the last open. In the
1844	* case of a pty we may have to wait around for the other side
1845	* to close, and TTY_CLOSING makes sure we can't be reopened.
1846	*/
1847	if (tty_closing)
1848	set_bit(TTY_CLOSING, &tty->flags);
1849	if (o_tty_closing)
1850	set_bit(TTY_CLOSING, &o_tty->flags);
1851
1852	/*
1853	* If _either_ side is closing, make sure there aren't any	1874	* If _either_ side is closing, make sure there aren't any
1854	* processes that still think tty or o_tty is their controlling	1875	* processes that still think tty or o_tty is their controlling
1855	* tty.	1876	* tty.
1856	*/	1877	*/
1857	if (tty_closing \|\| o_tty_closing) {	1878	if (!tty->count) {
1858	read_lock(&tasklist_lock);	1879	read_lock(&tasklist_lock);
1859	session_clear_tty(tty->session);	1880	session_clear_tty(tty->session);
1860	if (o_tty)	1881	if (o_tty)
@@ -1862,13 +1883,16 @@ int tty_release(struct inode inode, struct file filp) · 1 unmodified line
1862	read_unlock(&tasklist_lock);	1883	read_unlock(&tasklist_lock);
1863	}	1884	}
1864		1885
1865	mutex_unlock(&tty_mutex);	1886	/* check whether both sides are closing ... */
1866	tty_unlock_pair(tty, o_tty);	1887	final = !tty->count && !(o_tty && o_tty->count);
1867	/* At this point the TTY_CLOSING flag should ensure a dead tty	1888
		1889	tty_unlock_slave(o_tty);
		1890	tty_unlock(tty);
		1891
		1892	/* At this point, the tty->count == 0 should ensure a dead tty
1868	cannot be re-opened by a racing opener */	1893	cannot be re-opened by a racing opener */
1869		1894
1870	/* check whether both sides are closing ... */	1895	if (!final)
1871	if (!tty_closing \|\| (o_tty && !o_tty_closing))
1872	return 0;	1896	return 0;
1873		1897
1874	#ifdef TTY_DEBUG_HANGUP	1898	#ifdef TTY_DEBUG_HANGUP
@@ -1877,12 +1901,10 @@ int tty_release(struct inode inode, struct file filp) · 2 unmodified lines
1877	/*	1901	/*
1878	* Ask the line discipline code to release its structures	1902	* Ask the line discipline code to release its structures
1879	*/	1903	*/
1880	tty_ldisc_release(tty, o_tty);	1904	tty_ldisc_release(tty);
1881		1905
1882	/* Wait for pending work before tty destruction commmences */	1906	/* Wait for pending work before tty destruction commmences */
1883	tty_flush_works(tty);	1907	tty_flush_works(tty);
1884	if (o_tty)
1885	tty_flush_works(o_tty);
1886		1908
1887	#ifdef TTY_DEBUG_HANGUP	1909	#ifdef TTY_DEBUG_HANGUP
1888	printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));	1910	printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));
@@ -1901,20 +1923,20 @@ int tty_release(struct inode inode, struct file filp) · 12 unmodified lines
1901	}	1923	}
1902		1924
1903	/**	1925	/**
1904	* tty_open_current_tty - get tty of current task for open	1926	* tty_open_current_tty - get locked tty of current task
1905	* @device: device number	1927	* @device: device number
1906	* @filp: file pointer to tty	1928	* @filp: file pointer to tty
1907	* @return: tty of the current task iff @device is /dev/tty	1929	* @return: locked tty of the current task iff @device is /dev/tty
		1930	*
		1931	* Performs a re-open of the current task's controlling tty.
1908	*	1932	*
1909	* We cannot return driver and index like for the other nodes because	1933	* We cannot return driver and index like for the other nodes because
1910	* devpts will not work then. It expects inodes to be from devpts FS.	1934	* devpts will not work then. It expects inodes to be from devpts FS.
1911	*
1912	* We need to move to returning a refcounted object from all the lookup
1913	* paths including this one.
1914	*/	1935	*/
1915	static struct tty_struct tty_open_current_tty(dev_t device, struct file filp)	1936	static struct tty_struct tty_open_current_tty(dev_t device, struct file filp)
1916	{	1937	{
1917	struct tty_struct *tty;	1938	struct tty_struct *tty;
		1939	int retval;
1918		1940
1919	if (device != MKDEV(TTYAUX_MAJOR, 0))	1941	if (device != MKDEV(TTYAUX_MAJOR, 0))
1920	return NULL;	1942	return NULL;
@@ -1925,9 +1947,14 @@ static struct tty_struct tty_open_current_tty(dev_t device, struct file filp) · 4 unmodified lines
1925		1947
1926	filp->f_flags \|= O_NONBLOCK; /* Don't let /dev/tty block */	1948	filp->f_flags \|= O_NONBLOCK; /* Don't let /dev/tty block */
1927	/* noctty = 1; */	1949	/* noctty = 1; */
1928	tty_kref_put(tty);	1950	tty_lock(tty);
1929	/* FIXME: we put a reference and return a TTY! */	1951	tty_kref_put(tty); /* safe to drop the kref now */
1930	/* This is only safe because the caller holds tty_mutex */	1952
		1953	retval = tty_reopen(tty);
		1954	if (retval < 0) {
		1955	tty_unlock(tty);
		1956	tty = ERR_PTR(retval);
		1957	}
1931	return tty;	1958	return tty;
1932	}	1959	}
1933		1960
@@ -2025,13 +2052,9 @@ retry_open: · 91 unmodified lines
2025	index = -1;	2052	index = -1;
2026	retval = 0;	2053	retval = 0;
2027		2054
2028	mutex_lock(&tty_mutex);
2029	/* This is protected by the tty_mutex */
2030	tty = tty_open_current_tty(device, filp);	2055	tty = tty_open_current_tty(device, filp);
2031	if (IS_ERR(tty)) {	2056	if (!tty) {
2032	retval = PTR_ERR(tty);	2057	mutex_lock(&tty_mutex);
2033	goto err_unlock;
2034	} else if (!tty) {
2035	driver = tty_lookup_driver(device, filp, &noctty, &index);	2058	driver = tty_lookup_driver(device, filp, &noctty, &index);
2036	if (IS_ERR(driver)) {	2059	if (IS_ERR(driver)) {
2037	retval = PTR_ERR(driver);	2060	retval = PTR_ERR(driver);
@@ -2044,21 +2067,25 @@ retry_open: · 6 unmodified lines
2044	retval = PTR_ERR(tty);	2067	retval = PTR_ERR(tty);
2045	goto err_unlock;	2068	goto err_unlock;
2046	}	2069	}
2047	}
2048		2070
2049	if (tty) {	2071	if (tty) {
2050	tty_lock(tty);	2072	mutex_unlock(&tty_mutex);
2051	retval = tty_reopen(tty);	2073	tty_lock(tty);
2052	if (retval < 0) {	2074	/* safe to drop the kref from tty_driver_lookup_tty() */
2053	tty_unlock(tty);	2075	tty_kref_put(tty);
2054	tty = ERR_PTR(retval);	2076	retval = tty_reopen(tty);
		2077	if (retval < 0) {
		2078	tty_unlock(tty);
		2079	tty = ERR_PTR(retval);
		2080	}
		2081	} else { /* Returns with the tty_lock held for now */
		2082	tty = tty_init_dev(driver, index);
		2083	mutex_unlock(&tty_mutex);
2055	}	2084	}
2056	} else /* Returns with the tty_lock held for now */
2057	tty = tty_init_dev(driver, index);
2058		2085
2059	mutex_unlock(&tty_mutex);
2060	if (driver)
2061	tty_driver_kref_put(driver);	2086	tty_driver_kref_put(driver);
		2087	}
		2088
2062	if (IS_ERR(tty)) {	2089	if (IS_ERR(tty)) {
2063	retval = PTR_ERR(tty);	2090	retval = PTR_ERR(tty);
2064	goto err_file;	2091	goto err_file;
@@ -2100,25 +2127,23 @@ retry_open: · 35 unmodified lines
2100	/*	2127	/*
2101	* Need to reset f_op in case a hangup happened.	2128	* Need to reset f_op in case a hangup happened.
2102	*/	2129	*/
2103	if (filp->f_op == &hung_up_tty_fops)	2130	if (tty_hung_up_p(filp))
2104	filp->f_op = &tty_fops;	2131	filp->f_op = &tty_fops;
2105	goto retry_open;	2132	goto retry_open;
2106	}	2133	}
2107	clear_bit(TTY_HUPPED, &tty->flags);	2134	clear_bit(TTY_HUPPED, &tty->flags);
2108	tty_unlock(tty);
2109		2135
2110		2136
2111	mutex_lock(&tty_mutex);	2137	read_lock(&tasklist_lock);
2112	tty_lock(tty);
2113	spin_lock_irq(&current->sighand->siglock);	2138	spin_lock_irq(&current->sighand->siglock);
2114	if (!noctty &&	2139	if (!noctty &&
2115	current->signal->leader &&	2140	current->signal->leader &&
2116	!current->signal->tty &&	2141	!current->signal->tty &&
2117	tty->session == NULL)	2142	tty->session == NULL)
2118	__proc_set_tty(current, tty);	2143	__proc_set_tty(tty);
2119	spin_unlock_irq(&current->sighand->siglock);	2144	spin_unlock_irq(&current->sighand->siglock);
		2145	read_unlock(&tasklist_lock);
2120	tty_unlock(tty);	2146	tty_unlock(tty);
2121	mutex_unlock(&tty_mutex);
2122	return 0;	2147	return 0;
2123	err_unlock:	2148	err_unlock:
2124	mutex_unlock(&tty_mutex);	2149	mutex_unlock(&tty_mutex);
@@ -2155,7 +2180,7 @@ static unsigned int tty_poll(struct file filp, poll_table wait) · 30 unmodified lines
2155		2180
2156	ld = tty_ldisc_ref_wait(tty);	2181	ld = tty_ldisc_ref_wait(tty);
2157	if (ld->ops->poll)	2182	if (ld->ops->poll)
2158	ret = (ld->ops->poll)(tty, filp, wait);	2183	ret = ld->ops->poll(tty, filp, wait);
2159	tty_ldisc_deref(ld);	2184	tty_ldisc_deref(ld);
2160	return ret;	2185	return ret;
2161	}	2186	}
@@ -2283,18 +2308,14 @@ static int tiocgwinsz(struct tty_struct tty, struct winsize __user arg) · 121 unmodified lines
2283	int tty_do_resize(struct tty_struct tty, struct winsize ws)	2308	int tty_do_resize(struct tty_struct tty, struct winsize ws)
2284	{	2309	{
2285	struct pid *pgrp;	2310	struct pid *pgrp;
2286	unsigned long flags;
2287		2311
2288	/* Lock the tty */	2312	/* Lock the tty */
2289	mutex_lock(&tty->winsize_mutex);	2313	mutex_lock(&tty->winsize_mutex);
2290	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))	2314	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2291	goto done;	2315	goto done;
2292	/* Get the PID values and reference them so we can
2293	avoid holding the tty ctrl lock while sending signals */
2294	spin_lock_irqsave(&tty->ctrl_lock, flags);
2295	pgrp = get_pid(tty->pgrp);
2296	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2297		2316
		2317	/* Signal the foreground process group */
		2318	pgrp = tty_get_pgrp(tty);
2298	if (pgrp)	2319	if (pgrp)
2299	kill_pgrp(pgrp, SIGWINCH, 1);	2320	kill_pgrp(pgrp, SIGWINCH, 1);
2300	put_pid(pgrp);	2321	put_pid(pgrp);
@@ -2403,7 +2424,7 @@ static int fionbio(struct file file, int __user p) · 102 unmodified lines
2403	* leader to set this tty as the controlling tty for the session.	2424	* leader to set this tty as the controlling tty for the session.
2404	*	2425	*
2405	* Locking:	2426	* Locking:
2406	* Takes tty_mutex() to protect tty instance	2427	* Takes tty_lock() to serialize proc_set_tty() for this tty
2407	* Takes tasklist_lock internally to walk sessions	2428	* Takes tasklist_lock internally to walk sessions
2408	* Takes ->siglock() when updating signal->tty	2429	* Takes ->siglock() when updating signal->tty
2409	*/	2430	*/
@@ -2411,10 +2432,13 @@ static int fionbio(struct file file, int __user p) · 1 unmodified line
2411	static int tiocsctty(struct tty_struct *tty, int arg)	2432	static int tiocsctty(struct tty_struct *tty, int arg)
2412	{	2433	{
2413	int ret = 0;	2434	int ret = 0;
		2435
		2436	tty_lock(tty);
		2437	read_lock(&tasklist_lock);
		2438
2414	if (current->signal->leader && (task_session(current) == tty->session))	2439	if (current->signal->leader && (task_session(current) == tty->session))
2415	return ret;	2440	goto unlock;
2416		2441
2417	mutex_lock(&tty_mutex);
2418	/*	2442	/*
2419	* The process must be a session leader and	2443	* The process must be a session leader and
2420	* not have a controlling tty already.	2444	* not have a controlling tty already.
@@ -2433,17 +2457,16 @@ static int tiocsctty(struct tty_struct *tty, int arg) · 12 unmodified lines
2433	/*	2457	/*
2434	* Steal it away	2458	* Steal it away
2435	*/	2459	*/
2436	read_lock(&tasklist_lock);
2437	session_clear_tty(tty->session);	2460	session_clear_tty(tty->session);
2438	read_unlock(&tasklist_lock);
2439	} else {	2461	} else {
2440	ret = -EPERM;	2462	ret = -EPERM;
2441	goto unlock;	2463	goto unlock;
2442	}	2464	}
2443	}	2465	}
2444	proc_set_tty(current, tty);	2466	proc_set_tty(tty);
2445	unlock:	2467	unlock:
2446	mutex_unlock(&tty_mutex);	2468	read_unlock(&tasklist_lock);
		2469	tty_unlock(tty);
2447	return ret;	2470	return ret;
2448	}	2471	}
2449		2472
@@ -2468,6 +2491,27 @@ struct pid tty_get_pgrp(struct tty_struct tty) · 18 unmodified lines
2468	}	2491	}
2469	EXPORT_SYMBOL_GPL(tty_get_pgrp);	2492	EXPORT_SYMBOL_GPL(tty_get_pgrp);
2470		2493
		2494	/*
		2495	* This checks not only the pgrp, but falls back on the pid if no
		2496	* satisfactory pgrp is found. I dunno - gdb doesn't work correctly
		2497	* without this...
		2498	*
		2499	* The caller must hold rcu lock or the tasklist lock.
		2500	*/
		2501	static struct pid session_of_pgrp(struct pid pgrp)
		2502	{
		2503	struct task_struct *p;
		2504	struct pid *sid = NULL;
		2505
		2506	p = pid_task(pgrp, PIDTYPE_PGID);
		2507	if (p == NULL)
		2508	p = pid_task(pgrp, PIDTYPE_PID);
		2509	if (p != NULL)
		2510	sid = task_session(p);
		2511
		2512	return sid;
		2513	}
		2514
2471	/**	2515	/**
2472	* tiocgpgrp - get process group	2516	* tiocgpgrp - get process group
2473	* @tty: tty passed by user	2517	* @tty: tty passed by user
@@ -2714,23 +2758,35 @@ static int tty_tiocgicount(struct tty_struct tty, void __user arg) · 240 unmodified lines
2714	return 0;	2758	return 0;
2715	}	2759	}
2716		2760
2717	struct tty_struct tty_pair_get_tty(struct tty_struct tty)	2761	static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
2718	{	2762	{
2719	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	2763	static DEFINE_RATELIMIT_STATE(depr_flags,
2720	tty->driver->subtype == PTY_TYPE_MASTER)	2764	DEFAULT_RATELIMIT_INTERVAL,
2721	tty = tty->link;	2765	DEFAULT_RATELIMIT_BURST);
2722	return tty;	2766	char comm[TASK_COMM_LEN];
		2767	int flags;
		2768
		2769	if (get_user(flags, &ss->flags))
		2770	return;
		2771
		2772	flags &= ASYNC_DEPRECATED;
		2773
		2774	if (flags && __ratelimit(&depr_flags))
		2775	pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
		2776	__func__, get_task_comm(comm, current), flags);
2723	}	2777	}
2724	EXPORT_SYMBOL(tty_pair_get_tty);
2725		2778
2726	struct tty_struct tty_pair_get_pty(struct tty_struct tty)	2779	/*
		2780	* if pty, return the slave side (real_tty)
		2781	* otherwise, return self
		2782	*/
		2783	static struct tty_struct tty_pair_get_tty(struct tty_struct tty)
2727	{	2784	{
2728	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	2785	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2729	tty->driver->subtype == PTY_TYPE_MASTER)	2786	tty->driver->subtype == PTY_TYPE_MASTER)
2730	return tty;	2787	tty = tty->link;
2731	return tty->link;	2788	return tty;
2732	}	2789	}
2733	EXPORT_SYMBOL(tty_pair_get_pty);
2734		2790
2735	/*	2791	/*
2736	* Split this up, as gcc can choke on it otherwise..	2792	* Split this up, as gcc can choke on it otherwise..
@@ -2859,13 +2915,16 @@ long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 122 unmodified lines
2859	case TCIFLUSH:	2915	case TCIFLUSH:
2860	case TCIOFLUSH:	2916	case TCIOFLUSH:
2861	/* flush tty buffer and allow ldisc to process ioctl */	2917	/* flush tty buffer and allow ldisc to process ioctl */
2862	tty_buffer_flush(tty);	2918	tty_buffer_flush(tty, NULL);
2863	break;	2919	break;
2864	}	2920	}
2865	break;	2921	break;
		2922	case TIOCSSERIAL:
		2923	tty_warn_deprecated_flags(p);
		2924	break;
2866	}	2925	}
2867	if (tty->ops->ioctl) {	2926	if (tty->ops->ioctl) {
2868	retval = (tty->ops->ioctl)(tty, cmd, arg);	2927	retval = tty->ops->ioctl(tty, cmd, arg);
2869	if (retval != -ENOIOCTLCMD)	2928	if (retval != -ENOIOCTLCMD)
2870	return retval;	2929	return retval;
2871	}	2930	}
@@ -2892,7 +2951,7 @@ static long tty_compat_ioctl(struct file *file, unsigned int cmd, · 20 unmodified lines
2892	return -EINVAL;	2951	return -EINVAL;
2893		2952
2894	if (tty->ops->compat_ioctl) {	2953	if (tty->ops->compat_ioctl) {
2895	retval = (tty->ops->compat_ioctl)(tty, cmd, arg);	2954	retval = tty->ops->compat_ioctl(tty, cmd, arg);
2896	if (retval != -ENOIOCTLCMD)	2955	if (retval != -ENOIOCTLCMD)
2897	return retval;	2956	return retval;
2898	}	2957	}
@@ -3443,59 +3502,6 @@ dev_t tty_devnum(struct tty_struct *tty) · 544 unmodified lines
3443	}	3502	}
3444	EXPORT_SYMBOL(tty_devnum);	3503	EXPORT_SYMBOL(tty_devnum);
3445		3504
3446	void proc_clear_tty(struct task_struct *p)
3447	{
3448	unsigned long flags;
3449	struct tty_struct *tty;
3450	spin_lock_irqsave(&p->sighand->siglock, flags);
3451	tty = p->signal->tty;
3452	p->signal->tty = NULL;
3453	spin_unlock_irqrestore(&p->sighand->siglock, flags);
3454	tty_kref_put(tty);
3455	}
3456
3457	/* Called under the sighand lock */
3458
3459	static void __proc_set_tty(struct task_struct tsk, struct tty_struct tty)
3460	{
3461	if (tty) {
3462	unsigned long flags;
3463	/* We should not have a session or pgrp to put here but.... */
3464	spin_lock_irqsave(&tty->ctrl_lock, flags);
3465	put_pid(tty->session);
3466	put_pid(tty->pgrp);
3467	tty->pgrp = get_pid(task_pgrp(tsk));
3468	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3469	tty->session = get_pid(task_session(tsk));
3470	if (tsk->signal->tty) {
3471	printk(KERN_DEBUG "tty not NULL!!\n");
3472	tty_kref_put(tsk->signal->tty);
3473	}
3474	}
3475	put_pid(tsk->signal->tty_old_pgrp);
3476	tsk->signal->tty = tty_kref_get(tty);
3477	tsk->signal->tty_old_pgrp = NULL;
3478	}
3479
3480	static void proc_set_tty(struct task_struct tsk, struct tty_struct tty)
3481	{
3482	spin_lock_irq(&tsk->sighand->siglock);
3483	__proc_set_tty(tsk, tty);
3484	spin_unlock_irq(&tsk->sighand->siglock);
3485	}
3486
3487	struct tty_struct *get_current_tty(void)
3488	{
3489	struct tty_struct *tty;
3490	unsigned long flags;
3491
3492	spin_lock_irqsave(&current->sighand->siglock, flags);
3493	tty = tty_kref_get(current->signal->tty);
3494	spin_unlock_irqrestore(&current->sighand->siglock, flags);
3495	return tty;
3496	}
3497	EXPORT_SYMBOL_GPL(get_current_tty);
3498
3499	void tty_default_fops(struct file_operations *fops)	3505	void tty_default_fops(struct file_operations *fops)
3500	{	3506	{
3501	*fops = tty_fops;	3507	*fops = tty_fops;

drivers/tty/tty_ioctl.c+6−32

  *	@tty: tty to update
  *	@new_termios: desired new value
  *
- *	Perform updates to the termios values set on this terminal. There
+ *	Perform updates to the termios values set on this terminal.
- *	is a bit of layering violation here with n_tty in terms of the
+ *	A master pty's termios should never be set.
- *	internal knowledge of this function.
  *
  *	Locking: termios_rwsem
  */
 {
 	struct ktermios old_termios;
 	struct tty_ldisc *ld;
-	unsigned long flags;
+	WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+		tty->driver->subtype == PTY_TYPE_MASTER);
 	/*
 	 *	Perform the actual termios internal changes under lock.
 	 */
 	tty->termios = *new_termios;
 	unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);
-	/* See if packet mode change of state. */
-	if (tty->link && tty->link->packet) {
-		int extproc = (old_termios.c_lflag & EXTPROC) |
-				(tty->termios.c_lflag & EXTPROC);
-		int old_flow = ((old_termios.c_iflag & IXON) &&
-				(old_termios.c_cc[VSTOP] == '\023') &&
-				(old_termios.c_cc[VSTART] == '\021'));
-		int new_flow = (I_IXON(tty) &&
-				STOP_CHAR(tty) == '\023' &&
-				START_CHAR(tty) == '\021');
-		if ((old_flow != new_flow) || extproc) {
-			spin_lock_irqsave(&tty->ctrl_lock, flags);
-			if (old_flow != new_flow) {
-				tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
-				if (new_flow)
-					tty->ctrl_status |= TIOCPKT_DOSTOP;
-				else
-					tty->ctrl_status |= TIOCPKT_NOSTOP;
-			}
-			if (extproc)
-				tty->ctrl_status |= TIOCPKT_IOCTL;
-			spin_unlock_irqrestore(&tty->ctrl_lock, flags);
-			wake_up_interruptible(&tty->link->read_wait);
-		}
-	}
 	if (tty->ops->set_termios)
-		(*tty->ops->set_termios)(tty, &old_termios);
+		tty->ops->set_termios(tty, &old_termios);
 	else
 		tty_termios_copy_hw(&tty->termios, &old_termios);
 	ld = tty_ldisc_ref(tty);
 	if (ld != NULL) {
 		if (ld->ops->set_termios)
-			(ld->ops->set_termios)(tty, &old_termios);
+			ld->ops->set_termios(tty, &old_termios);
 		tty_ldisc_deref(ld);
 	}
 	up_write(&tty->termios_rwsem);

drivers/tty/tty_ldisc.c+56−55

@@ -308,23 +308,41 @@ EXPORT_SYMBOL_GPL(tty_ldisc_deref); · 307 unmodified lines
308		308
309		309
310	static inline int __lockfunc	310	static inline int __lockfunc
311	tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)	311	__tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
312	{	312	{
313	return ldsem_down_write(&tty->ldisc_sem, timeout);	313	return ldsem_down_write(&tty->ldisc_sem, timeout);
314	}	314	}
315		315
316	static inline int __lockfunc	316	static inline int __lockfunc
317	tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)	317	__tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
318	{	318	{
319	return ldsem_down_write_nested(&tty->ldisc_sem,	319	return ldsem_down_write_nested(&tty->ldisc_sem,
320	LDISC_SEM_OTHER, timeout);	320	LDISC_SEM_OTHER, timeout);
321	}	321	}
322		322
323	static inline void tty_ldisc_unlock(struct tty_struct *tty)	323	static inline void __tty_ldisc_unlock(struct tty_struct *tty)
324	{	324	{
325	return ldsem_up_write(&tty->ldisc_sem);	325	return ldsem_up_write(&tty->ldisc_sem);
326	}	326	}
327		327
		328	static int __lockfunc
		329	tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
		330	{
		331	int ret;
		332
		333	ret = __tty_ldisc_lock(tty, timeout);
		334	if (!ret)
		335	return -EBUSY;
		336	set_bit(TTY_LDISC_HALTED, &tty->flags);
		337	return 0;
		338	}
		339
		340	static void tty_ldisc_unlock(struct tty_struct *tty)
		341	{
		342	clear_bit(TTY_LDISC_HALTED, &tty->flags);
		343	__tty_ldisc_unlock(tty);
		344	}
		345
328	static int __lockfunc	346	static int __lockfunc
329	tty_ldisc_lock_pair_timeout(struct tty_struct tty, struct tty_struct tty2,	347	tty_ldisc_lock_pair_timeout(struct tty_struct tty, struct tty_struct tty2,
330	unsigned long timeout)	348	unsigned long timeout)
@@ -332,24 +350,24 @@ tty_ldisc_lock_pair_timeout(struct tty_struct tty, struct tty_struct tty2, · 1 unmodified line
332	int ret;	350	int ret;
333		351
334	if (tty < tty2) {	352	if (tty < tty2) {
335	ret = tty_ldisc_lock(tty, timeout);	353	ret = __tty_ldisc_lock(tty, timeout);
336	if (ret) {	354	if (ret) {
337	ret = tty_ldisc_lock_nested(tty2, timeout);	355	ret = __tty_ldisc_lock_nested(tty2, timeout);
338	if (!ret)	356	if (!ret)
339	tty_ldisc_unlock(tty);	357	__tty_ldisc_unlock(tty);
340	}	358	}
341	} else {	359	} else {
342	/* if this is possible, it has lots of implications */	360	/* if this is possible, it has lots of implications */
343	WARN_ON_ONCE(tty == tty2);	361	WARN_ON_ONCE(tty == tty2);
344	if (tty2 && tty != tty2) {	362	if (tty2 && tty != tty2) {
345	ret = tty_ldisc_lock(tty2, timeout);	363	ret = __tty_ldisc_lock(tty2, timeout);
346	if (ret) {	364	if (ret) {
347	ret = tty_ldisc_lock_nested(tty, timeout);	365	ret = __tty_ldisc_lock_nested(tty, timeout);
348	if (!ret)	366	if (!ret)
349	tty_ldisc_unlock(tty2);	367	__tty_ldisc_unlock(tty2);
350	}	368	}
351	} else	369	} else
352	ret = tty_ldisc_lock(tty, timeout);	370	ret = __tty_ldisc_lock(tty, timeout);
353	}	371	}
354		372
355	if (!ret)	373	if (!ret)
@@ -370,38 +388,26 @@ tty_ldisc_lock_pair(struct tty_struct tty, struct tty_struct tty2) · 14 unmodified lines
370	static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,	388	static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
371	struct tty_struct *tty2)	389	struct tty_struct *tty2)
372	{	390	{
373	tty_ldisc_unlock(tty);	391	__tty_ldisc_unlock(tty);
374	if (tty2)
375	tty_ldisc_unlock(tty2);
376	}
377
378	static void __lockfunc tty_ldisc_enable_pair(struct tty_struct *tty,
379	struct tty_struct *tty2)
380	{
381	clear_bit(TTY_LDISC_HALTED, &tty->flags);
382	if (tty2)	392	if (tty2)
383	clear_bit(TTY_LDISC_HALTED, &tty2->flags);	393	__tty_ldisc_unlock(tty2);
384
385	tty_ldisc_unlock_pair(tty, tty2);
386	}	394	}
387		395
388	/**	396	/**
389	* tty_ldisc_flush - flush line discipline queue	397	* tty_ldisc_flush - flush line discipline queue
390	* @tty: tty	398	* @tty: tty
391	*	399	*
392	* Flush the line discipline queue (if any) for this tty. If there	400	* Flush the line discipline queue (if any) and the tty flip buffers
393	* is no line discipline active this is a no-op.	401	* for this tty.
394	*/	402	*/
395		403
396	void tty_ldisc_flush(struct tty_struct *tty)	404	void tty_ldisc_flush(struct tty_struct *tty)
397	{	405	{
398	struct tty_ldisc *ld = tty_ldisc_ref(tty);	406	struct tty_ldisc *ld = tty_ldisc_ref(tty);
399	if (ld) {	407
400	if (ld->ops->flush_buffer)	408	tty_buffer_flush(tty, ld);
401	ld->ops->flush_buffer(tty);	409	if (ld)
402	tty_ldisc_deref(ld);	410	tty_ldisc_deref(ld);
403	}
404	tty_buffer_flush(tty);
405	}	411	}
406	EXPORT_SYMBOL_GPL(tty_ldisc_flush);	412	EXPORT_SYMBOL_GPL(tty_ldisc_flush);
407		413
@@ -517,15 +523,16 @@ int tty_set_ldisc(struct tty_struct *tty, int ldisc) · 109 unmodified lines
517	{	523	{
518	int retval;	524	int retval;
519	struct tty_ldisc old_ldisc, new_ldisc;	525	struct tty_ldisc old_ldisc, new_ldisc;
520	struct tty_struct *o_tty = tty->link;
521		526
522	new_ldisc = tty_ldisc_get(tty, ldisc);	527	new_ldisc = tty_ldisc_get(tty, ldisc);
523	if (IS_ERR(new_ldisc))	528	if (IS_ERR(new_ldisc))
524	return PTR_ERR(new_ldisc);	529	return PTR_ERR(new_ldisc);
525		530
526	retval = tty_ldisc_lock_pair_timeout(tty, o_tty, 5 * HZ);	531	tty_lock(tty);
		532	retval = tty_ldisc_lock(tty, 5 * HZ);
527	if (retval) {	533	if (retval) {
528	tty_ldisc_put(new_ldisc);	534	tty_ldisc_put(new_ldisc);
		535	tty_unlock(tty);
529	return retval;	536	return retval;
530	}	537	}
531		538
@@ -534,19 +541,18 @@ int tty_set_ldisc(struct tty_struct *tty, int ldisc) · 2 unmodified lines
534	*/	541	*/
535		542
536	if (tty->ldisc->ops->num == ldisc) {	543	if (tty->ldisc->ops->num == ldisc) {
537	tty_ldisc_enable_pair(tty, o_tty);	544	tty_ldisc_unlock(tty);
538	tty_ldisc_put(new_ldisc);	545	tty_ldisc_put(new_ldisc);
		546	tty_unlock(tty);
539	return 0;	547	return 0;
540	}	548	}
541		549
542	old_ldisc = tty->ldisc;	550	old_ldisc = tty->ldisc;
543	tty_lock(tty);
544		551
545	if (test_bit(TTY_HUPPING, &tty->flags) \|\|	552	if (test_bit(TTY_HUPPED, &tty->flags)) {
546	test_bit(TTY_HUPPED, &tty->flags)) {
547	/* We were raced by the hangup method. It will have stomped	553	/* We were raced by the hangup method. It will have stomped
548	the ldisc data and closed the ldisc down */	554	the ldisc data and closed the ldisc down */
549	tty_ldisc_enable_pair(tty, o_tty);	555	tty_ldisc_unlock(tty);
550	tty_ldisc_put(new_ldisc);	556	tty_ldisc_put(new_ldisc);
551	tty_unlock(tty);	557	tty_unlock(tty);
552	return -EIO;	558	return -EIO;
@@ -566,8 +572,11 @@ int tty_set_ldisc(struct tty_struct *tty, int ldisc) · 13 unmodified lines
566	tty_ldisc_restore(tty, old_ldisc);	572	tty_ldisc_restore(tty, old_ldisc);
567	}	573	}
568		574
569	if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc)	575	if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
		576	down_read(&tty->termios_rwsem);
570	tty->ops->set_ldisc(tty);	577	tty->ops->set_ldisc(tty);
		578	up_read(&tty->termios_rwsem);
		579	}
571		580
572	/* At this point we hold a reference to the new ldisc and a	581	/* At this point we hold a reference to the new ldisc and a
573	reference to the old ldisc, or we hold two references to	582	reference to the old ldisc, or we hold two references to
@@ -580,13 +589,11 @@ int tty_set_ldisc(struct tty_struct *tty, int ldisc) · 6 unmodified lines
580	/*	589	/*
581	* Allow ldisc referencing to occur again	590	* Allow ldisc referencing to occur again
582	*/	591	*/
583	tty_ldisc_enable_pair(tty, o_tty);	592	tty_ldisc_unlock(tty);
584		593
585	/* Restart the work queue in case no characters kick it off. Safe if	594	/* Restart the work queue in case no characters kick it off. Safe if
586	already running */	595	already running */
587	schedule_work(&tty->port->buf.work);	596	schedule_work(&tty->port->buf.work);
588	if (o_tty)
589	schedule_work(&o_tty->port->buf.work);
590		597
591	tty_unlock(tty);	598	tty_unlock(tty);
592	return retval;	599	return retval;
@@ -675,16 +682,13 @@ void tty_ldisc_hangup(struct tty_struct *tty) · 82 unmodified lines
675	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);	682	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
676	wake_up_interruptible_poll(&tty->read_wait, POLLIN);	683	wake_up_interruptible_poll(&tty->read_wait, POLLIN);
677		684
678	tty_unlock(tty);
679
680	/*	685	/*
681	* Shutdown the current line discipline, and reset it to	686	* Shutdown the current line discipline, and reset it to
682	* N_TTY if need be.	687	* N_TTY if need be.
683	*	688	*
684	* Avoid racing set_ldisc or tty_ldisc_release	689	* Avoid racing set_ldisc or tty_ldisc_release
685	*/	690	*/
686	tty_ldisc_lock_pair(tty, tty->link);	691	tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
687	tty_lock(tty);
688		692
689	if (tty->ldisc) {	693	if (tty->ldisc) {
690		694
@@ -706,7 +710,7 @@ void tty_ldisc_hangup(struct tty_struct *tty) · 15 unmodified lines
706	WARN_ON(tty_ldisc_open(tty, tty->ldisc));	710	WARN_ON(tty_ldisc_open(tty, tty->ldisc));
707	}	711	}
708	}	712	}
709	tty_ldisc_enable_pair(tty, tty->link);	713	tty_ldisc_unlock(tty);
710	if (reset)	714	if (reset)
711	tty_reset_termios(tty);	715	tty_reset_termios(tty);
712		716
@@ -758,16 +762,17 @@ static void tty_ldisc_kill(struct tty_struct *tty) · 45 unmodified lines
758		762
759	/**	763	/**
760	* tty_ldisc_release - release line discipline	764	* tty_ldisc_release - release line discipline
761	* @tty: tty being shut down	765	* @tty: tty being shut down (or one end of pty pair)
762	* @o_tty: pair tty for pty/tty pairs
763	*	766	*
764	* Called during the final close of a tty/pty pair in order to shut down	767	* Called during the final close of a tty or a pty pair in order to shut
765	* the line discpline layer. On exit the ldisc assigned is N_TTY and the	768	* down the line discpline layer. On exit, each ldisc assigned is N_TTY and
766	* ldisc has not been opened.	769	* each ldisc has not been opened.
767	*/	770	*/
768		771
769	void tty_ldisc_release(struct tty_struct tty, struct tty_struct o_tty)	772	void tty_ldisc_release(struct tty_struct *tty)
770	{	773	{
		774	struct tty_struct *o_tty = tty->link;
		775
771	/*	776	/*
772	* Shutdown this line discipline. As this is the final close,	777	* Shutdown this line discipline. As this is the final close,
773	* it does not race with the set_ldisc code path.	778	* it does not race with the set_ldisc code path.
@@ -776,13 +781,9 @@ void tty_ldisc_release(struct tty_struct tty, struct tty_struct o_tty) · 2 unmodified lines
776	tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);	781	tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
777		782
778	tty_ldisc_lock_pair(tty, o_tty);	783	tty_ldisc_lock_pair(tty, o_tty);
779	tty_lock_pair(tty, o_tty);
780
781	tty_ldisc_kill(tty);	784	tty_ldisc_kill(tty);
782	if (o_tty)	785	if (o_tty)
783	tty_ldisc_kill(o_tty);	786	tty_ldisc_kill(o_tty);
784
785	tty_unlock_pair(tty, o_tty);
786	tty_ldisc_unlock_pair(tty, o_tty);	787	tty_ldisc_unlock_pair(tty, o_tty);
787		788
788	/* And the memory resources remaining (buffers, termios) will be	789	/* And the memory resources remaining (buffers, termios) will be

drivers/tty/tty_mutex.c+21−28

 #include <linux/semaphore.h>
 #include <linux/sched.h>
+/*
+ * Nested tty locks are necessary for releasing pty pairs.
+ * The stable lock order is master pty first, then slave pty.
+ */
 /* Legacy tty mutex glue */
 enum {
 	TTY_MUTEX_NORMAL,
-	TTY_MUTEX_NESTED,
+	TTY_MUTEX_SLAVE,
 };
 /*
  * Getting the big tty mutex.
  */
-static void __lockfunc tty_lock_nested(struct tty_struct *tty,
+void __lockfunc tty_lock(struct tty_struct *tty)
-				       unsigned int subclass)
 {
 	if (tty->magic != TTY_MAGIC) {
 		pr_err("L Bad %p\n", tty);
 		return;
 	}
 	tty_kref_get(tty);
-	mutex_lock_nested(&tty->legacy_mutex, subclass);
+	mutex_lock(&tty->legacy_mutex);
-}
-void __lockfunc tty_lock(struct tty_struct *tty)
-{
-	return tty_lock_nested(tty, TTY_MUTEX_NORMAL);
 }
 EXPORT_SYMBOL(tty_lock);
 }
 EXPORT_SYMBOL(tty_unlock);
-/*
+void __lockfunc tty_lock_slave(struct tty_struct *tty)
- * Getting the big tty mutex for a pair of ttys with lock ordering
- * On a non pty/tty pair tty2 can be NULL which is just fine.
- */
-void __lockfunc tty_lock_pair(struct tty_struct *tty,
-					struct tty_struct *tty2)
 {
-	if (tty < tty2) {
+	if (tty && tty != tty->link) {
+		WARN_ON(!mutex_is_locked(&tty->link->legacy_mutex) ||
+			!tty->driver->type == TTY_DRIVER_TYPE_PTY ||
+			!tty->driver->type == PTY_TYPE_SLAVE);
 		tty_lock(tty);
-		tty_lock_nested(tty2, TTY_MUTEX_NESTED);
-	} else {
-		if (tty2 && tty2 != tty)
-			tty_lock(tty2);
-		tty_lock_nested(tty, TTY_MUTEX_NESTED);
 	}
 }
-EXPORT_SYMBOL(tty_lock_pair);
-void __lockfunc tty_unlock_pair(struct tty_struct *tty,
+void __lockfunc tty_unlock_slave(struct tty_struct *tty)
-						struct tty_struct *tty2)
+{
+	if (tty && tty != tty->link)
+		tty_unlock(tty);
+}
+void tty_set_lock_subclass(struct tty_struct *tty)
 {
-	tty_unlock(tty);
+	lockdep_set_subclass(&tty->legacy_mutex, TTY_MUTEX_SLAVE);
-	if (tty2 && tty2 != tty)
-		tty_unlock(tty2);
 }
-EXPORT_SYMBOL(tty_unlock_pair);

drivers/tty/tty_port.c+4−6

 	unsigned long flags;
 	spin_lock_irqsave(&port->lock, flags);
-	if (port->tty)
+	tty_kref_put(port->tty);
-		tty_kref_put(port->tty);
 	port->tty = tty_kref_get(tty);
 	spin_unlock_irqrestore(&port->lock, flags);
 }
 {
 	unsigned long flags;
-	spin_lock_irqsave(&port->lock, flags);
+	if (tty_hung_up_p(filp))
-	if (tty_hung_up_p(filp)) {
-		spin_unlock_irqrestore(&port->lock, flags);
 		return 0;
-	}
+	spin_lock_irqsave(&port->lock, flags);
 	if (tty->count == 1 && port->count != 1) {
 		printk(KERN_WARNING
 		    "tty_port_close_start: tty->count = 1 port count = %d.\n",
 {
 	unsigned long flags;
+	tty_ldisc_flush(tty);
 	tty->closing = 0;
 	spin_lock_irqsave(&port->lock, flags);

drivers/tty/vt/keyboard.c+3−3

@@ -924,7 +924,7 @@ static void k_brl(struct vc_data *vc, unsigned char value, char up_flag) · 923 unmodified lines
924		924
925	if (kbd->kbdmode != VC_UNICODE) {	925	if (kbd->kbdmode != VC_UNICODE) {
926	if (!up_flag)	926	if (!up_flag)
927	pr_warning("keyboard mode must be unicode for braille patterns\n");	927	pr_warn("keyboard mode must be unicode for braille patterns\n");
928	return;	928	return;
929	}	929	}
930		930
@@ -1253,8 +1253,8 @@ static void kbd_keycode(unsigned int keycode, int down, int hw_raw) · 322 unmodified lines
1253	if (raw_mode && !hw_raw)	1253	if (raw_mode && !hw_raw)
1254	if (emulate_raw(vc, keycode, !down << 7))	1254	if (emulate_raw(vc, keycode, !down << 7))
1255	if (keycode < BTN_MISC && printk_ratelimit())	1255	if (keycode < BTN_MISC && printk_ratelimit())
1256	pr_warning("can't emulate rawmode for keycode %d\n",	1256	pr_warn("can't emulate rawmode for keycode %d\n",
1257	keycode);	1257	keycode);
1258		1258
1259	#ifdef CONFIG_SPARC	1259	#ifdef CONFIG_SPARC
1260	if (keycode == KEY_A && sparc_l1_a_state) {	1260	if (keycode == KEY_A && sparc_l1_a_state) {

drivers/tty/vt/vt.c+14−8

 static void blank_screen_t(unsigned long dummy);
 static void set_palette(struct vc_data *vc);
+#define vt_get_kmsg_redirect() vt_kmsg_redirect(-1)
 static int printable;		/* Is console ready for printing? */
 int default_utf8 = true;
 module_param(default_utf8, int, S_IRUGO | S_IWUSR);
 						rgb_from_256(vc->vc_par[i]));
 				} else if (vc->vc_par[i] == 2 &&  /* 24 bit */
 				           i <= vc->vc_npar + 3) {/* extremely rare */
-					struct rgb c = {r:vc->vc_par[i+1],
+					struct rgb c = {
-							g:vc->vc_par[i+2],
+						.r = vc->vc_par[i + 1],
-							b:vc->vc_par[i+3]};
+						.g = vc->vc_par[i + 2],
+						.b = vc->vc_par[i + 3],
+					};
 					rgb_foreground(vc, c);
 					i += 3;
 				}
 						rgb_from_256(vc->vc_par[i]));
 				} else if (vc->vc_par[i] == 2 && /* 24 bit */
 				           i <= vc->vc_npar + 3) {
-					struct rgb c = {r:vc->vc_par[i+1],
+					struct rgb c = {
-							g:vc->vc_par[i+2],
+						.r = vc->vc_par[i + 1],
-							b:vc->vc_par[i+3]};
+						.g = vc->vc_par[i + 2],
+						.b = vc->vc_par[i + 3],
+					};
 					rgb_background(vc, c);
 					i += 3;
 				}
 		return;
 	if (!vc_cons_allocated(fg_console)) {
 		/* impossible */
-		pr_warning("unblank_screen: tty %d not allocated ??\n",
+		pr_warn("unblank_screen: tty %d not allocated ??\n",
-			   fg_console+1);
+			fg_console + 1);
 		return;
 	}
 	vc = vc_cons[fg_console].d;

include/linux/kernel.h+0−3

@@ -416,9 +416,6 @@ extern int __kernel_text_address(unsigned long addr); · 415 unmodified lines
416	extern int kernel_text_address(unsigned long addr);	416	extern int kernel_text_address(unsigned long addr);
417	extern int func_ptr_is_kernel_text(void *ptr);	417	extern int func_ptr_is_kernel_text(void *ptr);
418		418
419	struct pid;
420	extern struct pid session_of_pgrp(struct pid pgrp);
421
422	unsigned long int_sqrt(unsigned long);	419	unsigned long int_sqrt(unsigned long);
423		420
424	extern void bust_spinlocks(int yes);	421	extern void bust_spinlocks(int yes);

include/linux/serial_8250.h+0−3

 	unsigned char		msr_saved_flags;
 	struct uart_8250_dma	*dma;
-	struct serial_rs485     rs485;
 	/* 8250 specific callbacks */
 	int			(*dl_read)(struct uart_8250_port *);
 	void			(*dl_write)(struct uart_8250_port *, int);
-	int			(*rs485_config)(struct uart_8250_port *,
-						struct serial_rs485 *rs485);
 };
 static inline struct uart_8250_port *up_to_u8250p(struct uart_port *up)

include/linux/serial_bcm63xx.h+0−2

@@ -116,6 +116,4 @@ · 115 unmodified lines
116	UART_FIFO_PARERR_MASK \| \	116	UART_FIFO_PARERR_MASK \| \
117	UART_FIFO_BRKDET_MASK)	117	UART_FIFO_BRKDET_MASK)
118		118
119	#define UART_REG_SIZE 24
120
121	#endif /* _LINUX_SERIAL_BCM63XX_H */	119	#endif /* _LINUX_SERIAL_BCM63XX_H */

include/linux/serial_core.h+44−23

 	void		(*flush_buffer)(struct uart_port *);
 	void		(*set_termios)(struct uart_port *, struct ktermios *new,
 				       struct ktermios *old);
-	void		(*set_ldisc)(struct uart_port *, int new);
+	void		(*set_ldisc)(struct uart_port *, struct ktermios *);
 	void		(*pm)(struct uart_port *, unsigned int state,
 			      unsigned int oldstate);
 	void			(*pm)(struct uart_port *, unsigned int state,
 				      unsigned int old);
 	void			(*handle_break)(struct uart_port *);
+	int			(*rs485_config)(struct uart_port *,
+						struct serial_rs485 *rs485);
 	unsigned int		irq;			/* irq number */
 	unsigned long		irqflags;		/* irq flags  */
 	unsigned int		uartclk;		/* base uart clock */
 	unsigned char		iotype;			/* io access style */
 	unsigned char		unused1;
-#define UPIO_PORT		(0)
+#define UPIO_PORT		(0)			/* 8b I/O port access */
-#define UPIO_HUB6		(1)
+#define UPIO_HUB6		(1)			/* Hub6 ISA card */
-#define UPIO_MEM		(2)
+#define UPIO_MEM		(2)			/* 8b MMIO access */
-#define UPIO_MEM32		(3)
+#define UPIO_MEM32		(3)			/* 32b little endian */
-#define UPIO_AU			(4)			/* Au1x00 and RT288x type IO */
+#define UPIO_MEM32BE		(4)			/* 32b big endian */
-#define UPIO_TSI		(5)			/* Tsi108/109 type IO */
+#define UPIO_AU			(5)			/* Au1x00 and RT288x type IO */
+#define UPIO_TSI		(6)			/* Tsi108/109 type IO */
 	unsigned int		read_status_mask;	/* driver specific */
 	unsigned int		ignore_status_mask;	/* driver specific */
 	/* flags must be updated while holding port mutex */
 	upf_t			flags;
-#define UPF_FOURPORT		((__force upf_t) (1 << 1))
+	/*
-#define UPF_SAK			((__force upf_t) (1 << 2))
+	 * These flags must be equivalent to the flags defined in
-#define UPF_SPD_MASK		((__force upf_t) (0x1030))
+	 * include/uapi/linux/tty_flags.h which are the userspace definitions
-#define UPF_SPD_HI		((__force upf_t) (0x0010))
+	 * assigned from the serial_struct flags in uart_set_info()
-#define UPF_SPD_VHI		((__force upf_t) (0x0020))
+	 * [for bit definitions in the UPF_CHANGE_MASK]
-#define UPF_SPD_CUST		((__force upf_t) (0x0030))
+	 *
-#define UPF_SPD_SHI		((__force upf_t) (0x1000))
+	 * Bits [0..UPF_LAST_USER] are userspace defined/visible/changeable
-#define UPF_SPD_WARP		((__force upf_t) (0x1010))
+	 * except bit 15 (UPF_NO_TXEN_TEST) which is masked off.
-#define UPF_SKIP_TEST		((__force upf_t) (1 << 6))
+	 * The remaining bits are serial-core specific and not modifiable by
-#define UPF_AUTO_IRQ		((__force upf_t) (1 << 7))
+	 * userspace.
-#define UPF_HARDPPS_CD		((__force upf_t) (1 << 11))
+	 */
-#define UPF_LOW_LATENCY		((__force upf_t) (1 << 13))
+#define UPF_FOURPORT		((__force upf_t) ASYNC_FOURPORT       /* 1  */ )
-#define UPF_BUGGY_UART		((__force upf_t) (1 << 14))
+#define UPF_SAK			((__force upf_t) ASYNC_SAK            /* 2  */ )
+#define UPF_SPD_HI		((__force upf_t) ASYNC_SPD_HI         /* 4  */ )
+#define UPF_SPD_VHI		((__force upf_t) ASYNC_SPD_VHI        /* 5  */ )
+#define UPF_SPD_CUST		((__force upf_t) ASYNC_SPD_CUST   /* 0x0030 */ )
+#define UPF_SPD_WARP		((__force upf_t) ASYNC_SPD_WARP   /* 0x1010 */ )
+#define UPF_SPD_MASK		((__force upf_t) ASYNC_SPD_MASK   /* 0x1030 */ )
+#define UPF_SKIP_TEST		((__force upf_t) ASYNC_SKIP_TEST      /* 6  */ )
+#define UPF_AUTO_IRQ		((__force upf_t) ASYNC_AUTO_IRQ       /* 7  */ )
+#define UPF_HARDPPS_CD		((__force upf_t) ASYNC_HARDPPS_CD     /* 11 */ )
+#define UPF_SPD_SHI		((__force upf_t) ASYNC_SPD_SHI        /* 12 */ )
+#define UPF_LOW_LATENCY		((__force upf_t) ASYNC_LOW_LATENCY    /* 13 */ )
+#define UPF_BUGGY_UART		((__force upf_t) ASYNC_BUGGY_UART     /* 14 */ )
 #define UPF_NO_TXEN_TEST	((__force upf_t) (1 << 15))
-#define UPF_MAGIC_MULTIPLIER	((__force upf_t) (1 << 16))
+#define UPF_MAGIC_MULTIPLIER	((__force upf_t) ASYNC_MAGIC_MULTIPLIER /* 16 */ )
 /* Port has hardware-assisted h/w flow control (iow, auto-RTS *not* auto-CTS) */
 #define UPF_HARD_FLOW		((__force upf_t) (1 << 21))
 /* Port has hardware-assisted s/w flow control */
 #define UPF_DEAD		((__force upf_t) (1 << 30))
 #define UPF_IOREMAP		((__force upf_t) (1 << 31))
-#define UPF_CHANGE_MASK		((__force upf_t) (0x17fff))
+#define __UPF_CHANGE_MASK	0x17fff
+#define UPF_CHANGE_MASK		((__force upf_t) __UPF_CHANGE_MASK)
 #define UPF_USR_MASK		((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
+#if __UPF_CHANGE_MASK > ASYNC_FLAGS
+#error Change mask not equivalent to userspace-visible bit defines
+#endif
 	/* status must be updated while holding port lock */
 	upstat_t		status;
 	unsigned char		unused[2];
 	struct attribute_group	*attr_group;		/* port specific attributes */
 	const struct attribute_group **tty_groups;	/* all attributes (serial core use only) */
+	struct serial_rs485     rs485;
 	void			*private_data;		/* generic platform data pointer */
 };
 static inline bool uart_cts_enabled(struct uart_port *uport)
 {
-	return uport->status & UPSTAT_CTS_ENABLE;
+	return !!(uport->status & UPSTAT_CTS_ENABLE);
 }
 /*

include/linux/tty.h+6−22

 #define N_TTY_BUF_SIZE 4096
-	unsigned char closing:1;
+	int closing;
 	unsigned char *write_buf;
 	int write_cnt;
 	/* If the tty has a pending do_SAK, queue it here - akpm */
 #define TTY_EXCLUSIVE 		3	/* Exclusive open mode */
 #define TTY_DEBUG 		4	/* Debugging */
 #define TTY_DO_WRITE_WAKEUP 	5	/* Call write_wakeup after queuing new */
-#define TTY_CLOSING 		7	/* ->close() in progress */
 #define TTY_LDISC_OPEN	 	11	/* Line discipline is open */
 #define TTY_PTY_LOCK 		16	/* pty private */
 #define TTY_NO_WRITE_SPLIT 	17	/* Preserve write boundaries to driver */
 #define TTY_HUPPED 		18	/* Post driver->hangup() */
-#define TTY_HUPPING 		21	/* ->hangup() in progress */
 #define TTY_LDISC_HALTED	22	/* Line discipline is halted */
 #define TTY_WRITE_FLUSH(tty) tty_write_flush((tty))
 extern int tty_signal(int sig, struct tty_struct *tty);
 extern void tty_hangup(struct tty_struct *tty);
 extern void tty_vhangup(struct tty_struct *tty);
-extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file *filp);
 extern void do_SAK(struct tty_struct *tty);
 extern void __do_SAK(struct tty_struct *tty);
 extern void no_tty(void);
 extern void tty_flush_to_ldisc(struct tty_struct *tty);
 extern void tty_buffer_free_all(struct tty_port *port);
-extern void tty_buffer_flush(struct tty_struct *tty);
+extern void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld);
 extern void tty_buffer_init(struct tty_port *port);
 extern speed_t tty_termios_baud_rate(struct ktermios *termios);
 extern speed_t tty_termios_input_baud_rate(struct ktermios *termios);
 extern int tty_standard_install(struct tty_driver *driver,
 		struct tty_struct *tty);
-extern struct tty_struct *tty_pair_get_tty(struct tty_struct *tty);
-extern struct tty_struct *tty_pair_get_pty(struct tty_struct *tty);
 extern struct mutex tty_mutex;
 extern spinlock_t tty_files_lock;
 extern int tty_unregister_ldisc(int disc);
 extern int tty_set_ldisc(struct tty_struct *tty, int ldisc);
 extern int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty);
-extern void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty);
+extern void tty_ldisc_release(struct tty_struct *tty);
 extern void tty_ldisc_init(struct tty_struct *tty);
 extern void tty_ldisc_deinit(struct tty_struct *tty);
 extern void tty_ldisc_begin(void);
 extern long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
 		       unsigned int cmd, unsigned long arg);
-/* serial.c */
-extern void serial_console_init(void);
-/* pcxx.c */
-extern int pcxe_open(struct tty_struct *tty, struct file *filp);
 /* vt.c */
 extern int vt_ioctl(struct tty_struct *tty,
 /* functions for preparation of BKL removal */
 extern void __lockfunc tty_lock(struct tty_struct *tty);
 extern void __lockfunc tty_unlock(struct tty_struct *tty);
-extern void __lockfunc tty_lock_pair(struct tty_struct *tty,
+extern void __lockfunc tty_lock_slave(struct tty_struct *tty);
-				struct tty_struct *tty2);
+extern void __lockfunc tty_unlock_slave(struct tty_struct *tty);
-extern void __lockfunc tty_unlock_pair(struct tty_struct *tty,
+extern void tty_set_lock_subclass(struct tty_struct *tty);
-				struct tty_struct *tty2);
 /*
  * this shall be called only from where BTM is held (like close)
  *

include/uapi/linux/serial_core.h+2−1

@@ -54,7 +54,8 @@ · 53 unmodified lines
54	#define PORT_ALTR_16550_F32 26 /* Altera 16550 UART with 32 FIFOs */	54	#define PORT_ALTR_16550_F32 26 /* Altera 16550 UART with 32 FIFOs */
55	#define PORT_ALTR_16550_F64 27 /* Altera 16550 UART with 64 FIFOs */	55	#define PORT_ALTR_16550_F64 27 /* Altera 16550 UART with 64 FIFOs */
56	#define PORT_ALTR_16550_F128 28 /* Altera 16550 UART with 128 FIFOs */	56	#define PORT_ALTR_16550_F128 28 /* Altera 16550 UART with 128 FIFOs */
57	#define PORT_MAX_8250 28 /* max port ID */	57	#define PORT_RT2880 29 /* Ralink RT2880 internal UART */
		58	#define PORT_MAX_8250 29 /* max port ID */
58		59
59	/*	60	/*
60	* ARM specific type numbers. These are not currently guaranteed	61	* ARM specific type numbers. These are not currently guaranteed

include/uapi/linux/serial_reg.h+1−0

@@ -359,6 +359,7 @@ · 358 unmodified lines
359	#define UART_OMAP_SYSC 0x15 /* System configuration register */	359	#define UART_OMAP_SYSC 0x15 /* System configuration register */
360	#define UART_OMAP_SYSS 0x16 /* System status register */	360	#define UART_OMAP_SYSS 0x16 /* System status register */
361	#define UART_OMAP_WER 0x17 /* Wake-up enable register */	361	#define UART_OMAP_WER 0x17 /* Wake-up enable register */
		362	#define UART_OMAP_TX_LVL 0x1a /* TX FIFO level register */
362		363
363	/*	364	/*
364	* These are the definitions for the MDR1 register	365	* These are the definitions for the MDR1 register

include/uapi/linux/tty_flags.h+13−6

  * shared by the tty_port flags structures.
  *
  * Define ASYNCB_* for convenient use with {test,set,clear}_bit.
+ *
+ * Bits [0..ASYNCB_LAST_USER] are userspace defined/visible/changeable
+ * [x] in the bit comments indicates the flag is defunct and no longer used.
  */
 #define ASYNCB_HUP_NOTIFY	 0 /* Notify getty on hangups and closes
 				    * on the callout port */
 #define ASYNCB_FOURPORT		 1 /* Set OU1, OUT2 per AST Fourport settings */
 #define ASYNCB_SAK		 2 /* Secure Attention Key (Orange book) */
-#define ASYNCB_SPLIT_TERMIOS	 3 /* Separate termios for dialin/callout */
+#define ASYNCB_SPLIT_TERMIOS	 3 /* [x] Separate termios for dialin/callout */
 #define ASYNCB_SPD_HI		 4 /* Use 56000 instead of 38400 bps */
 #define ASYNCB_SPD_VHI		 5 /* Use 115200 instead of 38400 bps */
 #define ASYNCB_SKIP_TEST	 6 /* Skip UART test during autoconfiguration */
 #define ASYNCB_AUTO_IRQ		 7 /* Do automatic IRQ during
 				    * autoconfiguration */
-#define ASYNCB_SESSION_LOCKOUT	 8 /* Lock out cua opens based on session */
+#define ASYNCB_SESSION_LOCKOUT	 8 /* [x] Lock out cua opens based on session */
-#define ASYNCB_PGRP_LOCKOUT	 9 /* Lock out cua opens based on pgrp */
+#define ASYNCB_PGRP_LOCKOUT	 9 /* [x] Lock out cua opens based on pgrp */
-#define ASYNCB_CALLOUT_NOHUP	10 /* Don't do hangups for cua device */
+#define ASYNCB_CALLOUT_NOHUP	10 /* [x] Don't do hangups for cua device */
 #define ASYNCB_HARDPPS_CD	11 /* Call hardpps when CD goes high  */
 #define ASYNCB_SPD_SHI		12 /* Use 230400 instead of 38400 bps */
 #define ASYNCB_LOW_LATENCY	13 /* Request low latency behaviour */
 #define ASYNCB_BUGGY_UART	14 /* This is a buggy UART, skip some safety
 				    * checks.  Note: can be dangerous! */
-#define ASYNCB_AUTOPROBE	15 /* Port was autoprobed by PCI or PNP code */
+#define ASYNCB_AUTOPROBE	15 /* [x] Port was autoprobed by PCI/PNP code */
-#define ASYNCB_LAST_USER	15
+#define ASYNCB_MAGIC_MULTIPLIER	16 /* Use special CLK or divisor */
+#define ASYNCB_LAST_USER	16
 /* Internal flags used only by kernel */
 #define ASYNCB_INITIALIZED	31 /* Serial port was initialized */
 #define ASYNC_LOW_LATENCY	(1U << ASYNCB_LOW_LATENCY)
 #define ASYNC_BUGGY_UART	(1U << ASYNCB_BUGGY_UART)
 #define ASYNC_AUTOPROBE		(1U << ASYNCB_AUTOPROBE)
+#define ASYNC_MAGIC_MULTIPLIER	(1U << ASYNCB_MAGIC_MULTIPLIER)
 #define ASYNC_FLAGS		((1U << (ASYNCB_LAST_USER + 1)) - 1)
+#define ASYNC_DEPRECATED	(ASYNC_SESSION_LOCKOUT | ASYNC_PGRP_LOCKOUT | \
+		ASYNC_CALLOUT_NOHUP | ASYNC_AUTOPROBE)
 #define ASYNC_USR_MASK		(ASYNC_SPD_MASK|ASYNC_CALLOUT_NOHUP| \
 		ASYNC_LOW_LATENCY)
 #define ASYNC_SPD_CUST		(ASYNC_SPD_HI|ASYNC_SPD_VHI)

include/uapi/linux/vt.h+0−3

@@ -84,7 +84,4 @@ struct vt_setactivate { · 83 unmodified lines
84		84
85	#define VT_SETACTIVATE 0x560F /* Activate and set the mode of a console */	85	#define VT_SETACTIVATE 0x560F /* Activate and set the mode of a console */
86		86
87
88	#define vt_get_kmsg_redirect() vt_kmsg_redirect(-1)
89
90	#endif /* _UAPI_LINUX_VT_H */	87	#endif /* _UAPI_LINUX_VT_H */

kernel/exit.c+0−21

@@ -211,27 +211,6 @@ repeat: · 210 unmodified lines
211	goto repeat;	211	goto repeat;
212	}	212	}
213		213
214	/*
215	* This checks not only the pgrp, but falls back on the pid if no
216	* satisfactory pgrp is found. I dunno - gdb doesn't work correctly
217	* without this...
218	*
219	* The caller must hold rcu lock or the tasklist lock.
220	*/
221	struct pid session_of_pgrp(struct pid pgrp)
222	{
223	struct task_struct *p;
224	struct pid *sid = NULL;
225
226	p = pid_task(pgrp, PIDTYPE_PGID);
227	if (p == NULL)
228	p = pid_task(pgrp, PIDTYPE_PID);
229	if (p != NULL)
230	sid = task_session(p);
231
232	return sid;
233	}
234
235	/*	214	/*
236	* Determine if a process group is "orphaned", according to the POSIX	215	* Determine if a process group is "orphaned", according to the POSIX
237	* definition in 2.2.2.52. Orphaned process groups are not to be affected	216	* definition in 2.2.2.52. Orphaned process groups are not to be affected