lael-labs/linux

Documentation/devicetree/bindings/serial/rs485.txt+31−0

@@ -0,0 +1,31 @@
	1	* RS485 serial communications
	2
	3	The RTS signal is capable of automatically controlling line direction for
	4	the built-in half-duplex mode.
	5	The properties described hereafter shall be given to a half-duplex capable
	6	UART node.
	7
	8	Required properties:
	9	- rs485-rts-delay: prop-encoded-array <a b> where:
	10	* a is the delay beteween rts signal and beginning of data sent in milliseconds.
	11	it corresponds to the delay before sending data.
	12	* b is the delay between end of data sent and rts signal in milliseconds
	13	it corresponds to the delay after sending data and actual release of the line.
	14
	15	Optional properties:
	16	- linux,rs485-enabled-at-boot-time: empty property telling to enable the rs485
	17	feature at boot time. It can be disabled later with proper ioctl.
	18	- rs485-rx-during-tx: empty property that enables the receiving of data even
	19	whilst sending data.
	20
	21	RS485 example for Atmel USART:
	22	usart0: serial@fff8c000 {
	23	compatible = "atmel,at91sam9260-usart";
	24	reg = <0xfff8c000 0x4000>;
	25	interrupts = <7>;
	26	atmel,use-dma-rx;
	27	atmel,use-dma-tx;
	28	linux,rs485-enabled-at-boot-time;
	29	rs485-rts-delay = <0 200>; // in milliseconds
	30	};
	31

Documentation/devicetree/bindings/tty/serial/atmel-usart.txt+27−0

@@ -0,0 +1,27 @@
	1	* Atmel Universal Synchronous Asynchronous Receiver/Transmitter (USART)
	2
	3	Required properties:
	4	- compatible: Should be "atmel,<chip>-usart"
	5	The compatible <chip> indicated will be the first SoC to support an
	6	additional mode or an USART new feature.
	7	- reg: Should contain registers location and length
	8	- interrupts: Should contain interrupt
	9
	10	Optional properties:
	11	- atmel,use-dma-rx: use of PDC or DMA for receiving data
	12	- atmel,use-dma-tx: use of PDC or DMA for transmitting data
	13
	14	<chip> compatible description:
	15	- at91rm9200: legacy USART support
	16	- at91sam9260: generic USART implementation for SAM9 SoCs
	17
	18	Example:
	19
	20	usart0: serial@fff8c000 {
	21	compatible = "atmel,at91sam9260-usart";
	22	reg = <0xfff8c000 0x4000>;
	23	interrupts = <7>;
	24	atmel,use-dma-rx;
	25	atmel,use-dma-tx;
	26	};
	27

Documentation/devicetree/bindings/tty/serial/snps-dw-apb-uart.txt+25−0

@@ -0,0 +1,25 @@
	1	* Synopsys DesignWare ABP UART
	2
	3	Required properties:
	4	- compatible : "snps,dw-apb-uart"
	5	- reg : offset and length of the register set for the device.
	6	- interrupts : should contain uart interrupt.
	7	- clock-frequency : the input clock frequency for the UART.
	8
	9	Optional properties:
	10	- reg-shift : quantity to shift the register offsets by. If this property is
	11	not present then the register offsets are not shifted.
	12	- reg-io-width : the size (in bytes) of the IO accesses that should be
	13	performed on the device. If this property is not present then single byte
	14	accesses are used.
	15
	16	Example:
	17
	18	uart@80230000 {
	19	compatible = "snps,dw-apb-uart";
	20	reg = <0x80230000 0x100>;
	21	clock-frequency = <3686400>;
	22	interrupts = <10>;
	23	reg-shift = <2>;
	24	reg-io-width = <4>;
	25	};

Documentation/serial/serial-rs485.txt+8−0

    RS485 communications. This data structure is used to set and configure RS485
    parameters in the platform data and in ioctls.
+   The device tree can also provide RS485 boot time parameters (see [2]
+   for bindings). The driver is in charge of filling this data structure from
+   the values given by the device tree.
    Any driver for devices capable of working both as RS232 and RS485 should
    provide at least the following ioctls:
 	rs485conf.flags |= SER_RS485_RTS_AFTER_SEND;
 	rs485conf.delay_rts_after_send = ...;
+	/* Set this flag if you want to receive data even whilst sending data */
+	rs485conf.flags |= SER_RS485_RX_DURING_TX;
 	if (ioctl (fd, TIOCSRS485, &rs485conf) < 0) {
 		/* Error handling. See errno. */
 	}
 5. REFERENCES
  [1]	include/linux/serial.h
+ [2]	Documentation/devicetree/bindings/serial/rs485.txt

arch/arm/Kconfig+0−1

@@ -727,7 +727,6 @@ config ARCH_S3C64XX · 726 unmodified lines
727	select ARCH_REQUIRE_GPIOLIB	727	select ARCH_REQUIRE_GPIOLIB
728	select SAMSUNG_CLKSRC	728	select SAMSUNG_CLKSRC
729	select SAMSUNG_IRQ_VIC_TIMER	729	select SAMSUNG_IRQ_VIC_TIMER
730	select SAMSUNG_IRQ_UART
731	select S3C_GPIO_TRACK	730	select S3C_GPIO_TRACK
732	select S3C_GPIO_PULL_UPDOWN	731	select S3C_GPIO_PULL_UPDOWN
733	select S3C_GPIO_CFG_S3C24XX	732	select S3C_GPIO_CFG_S3C24XX

arch/arm/mach-s3c64xx/dev-uart.c+8−52

@@ -37,21 +37,10 @@ static struct resource s3c64xx_uart0_resource[] = { · 36 unmodified lines
37	.flags = IORESOURCE_MEM,	37	.flags = IORESOURCE_MEM,
38	},	38	},
39	[1] = {	39	[1] = {
40	.start = IRQ_S3CUART_RX0,	40	.start = IRQ_UART0,
41	.end = IRQ_S3CUART_RX0,	41	.end = IRQ_UART0,
42	.flags = IORESOURCE_IRQ,	42	.flags = IORESOURCE_IRQ,
43	},	43	},
44	[2] = {
45	.start = IRQ_S3CUART_TX0,
46	.end = IRQ_S3CUART_TX0,
47	.flags = IORESOURCE_IRQ,
48
49	},
50	[3] = {
51	.start = IRQ_S3CUART_ERR0,
52	.end = IRQ_S3CUART_ERR0,
53	.flags = IORESOURCE_IRQ,
54	}
55	};	44	};
56		45
57	static struct resource s3c64xx_uart1_resource[] = {	46	static struct resource s3c64xx_uart1_resource[] = {
@@ -61,19 +50,8 @@ static struct resource s3c64xx_uart1_resource[] = { · 3 unmodified lines
61	.flags = IORESOURCE_MEM,	50	.flags = IORESOURCE_MEM,
62	},	51	},
63	[1] = {	52	[1] = {
64	.start = IRQ_S3CUART_RX1,	53	.start = IRQ_UART1,
65	.end = IRQ_S3CUART_RX1,	54	.end = IRQ_UART1,
66	.flags = IORESOURCE_IRQ,
67	},
68	[2] = {
69	.start = IRQ_S3CUART_TX1,
70	.end = IRQ_S3CUART_TX1,
71	.flags = IORESOURCE_IRQ,
72
73	},
74	[3] = {
75	.start = IRQ_S3CUART_ERR1,
76	.end = IRQ_S3CUART_ERR1,
77	.flags = IORESOURCE_IRQ,	55	.flags = IORESOURCE_IRQ,
78	},	56	},
79	};	57	};
@@ -85,19 +63,8 @@ static struct resource s3c6xx_uart2_resource[] = { · 5 unmodified lines
85	.flags = IORESOURCE_MEM,	63	.flags = IORESOURCE_MEM,
86	},	64	},
87	[1] = {	65	[1] = {
88	.start = IRQ_S3CUART_RX2,	66	.start = IRQ_UART2,
89	.end = IRQ_S3CUART_RX2,	67	.end = IRQ_UART2,
90	.flags = IORESOURCE_IRQ,
91	},
92	[2] = {
93	.start = IRQ_S3CUART_TX2,
94	.end = IRQ_S3CUART_TX2,
95	.flags = IORESOURCE_IRQ,
96
97	},
98	[3] = {
99	.start = IRQ_S3CUART_ERR2,
100	.end = IRQ_S3CUART_ERR2,
101	.flags = IORESOURCE_IRQ,	68	.flags = IORESOURCE_IRQ,
102	},	69	},
103	};	70	};
@@ -109,19 +76,8 @@ static struct resource s3c64xx_uart3_resource[] = { · 5 unmodified lines
109	.flags = IORESOURCE_MEM,	76	.flags = IORESOURCE_MEM,
110	},	77	},
111	[1] = {	78	[1] = {
112	.start = IRQ_S3CUART_RX3,	79	.start = IRQ_UART3,
113	.end = IRQ_S3CUART_RX3,	80	.end = IRQ_UART3,
114	.flags = IORESOURCE_IRQ,
115	},
116	[2] = {
117	.start = IRQ_S3CUART_TX3,
118	.end = IRQ_S3CUART_TX3,
119	.flags = IORESOURCE_IRQ,
120
121	},
122	[3] = {
123	.start = IRQ_S3CUART_ERR3,
124	.end = IRQ_S3CUART_ERR3,
125	.flags = IORESOURCE_IRQ,	81	.flags = IORESOURCE_IRQ,
126	},	82	},
127	};	83	};

arch/arm/mach-s3c64xx/include/mach/irqs.h+0−30

@@ -27,36 +27,6 @@ · 26 unmodified lines
27	#define IRQ_VIC0_BASE S3C_IRQ(0)	27	#define IRQ_VIC0_BASE S3C_IRQ(0)
28	#define IRQ_VIC1_BASE S3C_IRQ(32)	28	#define IRQ_VIC1_BASE S3C_IRQ(32)
29		29
30	/* UART interrupts, each UART has 4 intterupts per channel so
31	* use the space between the ISA and S3C main interrupts. Note, these
32	* are not in the same order as the S3C24XX series! */
33
34	#define IRQ_S3CUART_BASE0 (16)
35	#define IRQ_S3CUART_BASE1 (20)
36	#define IRQ_S3CUART_BASE2 (24)
37	#define IRQ_S3CUART_BASE3 (28)
38
39	#define UART_IRQ_RXD (0)
40	#define UART_IRQ_ERR (1)
41	#define UART_IRQ_TXD (2)
42	#define UART_IRQ_MODEM (3)
43
44	#define IRQ_S3CUART_RX0 (IRQ_S3CUART_BASE0 + UART_IRQ_RXD)
45	#define IRQ_S3CUART_TX0 (IRQ_S3CUART_BASE0 + UART_IRQ_TXD)
46	#define IRQ_S3CUART_ERR0 (IRQ_S3CUART_BASE0 + UART_IRQ_ERR)
47
48	#define IRQ_S3CUART_RX1 (IRQ_S3CUART_BASE1 + UART_IRQ_RXD)
49	#define IRQ_S3CUART_TX1 (IRQ_S3CUART_BASE1 + UART_IRQ_TXD)
50	#define IRQ_S3CUART_ERR1 (IRQ_S3CUART_BASE1 + UART_IRQ_ERR)
51
52	#define IRQ_S3CUART_RX2 (IRQ_S3CUART_BASE2 + UART_IRQ_RXD)
53	#define IRQ_S3CUART_TX2 (IRQ_S3CUART_BASE2 + UART_IRQ_TXD)
54	#define IRQ_S3CUART_ERR2 (IRQ_S3CUART_BASE2 + UART_IRQ_ERR)
55
56	#define IRQ_S3CUART_RX3 (IRQ_S3CUART_BASE3 + UART_IRQ_RXD)
57	#define IRQ_S3CUART_TX3 (IRQ_S3CUART_BASE3 + UART_IRQ_TXD)
58	#define IRQ_S3CUART_ERR3 (IRQ_S3CUART_BASE3 + UART_IRQ_ERR)
59
60	/* VIC based IRQs */	30	/* VIC based IRQs */
61		31
62	#define S3C64XX_IRQ_VIC0(x) (IRQ_VIC0_BASE + (x))	32	#define S3C64XX_IRQ_VIC0(x) (IRQ_VIC0_BASE + (x))

arch/arm/mach-s3c64xx/irq.c+0−25

@@ -25,29 +25,6 @@ · 24 unmodified lines
25	#include <plat/irq-uart.h>	25	#include <plat/irq-uart.h>
26	#include <plat/cpu.h>	26	#include <plat/cpu.h>
27		27
28	static struct s3c_uart_irq uart_irqs[] = {
29	[0] = {
30	.regs = S3C_VA_UART0,
31	.base_irq = IRQ_S3CUART_BASE0,
32	.parent_irq = IRQ_UART0,
33	},
34	[1] = {
35	.regs = S3C_VA_UART1,
36	.base_irq = IRQ_S3CUART_BASE1,
37	.parent_irq = IRQ_UART1,
38	},
39	[2] = {
40	.regs = S3C_VA_UART2,
41	.base_irq = IRQ_S3CUART_BASE2,
42	.parent_irq = IRQ_UART2,
43	},
44	[3] = {
45	.regs = S3C_VA_UART3,
46	.base_irq = IRQ_S3CUART_BASE3,
47	.parent_irq = IRQ_UART3,
48	},
49	};
50
51	/* setup the sources the vic should advertise resume for, even though it	28	/* setup the sources the vic should advertise resume for, even though it
52	* is not doing the wake (set_irq_wake needs to be valid) */	29	* is not doing the wake (set_irq_wake needs to be valid) */
53	#define IRQ_VIC0_RESUME (1 << (IRQ_RTC_TIC - IRQ_VIC0_BASE))	30	#define IRQ_VIC0_RESUME (1 << (IRQ_RTC_TIC - IRQ_VIC0_BASE))
@@ -67,6 +44,4 @@ void __init s3c64xx_init_irq(u32 vic0_valid, u32 vic1_valid) · 13 unmodified lines
67		44
68	/* add the timer sub-irqs */	45	/* add the timer sub-irqs */
69	s3c_init_vic_timer_irq(5, IRQ_TIMER0);	46	s3c_init_vic_timer_irq(5, IRQ_TIMER0);
70
71	s3c_init_uart_irqs(uart_irqs, ARRAY_SIZE(uart_irqs));
72	}	47	}

arch/arm/plat-s5p/Kconfig+0−1

@@ -22,7 +22,6 @@ config PLAT_S5P · 21 unmodified lines
22	select PLAT_SAMSUNG	22	select PLAT_SAMSUNG
23	select SAMSUNG_CLKSRC	23	select SAMSUNG_CLKSRC
24	select SAMSUNG_IRQ_VIC_TIMER	24	select SAMSUNG_IRQ_VIC_TIMER
25	select SAMSUNG_IRQ_UART
26	help	25	help
27	Base platform code for Samsung's S5P series SoC.	26	Base platform code for Samsung's S5P series SoC.
28		27

arch/arm/plat-s5p/dev-uart.c+12−72

@@ -32,20 +32,10 @@ static struct resource s5p_uart0_resource[] = { · 31 unmodified lines
32	.flags = IORESOURCE_MEM,	32	.flags = IORESOURCE_MEM,
33	},	33	},
34	[1] = {	34	[1] = {
35	.start = IRQ_S5P_UART_RX0,	35	.start = IRQ_UART0,
36	.end = IRQ_S5P_UART_RX0,	36	.end = IRQ_UART0,
37	.flags = IORESOURCE_IRQ,	37	.flags = IORESOURCE_IRQ,
38	},	38	},
39	[2] = {
40	.start = IRQ_S5P_UART_TX0,
41	.end = IRQ_S5P_UART_TX0,
42	.flags = IORESOURCE_IRQ,
43	},
44	[3] = {
45	.start = IRQ_S5P_UART_ERR0,
46	.end = IRQ_S5P_UART_ERR0,
47	.flags = IORESOURCE_IRQ,
48	}
49	};	39	};
50		40
51	static struct resource s5p_uart1_resource[] = {	41	static struct resource s5p_uart1_resource[] = {
@@ -55,18 +45,8 @@ static struct resource s5p_uart1_resource[] = { · 3 unmodified lines
55	.flags = IORESOURCE_MEM,	45	.flags = IORESOURCE_MEM,
56	},	46	},
57	[1] = {	47	[1] = {
58	.start = IRQ_S5P_UART_RX1,	48	.start = IRQ_UART1,
59	.end = IRQ_S5P_UART_RX1,	49	.end = IRQ_UART1,
60	.flags = IORESOURCE_IRQ,
61	},
62	[2] = {
63	.start = IRQ_S5P_UART_TX1,
64	.end = IRQ_S5P_UART_TX1,
65	.flags = IORESOURCE_IRQ,
66	},
67	[3] = {
68	.start = IRQ_S5P_UART_ERR1,
69	.end = IRQ_S5P_UART_ERR1,
70	.flags = IORESOURCE_IRQ,	50	.flags = IORESOURCE_IRQ,
71	},	51	},
72	};	52	};
@@ -78,18 +58,8 @@ static struct resource s5p_uart2_resource[] = { · 5 unmodified lines
78	.flags = IORESOURCE_MEM,	58	.flags = IORESOURCE_MEM,
79	},	59	},
80	[1] = {	60	[1] = {
81	.start = IRQ_S5P_UART_RX2,	61	.start = IRQ_UART2,
82	.end = IRQ_S5P_UART_RX2,	62	.end = IRQ_UART2,
83	.flags = IORESOURCE_IRQ,
84	},
85	[2] = {
86	.start = IRQ_S5P_UART_TX2,
87	.end = IRQ_S5P_UART_TX2,
88	.flags = IORESOURCE_IRQ,
89	},
90	[3] = {
91	.start = IRQ_S5P_UART_ERR2,
92	.end = IRQ_S5P_UART_ERR2,
93	.flags = IORESOURCE_IRQ,	63	.flags = IORESOURCE_IRQ,
94	},	64	},
95	};	65	};
@@ -102,18 +72,8 @@ static struct resource s5p_uart3_resource[] = { · 6 unmodified lines
102	.flags = IORESOURCE_MEM,	72	.flags = IORESOURCE_MEM,
103	},	73	},
104	[1] = {	74	[1] = {
105	.start = IRQ_S5P_UART_RX3,	75	.start = IRQ_UART3,
106	.end = IRQ_S5P_UART_RX3,	76	.end = IRQ_UART3,
107	.flags = IORESOURCE_IRQ,
108	},
109	[2] = {
110	.start = IRQ_S5P_UART_TX3,
111	.end = IRQ_S5P_UART_TX3,
112	.flags = IORESOURCE_IRQ,
113	},
114	[3] = {
115	.start = IRQ_S5P_UART_ERR3,
116	.end = IRQ_S5P_UART_ERR3,
117	.flags = IORESOURCE_IRQ,	77	.flags = IORESOURCE_IRQ,
118	},	78	},
119	#endif	79	#endif
@@ -127,18 +87,8 @@ static struct resource s5p_uart4_resource[] = { · 7 unmodified lines
127	.flags = IORESOURCE_MEM,	87	.flags = IORESOURCE_MEM,
128	},	88	},
129	[1] = {	89	[1] = {
130	.start = IRQ_S5P_UART_RX4,	90	.start = IRQ_UART4,
131	.end = IRQ_S5P_UART_RX4,	91	.end = IRQ_UART4,
132	.flags = IORESOURCE_IRQ,
133	},
134	[2] = {
135	.start = IRQ_S5P_UART_TX4,
136	.end = IRQ_S5P_UART_TX4,
137	.flags = IORESOURCE_IRQ,
138	},
139	[3] = {
140	.start = IRQ_S5P_UART_ERR4,
141	.end = IRQ_S5P_UART_ERR4,
142	.flags = IORESOURCE_IRQ,	92	.flags = IORESOURCE_IRQ,
143	},	93	},
144	#endif	94	#endif
@@ -152,18 +102,8 @@ static struct resource s5p_uart5_resource[] = { · 7 unmodified lines
152	.flags = IORESOURCE_MEM,	102	.flags = IORESOURCE_MEM,
153	},	103	},
154	[1] = {	104	[1] = {
155	.start = IRQ_S5P_UART_RX5,	105	.start = IRQ_UART5,
156	.end = IRQ_S5P_UART_RX5,	106	.end = IRQ_UART5,
157	.flags = IORESOURCE_IRQ,
158	},
159	[2] = {
160	.start = IRQ_S5P_UART_TX5,
161	.end = IRQ_S5P_UART_TX5,
162	.flags = IORESOURCE_IRQ,
163	},
164	[3] = {
165	.start = IRQ_S5P_UART_ERR5,
166	.end = IRQ_S5P_UART_ERR5,
167	.flags = IORESOURCE_IRQ,	107	.flags = IORESOURCE_IRQ,
168	},	108	},
169	#endif	109	#endif

arch/arm/plat-s5p/include/plat/irqs.h+0−35

@@ -37,41 +37,6 @@ · 36 unmodified lines
37	#define IRQ_VIC1_BASE S5P_VIC1_BASE	37	#define IRQ_VIC1_BASE S5P_VIC1_BASE
38	#define IRQ_VIC2_BASE S5P_VIC2_BASE	38	#define IRQ_VIC2_BASE S5P_VIC2_BASE
39		39
40	/* UART interrupts, each UART has 4 intterupts per channel so
41	* use the space between the ISA and S3C main interrupts. Note, these
42	* are not in the same order as the S3C24XX series! */
43
44	#define IRQ_S5P_UART_BASE0 (16)
45	#define IRQ_S5P_UART_BASE1 (20)
46	#define IRQ_S5P_UART_BASE2 (24)
47	#define IRQ_S5P_UART_BASE3 (28)
48
49	#define UART_IRQ_RXD (0)
50	#define UART_IRQ_ERR (1)
51	#define UART_IRQ_TXD (2)
52
53	#define IRQ_S5P_UART_RX0 (IRQ_S5P_UART_BASE0 + UART_IRQ_RXD)
54	#define IRQ_S5P_UART_TX0 (IRQ_S5P_UART_BASE0 + UART_IRQ_TXD)
55	#define IRQ_S5P_UART_ERR0 (IRQ_S5P_UART_BASE0 + UART_IRQ_ERR)
56
57	#define IRQ_S5P_UART_RX1 (IRQ_S5P_UART_BASE1 + UART_IRQ_RXD)
58	#define IRQ_S5P_UART_TX1 (IRQ_S5P_UART_BASE1 + UART_IRQ_TXD)
59	#define IRQ_S5P_UART_ERR1 (IRQ_S5P_UART_BASE1 + UART_IRQ_ERR)
60
61	#define IRQ_S5P_UART_RX2 (IRQ_S5P_UART_BASE2 + UART_IRQ_RXD)
62	#define IRQ_S5P_UART_TX2 (IRQ_S5P_UART_BASE2 + UART_IRQ_TXD)
63	#define IRQ_S5P_UART_ERR2 (IRQ_S5P_UART_BASE2 + UART_IRQ_ERR)
64
65	#define IRQ_S5P_UART_RX3 (IRQ_S5P_UART_BASE3 + UART_IRQ_RXD)
66	#define IRQ_S5P_UART_TX3 (IRQ_S5P_UART_BASE3 + UART_IRQ_TXD)
67	#define IRQ_S5P_UART_ERR3 (IRQ_S5P_UART_BASE3 + UART_IRQ_ERR)
68
69	/* S3C compatibilty defines */
70	#define IRQ_S3CUART_RX0 IRQ_S5P_UART_RX0
71	#define IRQ_S3CUART_RX1 IRQ_S5P_UART_RX1
72	#define IRQ_S3CUART_RX2 IRQ_S5P_UART_RX2
73	#define IRQ_S3CUART_RX3 IRQ_S5P_UART_RX3
74
75	/* VIC based IRQs */	40	/* VIC based IRQs */
76		41
77	#define S5P_IRQ_VIC0(x) (S5P_VIC0_BASE + (x))	42	#define S5P_IRQ_VIC0(x) (S5P_VIC0_BASE + (x))

arch/arm/plat-s5p/irq.c+0−34

@@ -17,42 +17,10 @@ · 16 unmodified lines
17		17
18	#include <asm/hardware/vic.h>	18	#include <asm/hardware/vic.h>
19		19
20	#include <linux/serial_core.h>
21	#include <mach/map.h>	20	#include <mach/map.h>
22	#include <plat/regs-timer.h>	21	#include <plat/regs-timer.h>
23	#include <plat/regs-serial.h>
24	#include <plat/cpu.h>	22	#include <plat/cpu.h>
25	#include <plat/irq-vic-timer.h>	23	#include <plat/irq-vic-timer.h>
26	#include <plat/irq-uart.h>
27
28	/*
29	* Note, we make use of the fact that the parent IRQs, IRQ_UART[0..3]
30	* are consecutive when looking up the interrupt in the demux routines.
31	*/
32	static struct s3c_uart_irq uart_irqs[] = {
33	[0] = {
34	.regs = S5P_VA_UART0,
35	.base_irq = IRQ_S5P_UART_BASE0,
36	.parent_irq = IRQ_UART0,
37	},
38	[1] = {
39	.regs = S5P_VA_UART1,
40	.base_irq = IRQ_S5P_UART_BASE1,
41	.parent_irq = IRQ_UART1,
42	},
43	[2] = {
44	.regs = S5P_VA_UART2,
45	.base_irq = IRQ_S5P_UART_BASE2,
46	.parent_irq = IRQ_UART2,
47	},
48	#if CONFIG_SERIAL_SAMSUNG_UARTS > 3
49	[3] = {
50	.regs = S5P_VA_UART3,
51	.base_irq = IRQ_S5P_UART_BASE3,
52	.parent_irq = IRQ_UART3,
53	},
54	#endif
55	};
56		24
57	void __init s5p_init_irq(u32 *vic, u32 num_vic)	25	void __init s5p_init_irq(u32 *vic, u32 num_vic)
58	{	26	{
@@ -65,6 +33,4 @@ void __init s5p_init_irq(u32 *vic, u32 num_vic) · 6 unmodified lines
65	#endif	33	#endif
66		34
67	s3c_init_vic_timer_irq(5, IRQ_TIMER0);	35	s3c_init_vic_timer_irq(5, IRQ_TIMER0);
68
69	s3c_init_uart_irqs(uart_irqs, ARRAY_SIZE(uart_irqs));
70	}	36	}

arch/arm/plat-samsung/Kconfig+0−5

        help
          Internal configuration to build the VIC timer interrupt code.
-config SAMSUNG_IRQ_UART
-       bool
-       help
-         Internal configuration to build the IRQ UART demux code.
 # options for gpio configuration support
 config SAMSUNG_GPIOLIB_4BIT

arch/arm/plat-samsung/Makefile+0−1

@@ -21,7 +21,6 @@ obj-y += dev-asocdma.o · 20 unmodified lines
21		21
22	obj-$(CONFIG_SAMSUNG_CLKSRC) += clock-clksrc.o	22	obj-$(CONFIG_SAMSUNG_CLKSRC) += clock-clksrc.o
23		23
24	obj-$(CONFIG_SAMSUNG_IRQ_UART) += irq-uart.o
25	obj-$(CONFIG_SAMSUNG_IRQ_VIC_TIMER) += irq-vic-timer.o	24	obj-$(CONFIG_SAMSUNG_IRQ_VIC_TIMER) += irq-vic-timer.o
26		25
27	# ADC	26	# ADC

arch/arm/plat-samsung/include/plat/regs-serial.h+5−0

 #define S3C64XX_UINTSP		0x34
 #define S3C64XX_UINTM		0x38
+#define S3C64XX_UINTM_RXD	(0)
+#define S3C64XX_UINTM_TXD	(2)
+#define S3C64XX_UINTM_RXD_MSK	(1 << S3C64XX_UINTM_RXD)
+#define S3C64XX_UINTM_TXD_MSK	(1 << S3C64XX_UINTM_TXD)
 /* Following are specific to S5PV210 */
 #define S5PV210_UCON_CLKMASK	(1<<10)
 #define S5PV210_UCON_PCLK	(0<<10)

arch/arm/plat-samsung/irq-uart.c+0−96

@@ -1,96 +0,0 @@
1	/* arch/arm/plat-samsung/irq-uart.c
2	* originally part of arch/arm/plat-s3c64xx/irq.c
3	*
4	* Copyright 2008 Openmoko, Inc.
5	* Copyright 2008 Simtec Electronics
6	* Ben Dooks <ben@simtec.co.uk>
7	* http://armlinux.simtec.co.uk/
8	*
9	* Samsung- UART Interrupt handling
10	*
11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License version 2 as
13	* published by the Free Software Foundation.
14	*/
15
16	#include <linux/kernel.h>
17	#include <linux/interrupt.h>
18	#include <linux/serial_core.h>
19	#include <linux/irq.h>
20	#include <linux/io.h>
21
22	#include <asm/mach/irq.h>
23
24	#include <mach/map.h>
25	#include <plat/irq-uart.h>
26	#include <plat/regs-serial.h>
27	#include <plat/cpu.h>
28
29	/* Note, we make use of the fact that the parent IRQs, IRQ_UART[0..3]
30	* are consecutive when looking up the interrupt in the demux routines.
31	*/
32	static void s3c_irq_demux_uart(unsigned int irq, struct irq_desc *desc)
33	{
34	struct s3c_uart_irq *uirq = desc->irq_data.handler_data;
35	struct irq_chip *chip = irq_get_chip(irq);
36	u32 pend = __raw_readl(uirq->regs + S3C64XX_UINTP);
37	int base = uirq->base_irq;
38
39	chained_irq_enter(chip, desc);
40
41	if (pend & (1 << 0))
42	generic_handle_irq(base);
43	if (pend & (1 << 1))
44	generic_handle_irq(base + 1);
45	if (pend & (1 << 2))
46	generic_handle_irq(base + 2);
47	if (pend & (1 << 3))
48	generic_handle_irq(base + 3);
49
50	chained_irq_exit(chip, desc);
51	}
52
53	static void __init s3c_init_uart_irq(struct s3c_uart_irq *uirq)
54	{
55	void __iomem *reg_base = uirq->regs;
56	struct irq_chip_generic *gc;
57	struct irq_chip_type *ct;
58
59	/* mask all interrupts at the start. */
60	__raw_writel(0xf, reg_base + S3C64XX_UINTM);
61
62	gc = irq_alloc_generic_chip("s3c-uart", 1, uirq->base_irq, reg_base,
63	handle_level_irq);
64
65	if (!gc) {
66	pr_err("%s: irq_alloc_generic_chip for IRQ %u failed\n",
67	__func__, uirq->base_irq);
68	return;
69	}
70
71	ct = gc->chip_types;
72	ct->chip.irq_ack = irq_gc_ack_set_bit;
73	ct->chip.irq_mask = irq_gc_mask_set_bit;
74	ct->chip.irq_unmask = irq_gc_mask_clr_bit;
75	ct->regs.ack = S3C64XX_UINTP;
76	ct->regs.mask = S3C64XX_UINTM;
77	irq_setup_generic_chip(gc, IRQ_MSK(4), IRQ_GC_INIT_MASK_CACHE,
78	IRQ_NOREQUEST \| IRQ_NOPROBE, 0);
79
80	irq_set_handler_data(uirq->parent_irq, uirq);
81	irq_set_chained_handler(uirq->parent_irq, s3c_irq_demux_uart);
82	}
83
84	/**
85	* s3c_init_uart_irqs() - initialise UART IRQs and the necessary demuxing
86	* @irq: The interrupt data for registering
87	* @nr_irqs: The number of interrupt descriptions in @irq.
88	*
89	* Register the UART interrupts specified by @irq including the demuxing
90	* routines. This supports the S3C6400 and newer style of devices.
91	*/
92	void __init s3c_init_uart_irqs(struct s3c_uart_irq *irq, unsigned int nr_irqs)
93	{
94	for (; nr_irqs > 0; nr_irqs--, irq++)
95	s3c_init_uart_irq(irq);
96	}

arch/h8300/Kconfig+1−1

@@ -195,7 +195,7 @@ config UNIX98_PTYS · 194 unmodified lines
195		195
196	source "drivers/char/pcmcia/Kconfig"	196	source "drivers/char/pcmcia/Kconfig"
197		197
198	source "drivers/serial/Kconfig"	198	source "drivers/tty/serial/Kconfig"
199		199
200	source "drivers/i2c/Kconfig"	200	source "drivers/i2c/Kconfig"
201		201

arch/mips/pmc-sierra/msp71xx/msp_serial.c+67−6

@@ -27,6 +27,7 @@ · 26 unmodified lines
27	#include <linux/serial.h>	27	#include <linux/serial.h>
28	#include <linux/serial_core.h>	28	#include <linux/serial_core.h>
29	#include <linux/serial_reg.h>	29	#include <linux/serial_reg.h>
		30	#include <linux/slab.h>
30		31
31	#include <asm/bootinfo.h>	32	#include <asm/bootinfo.h>
32	#include <asm/io.h>	33	#include <asm/io.h>
@@ -38,6 +39,55 @@ · 5 unmodified lines
38	#include <msp_int.h>	39	#include <msp_int.h>
39	#include <msp_regs.h>	40	#include <msp_regs.h>
40		41
		42	struct msp_uart_data {
		43	int last_lcr;
		44	};
		45
		46	static void msp_serial_out(struct uart_port *p, int offset, int value)
		47	{
		48	struct msp_uart_data *d = p->private_data;
		49
		50	if (offset == UART_LCR)
		51	d->last_lcr = value;
		52
		53	offset <<= p->regshift;
		54	writeb(value, p->membase + offset);
		55	}
		56
		57	static unsigned int msp_serial_in(struct uart_port *p, int offset)
		58	{
		59	offset <<= p->regshift;
		60
		61	return readb(p->membase + offset);
		62	}
		63
		64	static int msp_serial_handle_irq(struct uart_port *p)
		65	{
		66	struct msp_uart_data *d = p->private_data;
		67	unsigned int iir = readb(p->membase + (UART_IIR << p->regshift));
		68
		69	if (serial8250_handle_irq(p, iir)) {
		70	return 1;
		71	} else if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
		72	/*
		73	* The DesignWare APB UART has an Busy Detect (0x07) interrupt
		74	* meaning an LCR write attempt occurred while the UART was
		75	* busy. The interrupt must be cleared by reading the UART
		76	* status register (USR) and the LCR re-written.
		77	*
		78	* Note: MSP reserves 0x20 bytes of address space for the UART
		79	* and the USR is mapped in a separate block at an offset of
		80	* 0xc0 from the start of the UART.
		81	*/
		82	(void)readb(p->membase + 0xc0);
		83	writeb(d->last_lcr, p->membase + (UART_LCR << p->regshift));
		84
		85	return 1;
		86	}
		87
		88	return 0;
		89	}
		90
41	void __init msp_serial_setup(void)	91	void __init msp_serial_setup(void)
42	{	92	{
43	char *s;	93	char *s;
@@ -59,13 +109,22 @@ void __init msp_serial_setup(void) · 15 unmodified lines
59	up.irq = MSP_INT_UART0;	109	up.irq = MSP_INT_UART0;
60	up.uartclk = uartclk;	110	up.uartclk = uartclk;
61	up.regshift = 2;	111	up.regshift = 2;
62	up.iotype = UPIO_DWAPB; /* UPIO_MEM like */	112	up.iotype = UPIO_MEM;
63	up.flags = ASYNC_BOOT_AUTOCONF \| ASYNC_SKIP_TEST;	113	up.flags = ASYNC_BOOT_AUTOCONF \| ASYNC_SKIP_TEST;
64	up.type = PORT_16550A;	114	up.type = PORT_16550A;
65	up.line = 0;	115	up.line = 0;
66	up.private_data = (void*)UART0_STATUS_REG;	116	up.serial_out = msp_serial_out;
67	if (early_serial_setup(&up))	117	up.serial_in = msp_serial_in;
68	printk(KERN_ERR "Early serial init of port 0 failed\n");	118	up.handle_irq = msp_serial_handle_irq;
		119	up.private_data = kzalloc(sizeof(struct msp_uart_data), GFP_KERNEL);
		120	if (!up.private_data) {
		121	pr_err("failed to allocate uart private data\n");
		122	return;
		123	}
		124	if (early_serial_setup(&up)) {
		125	kfree(up.private_data);
		126	pr_err("Early serial init of port 0 failed\n");
		127	}
69		128
70	/* Initialize the second serial port, if one exists */	129	/* Initialize the second serial port, if one exists */
71	switch (mips_machtype) {	130	switch (mips_machtype) {
@@ -88,6 +147,8 @@ void __init msp_serial_setup(void) · 16 unmodified lines
88	up.irq = MSP_INT_UART1;	147	up.irq = MSP_INT_UART1;
89	up.line = 1;	148	up.line = 1;
90	up.private_data = (void*)UART1_STATUS_REG;	149	up.private_data = (void*)UART1_STATUS_REG;
91	if (early_serial_setup(&up))	150	if (early_serial_setup(&up)) {
92	printk(KERN_ERR "Early serial init of port 1 failed\n");	151	kfree(up.private_data);
		152	pr_err("Early serial init of port 1 failed\n");
		153	}
93	}	154	}

arch/powerpc/include/asm/udbg.h+1−0

@@ -54,6 +54,7 @@ extern void __init udbg_init_40x_realmode(void); · 53 unmodified lines
54	extern void __init udbg_init_cpm(void);	54	extern void __init udbg_init_cpm(void);
55	extern void __init udbg_init_usbgecko(void);	55	extern void __init udbg_init_usbgecko(void);
56	extern void __init udbg_init_wsp(void);	56	extern void __init udbg_init_wsp(void);
		57	extern void __init udbg_init_ehv_bc(void);
57		58
58	#endif /* __KERNEL__ */	59	#endif /* __KERNEL__ */
59	#endif /* _ASM_POWERPC_UDBG_H */	60	#endif /* _ASM_POWERPC_UDBG_H */

arch/powerpc/kernel/udbg.c+2−0

@@ -67,6 +67,8 @@ void __init udbg_early_init(void) · 66 unmodified lines
67	udbg_init_usbgecko();	67	udbg_init_usbgecko();
68	#elif defined(CONFIG_PPC_EARLY_DEBUG_WSP)	68	#elif defined(CONFIG_PPC_EARLY_DEBUG_WSP)
69	udbg_init_wsp();	69	udbg_init_wsp();
		70	#elif defined(CONFIG_PPC_EARLY_DEBUG_EHV_BC)
		71	udbg_init_ehv_bc();
70	#endif	72	#endif
71		73
72	#ifdef CONFIG_PPC_EARLY_DEBUG	74	#ifdef CONFIG_PPC_EARLY_DEBUG

arch/x86/platform/mrst/mrst.c+3−0

 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/scatterlist.h>
 #include <linux/sfi.h>
 #include <linux/intel_pmic_gpio.h>
 #include <linux/spi/spi.h>
 	struct spi_board_info *spi_info = info;
 	int intr = get_gpio_by_name("max3111_int");
+	spi_info->mode = SPI_MODE_0;
 	if (intr == -1)
 		return NULL;
 	spi_info->irq = intr + MRST_IRQ_OFFSET;

drivers/isdn/i4l/isdn_tty.c+1−1

@@ -1693,7 +1693,7 @@ isdn_tty_close(struct tty_struct tty, struct file filp) · 1692 unmodified lines
1693	* line status register.	1693	* line status register.
1694	*/	1694	*/
1695	if (info->flags & ISDN_ASYNC_INITIALIZED) {	1695	if (info->flags & ISDN_ASYNC_INITIALIZED) {
1696	tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */	1696	tty_wait_until_sent_from_close(tty, 3000); /* 30 seconds timeout */
1697	/*	1697	/*
1698	* Before we drop DTR, make sure the UART transmitter	1698	* Before we drop DTR, make sure the UART transmitter
1699	* has completely drained; this is especially	1699	* has completely drained; this is especially

drivers/parport/parport_pc.c+3−0

 		break;
 	case 0x6:
 		printk(KERN_INFO "parport_pc: ITE8873 found (1S)\n");
+		release_region(inta_addr[i], 32);
 		return 0;
 	case 0x8:
 		printk(KERN_INFO "parport_pc: ITE8874 found (2S)\n");
+		release_region(inta_addr[i], 32);
 		return 0;
 	default:
 		printk(KERN_INFO "parport_pc: unknown ITE887x\n");
 		printk(KERN_INFO "parport_pc: please mail 'lspci -nvv' "
 			"output to Rich.Liu@ite.com.tw\n");
+		release_region(inta_addr[i], 32);
 		return 0;
 	}

drivers/staging/Kconfig+2−0

@@ -24,6 +24,8 @@ menuconfig STAGING · 23 unmodified lines
24		24
25	if STAGING	25	if STAGING
26		26
		27	source "drivers/staging/serial/Kconfig"
		28
27	source "drivers/staging/et131x/Kconfig"	29	source "drivers/staging/et131x/Kconfig"
28		30
29	source "drivers/staging/slicoss/Kconfig"	31	source "drivers/staging/slicoss/Kconfig"

drivers/staging/Makefile+1−0

@@ -3,6 +3,7 @@ · 2 unmodified lines
3	# fix for build system bug...	3	# fix for build system bug...
4	obj-$(CONFIG_STAGING) += staging.o	4	obj-$(CONFIG_STAGING) += staging.o
5		5
		6	obj-y += serial/
6	obj-$(CONFIG_ET131X) += et131x/	7	obj-$(CONFIG_ET131X) += et131x/
7	obj-$(CONFIG_SLICOSS) += slicoss/	8	obj-$(CONFIG_SLICOSS) += slicoss/
8	obj-$(CONFIG_VIDEO_GO7007) += go7007/	9	obj-$(CONFIG_VIDEO_GO7007) += go7007/

drivers/staging/serial/68360serial.crenamed from drivers/tty/serial/68360serial.c+0−0

File renamed without changes.

drivers/staging/serial/Kconfig+16−0

@@ -0,0 +1,16 @@
	1	config SERIAL_68360_SMC
	2	bool "68360 SMC uart support"
	3	depends on M68360
	4	help
	5	This driver supports the SMC serial ports of the Motorola 68360 CPU.
	6
	7	config SERIAL_68360_SCC
	8	bool "68360 SCC uart support"
	9	depends on M68360
	10	help
	11	This driver supports the SCC serial ports of the Motorola 68360 CPU.
	12
	13	config SERIAL_68360
	14	bool
	15	depends on SERIAL_68360_SMC \|\| SERIAL_68360_SCC
	16	default y

drivers/staging/serial/Makefile+1−0

@@ -0,0 +1 @@
		1	obj-$(CONFIG_SERIAL_68360) += 68360serial.o

drivers/staging/serial/TODO+6−0

@@ -0,0 +1,6 @@
	1	These are a few serial drivers that either do not build, or do not work if they
	2	do build, or if they seem to work, are for obsolete hardware, or are full of
	3	unfixable races and no one uses them anymore.
	4
	5	If no one steps up to adopt any of these drivers, they will be removed
	6	in the 3.4 release.

drivers/tty/Kconfig+34−0

@@ -354,3 +354,37 @@ config TRACE_SINK · 353 unmodified lines
354		354
355	If you select this option, you need to select	355	If you select this option, you need to select
356	"Trace data router for MIPI P1149.7 cJTAG standard".	356	"Trace data router for MIPI P1149.7 cJTAG standard".
		357
		358	config PPC_EPAPR_HV_BYTECHAN
		359	tristate "ePAPR hypervisor byte channel driver"
		360	depends on PPC
		361	help
		362	This driver creates /dev entries for each ePAPR hypervisor byte
		363	channel, thereby allowing applications to communicate with byte
		364	channels as if they were serial ports.
		365
		366	config PPC_EARLY_DEBUG_EHV_BC
		367	bool "Early console (udbg) support for ePAPR hypervisors"
		368	depends on PPC_EPAPR_HV_BYTECHAN
		369	help
		370	Select this option to enable early console (a.k.a. "udbg") support
		371	via an ePAPR byte channel. You also need to choose the byte channel
		372	handle below.
		373
		374	config PPC_EARLY_DEBUG_EHV_BC_HANDLE
		375	int "Byte channel handle for early console (udbg)"
		376	depends on PPC_EARLY_DEBUG_EHV_BC
		377	default 0
		378	help
		379	If you want early console (udbg) output through a byte channel,
		380	specify the handle of the byte channel to use.
		381
		382	For this to work, the byte channel driver must be compiled
		383	in-kernel, not as a module.
		384
		385	Note that only one early console driver can be enabled, so don't
		386	enable any others if you enable this one.
		387
		388	If the number you specify is not a valid byte channel handle, then
		389	there simply will be no early console output. This is true also
		390	if you don't boot under a hypervisor at all.

drivers/tty/Makefile+1−0

@@ -26,5 +26,6 @@ obj-$(CONFIG_ROCKETPORT) += rocket.o · 25 unmodified lines
26	obj-$(CONFIG_SYNCLINK_GT) += synclink_gt.o	26	obj-$(CONFIG_SYNCLINK_GT) += synclink_gt.o
27	obj-$(CONFIG_SYNCLINKMP) += synclinkmp.o	27	obj-$(CONFIG_SYNCLINKMP) += synclinkmp.o
28	obj-$(CONFIG_SYNCLINK) += synclink.o	28	obj-$(CONFIG_SYNCLINK) += synclink.o
		29	obj-$(CONFIG_PPC_EPAPR_HV_BYTECHAN) += ehv_bytechan.o
29		30
30	obj-y += ipwireless/	31	obj-y += ipwireless/

drivers/tty/amiserial.c+2−10

@@ -1529,7 +1529,6 @@ static void rs_wait_until_sent(struct tty_struct *tty, int timeout) · 1528 unmodified lines
1529	{	1529	{
1530	struct async_struct * info = tty->driver_data;	1530	struct async_struct * info = tty->driver_data;
1531	unsigned long orig_jiffies, char_time;	1531	unsigned long orig_jiffies, char_time;
1532	int tty_was_locked = tty_locked();
1533	int lsr;	1532	int lsr;
1534		1533
1535	if (serial_paranoia_check(info, tty->name, "rs_wait_until_sent"))	1534	if (serial_paranoia_check(info, tty->name, "rs_wait_until_sent"))
@@ -1540,12 +1539,6 @@ static void rs_wait_until_sent(struct tty_struct *tty, int timeout) · 4 unmodified lines
1540		1539
1541	orig_jiffies = jiffies;	1540	orig_jiffies = jiffies;
1542		1541
1543	/*
1544	* tty_wait_until_sent is called from lots of places,
1545	* with or without the BTM.
1546	*/
1547	if (!tty_was_locked)
1548	tty_lock();
1549	/*	1542	/*
1550	* Set the check interval to be 1/5 of the estimated time to	1543	* Set the check interval to be 1/5 of the estimated time to
1551	* send a single character, and make it at least 1. The check	1544	* send a single character, and make it at least 1. The check
@@ -1586,8 +1579,7 @@ static void rs_wait_until_sent(struct tty_struct *tty, int timeout) · 34 unmodified lines
1586	break;	1579	break;
1587	}	1580	}
1588	__set_current_state(TASK_RUNNING);	1581	__set_current_state(TASK_RUNNING);
1589	if (!tty_was_locked)	1582
1590	tty_unlock();
1591	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT	1583	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1592	printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);	1584	printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
1593	#endif	1585	#endif
@@ -2025,7 +2017,7 @@ static int __init amiga_serial_probe(struct platform_device *pdev) · 431 unmodified lines
2025	if (error)	2017	if (error)
2026	goto fail_unregister;	2018	goto fail_unregister;
2027		2019
2028	error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, IRQF_DISABLED,	2020	error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0,
2029	"serial RX", state);	2021	"serial RX", state);
2030	if (error)	2022	if (error)
2031	goto fail_free_irq;	2023	goto fail_free_irq;

drivers/tty/cyclades.c+2−12

@@ -45,7 +45,6 @@ · 44 unmodified lines
45	#undef CY_DEBUG_IO	45	#undef CY_DEBUG_IO
46	#undef CY_DEBUG_COUNT	46	#undef CY_DEBUG_COUNT
47	#undef CY_DEBUG_DTR	47	#undef CY_DEBUG_DTR
48	#undef CY_DEBUG_WAIT_UNTIL_SENT
49	#undef CY_DEBUG_INTERRUPTS	48	#undef CY_DEBUG_INTERRUPTS
50	#undef CY_16Y_HACK	49	#undef CY_16Y_HACK
51	#undef CY_ENABLE_MONITORING	50	#undef CY_ENABLE_MONITORING
@@ -1678,16 +1677,10 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout) · 1626 unmodified lines
1678	*/	1677	*/
1679	if (!timeout \|\| timeout > 2 * info->timeout)	1678	if (!timeout \|\| timeout > 2 * info->timeout)
1680	timeout = 2 * info->timeout;	1679	timeout = 2 * info->timeout;
1681	#ifdef CY_DEBUG_WAIT_UNTIL_SENT	1680
1682	printk(KERN_DEBUG "In cy_wait_until_sent(%d) check=%d, jiff=%lu...",
1683	timeout, char_time, jiffies);
1684	#endif
1685	card = info->card;	1681	card = info->card;
1686	if (!cy_is_Z(card)) {	1682	if (!cy_is_Z(card)) {
1687	while (cyy_readb(info, CySRER) & CyTxRdy) {	1683	while (cyy_readb(info, CySRER) & CyTxRdy) {
1688	#ifdef CY_DEBUG_WAIT_UNTIL_SENT
1689	printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
1690	#endif
1691	if (msleep_interruptible(jiffies_to_msecs(char_time)))	1684	if (msleep_interruptible(jiffies_to_msecs(char_time)))
1692	break;	1685	break;
1693	if (timeout && time_after(jiffies, orig_jiffies +	1686	if (timeout && time_after(jiffies, orig_jiffies +
@@ -1697,9 +1690,6 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout) · 3 unmodified lines
1697	}	1690	}
1698	/* Run one more char cycle */	1691	/* Run one more char cycle */
1699	msleep_interruptible(jiffies_to_msecs(char_time * 5));	1692	msleep_interruptible(jiffies_to_msecs(char_time * 5));
1700	#ifdef CY_DEBUG_WAIT_UNTIL_SENT
1701	printk(KERN_DEBUG "Clean (jiff=%lu)...done\n", jiffies);
1702	#endif
1703	}	1693	}
1704		1694
1705	static void cy_flush_buffer(struct tty_struct *tty)	1695	static void cy_flush_buffer(struct tty_struct *tty)
@@ -3377,7 +3367,7 @@ static int __init cy_detect_isa(void) · 1671 unmodified lines
3377		3367
3378	/* allocate IRQ */	3368	/* allocate IRQ */
3379	if (request_irq(cy_isa_irq, cyy_interrupt,	3369	if (request_irq(cy_isa_irq, cyy_interrupt,
3380	IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {	3370	0, "Cyclom-Y", &cy_card[j])) {
3381	printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "	3371	printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
3382	"could not allocate IRQ#%d.\n",	3372	"could not allocate IRQ#%d.\n",
3383	(unsigned long)cy_isa_address, cy_isa_irq);	3373	(unsigned long)cy_isa_address, cy_isa_irq);

drivers/tty/ehv_bytechan.c+881−0

@@ -0,0 +1,881 @@
	1	/* ePAPR hypervisor byte channel device driver
	2	*
	3	* Copyright 2009-2011 Freescale Semiconductor, Inc.
	4	*
	5	* Author: Timur Tabi <timur@freescale.com>
	6	*
	7	* This file is licensed under the terms of the GNU General Public License
	8	* version 2. This program is licensed "as is" without any warranty of any
	9	* kind, whether express or implied.
	10	*
	11	* This driver support three distinct interfaces, all of which are related to
	12	* ePAPR hypervisor byte channels.
	13	*
	14	* 1) An early-console (udbg) driver. This provides early console output
	15	* through a byte channel. The byte channel handle must be specified in a
	16	* Kconfig option.
	17	*
	18	* 2) A normal console driver. Output is sent to the byte channel designated
	19	* for stdout in the device tree. The console driver is for handling kernel
	20	* printk calls.
	21	*
	22	* 3) A tty driver, which is used to handle user-space input and output. The
	23	* byte channel used for the console is designated as the default tty.
	24	*/
	25
	26	#include <linux/module.h>
	27	#include <linux/init.h>
	28	#include <linux/slab.h>
	29	#include <linux/err.h>
	30	#include <linux/interrupt.h>
	31	#include <linux/fs.h>
	32	#include <linux/poll.h>
	33	#include <asm/epapr_hcalls.h>
	34	#include <linux/of.h>
	35	#include <linux/platform_device.h>
	36	#include <linux/cdev.h>
	37	#include <linux/console.h>
	38	#include <linux/tty.h>
	39	#include <linux/tty_flip.h>
	40	#include <linux/circ_buf.h>
	41	#include <asm/udbg.h>
	42
	43	/* The size of the transmit circular buffer. This must be a power of two. */
	44	#define BUF_SIZE 2048
	45
	46	/* Per-byte channel private data */
	47	struct ehv_bc_data {
	48	struct device *dev;
	49	struct tty_port port;
	50	uint32_t handle;
	51	unsigned int rx_irq;
	52	unsigned int tx_irq;
	53
	54	spinlock_t lock; /* lock for transmit buffer */
	55	unsigned char buf[BUF_SIZE]; /* transmit circular buffer */
	56	unsigned int head; /* circular buffer head */
	57	unsigned int tail; /* circular buffer tail */
	58
	59	int tx_irq_enabled; /* true == TX interrupt is enabled */
	60	};
	61
	62	/* Array of byte channel objects */
	63	static struct ehv_bc_data *bcs;
	64
	65	/* Byte channel handle for stdout (and stdin), taken from device tree */
	66	static unsigned int stdout_bc;
	67
	68	/* Virtual IRQ for the byte channel handle for stdin, taken from device tree */
	69	static unsigned int stdout_irq;
	70
	71	/************************** SUPPORT FUNCTIONS **************************/
	72
	73	/*
	74	* Enable the transmit interrupt
	75	*
	76	* Unlike a serial device, byte channels have no mechanism for disabling their
	77	* own receive or transmit interrupts. To emulate that feature, we toggle
	78	* the IRQ in the kernel.
	79	*
	80	* We cannot just blindly call enable_irq() or disable_irq(), because these
	81	* calls are reference counted. This means that we cannot call enable_irq()
	82	* if interrupts are already enabled. This can happen in two situations:
	83	*
	84	* 1. The tty layer makes two back-to-back calls to ehv_bc_tty_write()
	85	* 2. A transmit interrupt occurs while executing ehv_bc_tx_dequeue()
	86	*
	87	* To work around this, we keep a flag to tell us if the IRQ is enabled or not.
	88	*/
	89	static void enable_tx_interrupt(struct ehv_bc_data *bc)
	90	{
	91	if (!bc->tx_irq_enabled) {
	92	enable_irq(bc->tx_irq);
	93	bc->tx_irq_enabled = 1;
	94	}
	95	}
	96
	97	static void disable_tx_interrupt(struct ehv_bc_data *bc)
	98	{
	99	if (bc->tx_irq_enabled) {
	100	disable_irq_nosync(bc->tx_irq);
	101	bc->tx_irq_enabled = 0;
	102	}
	103	}
	104
	105	/*
	106	* find the byte channel handle to use for the console
	107	*
	108	* The byte channel to be used for the console is specified via a "stdout"
	109	* property in the /chosen node.
	110	*
	111	* For compatible with legacy device trees, we also look for a "stdout" alias.
	112	*/
	113	static int find_console_handle(void)
	114	{
	115	struct device_node np, np2;
	116	const char *sprop = NULL;
	117	const uint32_t *iprop;
	118
	119	np = of_find_node_by_path("/chosen");
	120	if (np)
	121	sprop = of_get_property(np, "stdout-path", NULL);
	122
	123	if (!np \|\| !sprop) {
	124	of_node_put(np);
	125	np = of_find_node_by_name(NULL, "aliases");
	126	if (np)
	127	sprop = of_get_property(np, "stdout", NULL);
	128	}
	129
	130	if (!sprop) {
	131	of_node_put(np);
	132	return 0;
	133	}
	134
	135	/* We don't care what the aliased node is actually called. We only
	136	* care if it's compatible with "epapr,hv-byte-channel", because that
	137	* indicates that it's a byte channel node. We use a temporary
	138	* variable, 'np2', because we can't release 'np' until we're done with
	139	* 'sprop'.
	140	*/
	141	np2 = of_find_node_by_path(sprop);
	142	of_node_put(np);
	143	np = np2;
	144	if (!np) {
	145	pr_warning("ehv-bc: stdout node '%s' does not exist\n", sprop);
	146	return 0;
	147	}
	148
	149	/* Is it a byte channel? */
	150	if (!of_device_is_compatible(np, "epapr,hv-byte-channel")) {
	151	of_node_put(np);
	152	return 0;
	153	}
	154
	155	stdout_irq = irq_of_parse_and_map(np, 0);
	156	if (stdout_irq == NO_IRQ) {
	157	pr_err("ehv-bc: no 'interrupts' property in %s node\n", sprop);
	158	of_node_put(np);
	159	return 0;
	160	}
	161
	162	/*
	163	* The 'hv-handle' property contains the handle for this byte channel.
	164	*/
	165	iprop = of_get_property(np, "hv-handle", NULL);
	166	if (!iprop) {
	167	pr_err("ehv-bc: no 'hv-handle' property in %s node\n",
	168	np->name);
	169	of_node_put(np);
	170	return 0;
	171	}
	172	stdout_bc = be32_to_cpu(*iprop);
	173
	174	of_node_put(np);
	175	return 1;
	176	}
	177
	178	/************************* EARLY CONSOLE DRIVER *************************/
	179
	180	#ifdef CONFIG_PPC_EARLY_DEBUG_EHV_BC
	181
	182	/*
	183	* send a byte to a byte channel, wait if necessary
	184	*
	185	* This function sends a byte to a byte channel, and it waits and
	186	* retries if the byte channel is full. It returns if the character
	187	* has been sent, or if some error has occurred.
	188	*
	189	*/
	190	static void byte_channel_spin_send(const char data)
	191	{
	192	int ret, count;
	193
	194	do {
	195	count = 1;
	196	ret = ev_byte_channel_send(CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE,
	197	&count, &data);
	198	} while (ret == EV_EAGAIN);
	199	}
	200
	201	/*
	202	* The udbg subsystem calls this function to display a single character.
	203	* We convert CR to a CR/LF.
	204	*/
	205	static void ehv_bc_udbg_putc(char c)
	206	{
	207	if (c == '\n')
	208	byte_channel_spin_send('\r');
	209
	210	byte_channel_spin_send(c);
	211	}
	212
	213	/*
	214	* early console initialization
	215	*
	216	* PowerPC kernels support an early printk console, also known as udbg.
	217	* This function must be called via the ppc_md.init_early function pointer.
	218	* At this point, the device tree has been unflattened, so we can obtain the
	219	* byte channel handle for stdout.
	220	*
	221	* We only support displaying of characters (putc). We do not support
	222	* keyboard input.
	223	*/
	224	void __init udbg_init_ehv_bc(void)
	225	{
	226	unsigned int rx_count, tx_count;
	227	unsigned int ret;
	228
	229	/* Verify the byte channel handle */
	230	ret = ev_byte_channel_poll(CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE,
	231	&rx_count, &tx_count);
	232	if (ret)
	233	return;
	234
	235	udbg_putc = ehv_bc_udbg_putc;
	236	register_early_udbg_console();
	237
	238	udbg_printf("ehv-bc: early console using byte channel handle %u\n",
	239	CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);
	240	}
	241
	242	#endif
	243
	244	/**************************** CONSOLE DRIVER ****************************/
	245
	246	static struct tty_driver *ehv_bc_driver;
	247
	248	/*
	249	* Byte channel console sending worker function.
	250	*
	251	* For consoles, if the output buffer is full, we should just spin until it
	252	* clears.
	253	*/
	254	static int ehv_bc_console_byte_channel_send(unsigned int handle, const char *s,
	255	unsigned int count)
	256	{
	257	unsigned int len;
	258	int ret = 0;
	259
	260	while (count) {
	261	len = min_t(unsigned int, count, EV_BYTE_CHANNEL_MAX_BYTES);
	262	do {
	263	ret = ev_byte_channel_send(handle, &len, s);
	264	} while (ret == EV_EAGAIN);
	265	count -= len;
	266	s += len;
	267	}
	268
	269	return ret;
	270	}
	271
	272	/*
	273	* write a string to the console
	274	*
	275	* This function gets called to write a string from the kernel, typically from
	276	* a printk(). This function spins until all data is written.
	277	*
	278	* We copy the data to a temporary buffer because we need to insert a \r in
	279	* front of every \n. It's more efficient to copy the data to the buffer than
	280	* it is to make multiple hcalls for each character or each newline.
	281	*/
	282	static void ehv_bc_console_write(struct console co, const char s,
	283	unsigned int count)
	284	{
	285	char s2[EV_BYTE_CHANNEL_MAX_BYTES];
	286	unsigned int i, j = 0;
	287	char c;
	288
	289	for (i = 0; i < count; i++) {
	290	c = *s++;
	291
	292	if (c == '\n')
	293	s2[j++] = '\r';
	294
	295	s2[j++] = c;
	296	if (j >= (EV_BYTE_CHANNEL_MAX_BYTES - 1)) {
	297	if (ehv_bc_console_byte_channel_send(stdout_bc, s2, j))
	298	return;
	299	j = 0;
	300	}
	301	}
	302
	303	if (j)
	304	ehv_bc_console_byte_channel_send(stdout_bc, s2, j);
	305	}
	306
	307	/*
	308	* When /dev/console is opened, the kernel iterates the console list looking
	309	* for one with ->device and then calls that method. On success, it expects
	310	* the passed-in int* to contain the minor number to use.
	311	*/
	312	static struct tty_driver ehv_bc_console_device(struct console co, int *index)
	313	{
	314	*index = co->index;
	315
	316	return ehv_bc_driver;
	317	}
	318
	319	static struct console ehv_bc_console = {
	320	.name = "ttyEHV",
	321	.write = ehv_bc_console_write,
	322	.device = ehv_bc_console_device,
	323	.flags = CON_PRINTBUFFER \| CON_ENABLED,
	324	};
	325
	326	/*
	327	* Console initialization
	328	*
	329	* This is the first function that is called after the device tree is
	330	* available, so here is where we determine the byte channel handle and IRQ for
	331	* stdout/stdin, even though that information is used by the tty and character
	332	* drivers.
	333	*/
	334	static int __init ehv_bc_console_init(void)
	335	{
	336	if (!find_console_handle()) {
	337	pr_debug("ehv-bc: stdout is not a byte channel\n");
	338	return -ENODEV;
	339	}
	340
	341	#ifdef CONFIG_PPC_EARLY_DEBUG_EHV_BC
	342	/* Print a friendly warning if the user chose the wrong byte channel
	343	* handle for udbg.
	344	*/
	345	if (stdout_bc != CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE)
	346	pr_warning("ehv-bc: udbg handle %u is not the stdout handle\n",
	347	CONFIG_PPC_EARLY_DEBUG_EHV_BC_HANDLE);
	348	#endif
	349
	350	/* add_preferred_console() must be called before register_console(),
	351	otherwise it won't work. However, we don't want to enumerate all the
	352	byte channels here, either, since we only care about one. */
	353
	354	add_preferred_console(ehv_bc_console.name, ehv_bc_console.index, NULL);
	355	register_console(&ehv_bc_console);
	356
	357	pr_info("ehv-bc: registered console driver for byte channel %u\n",
	358	stdout_bc);
	359
	360	return 0;
	361	}
	362	console_initcall(ehv_bc_console_init);
	363
	364	/****************************** TTY DRIVER ******************************/
	365
	366	/*
	367	* byte channel receive interupt handler
	368	*
	369	* This ISR is called whenever data is available on a byte channel.
	370	*/
	371	static irqreturn_t ehv_bc_tty_rx_isr(int irq, void *data)
	372	{
	373	struct ehv_bc_data *bc = data;
	374	struct tty_struct *ttys = tty_port_tty_get(&bc->port);
	375	unsigned int rx_count, tx_count, len;
	376	int count;
	377	char buffer[EV_BYTE_CHANNEL_MAX_BYTES];
	378	int ret;
	379
	380	/* ttys could be NULL during a hangup */
	381	if (!ttys)
	382	return IRQ_HANDLED;
	383
	384	/* Find out how much data needs to be read, and then ask the TTY layer
	385	* if it can handle that much. We want to ensure that every byte we
	386	* read from the byte channel will be accepted by the TTY layer.
	387	*/
	388	ev_byte_channel_poll(bc->handle, &rx_count, &tx_count);
	389	count = tty_buffer_request_room(ttys, rx_count);
	390
	391	/* 'count' is the maximum amount of data the TTY layer can accept at
	392	* this time. However, during testing, I was never able to get 'count'
	393	* to be less than 'rx_count'. I'm not sure whether I'm calling it
	394	* correctly.
	395	*/
	396
	397	while (count > 0) {
	398	len = min_t(unsigned int, count, sizeof(buffer));
	399
	400	/* Read some data from the byte channel. This function will
	401	* never return more than EV_BYTE_CHANNEL_MAX_BYTES bytes.
	402	*/
	403	ev_byte_channel_receive(bc->handle, &len, buffer);
	404
	405	/* 'len' is now the amount of data that's been received. 'len'
	406	* can't be zero, and most likely it's equal to one.
	407	*/
	408
	409	/* Pass the received data to the tty layer. */
	410	ret = tty_insert_flip_string(ttys, buffer, len);
	411
	412	/* 'ret' is the number of bytes that the TTY layer accepted.
	413	* If it's not equal to 'len', then it means the buffer is
	414	* full, which should never happen. If it does happen, we can
	415	* exit gracefully, but we drop the last 'len - ret' characters
	416	* that we read from the byte channel.
	417	*/
	418	if (ret != len)
	419	break;
	420
	421	count -= len;
	422	}
	423
	424	/* Tell the tty layer that we're done. */
	425	tty_flip_buffer_push(ttys);
	426
	427	tty_kref_put(ttys);
	428
	429	return IRQ_HANDLED;
	430	}
	431
	432	/*
	433	* dequeue the transmit buffer to the hypervisor
	434	*
	435	* This function, which can be called in interrupt context, dequeues as much
	436	* data as possible from the transmit buffer to the byte channel.
	437	*/
	438	static void ehv_bc_tx_dequeue(struct ehv_bc_data *bc)
	439	{
	440	unsigned int count;
	441	unsigned int len, ret;
	442	unsigned long flags;
	443
	444	do {
	445	spin_lock_irqsave(&bc->lock, flags);
	446	len = min_t(unsigned int,
	447	CIRC_CNT_TO_END(bc->head, bc->tail, BUF_SIZE),
	448	EV_BYTE_CHANNEL_MAX_BYTES);
	449
	450	ret = ev_byte_channel_send(bc->handle, &len, bc->buf + bc->tail);
	451
	452	/* 'len' is valid only if the return code is 0 or EV_EAGAIN */
	453	if (!ret \|\| (ret == EV_EAGAIN))
	454	bc->tail = (bc->tail + len) & (BUF_SIZE - 1);
	455
	456	count = CIRC_CNT(bc->head, bc->tail, BUF_SIZE);
	457	spin_unlock_irqrestore(&bc->lock, flags);
	458	} while (count && !ret);
	459
	460	spin_lock_irqsave(&bc->lock, flags);
	461	if (CIRC_CNT(bc->head, bc->tail, BUF_SIZE))
	462	/*
	463	* If we haven't emptied the buffer, then enable the TX IRQ.
	464	* We'll get an interrupt when there's more room in the
	465	* hypervisor's output buffer.
	466	*/
	467	enable_tx_interrupt(bc);
	468	else
	469	disable_tx_interrupt(bc);
	470	spin_unlock_irqrestore(&bc->lock, flags);
	471	}
	472
	473	/*
	474	* byte channel transmit interupt handler
	475	*
	476	* This ISR is called whenever space becomes available for transmitting
	477	* characters on a byte channel.
	478	*/
	479	static irqreturn_t ehv_bc_tty_tx_isr(int irq, void *data)
	480	{
	481	struct ehv_bc_data *bc = data;
	482	struct tty_struct *ttys = tty_port_tty_get(&bc->port);
	483
	484	ehv_bc_tx_dequeue(bc);
	485	if (ttys) {
	486	tty_wakeup(ttys);
	487	tty_kref_put(ttys);
	488	}
	489
	490	return IRQ_HANDLED;
	491	}
	492
	493	/*
	494	* This function is called when the tty layer has data for us send. We store
	495	* the data first in a circular buffer, and then dequeue as much of that data
	496	* as possible.
	497	*
	498	* We don't need to worry about whether there is enough room in the buffer for
	499	* all the data. The purpose of ehv_bc_tty_write_room() is to tell the tty
	500	* layer how much data it can safely send to us. We guarantee that
	501	* ehv_bc_tty_write_room() will never lie, so the tty layer will never send us
	502	* too much data.
	503	*/
	504	static int ehv_bc_tty_write(struct tty_struct ttys, const unsigned char s,
	505	int count)
	506	{
	507	struct ehv_bc_data *bc = ttys->driver_data;
	508	unsigned long flags;
	509	unsigned int len;
	510	unsigned int written = 0;
	511
	512	while (1) {
	513	spin_lock_irqsave(&bc->lock, flags);
	514	len = CIRC_SPACE_TO_END(bc->head, bc->tail, BUF_SIZE);
	515	if (count < len)
	516	len = count;
	517	if (len) {
	518	memcpy(bc->buf + bc->head, s, len);
	519	bc->head = (bc->head + len) & (BUF_SIZE - 1);
	520	}
	521	spin_unlock_irqrestore(&bc->lock, flags);
	522	if (!len)
	523	break;
	524
	525	s += len;
	526	count -= len;
	527	written += len;
	528	}
	529
	530	ehv_bc_tx_dequeue(bc);
	531
	532	return written;
	533	}
	534
	535	/*
	536	* This function can be called multiple times for a given tty_struct, which is
	537	* why we initialize bc->ttys in ehv_bc_tty_port_activate() instead.
	538	*
	539	* The tty layer will still call this function even if the device was not
	540	* registered (i.e. tty_register_device() was not called). This happens
	541	* because tty_register_device() is optional and some legacy drivers don't
	542	* use it. So we need to check for that.
	543	*/
	544	static int ehv_bc_tty_open(struct tty_struct ttys, struct file filp)
	545	{
	546	struct ehv_bc_data *bc = &bcs[ttys->index];
	547
	548	if (!bc->dev)
	549	return -ENODEV;
	550
	551	return tty_port_open(&bc->port, ttys, filp);
	552	}
	553
	554	/*
	555	* Amazingly, if ehv_bc_tty_open() returns an error code, the tty layer will
	556	* still call this function to close the tty device. So we can't assume that
	557	* the tty port has been initialized.
	558	*/
	559	static void ehv_bc_tty_close(struct tty_struct ttys, struct file filp)
	560	{
	561	struct ehv_bc_data *bc = &bcs[ttys->index];
	562
	563	if (bc->dev)
	564	tty_port_close(&bc->port, ttys, filp);
	565	}
	566
	567	/*
	568	* Return the amount of space in the output buffer
	569	*
	570	* This is actually a contract between the driver and the tty layer outlining
	571	* how much write room the driver can guarantee will be sent OR BUFFERED. This
	572	* driver MUST honor the return value.
	573	*/
	574	static int ehv_bc_tty_write_room(struct tty_struct *ttys)
	575	{
	576	struct ehv_bc_data *bc = ttys->driver_data;
	577	unsigned long flags;
	578	int count;
	579
	580	spin_lock_irqsave(&bc->lock, flags);
	581	count = CIRC_SPACE(bc->head, bc->tail, BUF_SIZE);
	582	spin_unlock_irqrestore(&bc->lock, flags);
	583
	584	return count;
	585	}
	586
	587	/*
	588	* Stop sending data to the tty layer
	589	*
	590	* This function is called when the tty layer's input buffers are getting full,
	591	* so the driver should stop sending it data. The easiest way to do this is to
	592	* disable the RX IRQ, which will prevent ehv_bc_tty_rx_isr() from being
	593	* called.
	594	*
	595	* The hypervisor will continue to queue up any incoming data. If there is any
	596	* data in the queue when the RX interrupt is enabled, we'll immediately get an
	597	* RX interrupt.
	598	*/
	599	static void ehv_bc_tty_throttle(struct tty_struct *ttys)
	600	{
	601	struct ehv_bc_data *bc = ttys->driver_data;
	602
	603	disable_irq(bc->rx_irq);
	604	}
	605
	606	/*
	607	* Resume sending data to the tty layer
	608	*
	609	* This function is called after previously calling ehv_bc_tty_throttle(). The
	610	* tty layer's input buffers now have more room, so the driver can resume
	611	* sending it data.
	612	*/
	613	static void ehv_bc_tty_unthrottle(struct tty_struct *ttys)
	614	{
	615	struct ehv_bc_data *bc = ttys->driver_data;
	616
	617	/* If there is any data in the queue when the RX interrupt is enabled,
	618	* we'll immediately get an RX interrupt.
	619	*/
	620	enable_irq(bc->rx_irq);
	621	}
	622
	623	static void ehv_bc_tty_hangup(struct tty_struct *ttys)
	624	{
	625	struct ehv_bc_data *bc = ttys->driver_data;
	626
	627	ehv_bc_tx_dequeue(bc);
	628	tty_port_hangup(&bc->port);
	629	}
	630
	631	/*
	632	* TTY driver operations
	633	*
	634	* If we could ask the hypervisor how much data is still in the TX buffer, or
	635	* at least how big the TX buffers are, then we could implement the
	636	* .wait_until_sent and .chars_in_buffer functions.
	637	*/
	638	static const struct tty_operations ehv_bc_ops = {
	639	.open = ehv_bc_tty_open,
	640	.close = ehv_bc_tty_close,
	641	.write = ehv_bc_tty_write,
	642	.write_room = ehv_bc_tty_write_room,
	643	.throttle = ehv_bc_tty_throttle,
	644	.unthrottle = ehv_bc_tty_unthrottle,
	645	.hangup = ehv_bc_tty_hangup,
	646	};
	647
	648	/*
	649	* initialize the TTY port
	650	*
	651	* This function will only be called once, no matter how many times
	652	* ehv_bc_tty_open() is called. That's why we register the ISR here, and also
	653	* why we initialize tty_struct-related variables here.
	654	*/
	655	static int ehv_bc_tty_port_activate(struct tty_port *port,
	656	struct tty_struct *ttys)
	657	{
	658	struct ehv_bc_data *bc = container_of(port, struct ehv_bc_data, port);
	659	int ret;
	660
	661	ttys->driver_data = bc;
	662
	663	ret = request_irq(bc->rx_irq, ehv_bc_tty_rx_isr, 0, "ehv-bc", bc);
	664	if (ret < 0) {
	665	dev_err(bc->dev, "could not request rx irq %u (ret=%i)\n",
	666	bc->rx_irq, ret);
	667	return ret;
	668	}
	669
	670	/* request_irq also enables the IRQ */
	671	bc->tx_irq_enabled = 1;
	672
	673	ret = request_irq(bc->tx_irq, ehv_bc_tty_tx_isr, 0, "ehv-bc", bc);
	674	if (ret < 0) {
	675	dev_err(bc->dev, "could not request tx irq %u (ret=%i)\n",
	676	bc->tx_irq, ret);
	677	free_irq(bc->rx_irq, bc);
	678	return ret;
	679	}
	680
	681	/* The TX IRQ is enabled only when we can't write all the data to the
	682	* byte channel at once, so by default it's disabled.
	683	*/
	684	disable_tx_interrupt(bc);
	685
	686	return 0;
	687	}
	688
	689	static void ehv_bc_tty_port_shutdown(struct tty_port *port)
	690	{
	691	struct ehv_bc_data *bc = container_of(port, struct ehv_bc_data, port);
	692
	693	free_irq(bc->tx_irq, bc);
	694	free_irq(bc->rx_irq, bc);
	695	}
	696
	697	static const struct tty_port_operations ehv_bc_tty_port_ops = {
	698	.activate = ehv_bc_tty_port_activate,
	699	.shutdown = ehv_bc_tty_port_shutdown,
	700	};
	701
	702	static int __devinit ehv_bc_tty_probe(struct platform_device *pdev)
	703	{
	704	struct device_node *np = pdev->dev.of_node;
	705	struct ehv_bc_data *bc;
	706	const uint32_t *iprop;
	707	unsigned int handle;
	708	int ret;
	709	static unsigned int index = 1;
	710	unsigned int i;
	711
	712	iprop = of_get_property(np, "hv-handle", NULL);
	713	if (!iprop) {
	714	dev_err(&pdev->dev, "no 'hv-handle' property in %s node\n",
	715	np->name);
	716	return -ENODEV;
	717	}
	718
	719	/* We already told the console layer that the index for the console
	720	* device is zero, so we need to make sure that we use that index when
	721	* we probe the console byte channel node.
	722	*/
	723	handle = be32_to_cpu(*iprop);
	724	i = (handle == stdout_bc) ? 0 : index++;
	725	bc = &bcs[i];
	726
	727	bc->handle = handle;
	728	bc->head = 0;
	729	bc->tail = 0;
	730	spin_lock_init(&bc->lock);
	731
	732	bc->rx_irq = irq_of_parse_and_map(np, 0);
	733	bc->tx_irq = irq_of_parse_and_map(np, 1);
	734	if ((bc->rx_irq == NO_IRQ) \|\| (bc->tx_irq == NO_IRQ)) {
	735	dev_err(&pdev->dev, "no 'interrupts' property in %s node\n",
	736	np->name);
	737	ret = -ENODEV;
	738	goto error;
	739	}
	740
	741	bc->dev = tty_register_device(ehv_bc_driver, i, &pdev->dev);
	742	if (IS_ERR(bc->dev)) {
	743	ret = PTR_ERR(bc->dev);
	744	dev_err(&pdev->dev, "could not register tty (ret=%i)\n", ret);
	745	goto error;
	746	}
	747
	748	tty_port_init(&bc->port);
	749	bc->port.ops = &ehv_bc_tty_port_ops;
	750
	751	dev_set_drvdata(&pdev->dev, bc);
	752
	753	dev_info(&pdev->dev, "registered /dev/%s%u for byte channel %u\n",
	754	ehv_bc_driver->name, i, bc->handle);
	755
	756	return 0;
	757
	758	error:
	759	irq_dispose_mapping(bc->tx_irq);
	760	irq_dispose_mapping(bc->rx_irq);
	761
	762	memset(bc, 0, sizeof(struct ehv_bc_data));
	763	return ret;
	764	}
	765
	766	static int ehv_bc_tty_remove(struct platform_device *pdev)
	767	{
	768	struct ehv_bc_data *bc = dev_get_drvdata(&pdev->dev);
	769
	770	tty_unregister_device(ehv_bc_driver, bc - bcs);
	771
	772	irq_dispose_mapping(bc->tx_irq);
	773	irq_dispose_mapping(bc->rx_irq);
	774
	775	return 0;
	776	}
	777
	778	static const struct of_device_id ehv_bc_tty_of_ids[] = {
	779	{ .compatible = "epapr,hv-byte-channel" },
	780	{}
	781	};
	782
	783	static struct platform_driver ehv_bc_tty_driver = {
	784	.driver = {
	785	.owner = THIS_MODULE,
	786	.name = "ehv-bc",
	787	.of_match_table = ehv_bc_tty_of_ids,
	788	},
	789	.probe = ehv_bc_tty_probe,
	790	.remove = ehv_bc_tty_remove,
	791	};
	792
	793	/**
	794	* ehv_bc_init - ePAPR hypervisor byte channel driver initialization
	795	*
	796	* This function is called when this module is loaded.
	797	*/
	798	static int __init ehv_bc_init(void)
	799	{
	800	struct device_node *np;
	801	unsigned int count = 0; /* Number of elements in bcs[] */
	802	int ret;
	803
	804	pr_info("ePAPR hypervisor byte channel driver\n");
	805
	806	/* Count the number of byte channels */
	807	for_each_compatible_node(np, NULL, "epapr,hv-byte-channel")
	808	count++;
	809
	810	if (!count)
	811	return -ENODEV;
	812
	813	/* The array index of an element in bcs[] is the same as the tty index
	814	* for that element. If you know the address of an element in the
	815	* array, then you can use pointer math (e.g. "bc - bcs") to get its
	816	* tty index.
	817	*/
	818	bcs = kzalloc(count * sizeof(struct ehv_bc_data), GFP_KERNEL);
	819	if (!bcs)
	820	return -ENOMEM;
	821
	822	ehv_bc_driver = alloc_tty_driver(count);
	823	if (!ehv_bc_driver) {
	824	ret = -ENOMEM;
	825	goto error;
	826	}
	827
	828	ehv_bc_driver->owner = THIS_MODULE;
	829	ehv_bc_driver->driver_name = "ehv-bc";
	830	ehv_bc_driver->name = ehv_bc_console.name;
	831	ehv_bc_driver->type = TTY_DRIVER_TYPE_CONSOLE;
	832	ehv_bc_driver->subtype = SYSTEM_TYPE_CONSOLE;
	833	ehv_bc_driver->init_termios = tty_std_termios;
	834	ehv_bc_driver->flags = TTY_DRIVER_REAL_RAW \| TTY_DRIVER_DYNAMIC_DEV;
	835	tty_set_operations(ehv_bc_driver, &ehv_bc_ops);
	836
	837	ret = tty_register_driver(ehv_bc_driver);
	838	if (ret) {
	839	pr_err("ehv-bc: could not register tty driver (ret=%i)\n", ret);
	840	goto error;
	841	}
	842
	843	ret = platform_driver_register(&ehv_bc_tty_driver);
	844	if (ret) {
	845	pr_err("ehv-bc: could not register platform driver (ret=%i)\n",
	846	ret);
	847	goto error;
	848	}
	849
	850	return 0;
	851
	852	error:
	853	if (ehv_bc_driver) {
	854	tty_unregister_driver(ehv_bc_driver);
	855	put_tty_driver(ehv_bc_driver);
	856	}
	857
	858	kfree(bcs);
	859
	860	return ret;
	861	}
	862
	863
	864	/**
	865	* ehv_bc_exit - ePAPR hypervisor byte channel driver termination
	866	*
	867	* This function is called when this driver is unloaded.
	868	*/
	869	static void __exit ehv_bc_exit(void)
	870	{
	871	tty_unregister_driver(ehv_bc_driver);
	872	put_tty_driver(ehv_bc_driver);
	873	kfree(bcs);
	874	}
	875
	876	module_init(ehv_bc_init);
	877	module_exit(ehv_bc_exit);
	878
	879	MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
	880	MODULE_DESCRIPTION("ePAPR hypervisor byte channel driver");
	881	MODULE_LICENSE("GPL v2");

drivers/tty/hvc/hvc_console.c+7−2

 		 * there is no buffered data otherwise sleeps on a wait queue
 		 * waking periodically to check chars_in_buffer().
 		 */
-		tty_wait_until_sent(tty, HVC_CLOSE_WAIT);
+		tty_wait_until_sent_from_close(tty, HVC_CLOSE_WAIT);
 	} else {
 		if (hp->count < 0)
 			printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
 	 * find index to use:
 	 * see if this vterm id matches one registered for console.
 	 */
-	for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
+	for (i = 0; i < MAX_NR_HVC_CONSOLES; i++)
 		if (vtermnos[i] == hp->vtermno &&
 		    cons_ops[i] == hp->ops)
 			break;
 		i = ++last_hvc;
 	hp->index = i;
+	hvc_console.index = i;
+	vtermnos[i] = vtermno;
+	cons_ops[i] = ops;
 	list_add_tail(&(hp->next), &hvc_structs);
 	spin_unlock(&hvc_structs_lock);
+	register_console(&hvc_console);
 	return hp;
 }
 	unsigned long flags;
 	struct tty_struct *tty;
+	unregister_console(&hvc_console);
 	spin_lock_irqsave(&hp->lock, flags);
 	tty = tty_kref_get(hp->tty);

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

@@ -28,7 +28,7 @@ int notifier_add_irq(struct hvc_struct *hp, int irq) · 27 unmodified lines
28	hp->irq_requested = 0;	28	hp->irq_requested = 0;
29	return 0;	29	return 0;
30	}	30	}
31	rc = request_irq(irq, hvc_handle_interrupt, IRQF_DISABLED,	31	rc = request_irq(irq, hvc_handle_interrupt, 0,
32	"hvc_console", hp);	32	"hvc_console", hp);
33	if (!rc)	33	if (!rc)
34	hp->irq_requested = 1;	34	hp->irq_requested = 1;

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

@@ -1057,7 +1057,7 @@ static int hvcs_enable_device(struct hvcs_struct *hvcsd, uint32_t unit_address, · 1056 unmodified lines
1057	* the conn was registered and now.	1057	* the conn was registered and now.
1058	*/	1058	*/
1059	if (!(rc = request_irq(irq, &hvcs_handle_interrupt,	1059	if (!(rc = request_irq(irq, &hvcs_handle_interrupt,
1060	IRQF_DISABLED, "ibmhvcs", hvcsd))) {	1060	0, "ibmhvcs", hvcsd))) {
1061	/*	1061	/*
1062	* It is possible the vty-server was removed after the irq was	1062	* It is possible the vty-server was removed after the irq was
1063	* requested but before we have time to enable interrupts.	1063	* requested but before we have time to enable interrupts.
@@ -1237,7 +1237,7 @@ static void hvcs_close(struct tty_struct tty, struct file filp) · 173 unmodified lines
1237	irq = hvcsd->vdev->irq;	1237	irq = hvcsd->vdev->irq;
1238	spin_unlock_irqrestore(&hvcsd->lock, flags);	1238	spin_unlock_irqrestore(&hvcsd->lock, flags);
1239		1239
1240	tty_wait_until_sent(tty, HVCS_CLOSE_WAIT);	1240	tty_wait_until_sent_from_close(tty, HVCS_CLOSE_WAIT);
1241		1241
1242	/*	1242	/*
1243	* This line is important because it tells hvcs_open that this	1243	* This line is important because it tells hvcs_open that this

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

@@ -1105,7 +1105,7 @@ static int __init hvsi_init(void) · 1104 unmodified lines
1105	struct hvsi_struct *hp = &hvsi_ports[i];	1105	struct hvsi_struct *hp = &hvsi_ports[i];
1106	int ret = 1;	1106	int ret = 1;
1107		1107
1108	ret = request_irq(hp->virq, hvsi_interrupt, IRQF_DISABLED, "hvsi", hp);	1108	ret = request_irq(hp->virq, hvsi_interrupt, 0, "hvsi", hp);
1109	if (ret)	1109	if (ret)
1110	printk(KERN_ERR "HVSI: couldn't reserve irq 0x%x (error %i)\n",	1110	printk(KERN_ERR "HVSI: couldn't reserve irq 0x%x (error %i)\n",
1111	hp->virq, ret);	1111	hp->virq, ret);

drivers/tty/isicom.c+1−1

@@ -1598,7 +1598,7 @@ static int __devinit isicom_probe(struct pci_dev *pdev, · 1597 unmodified lines
1598	}	1598	}
1599		1599
1600	retval = request_irq(board->irq, isicom_interrupt,	1600	retval = request_irq(board->irq, isicom_interrupt,
1601	IRQF_SHARED \| IRQF_DISABLED, ISICOM_NAME, board);	1601	IRQF_SHARED, ISICOM_NAME, board);
1602	if (retval < 0) {	1602	if (retval < 0) {
1603	dev_err(&pdev->dev, "Could not install handler at Irq %d. "	1603	dev_err(&pdev->dev, "Could not install handler at Irq %d. "
1604	"Card%d will be disabled.\n", board->irq, index + 1);	1604	"Card%d will be disabled.\n", board->irq, index + 1);

drivers/tty/mxser.c+1−12

@@ -2005,16 +2005,9 @@ static void mxser_wait_until_sent(struct tty_struct *tty, int timeout) · 2004 unmodified lines
2005	*/	2005	*/
2006	if (!timeout \|\| timeout > 2 * info->timeout)	2006	if (!timeout \|\| timeout > 2 * info->timeout)
2007	timeout = 2 * info->timeout;	2007	timeout = 2 * info->timeout;
2008	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT	2008
2009	printk(KERN_DEBUG "In rs_wait_until_sent(%d) check=%lu...",
2010	timeout, char_time);
2011	printk("jiff=%lu...", jiffies);
2012	#endif
2013	spin_lock_irqsave(&info->slock, flags);	2009	spin_lock_irqsave(&info->slock, flags);
2014	while (!((lsr = inb(info->ioaddr + UART_LSR)) & UART_LSR_TEMT)) {	2010	while (!((lsr = inb(info->ioaddr + UART_LSR)) & UART_LSR_TEMT)) {
2015	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
2016	printk("lsr = %d (jiff=%lu)...", lsr, jiffies);
2017	#endif
2018	spin_unlock_irqrestore(&info->slock, flags);	2011	spin_unlock_irqrestore(&info->slock, flags);
2019	schedule_timeout_interruptible(char_time);	2012	schedule_timeout_interruptible(char_time);
2020	spin_lock_irqsave(&info->slock, flags);	2013	spin_lock_irqsave(&info->slock, flags);
@@ -2025,10 +2018,6 @@ static void mxser_wait_until_sent(struct tty_struct *tty, int timeout) · 4 unmodified lines
2025	}	2018	}
2026	spin_unlock_irqrestore(&info->slock, flags);	2019	spin_unlock_irqrestore(&info->slock, flags);
2027	set_current_state(TASK_RUNNING);	2020	set_current_state(TASK_RUNNING);
2028
2029	#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
2030	printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
2031	#endif
2032	}	2021	}
2033		2022
2034	/*	2023	/*

drivers/tty/n_gsm.c+40−30

@@ -21,7 +21,6 @@ · 20 unmodified lines
21	* Mostly done: ioctls for setting modes/timing	21	* Mostly done: ioctls for setting modes/timing
22	* Partly done: hooks so you can pull off frames to non tty devs	22	* Partly done: hooks so you can pull off frames to non tty devs
23	* Restart DLCI 0 when it closes ?	23	* Restart DLCI 0 when it closes ?
24	* Test basic encoding
25	* Improve the tx engine	24	* Improve the tx engine
26	* Resolve tx side locking by adding a queue_head and routing	25	* Resolve tx side locking by adding a queue_head and routing
27	* all control traffic via it	26	* all control traffic via it
@@ -810,38 +809,41 @@ static int gsm_dlci_data_output(struct gsm_mux gsm, struct gsm_dlci dlci) · 782 unmodified lines
810	{	809	{
811	struct gsm_msg *msg;	810	struct gsm_msg *msg;
812	u8 *dp;	811	u8 *dp;
813	int len, size;	812	int len, total_size, size;
814	int h = dlci->adaption - 1;	813	int h = dlci->adaption - 1;
815		814
816	len = kfifo_len(dlci->fifo);	815	total_size = 0;
817	if (len == 0)	816	while(1) {
818	return 0;	817	len = kfifo_len(dlci->fifo);
819		818	if (len == 0)
820	/* MTU/MRU count only the data bits */	819	return total_size;
821	if (len > gsm->mtu)	820
822	len = gsm->mtu;	821	/* MTU/MRU count only the data bits */
823		822	if (len > gsm->mtu)
824	size = len + h;	823	len = gsm->mtu;
825		824
826	msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);	825	size = len + h;
827	/* FIXME: need a timer or something to kick this so it can't	826
828	get stuck with no work outstanding and no buffer free */	827	msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
829	if (msg == NULL)	828	/* FIXME: need a timer or something to kick this so it can't
830	return -ENOMEM;	829	get stuck with no work outstanding and no buffer free */
831	dp = msg->data;	830	if (msg == NULL)
832	switch (dlci->adaption) {	831	return -ENOMEM;
833	case 1: /* Unstructured */	832	dp = msg->data;
834	break;	833	switch (dlci->adaption) {
835	case 2: /* Unstructed with modem bits. Always one byte as we never	834	case 1: /* Unstructured */
836	send inline break data */	835	break;
837	*dp += gsm_encode_modem(dlci);	836	case 2: /* Unstructed with modem bits. Always one byte as we never
838	len--;	837	send inline break data */
839	break;	838	*dp++ = gsm_encode_modem(dlci);
		839	break;
		840	}
		841	WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
		842	__gsm_data_queue(dlci, msg);
		843	total_size += size;
840	}	844	}
841	WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
842	__gsm_data_queue(dlci, msg);
843	/* Bytes of data we used up */	845	/* Bytes of data we used up */
844	return size;	846	return total_size;
845	}	847	}
846		848
847	/**	849	/**
@@ -2004,6 +2006,7 @@ void gsm_cleanup_mux(struct gsm_mux *gsm) · 1156 unmodified lines
2004	int i;	2006	int i;
2005	struct gsm_dlci *dlci = gsm->dlci[0];	2007	struct gsm_dlci *dlci = gsm->dlci[0];
2006	struct gsm_msg *txq;	2008	struct gsm_msg *txq;
		2009	struct gsm_control *gc;
2007		2010
2008	gsm->dead = 1;	2011	gsm->dead = 1;
2009		2012
@@ -2017,6 +2020,13 @@ void gsm_cleanup_mux(struct gsm_mux *gsm) · 7 unmodified lines
2017	spin_unlock(&gsm_mux_lock);	2020	spin_unlock(&gsm_mux_lock);
2018	WARN_ON(i == MAX_MUX);	2021	WARN_ON(i == MAX_MUX);
2019		2022
		2023	/* In theory disconnecting DLCI 0 is sufficient but for some
		2024	modems this is apparently not the case. */
		2025	if (dlci) {
		2026	gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
		2027	if (gc)
		2028	gsm_control_wait(gsm, gc);
		2029	}
2020	del_timer_sync(&gsm->t2_timer);	2030	del_timer_sync(&gsm->t2_timer);
2021	/* Now we are sure T2 has stopped */	2031	/* Now we are sure T2 has stopped */
2022	if (dlci) {	2032	if (dlci) {
@@ -2982,7 +2992,7 @@ static int gsmtty_tiocmset(struct tty_struct *tty, · 959 unmodified lines
2982	struct gsm_dlci *dlci = tty->driver_data;	2992	struct gsm_dlci *dlci = tty->driver_data;
2983	unsigned int modem_tx = dlci->modem_tx;	2993	unsigned int modem_tx = dlci->modem_tx;
2984		2994
2985	modem_tx &= clear;	2995	modem_tx &= ~clear;
2986	modem_tx \|= set;	2996	modem_tx \|= set;
2987		2997
2988	if (modem_tx != dlci->modem_tx) {	2998	if (modem_tx != dlci->modem_tx) {

drivers/tty/pty.c+16−10

@@ -670,12 +670,18 @@ static int ptmx_open(struct inode inode, struct file filp) · 669 unmodified lines
670		670
671	nonseekable_open(inode, filp);	671	nonseekable_open(inode, filp);
672		672
		673	retval = tty_alloc_file(filp);
		674	if (retval)
		675	return retval;
		676
673	/* find a device that is not in use. */	677	/* find a device that is not in use. */
674	tty_lock();	678	tty_lock();
675	index = devpts_new_index(inode);	679	index = devpts_new_index(inode);
676	tty_unlock();	680	tty_unlock();
677	if (index < 0)	681	if (index < 0) {
678	return index;	682	retval = index;
		683	goto err_file;
		684	}
679		685
680	mutex_lock(&tty_mutex);	686	mutex_lock(&tty_mutex);
681	tty_lock();	687	tty_lock();
@@ -689,27 +695,27 @@ static int ptmx_open(struct inode inode, struct file filp) · 7 unmodified lines
689		695
690	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */	696	set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
691		697
692	retval = tty_add_file(tty, filp);	698	tty_add_file(tty, filp);
693	if (retval)
694	goto out;
695		699
696	retval = devpts_pty_new(inode, tty->link);	700	retval = devpts_pty_new(inode, tty->link);
697	if (retval)	701	if (retval)
698	goto out1;	702	goto err_release;
699		703
700	retval = ptm_driver->ops->open(tty, filp);	704	retval = ptm_driver->ops->open(tty, filp);
701	if (retval)	705	if (retval)
702	goto out2;	706	goto err_release;
703	out1:	707
704	tty_unlock();	708	tty_unlock();
705	return retval;	709	return 0;
706	out2:	710	err_release:
707	tty_unlock();	711	tty_unlock();
708	tty_release(inode, filp);	712	tty_release(inode, filp);
709	return retval;	713	return retval;
710	out:	714	out:
711	devpts_kill_index(inode, index);	715	devpts_kill_index(inode, index);
712	tty_unlock();	716	tty_unlock();
		717	err_file:
		718	tty_free_file(filp);
713	return retval;	719	return retval;
714	}	720	}
715		721

drivers/tty/serial/68328serial.c+1−36

@@ -235,22 +235,6 @@ static void batten_down_hatches(void) · 234 unmodified lines
235		235
236	static void status_handle(struct m68k_serial *info, unsigned short status)	236	static void status_handle(struct m68k_serial *info, unsigned short status)
237	{	237	{
238	#if 0
239	if(status & DCD) {
240	if((info->port.tty->termios->c_cflag & CRTSCTS) &&
241	((info->curregs[3] & AUTO_ENAB)==0)) {
242	info->curregs[3] \|= AUTO_ENAB;
243	info->pendregs[3] \|= AUTO_ENAB;
244	write_zsreg(info->m68k_channel, 3, info->curregs[3]);
245	}
246	} else {
247	if((info->curregs[3] & AUTO_ENAB)) {
248	info->curregs[3] &= ~AUTO_ENAB;
249	info->pendregs[3] &= ~AUTO_ENAB;
250	write_zsreg(info->m68k_channel, 3, info->curregs[3]);
251	}
252	}
253	#endif
254	/* If this is console input and this is a	238	/* If this is console input and this is a
255	* 'break asserted' status change interrupt	239	* 'break asserted' status change interrupt
256	* see if we can drop into the debugger	240	* see if we can drop into the debugger
@@ -340,9 +324,6 @@ static void transmit_chars(struct m68k_serial *info) · 83 unmodified lines
340	info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);	324	info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
341	info->xmit_cnt--;	325	info->xmit_cnt--;
342		326
343	if (info->xmit_cnt < WAKEUP_CHARS)
344	schedule_work(&info->tqueue);
345
346	if(info->xmit_cnt <= 0) {	327	if(info->xmit_cnt <= 0) {
347	/* All done for now... TX ints off */	328	/* All done for now... TX ints off */
348	uart->ustcnt &= ~USTCNT_TX_INTR_MASK;	329	uart->ustcnt &= ~USTCNT_TX_INTR_MASK;
@@ -378,21 +359,6 @@ irqreturn_t rs_interrupt(int irq, void *dev_id) · 29 unmodified lines
378	return IRQ_HANDLED;	359	return IRQ_HANDLED;
379	}	360	}
380		361
381	static void do_softint(struct work_struct *work)
382	{
383	struct m68k_serial *info = container_of(work, struct m68k_serial, tqueue);
384	struct tty_struct *tty;
385
386	tty = info->tty;
387	if (!tty)
388	return;
389	#if 0
390	if (clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) {
391	tty_wakeup(tty);
392	}
393	#endif
394	}
395
396	static int startup(struct m68k_serial * info)	362	static int startup(struct m68k_serial * info)
397	{	363	{
398	m68328_uart *uart = &uart_addr[info->line];	364	m68328_uart *uart = &uart_addr[info->line];
@@ -1324,7 +1290,6 @@ rs68328_init(void) · 925 unmodified lines
1324	info->event = 0;	1290	info->event = 0;
1325	info->count = 0;	1291	info->count = 0;
1326	info->blocked_open = 0;	1292	info->blocked_open = 0;
1327	INIT_WORK(&info->tqueue, do_softint);
1328	init_waitqueue_head(&info->open_wait);	1293	init_waitqueue_head(&info->open_wait);
1329	init_waitqueue_head(&info->close_wait);	1294	init_waitqueue_head(&info->close_wait);
1330	info->line = i;	1295	info->line = i;
@@ -1341,7 +1306,7 @@ rs68328_init(void) · 10 unmodified lines
1341		1306
1342	if (request_irq(uart_irqs[i],	1307	if (request_irq(uart_irqs[i],
1343	rs_interrupt,	1308	rs_interrupt,
1344	IRQF_DISABLED,	1309	0,
1345	"M68328_UART", info))	1310	"M68328_UART", info))
1346	panic("Unable to attach 68328 serial interrupt\n");	1311	panic("Unable to attach 68328 serial interrupt\n");
1347	}	1312	}

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

@@ -158,7 +158,6 @@ struct m68k_serial { · 157 unmodified lines
158	int xmit_head;	158	int xmit_head;
159	int xmit_tail;	159	int xmit_tail;
160	int xmit_cnt;	160	int xmit_cnt;
161	struct work_struct tqueue;
162	wait_queue_head_t open_wait;	161	wait_queue_head_t open_wait;
163	wait_queue_head_t close_wait;	162	wait_queue_head_t close_wait;
164	};	163	};

drivers/tty/serial/8250.c+57−75

 				  UART_FCR_T_TRIG_01,
 		.flags		= UART_CAP_FIFO | UART_CAP_RTOIE,
 	},
+	[PORT_XR17D15X] = {
+		.name		= "XR17D15X",
+		.fifo_size	= 64,
+		.tx_loadsz	= 64,
+		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
+		.flags		= UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR,
+	},
 };
 #if defined(CONFIG_MIPS_ALCHEMY)
 		writeb(value, p->membase + offset);
 }
-/* Save the LCR value so it can be re-written when a Busy Detect IRQ occurs. */
-static inline void dwapb_save_out_value(struct uart_port *p, int offset,
-					int value)
-{
-	struct uart_8250_port *up =
-		container_of(p, struct uart_8250_port, port);
-	if (offset == UART_LCR)
-		up->lcr = value;
-}
-/* Read the IER to ensure any interrupt is cleared before returning from ISR. */
-static inline void dwapb_check_clear_ier(struct uart_port *p, int offset)
-{
-	if (offset == UART_TX || offset == UART_IER)
-		p->serial_in(p, UART_IER);
-}
-static void dwapb_serial_out(struct uart_port *p, int offset, int value)
-{
-	int save_offset = offset;
-	offset = map_8250_out_reg(p, offset) << p->regshift;
-	dwapb_save_out_value(p, save_offset, value);
-	writeb(value, p->membase + offset);
-	dwapb_check_clear_ier(p, save_offset);
-}
-static void dwapb32_serial_out(struct uart_port *p, int offset, int value)
-{
-	int save_offset = offset;
-	offset = map_8250_out_reg(p, offset) << p->regshift;
-	dwapb_save_out_value(p, save_offset, value);
-	writel(value, p->membase + offset);
-	dwapb_check_clear_ier(p, save_offset);
-}
 static unsigned int io_serial_in(struct uart_port *p, int offset)
 {
 	offset = map_8250_in_reg(p, offset) << p->regshift;
 	outb(value, p->iobase + offset);
 }
+static int serial8250_default_handle_irq(struct uart_port *port);
 static void set_io_from_upio(struct uart_port *p)
 {
 	struct uart_8250_port *up =
 		p->serial_out = tsi_serial_out;
 		break;
-	case UPIO_DWAPB:
-		p->serial_in = mem_serial_in;
-		p->serial_out = dwapb_serial_out;
-		break;
-	case UPIO_DWAPB32:
-		p->serial_in = mem32_serial_in;
-		p->serial_out = dwapb32_serial_out;
-		break;
 	default:
 		p->serial_in = io_serial_in;
 		p->serial_out = io_serial_out;
 	}
 	/* Remember loaded iotype */
 	up->cur_iotype = p->iotype;
+	p->handle_irq = serial8250_default_handle_irq;
 }
 static void
 	case UPIO_MEM:
 	case UPIO_MEM32:
 	case UPIO_AU:
-	case UPIO_DWAPB:
-	case UPIO_DWAPB32:
 		p->serial_out(p, offset, value);
 		p->serial_in(p, UART_LCR);	/* safe, no side-effects */
 		break;
 	}
 	serial_outp(up, UART_IER, iersave);
+	/*
+	 * Exar uarts have EFR in a weird location
+	 */
+	if (up->port.flags & UPF_EXAR_EFR) {
+		up->port.type = PORT_XR17D15X;
+		up->capabilities |= UART_CAP_AFE | UART_CAP_EFR;
+	}
 	/*
 	 * We distinguish between 16550A and U6 16550A by counting
 	 * how many bytes are in the FIFO.
 	spin_unlock_irqrestore(&up->port.lock, flags);
 }
+int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
+{
+	struct uart_8250_port *up =
+		container_of(port, struct uart_8250_port, port);
+	if (!(iir & UART_IIR_NO_INT)) {
+		serial8250_handle_port(up);
+		return 1;
+	}
+	return 0;
+}
+EXPORT_SYMBOL_GPL(serial8250_handle_irq);
+static int serial8250_default_handle_irq(struct uart_port *port)
+{
+	struct uart_8250_port *up =
+		container_of(port, struct uart_8250_port, port);
+	unsigned int iir = serial_in(up, UART_IIR);
+	return serial8250_handle_irq(port, iir);
+}
 /*
  * This is the serial driver's interrupt routine.
  *
 	l = i->head;
 	do {
 		struct uart_8250_port *up;
-		unsigned int iir;
+		struct uart_port *port;
 		up = list_entry(l, struct uart_8250_port, list);
+		port = &up->port;
-		iir = serial_in(up, UART_IIR);
+		if (port->handle_irq(port)) {
-		if (!(iir & UART_IIR_NO_INT)) {
-			serial8250_handle_port(up);
 			handled = 1;
-			end = NULL;
-		} else if ((up->port.iotype == UPIO_DWAPB ||
-			    up->port.iotype == UPIO_DWAPB32) &&
-			  (iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
-			/* The DesignWare APB UART has an Busy Detect (0x07)
-			 * interrupt meaning an LCR write attempt occurred while the
-			 * UART was busy. The interrupt must be cleared by reading
-			 * the UART status register (USR) and the LCR re-written. */
-			unsigned int status;
-			status = *(volatile u32 *)up->port.private_data;
-			serial_out(up, UART_LCR, up->lcr);
-			handled = 1;
 			end = NULL;
 		} else if (end == NULL)
 			end = l;
 	 */
 	if (!(up->port.flags & UPF_BUGGY_UART) &&
 	    (serial_inp(up, UART_LSR) == 0xff)) {
-		printk(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
+		printk_ratelimited(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
-		       serial_index(&up->port));
+				   serial_index(&up->port));
 		return -ENODEV;
 	}
 			efr |= UART_EFR_CTS;
 		serial_outp(up, UART_LCR, UART_LCR_CONF_MODE_B);
-		serial_outp(up, UART_EFR, efr);
+		if (up->port.flags & UPF_EXAR_EFR)
+			serial_outp(up, UART_XR_EFR, efr);
+		else
+			serial_outp(up, UART_EFR, efr);
 	}
 #ifdef CONFIG_ARCH_OMAP
 	case UPIO_TSI:
 	case UPIO_MEM32:
 	case UPIO_MEM:
-	case UPIO_DWAPB:
-	case UPIO_DWAPB32:
 		if (!up->port.mapbase)
 			break;
 	case UPIO_TSI:
 	case UPIO_MEM32:
 	case UPIO_MEM:
-	case UPIO_DWAPB:
-	case UPIO_DWAPB32:
 		if (!up->port.mapbase)
 			break;
 		p->serial_in = port->serial_in;
 	if (port->serial_out)
 		p->serial_out = port->serial_out;
+	if (port->handle_irq)
+		p->handle_irq = port->handle_irq;
+	else
+		p->handle_irq = serial8250_default_handle_irq;
 	return 0;
 }
 		port.type		= p->type;
 		port.serial_in		= p->serial_in;
 		port.serial_out		= p->serial_out;
+		port.handle_irq		= p->handle_irq;
 		port.set_termios	= p->set_termios;
 		port.pm			= p->pm;
 		port.dev		= &dev->dev;
 			uart->port.serial_in = port->serial_in;
 		if (port->serial_out)
 			uart->port.serial_out = port->serial_out;
+		if (port->handle_irq)
+			uart->port.handle_irq = port->handle_irq;
 		/*  Possibly override set_termios call */
 		if (port->set_termios)
 			uart->port.set_termios = port->set_termios;

drivers/tty/serial/8250_dw.c+194−0

@@ -0,0 +1,194 @@
	1	/*
	2	* Synopsys DesignWare 8250 driver.
	3	*
	4	* Copyright 2011 Picochip, Jamie Iles.
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* The Synopsys DesignWare 8250 has an extra feature whereby it detects if the
	12	* LCR is written whilst busy. If it is, then a busy detect interrupt is
	13	* raised, the LCR needs to be rewritten and the uart status register read.
	14	*/
	15	#include <linux/device.h>
	16	#include <linux/init.h>
	17	#include <linux/io.h>
	18	#include <linux/module.h>
	19	#include <linux/serial_8250.h>
	20	#include <linux/serial_core.h>
	21	#include <linux/serial_reg.h>
	22	#include <linux/of.h>
	23	#include <linux/of_irq.h>
	24	#include <linux/of_platform.h>
	25	#include <linux/platform_device.h>
	26	#include <linux/slab.h>
	27
	28	struct dw8250_data {
	29	int last_lcr;
	30	int line;
	31	};
	32
	33	static void dw8250_serial_out(struct uart_port *p, int offset, int value)
	34	{
	35	struct dw8250_data *d = p->private_data;
	36
	37	if (offset == UART_LCR)
	38	d->last_lcr = value;
	39
	40	offset <<= p->regshift;
	41	writeb(value, p->membase + offset);
	42	}
	43
	44	static unsigned int dw8250_serial_in(struct uart_port *p, int offset)
	45	{
	46	offset <<= p->regshift;
	47
	48	return readb(p->membase + offset);
	49	}
	50
	51	static void dw8250_serial_out32(struct uart_port *p, int offset, int value)
	52	{
	53	struct dw8250_data *d = p->private_data;
	54
	55	if (offset == UART_LCR)
	56	d->last_lcr = value;
	57
	58	offset <<= p->regshift;
	59	writel(value, p->membase + offset);
	60	}
	61
	62	static unsigned int dw8250_serial_in32(struct uart_port *p, int offset)
	63	{
	64	offset <<= p->regshift;
	65
	66	return readl(p->membase + offset);
	67	}
	68
	69	/* Offset for the DesignWare's UART Status Register. */
	70	#define UART_USR 0x1f
	71
	72	static int dw8250_handle_irq(struct uart_port *p)
	73	{
	74	struct dw8250_data *d = p->private_data;
	75	unsigned int iir = p->serial_in(p, UART_IIR);
	76
	77	if (serial8250_handle_irq(p, iir)) {
	78	return 1;
	79	} else if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
	80	/* Clear the USR and write the LCR again. */
	81	(void)p->serial_in(p, UART_USR);
	82	p->serial_out(p, d->last_lcr, UART_LCR);
	83
	84	return 1;
	85	}
	86
	87	return 0;
	88	}
	89
	90	static int __devinit dw8250_probe(struct platform_device *pdev)
	91	{
	92	struct uart_port port = {};
	93	struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	94	struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	95	struct device_node *np = pdev->dev.of_node;
	96	u32 val;
	97	struct dw8250_data *data;
	98
	99	if (!regs \|\| !irq) {
	100	dev_err(&pdev->dev, "no registers/irq defined\n");
	101	return -EINVAL;
	102	}
	103
	104	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	105	if (!data)
	106	return -ENOMEM;
	107	port.private_data = data;
	108
	109	spin_lock_init(&port.lock);
	110	port.mapbase = regs->start;
	111	port.irq = irq->start;
	112	port.handle_irq = dw8250_handle_irq;
	113	port.type = PORT_8250;
	114	port.flags = UPF_SHARE_IRQ \| UPF_BOOT_AUTOCONF \| UPF_IOREMAP \|
	115	UPF_FIXED_PORT \| UPF_FIXED_TYPE;
	116	port.dev = &pdev->dev;
	117
	118	port.iotype = UPIO_MEM;
	119	port.serial_in = dw8250_serial_in;
	120	port.serial_out = dw8250_serial_out;
	121	if (!of_property_read_u32(np, "reg-io-width", &val)) {
	122	switch (val) {
	123	case 1:
	124	break;
	125	case 4:
	126	port.iotype = UPIO_MEM32;
	127	port.serial_in = dw8250_serial_in32;
	128	port.serial_out = dw8250_serial_out32;
	129	break;
	130	default:
	131	dev_err(&pdev->dev, "unsupported reg-io-width (%u)\n",
	132	val);
	133	return -EINVAL;
	134	}
	135	}
	136
	137	if (!of_property_read_u32(np, "reg-shift", &val))
	138	port.regshift = val;
	139
	140	if (of_property_read_u32(np, "clock-frequency", &val)) {
	141	dev_err(&pdev->dev, "no clock-frequency property set\n");
	142	return -EINVAL;
	143	}
	144	port.uartclk = val;
	145
	146	data->line = serial8250_register_port(&port);
	147	if (data->line < 0)
	148	return data->line;
	149
	150	platform_set_drvdata(pdev, data);
	151
	152	return 0;
	153	}
	154
	155	static int __devexit dw8250_remove(struct platform_device *pdev)
	156	{
	157	struct dw8250_data *data = platform_get_drvdata(pdev);
	158
	159	serial8250_unregister_port(data->line);
	160
	161	return 0;
	162	}
	163
	164	static const struct of_device_id dw8250_match[] = {
	165	{ .compatible = "snps,dw-apb-uart" },
	166	{ /* Sentinel */ }
	167	};
	168	MODULE_DEVICE_TABLE(of, dw8250_match);
	169
	170	static struct platform_driver dw8250_platform_driver = {
	171	.driver = {
	172	.name = "dw-apb-uart",
	173	.owner = THIS_MODULE,
	174	.of_match_table = dw8250_match,
	175	},
	176	.probe = dw8250_probe,
	177	.remove = __devexit_p(dw8250_remove),
	178	};
	179
	180	static int __init dw8250_init(void)
	181	{
	182	return platform_driver_register(&dw8250_platform_driver);
	183	}
	184	module_init(dw8250_init);
	185
	186	static void __exit dw8250_exit(void)
	187	{
	188	platform_driver_unregister(&dw8250_platform_driver);
	189	}
	190	module_exit(dw8250_exit);
	191
	192	MODULE_AUTHOR("Jamie Iles");
	193	MODULE_LICENSE("GPL");
	194	MODULE_DESCRIPTION("Synopsys DesignWare 8250 serial port driver");

drivers/tty/serial/8250_pci.c+42−0

 #endif
 }
+static int
+pci_xr17c154_setup(struct serial_private *priv,
+		  const struct pciserial_board *board,
+		  struct uart_port *port, int idx)
+{
+	port->flags |= UPF_EXAR_EFR;
+	return pci_default_setup(priv, board, port, idx);
+}
 /* This should be in linux/pci_ids.h */
 #define PCI_VENDOR_ID_SBSMODULARIO	0x124B
 #define PCI_SUBVENDOR_ID_SBSMODULARIO	0x124B
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_timedia_setup,
 	},
+	/*
+	 * Exar cards
+	 */
+	{
+		.vendor = PCI_VENDOR_ID_EXAR,
+		.device = PCI_DEVICE_ID_EXAR_XR17C152,
+		.subvendor	= PCI_ANY_ID,
+		.subdevice	= PCI_ANY_ID,
+		.setup		= pci_xr17c154_setup,
+	},
+	{
+		.vendor = PCI_VENDOR_ID_EXAR,
+		.device = PCI_DEVICE_ID_EXAR_XR17C154,
+		.subvendor	= PCI_ANY_ID,
+		.subdevice	= PCI_ANY_ID,
+		.setup		= pci_xr17c154_setup,
+	},
+	{
+		.vendor = PCI_VENDOR_ID_EXAR,
+		.device = PCI_DEVICE_ID_EXAR_XR17C158,
+		.subvendor	= PCI_ANY_ID,
+		.subdevice	= PCI_ANY_ID,
+		.setup		= pci_xr17c154_setup,
+	},
 	/*
 	 * Xircom cards
 	 */
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8811,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8812,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8813,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8814,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x8027,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x8028,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x8029,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x800C,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x800D,
 		.init		= pci_eg20t_init,
+		.setup		= pci_default_setup,
 	},
 	/*
 	 * Cronyx Omega PCI (PLX-chip based)

drivers/tty/serial/Kconfig+10−20

 	  port hardware found on MIPS RM9122 and similar processors.
 	  If unsure, say N.
+config SERIAL_8250_DW
+	tristate "Support for Synopsys DesignWare 8250 quirks"
+	depends on SERIAL_8250 && OF
+	help
+	  Selecting this option will enable handling of the extra features
+	  present in the Synopsys DesignWare APB UART.
 comment "Non-8250 serial port support"
 config SERIAL_AMBA_PL010
 config SERIAL_S5PV210
 	tristate "Samsung S5PV210 Serial port support"
-	depends on SERIAL_SAMSUNG && (CPU_S5PV210 || CPU_EXYNOS4210)
+	depends on SERIAL_SAMSUNG && (CPU_S5PV210 || CPU_EXYNOS4210 || SOC_EXYNOS4212)
-	select SERIAL_SAMSUNG_UARTS_4 if (CPU_S5PV210 || CPU_EXYNOS4210)
+	select SERIAL_SAMSUNG_UARTS_4 if (CPU_S5PV210 || CPU_EXYNOS4210 || SOC_EXYNOS4212)
 	default y
 	help
 	  Serial port support for Samsung's S5P Family of SoC's
 	  Add support for the built-in UARTs on the Blackfin.
 	  To compile this driver as a module, choose M here: the
-	  module will be called bfin_5xx.
+	  module is named bfin_uart.ko.
 config SERIAL_BFIN_CONSOLE
 	bool "Console on Blackfin serial port"
 	help
 	  Enable a ColdFire internal serial port to be the system console.
-config SERIAL_68360_SMC
-	bool "68360 SMC uart support"
-	depends on M68360
-	help
-	  This driver supports the SMC serial ports of the Motorola 68360 CPU.
-config SERIAL_68360_SCC
-	bool "68360 SCC uart support"
-	depends on M68360
-	help
-	  This driver supports the SCC serial ports of the Motorola 68360 CPU.
-config SERIAL_68360
-	bool
-	depends on SERIAL_68360_SMC || SERIAL_68360_SCC
-	default y
 config SERIAL_PMACZILOG
 	tristate "Mac or PowerMac z85c30 ESCC support"
 	depends on (M68K && MAC) || (PPC_OF && PPC_PMAC)

drivers/tty/serial/Makefile+2−2

 obj-$(CONFIG_SERIAL_8250_EXAR_ST16C554) += 8250_exar_st16c554.o
 obj-$(CONFIG_SERIAL_8250_HUB6) += 8250_hub6.o
 obj-$(CONFIG_SERIAL_8250_MCA) += 8250_mca.o
+obj-$(CONFIG_SERIAL_8250_DW) += 8250_dw.o
 obj-$(CONFIG_SERIAL_AMBA_PL010) += amba-pl010.o
 obj-$(CONFIG_SERIAL_AMBA_PL011) += amba-pl011.o
 obj-$(CONFIG_SERIAL_CLPS711X) += clps711x.o
 obj-$(CONFIG_SERIAL_PNX8XXX) += pnx8xxx_uart.o
 obj-$(CONFIG_SERIAL_SA1100) += sa1100.o
 obj-$(CONFIG_SERIAL_BCM63XX) += bcm63xx_uart.o
-obj-$(CONFIG_SERIAL_BFIN) += bfin_5xx.o
+obj-$(CONFIG_SERIAL_BFIN) += bfin_uart.o
 obj-$(CONFIG_SERIAL_BFIN_SPORT) += bfin_sport_uart.o
 obj-$(CONFIG_SERIAL_SAMSUNG) += samsung.o
 obj-$(CONFIG_SERIAL_S3C2410) += s3c2410.o
 obj-$(CONFIG_SERIAL_IP22_ZILOG) += ip22zilog.o
 obj-$(CONFIG_SERIAL_MUX) += mux.o
 obj-$(CONFIG_SERIAL_68328) += 68328serial.o
-obj-$(CONFIG_SERIAL_68360) += 68360serial.o
 obj-$(CONFIG_SERIAL_MCF) += mcf.o
 obj-$(CONFIG_SERIAL_PMACZILOG) += pmac_zilog.o
 obj-$(CONFIG_SERIAL_DZ) += dz.o

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

@@ -218,7 +218,7 @@ static int altera_jtaguart_startup(struct uart_port *port) · 217 unmodified lines
218	unsigned long flags;	218	unsigned long flags;
219	int ret;	219	int ret;
220		220
221	ret = request_irq(port->irq, altera_jtaguart_interrupt, IRQF_DISABLED,	221	ret = request_irq(port->irq, altera_jtaguart_interrupt, 0,
222	DRV_NAME, port);	222	DRV_NAME, port);
223	if (ret) {	223	if (ret) {
224	pr_err(DRV_NAME ": unable to attach Altera JTAG UART %d "	224	pr_err(DRV_NAME ": unable to attach Altera JTAG UART %d "

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

@@ -315,7 +315,7 @@ static int altera_uart_startup(struct uart_port *port) · 314 unmodified lines
315	return 0;	315	return 0;
316	}	316	}
317		317
318	ret = request_irq(port->irq, altera_uart_interrupt, IRQF_DISABLED,	318	ret = request_irq(port->irq, altera_uart_interrupt, 0,
319	DRV_NAME, port);	319	DRV_NAME, port);
320	if (ret) {	320	if (ret) {
321	pr_err(DRV_NAME ": unable to attach Altera UART %d "	321	pr_err(DRV_NAME ": unable to attach Altera UART %d "

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

@@ -16,6 +16,7 @@ · 15 unmodified lines
16		16
17	#include <linux/module.h>	17	#include <linux/module.h>
18	#include <linux/tty.h>	18	#include <linux/tty.h>
		19	#include <linux/tty_flip.h>
19	#include <linux/ioport.h>	20	#include <linux/ioport.h>
20	#include <linux/init.h>	21	#include <linux/init.h>
21	#include <linux/serial.h>	22	#include <linux/serial.h>

drivers/tty/serial/atmel_serial.c+111−17

@@ -33,6 +33,8 @@ · 32 unmodified lines
33	#include <linux/sysrq.h>	33	#include <linux/sysrq.h>
34	#include <linux/tty_flip.h>	34	#include <linux/tty_flip.h>
35	#include <linux/platform_device.h>	35	#include <linux/platform_device.h>
		36	#include <linux/of.h>
		37	#include <linux/of_device.h>
36	#include <linux/dma-mapping.h>	38	#include <linux/dma-mapping.h>
37	#include <linux/atmel_pdc.h>	39	#include <linux/atmel_pdc.h>
38	#include <linux/atmel_serial.h>	40	#include <linux/atmel_serial.h>
@@ -157,11 +159,22 @@ struct atmel_uart_port { · 118 unmodified lines
157	};	159	};
158		160
159	static struct atmel_uart_port atmel_ports[ATMEL_MAX_UART];	161	static struct atmel_uart_port atmel_ports[ATMEL_MAX_UART];
		162	static unsigned long atmel_ports_in_use;
160		163
161	#ifdef SUPPORT_SYSRQ	164	#ifdef SUPPORT_SYSRQ
162	static struct console atmel_console;	165	static struct console atmel_console;
163	#endif	166	#endif
164		167
		168	#if defined(CONFIG_OF)
		169	static const struct of_device_id atmel_serial_dt_ids[] = {
		170	{ .compatible = "atmel,at91rm9200-usart" },
		171	{ .compatible = "atmel,at91sam9260-usart" },
		172	{ /* sentinel */ }
		173	};
		174
		175	MODULE_DEVICE_TABLE(of, atmel_serial_dt_ids);
		176	#endif
		177
165	static inline struct atmel_uart_port *	178	static inline struct atmel_uart_port *
166	to_atmel_uart_port(struct uart_port *uart)	179	to_atmel_uart_port(struct uart_port *uart)
167	{	180	{
@@ -339,7 +352,8 @@ static void atmel_stop_tx(struct uart_port *port) · 171 unmodified lines
339	/* Disable interrupts */	352	/* Disable interrupts */
340	UART_PUT_IDR(port, atmel_port->tx_done_mask);	353	UART_PUT_IDR(port, atmel_port->tx_done_mask);
341		354
342	if (atmel_port->rs485.flags & SER_RS485_ENABLED)	355	if ((atmel_port->rs485.flags & SER_RS485_ENABLED) &&
		356	!(atmel_port->rs485.flags & SER_RS485_RX_DURING_TX))
343	atmel_start_rx(port);	357	atmel_start_rx(port);
344	}	358	}
345		359
@@ -356,7 +370,8 @@ static void atmel_start_tx(struct uart_port *port) · 10 unmodified lines
356	really need this.*/	370	really need this.*/
357	return;	371	return;
358		372
359	if (atmel_port->rs485.flags & SER_RS485_ENABLED)	373	if ((atmel_port->rs485.flags & SER_RS485_ENABLED) &&
		374	!(atmel_port->rs485.flags & SER_RS485_RX_DURING_TX))
360	atmel_stop_rx(port);	375	atmel_stop_rx(port);
361		376
362	/* re-enable PDC transmit */	377	/* re-enable PDC transmit */
@@ -680,7 +695,8 @@ static void atmel_tx_dma(struct uart_port *port) · 317 unmodified lines
680	/* Enable interrupts */	695	/* Enable interrupts */
681	UART_PUT_IER(port, atmel_port->tx_done_mask);	696	UART_PUT_IER(port, atmel_port->tx_done_mask);
682	} else {	697	} else {
683	if (atmel_port->rs485.flags & SER_RS485_ENABLED) {	698	if ((atmel_port->rs485.flags & SER_RS485_ENABLED) &&
		699	!(atmel_port->rs485.flags & SER_RS485_RX_DURING_TX)) {
684	/* DMA done, stop TX, start RX for RS485 */	700	/* DMA done, stop TX, start RX for RS485 */
685	atmel_start_rx(port);	701	atmel_start_rx(port);
686	}	702	}
@@ -1407,6 +1423,48 @@ static struct uart_ops atmel_pops = { · 720 unmodified lines
1407	#endif	1423	#endif
1408	};	1424	};
1409		1425
		1426	static void __devinit atmel_of_init_port(struct atmel_uart_port *atmel_port,
		1427	struct device_node *np)
		1428	{
		1429	u32 rs485_delay[2];
		1430
		1431	/* DMA/PDC usage specification */
		1432	if (of_get_property(np, "atmel,use-dma-rx", NULL))
		1433	atmel_port->use_dma_rx = 1;
		1434	else
		1435	atmel_port->use_dma_rx = 0;
		1436	if (of_get_property(np, "atmel,use-dma-tx", NULL))
		1437	atmel_port->use_dma_tx = 1;
		1438	else
		1439	atmel_port->use_dma_tx = 0;
		1440
		1441	/* rs485 properties */
		1442	if (of_property_read_u32_array(np, "rs485-rts-delay",
		1443	rs485_delay, 2) == 0) {
		1444	struct serial_rs485 *rs485conf = &atmel_port->rs485;
		1445
		1446	rs485conf->delay_rts_before_send = rs485_delay[0];
		1447	rs485conf->delay_rts_after_send = rs485_delay[1];
		1448	rs485conf->flags = 0;
		1449
		1450	if (rs485conf->delay_rts_before_send == 0 &&
		1451	rs485conf->delay_rts_after_send == 0) {
		1452	rs485conf->flags \|= SER_RS485_RTS_ON_SEND;
		1453	} else {
		1454	if (rs485conf->delay_rts_before_send)
		1455	rs485conf->flags \|= SER_RS485_RTS_BEFORE_SEND;
		1456	if (rs485conf->delay_rts_after_send)
		1457	rs485conf->flags \|= SER_RS485_RTS_AFTER_SEND;
		1458	}
		1459
		1460	if (of_get_property(np, "rs485-rx-during-tx", NULL))
		1461	rs485conf->flags \|= SER_RS485_RX_DURING_TX;
		1462
		1463	if (of_get_property(np, "linux,rs485-enabled-at-boot-time", NULL))
		1464	rs485conf->flags \|= SER_RS485_ENABLED;
		1465	}
		1466	}
		1467
1410	/*	1468	/*
1411	* Configure the port from the platform device resource info.	1469	* Configure the port from the platform device resource info.
1412	*/	1470	*/
@@ -1414,13 +1472,20 @@ static void __devinit atmel_init_port(struct atmel_uart_port *atmel_port, · 1 unmodified line
1414	struct platform_device *pdev)	1472	struct platform_device *pdev)
1415	{	1473	{
1416	struct uart_port *port = &atmel_port->uart;	1474	struct uart_port *port = &atmel_port->uart;
1417	struct atmel_uart_data *data = pdev->dev.platform_data;	1475	struct atmel_uart_data *pdata = pdev->dev.platform_data;
		1476
		1477	if (pdev->dev.of_node) {
		1478	atmel_of_init_port(atmel_port, pdev->dev.of_node);
		1479	} else {
		1480	atmel_port->use_dma_rx = pdata->use_dma_rx;
		1481	atmel_port->use_dma_tx = pdata->use_dma_tx;
		1482	atmel_port->rs485 = pdata->rs485;
		1483	}
1418		1484
1419	port->iotype = UPIO_MEM;	1485	port->iotype = UPIO_MEM;
1420	port->flags = UPF_BOOT_AUTOCONF;	1486	port->flags = UPF_BOOT_AUTOCONF;
1421	port->ops = &atmel_pops;	1487	port->ops = &atmel_pops;
1422	port->fifosize = 1;	1488	port->fifosize = 1;
1423	port->line = data->num;
1424	port->dev = &pdev->dev;	1489	port->dev = &pdev->dev;
1425	port->mapbase = pdev->resource[0].start;	1490	port->mapbase = pdev->resource[0].start;
1426	port->irq = pdev->resource[1].start;	1491	port->irq = pdev->resource[1].start;
@@ -1430,10 +1495,10 @@ static void __devinit atmel_init_port(struct atmel_uart_port *atmel_port, · 3 unmodified lines
1430		1495
1431	memset(&atmel_port->rx_ring, 0, sizeof(atmel_port->rx_ring));	1496	memset(&atmel_port->rx_ring, 0, sizeof(atmel_port->rx_ring));
1432		1497
1433	if (data->regs)	1498	if (pdata && pdata->regs) {
1434	/* Already mapped by setup code */	1499	/* Already mapped by setup code */
1435	port->membase = data->regs;	1500	port->membase = pdata->regs;
1436	else {	1501	} else {
1437	port->flags \|= UPF_IOREMAP;	1502	port->flags \|= UPF_IOREMAP;
1438	port->membase = NULL;	1503	port->membase = NULL;
1439	}	1504	}
@@ -1447,9 +1512,6 @@ static void __devinit atmel_init_port(struct atmel_uart_port *atmel_port, · 7 unmodified lines
1447	/* only enable clock when USART is in use */	1512	/* only enable clock when USART is in use */
1448	}	1513	}
1449		1514
1450	atmel_port->use_dma_rx = data->use_dma_rx;
1451	atmel_port->use_dma_tx = data->use_dma_tx;
1452	atmel_port->rs485 = data->rs485;
1453	/* Use TXEMPTY for interrupt when rs485 else TXRDY or ENDTX\|TXBUFE */	1515	/* Use TXEMPTY for interrupt when rs485 else TXRDY or ENDTX\|TXBUFE */
1454	if (atmel_port->rs485.flags & SER_RS485_ENABLED)	1516	if (atmel_port->rs485.flags & SER_RS485_ENABLED)
1455	atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;	1517	atmel_port->tx_done_mask = ATMEL_US_TXEMPTY;
@@ -1611,10 +1673,14 @@ static int __init atmel_console_init(void) · 155 unmodified lines
1611	if (atmel_default_console_device) {	1673	if (atmel_default_console_device) {
1612	struct atmel_uart_data *pdata =	1674	struct atmel_uart_data *pdata =
1613	atmel_default_console_device->dev.platform_data;	1675	atmel_default_console_device->dev.platform_data;
		1676	int id = pdata->num;
		1677	struct atmel_uart_port *port = &atmel_ports[id];
		1678
		1679	port->backup_imr = 0;
		1680	port->uart.line = id;
1614		1681
1615	add_preferred_console(ATMEL_DEVICENAME, pdata->num, NULL);	1682	add_preferred_console(ATMEL_DEVICENAME, id, NULL);
1616	atmel_init_port(&atmel_ports[pdata->num],	1683	atmel_init_port(port, atmel_default_console_device);
1617	atmel_default_console_device);
1618	register_console(&atmel_console);	1684	register_console(&atmel_console);
1619	}	1685	}
1620		1686
@@ -1711,14 +1777,39 @@ static int atmel_serial_resume(struct platform_device *pdev) · 90 unmodified lines
1711	static int __devinit atmel_serial_probe(struct platform_device *pdev)	1777	static int __devinit atmel_serial_probe(struct platform_device *pdev)
1712	{	1778	{
1713	struct atmel_uart_port *port;	1779	struct atmel_uart_port *port;
		1780	struct device_node *np = pdev->dev.of_node;
1714	struct atmel_uart_data *pdata = pdev->dev.platform_data;	1781	struct atmel_uart_data *pdata = pdev->dev.platform_data;
1715	void *data;	1782	void *data;
1716	int ret;	1783	int ret = -ENODEV;
1717		1784
1718	BUILD_BUG_ON(ATMEL_SERIAL_RINGSIZE & (ATMEL_SERIAL_RINGSIZE - 1));	1785	BUILD_BUG_ON(ATMEL_SERIAL_RINGSIZE & (ATMEL_SERIAL_RINGSIZE - 1));
1719		1786
1720	port = &atmel_ports[pdata->num];	1787	if (np)
		1788	ret = of_alias_get_id(np, "serial");
		1789	else
		1790	if (pdata)
		1791	ret = pdata->num;
		1792
		1793	if (ret < 0)
		1794	/* port id not found in platform data nor device-tree aliases:
		1795	* auto-enumerate it */
		1796	ret = find_first_zero_bit(&atmel_ports_in_use,
		1797	sizeof(atmel_ports_in_use));
		1798
		1799	if (ret > ATMEL_MAX_UART) {
		1800	ret = -ENODEV;
		1801	goto err;
		1802	}
		1803
		1804	if (test_and_set_bit(ret, &atmel_ports_in_use)) {
		1805	/* port already in use */
		1806	ret = -EBUSY;
		1807	goto err;
		1808	}
		1809
		1810	port = &atmel_ports[ret];
1721	port->backup_imr = 0;	1811	port->backup_imr = 0;
		1812	port->uart.line = ret;
1722		1813
1723	atmel_init_port(port, pdev);	1814	atmel_init_port(port, pdev);
1724		1815
@@ -1764,7 +1855,7 @@ err_alloc_ring: · 39 unmodified lines
1764	clk_put(port->clk);	1855	clk_put(port->clk);
1765	port->clk = NULL;	1856	port->clk = NULL;
1766	}	1857	}
1767		1858	err:
1768	return ret;	1859	return ret;
1769	}	1860	}
1770		1861
@@ -1784,6 +1875,8 @@ static int __devexit atmel_serial_remove(struct platform_device *pdev) · 13 unmodified lines
1784		1875
1785	/* "port" is allocated statically, so we shouldn't free it */	1876	/* "port" is allocated statically, so we shouldn't free it */
1786		1877
		1878	clear_bit(port->line, &atmel_ports_in_use);
		1879
1787	clk_put(atmel_port->clk);	1880	clk_put(atmel_port->clk);
1788		1881
1789	return ret;	1882	return ret;
@@ -1797,6 +1890,7 @@ static struct platform_driver atmel_serial_driver = { · 7 unmodified lines
1797	.driver = {	1890	.driver = {
1798	.name = "atmel_usart",	1891	.name = "atmel_usart",
1799	.owner = THIS_MODULE,	1892	.owner = THIS_MODULE,
		1893	.of_match_table = of_match_ptr(atmel_serial_dt_ids),
1800	},	1894	},
1801	};	1895	};
1802		1896

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

@@ -294,7 +294,7 @@ static int sport_startup(struct uart_port *port) · 293 unmodified lines
294	if (request_irq(gpio_to_irq(up->cts_pin),	294	if (request_irq(gpio_to_irq(up->cts_pin),
295	sport_mctrl_cts_int,	295	sport_mctrl_cts_int,
296	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING \|	296	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING \|
297	IRQF_DISABLED, "BFIN_SPORT_UART_CTS", up)) {	297	0, "BFIN_SPORT_UART_CTS", up)) {
298	up->cts_pin = -1;	298	up->cts_pin = -1;
299	dev_info(port->dev, "Unable to attach BlackFin UART over SPORT CTS interrupt. So, disable it.\n");	299	dev_info(port->dev, "Unable to attach BlackFin UART over SPORT CTS interrupt. So, disable it.\n");
300	}	300	}

drivers/tty/serial/bfin_uart.crenamed from drivers/tty/serial/bfin_5xx.c+40−25

 	status = UART_GET_LSR(uart);
 	UART_CLEAR_LSR(uart);
- 	ch = UART_GET_CHAR(uart);
+	ch = UART_GET_CHAR(uart);
- 	uart->port.icount.rx++;
+	uart->port.icount.rx++;
 #if defined(CONFIG_KGDB_SERIAL_CONSOLE) || \
 	defined(CONFIG_KGDB_SERIAL_CONSOLE_MODULE)
 		kgdboc_break_enabled = 0;
 	else {
 # endif
-	if (request_irq(uart->port.irq, bfin_serial_rx_int, IRQF_DISABLED,
+	if (request_irq(uart->rx_irq, bfin_serial_rx_int, 0,
 	     "BFIN_UART_RX", uart)) {
 		printk(KERN_NOTICE "Unable to attach BlackFin UART RX interrupt\n");
 		return -EBUSY;
 	}
 	if (request_irq
-	    (uart->port.irq+1, bfin_serial_tx_int, IRQF_DISABLED,
+	    (uart->tx_irq, bfin_serial_tx_int, 0,
 	     "BFIN_UART_TX", uart)) {
 		printk(KERN_NOTICE "Unable to attach BlackFin UART TX interrupt\n");
-		free_irq(uart->port.irq, uart);
+		free_irq(uart->rx_irq, uart);
 		return -EBUSY;
 	}
 		 */
 		unsigned uart_dma_ch_rx, uart_dma_ch_tx;
-		switch (uart->port.irq) {
+		switch (uart->rx_irq) {
 		case IRQ_UART3_RX:
 			uart_dma_ch_rx = CH_UART3_RX;
 			uart_dma_ch_tx = CH_UART3_TX;
 		if (uart_dma_ch_rx &&
 			request_dma(uart_dma_ch_rx, "BFIN_UART_RX") < 0) {
 			printk(KERN_NOTICE"Fail to attach UART interrupt\n");
-			free_irq(uart->port.irq, uart);
+			free_irq(uart->rx_irq, uart);
-			free_irq(uart->port.irq + 1, uart);
+			free_irq(uart->tx_irq, uart);
 			return -EBUSY;
 		}
 		if (uart_dma_ch_tx &&
 			request_dma(uart_dma_ch_tx, "BFIN_UART_TX") < 0) {
 			printk(KERN_NOTICE "Fail to attach UART interrupt\n");
 			free_dma(uart_dma_ch_rx);
-			free_irq(uart->port.irq, uart);
+			free_irq(uart->rx_irq, uart);
-			free_irq(uart->port.irq + 1, uart);
+			free_irq(uart->tx_irq, uart);
 			return -EBUSY;
 		}
 	}
 		if (request_irq(gpio_to_irq(uart->cts_pin),
 			bfin_serial_mctrl_cts_int,
 			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
-			IRQF_DISABLED, "BFIN_UART_CTS", uart)) {
+			0, "BFIN_UART_CTS", uart)) {
 			uart->cts_pin = -1;
 			pr_info("Unable to attach BlackFin UART CTS interrupt. So, disable it.\n");
 		}
 	}
-	if (uart->rts_pin >= 0) {
+	if (uart->rts_pin >= 0)
 		gpio_direction_output(uart->rts_pin, 0);
-	}
 #endif
 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
 	if (uart->cts_pin >= 0 && request_irq(uart->status_irq,
 		bfin_serial_mctrl_cts_int,
-		IRQF_DISABLED, "BFIN_UART_MODEM_STATUS", uart)) {
+		0, "BFIN_UART_MODEM_STATUS", uart)) {
 		uart->cts_pin = -1;
 		pr_info("Unable to attach BlackFin UART Modem Status interrupt.\n");
 	}
 		break;
 	};
 #endif
-	free_irq(uart->port.irq, uart);
+	free_irq(uart->rx_irq, uart);
-	free_irq(uart->port.irq+1, uart);
+	free_irq(uart->tx_irq, uart);
 #endif
 #ifdef CONFIG_SERIAL_BFIN_CTSRTS
 				*parity = 'o';
 		}
 		switch (lcr & 0x03) {
-			case 0:	*bits = 5; break;
+		case 0:
-			case 1:	*bits = 6; break;
+			*bits = 5;
-			case 2:	*bits = 7; break;
+			break;
-			case 3:	*bits = 8; break;
+		case 1:
+			*bits = 6;
+			break;
+		case 2:
+			*bits = 7;
+			break;
+		case 3:
+			*bits = 8;
+			break;
 		}
 		/* Set DLAB in LCR to Access DLL and DLH */
 		UART_SET_DLAB(uart);
 	.index		= -1,
 	.data		= &bfin_serial_reg,
 };
-#define BFIN_SERIAL_CONSOLE	&bfin_serial_console
+#define BFIN_SERIAL_CONSOLE	(&bfin_serial_console)
 #else
 #define BFIN_SERIAL_CONSOLE	NULL
 #endif /* CONFIG_SERIAL_BFIN_CONSOLE */
 		}
 		uart->port.mapbase = res->start;
-		uart->port.irq = platform_get_irq(pdev, 0);
+		uart->tx_irq = platform_get_irq(pdev, 0);
-		if (uart->port.irq < 0) {
+		if (uart->tx_irq < 0) {
-			dev_err(&pdev->dev, "No uart RX/TX IRQ specified\n");
+			dev_err(&pdev->dev, "No uart TX IRQ specified\n");
+			ret = -ENOENT;
+			goto out_error_unmap;
+		}
+		uart->rx_irq = platform_get_irq(pdev, 1);
+		if (uart->rx_irq < 0) {
+			dev_err(&pdev->dev, "No uart RX IRQ specified\n");
 			ret = -ENOENT;
 			goto out_error_unmap;
 		}
+		uart->port.irq = uart->rx_irq;
-		uart->status_irq = platform_get_irq(pdev, 1);
+		uart->status_irq = platform_get_irq(pdev, 2);
 		if (uart->status_irq < 0) {
 			dev_err(&pdev->dev, "No uart status IRQ specified\n");
 			ret = -ENOENT;

drivers/tty/serial/cpm_uart/cpm_uart_core.c+1−0

@@ -31,6 +31,7 @@ · 30 unmodified lines
31		31
32	#include <linux/module.h>	32	#include <linux/module.h>
33	#include <linux/tty.h>	33	#include <linux/tty.h>
		34	#include <linux/tty_flip.h>
34	#include <linux/ioport.h>	35	#include <linux/ioport.h>
35	#include <linux/init.h>	36	#include <linux/init.h>
36	#include <linux/serial.h>	37	#include <linux/serial.h>

drivers/tty/serial/crisv10.c+15−15

@@ -258,7 +258,7 @@ static struct e100_serial rs_table[] = { · 257 unmodified lines
258	.dma_out_enabled = 1,	258	.dma_out_enabled = 1,
259	.dma_out_nbr = SER0_TX_DMA_NBR,	259	.dma_out_nbr = SER0_TX_DMA_NBR,
260	.dma_out_irq_nbr = SER0_DMA_TX_IRQ_NBR,	260	.dma_out_irq_nbr = SER0_DMA_TX_IRQ_NBR,
261	.dma_out_irq_flags = IRQF_DISABLED,	261	.dma_out_irq_flags = 0,
262	.dma_out_irq_description = "serial 0 dma tr",	262	.dma_out_irq_description = "serial 0 dma tr",
263	#else	263	#else
264	.dma_out_enabled = 0,	264	.dma_out_enabled = 0,
@@ -271,7 +271,7 @@ static struct e100_serial rs_table[] = { · 6 unmodified lines
271	.dma_in_enabled = 1,	271	.dma_in_enabled = 1,
272	.dma_in_nbr = SER0_RX_DMA_NBR,	272	.dma_in_nbr = SER0_RX_DMA_NBR,
273	.dma_in_irq_nbr = SER0_DMA_RX_IRQ_NBR,	273	.dma_in_irq_nbr = SER0_DMA_RX_IRQ_NBR,
274	.dma_in_irq_flags = IRQF_DISABLED,	274	.dma_in_irq_flags = 0,
275	.dma_in_irq_description = "serial 0 dma rec",	275	.dma_in_irq_description = "serial 0 dma rec",
276	#else	276	#else
277	.dma_in_enabled = 0,	277	.dma_in_enabled = 0,
@@ -313,7 +313,7 @@ static struct e100_serial rs_table[] = { · 35 unmodified lines
313	.dma_out_enabled = 1,	313	.dma_out_enabled = 1,
314	.dma_out_nbr = SER1_TX_DMA_NBR,	314	.dma_out_nbr = SER1_TX_DMA_NBR,
315	.dma_out_irq_nbr = SER1_DMA_TX_IRQ_NBR,	315	.dma_out_irq_nbr = SER1_DMA_TX_IRQ_NBR,
316	.dma_out_irq_flags = IRQF_DISABLED,	316	.dma_out_irq_flags = 0,
317	.dma_out_irq_description = "serial 1 dma tr",	317	.dma_out_irq_description = "serial 1 dma tr",
318	#else	318	#else
319	.dma_out_enabled = 0,	319	.dma_out_enabled = 0,
@@ -326,7 +326,7 @@ static struct e100_serial rs_table[] = { · 6 unmodified lines
326	.dma_in_enabled = 1,	326	.dma_in_enabled = 1,
327	.dma_in_nbr = SER1_RX_DMA_NBR,	327	.dma_in_nbr = SER1_RX_DMA_NBR,
328	.dma_in_irq_nbr = SER1_DMA_RX_IRQ_NBR,	328	.dma_in_irq_nbr = SER1_DMA_RX_IRQ_NBR,
329	.dma_in_irq_flags = IRQF_DISABLED,	329	.dma_in_irq_flags = 0,
330	.dma_in_irq_description = "serial 1 dma rec",	330	.dma_in_irq_description = "serial 1 dma rec",
331	#else	331	#else
332	.dma_in_enabled = 0,	332	.dma_in_enabled = 0,
@@ -369,7 +369,7 @@ static struct e100_serial rs_table[] = { · 36 unmodified lines
369	.dma_out_enabled = 1,	369	.dma_out_enabled = 1,
370	.dma_out_nbr = SER2_TX_DMA_NBR,	370	.dma_out_nbr = SER2_TX_DMA_NBR,
371	.dma_out_irq_nbr = SER2_DMA_TX_IRQ_NBR,	371	.dma_out_irq_nbr = SER2_DMA_TX_IRQ_NBR,
372	.dma_out_irq_flags = IRQF_DISABLED,	372	.dma_out_irq_flags = 0,
373	.dma_out_irq_description = "serial 2 dma tr",	373	.dma_out_irq_description = "serial 2 dma tr",
374	#else	374	#else
375	.dma_out_enabled = 0,	375	.dma_out_enabled = 0,
@@ -382,7 +382,7 @@ static struct e100_serial rs_table[] = { · 6 unmodified lines
382	.dma_in_enabled = 1,	382	.dma_in_enabled = 1,
383	.dma_in_nbr = SER2_RX_DMA_NBR,	383	.dma_in_nbr = SER2_RX_DMA_NBR,
384	.dma_in_irq_nbr = SER2_DMA_RX_IRQ_NBR,	384	.dma_in_irq_nbr = SER2_DMA_RX_IRQ_NBR,
385	.dma_in_irq_flags = IRQF_DISABLED,	385	.dma_in_irq_flags = 0,
386	.dma_in_irq_description = "serial 2 dma rec",	386	.dma_in_irq_description = "serial 2 dma rec",
387	#else	387	#else
388	.dma_in_enabled = 0,	388	.dma_in_enabled = 0,
@@ -423,7 +423,7 @@ static struct e100_serial rs_table[] = { · 34 unmodified lines
423	.dma_out_enabled = 1,	423	.dma_out_enabled = 1,
424	.dma_out_nbr = SER3_TX_DMA_NBR,	424	.dma_out_nbr = SER3_TX_DMA_NBR,
425	.dma_out_irq_nbr = SER3_DMA_TX_IRQ_NBR,	425	.dma_out_irq_nbr = SER3_DMA_TX_IRQ_NBR,
426	.dma_out_irq_flags = IRQF_DISABLED,	426	.dma_out_irq_flags = 0,
427	.dma_out_irq_description = "serial 3 dma tr",	427	.dma_out_irq_description = "serial 3 dma tr",
428	#else	428	#else
429	.dma_out_enabled = 0,	429	.dma_out_enabled = 0,
@@ -436,7 +436,7 @@ static struct e100_serial rs_table[] = { · 6 unmodified lines
436	.dma_in_enabled = 1,	436	.dma_in_enabled = 1,
437	.dma_in_nbr = SER3_RX_DMA_NBR,	437	.dma_in_nbr = SER3_RX_DMA_NBR,
438	.dma_in_irq_nbr = SER3_DMA_RX_IRQ_NBR,	438	.dma_in_irq_nbr = SER3_DMA_RX_IRQ_NBR,
439	.dma_in_irq_flags = IRQF_DISABLED,	439	.dma_in_irq_flags = 0,
440	.dma_in_irq_description = "serial 3 dma rec",	440	.dma_in_irq_description = "serial 3 dma rec",
441	#else	441	#else
442	.dma_in_enabled = 0,	442	.dma_in_enabled = 0,
@@ -1788,7 +1788,7 @@ static unsigned int handle_descr_data(struct e100_serial *info, · 1345 unmodified lines
1788	struct etrax_recv_buffer buffer = phys_to_virt(descr->buf) - sizeof buffer;	1788	struct etrax_recv_buffer buffer = phys_to_virt(descr->buf) - sizeof buffer;
1789		1789
1790	if (info->recv_cnt + recvl > 65536) {	1790	if (info->recv_cnt + recvl > 65536) {
1791	printk(KERN_CRIT	1791	printk(KERN_WARNING
1792	"%s: Too much pending incoming serial data! Dropping %u bytes.\n", __func__, recvl);	1792	"%s: Too much pending incoming serial data! Dropping %u bytes.\n", __func__, recvl);
1793	return 0;	1793	return 0;
1794	}	1794	}
@@ -3813,13 +3813,13 @@ rs_close(struct tty_struct tty, struct file filp) · 2018 unmodified lines
3813	* one, we've got real problems, since it means the	3813	* one, we've got real problems, since it means the
3814	* serial port won't be shutdown.	3814	* serial port won't be shutdown.
3815	*/	3815	*/
3816	printk(KERN_CRIT	3816	printk(KERN_ERR
3817	"rs_close: bad serial port count; tty->count is 1, "	3817	"rs_close: bad serial port count; tty->count is 1, "
3818	"info->count is %d\n", info->count);	3818	"info->count is %d\n", info->count);
3819	info->count = 1;	3819	info->count = 1;
3820	}	3820	}
3821	if (--info->count < 0) {	3821	if (--info->count < 0) {
3822	printk(KERN_CRIT "rs_close: bad serial port count for ttyS%d: %d\n",	3822	printk(KERN_ERR "rs_close: bad serial port count for ttyS%d: %d\n",
3823	info->line, info->count);	3823	info->line, info->count);
3824	info->count = 0;	3824	info->count = 0;
3825	}	3825	}
@@ -4452,7 +4452,7 @@ static int __init rs_init(void) · 626 unmodified lines
4452	#if defined(CONFIG_ETRAX_RS485_ON_PA)	4452	#if defined(CONFIG_ETRAX_RS485_ON_PA)
4453	if (cris_io_interface_allocate_pins(if_serial_0, 'a', rs485_pa_bit,	4453	if (cris_io_interface_allocate_pins(if_serial_0, 'a', rs485_pa_bit,
4454	rs485_pa_bit)) {	4454	rs485_pa_bit)) {
4455	printk(KERN_CRIT "ETRAX100LX serial: Could not allocate "	4455	printk(KERN_ERR "ETRAX100LX serial: Could not allocate "
4456	"RS485 pin\n");	4456	"RS485 pin\n");
4457	put_tty_driver(driver);	4457	put_tty_driver(driver);
4458	return -EBUSY;	4458	return -EBUSY;
@@ -4461,7 +4461,7 @@ static int __init rs_init(void) · 2 unmodified lines
4461	#if defined(CONFIG_ETRAX_RS485_ON_PORT_G)	4461	#if defined(CONFIG_ETRAX_RS485_ON_PORT_G)
4462	if (cris_io_interface_allocate_pins(if_serial_0, 'g', rs485_pa_bit,	4462	if (cris_io_interface_allocate_pins(if_serial_0, 'g', rs485_pa_bit,
4463	rs485_port_g_bit)) {	4463	rs485_port_g_bit)) {
4464	printk(KERN_CRIT "ETRAX100LX serial: Could not allocate "	4464	printk(KERN_ERR "ETRAX100LX serial: Could not allocate "
4465	"RS485 pin\n");	4465	"RS485 pin\n");
4466	put_tty_driver(driver);	4466	put_tty_driver(driver);
4467	return -EBUSY;	4467	return -EBUSY;
@@ -4494,7 +4494,7 @@ static int __init rs_init(void) · 26 unmodified lines
4494	if (info->enabled) {	4494	if (info->enabled) {
4495	if (cris_request_io_interface(info->io_if,	4495	if (cris_request_io_interface(info->io_if,
4496	info->io_if_description)) {	4496	info->io_if_description)) {
4497	printk(KERN_CRIT "ETRAX100LX async serial: "	4497	printk(KERN_ERR "ETRAX100LX async serial: "
4498	"Could not allocate IO pins for "	4498	"Could not allocate IO pins for "
4499	"%s, port %d\n",	4499	"%s, port %d\n",
4500	info->io_if_description, i);	4500	info->io_if_description, i);
@@ -4558,7 +4558,7 @@ static int __init rs_init(void) · 57 unmodified lines
4558	/* hook the irq's for DMA channel 6 and 7, serial output and input, and some more... */	4558	/* hook the irq's for DMA channel 6 and 7, serial output and input, and some more... */
4559		4559
4560	if (request_irq(SERIAL_IRQ_NBR, ser_interrupt,	4560	if (request_irq(SERIAL_IRQ_NBR, ser_interrupt,
4561	IRQF_SHARED \| IRQF_DISABLED, "serial ", driver))	4561	IRQF_SHARED, "serial ", driver))
4562	panic("%s: Failed to request irq8", __func__);	4562	panic("%s: Failed to request irq8", __func__);
4563		4563
4564	#endif	4564	#endif

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

@@ -47,6 +47,7 @@ · 46 unmodified lines
47	#include <linux/serial_core.h>	47	#include <linux/serial_core.h>
48	#include <linux/sysrq.h>	48	#include <linux/sysrq.h>
49	#include <linux/tty.h>	49	#include <linux/tty.h>
		50	#include <linux/tty_flip.h>
50		51
51	#include <linux/atomic.h>	52	#include <linux/atomic.h>
52	#include <asm/bootinfo.h>	53	#include <asm/bootinfo.h>

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

@@ -1554,7 +1554,7 @@ static int __devinit icom_probe(struct pci_dev *dev, · 1553 unmodified lines
1554		1554
1555	/* save off irq and request irq line */	1555	/* save off irq and request irq line */
1556	if ( (retval = request_irq(dev->irq, icom_interrupt,	1556	if ( (retval = request_irq(dev->irq, icom_interrupt,
1557	IRQF_DISABLED \| IRQF_SHARED, ICOM_DRIVER_NAME,	1557	IRQF_SHARED, ICOM_DRIVER_NAME,
1558	(void *) icom_adapter))) {	1558	(void *) icom_adapter))) {
1559	goto probe_exit2;	1559	goto probe_exit2;
1560	}	1560	}

drivers/tty/serial/imx.c+7−3

 		if (uart_handle_sysrq_char(&sport->port, (unsigned char)rx))
 			continue;
-		if (rx & (URXD_PRERR | URXD_OVRRUN | URXD_FRMERR) ) {
+		if (unlikely(rx & URXD_ERR)) {
-			if (rx & URXD_PRERR)
+			if (rx & URXD_BRK)
+				sport->port.icount.brk++;
+			else if (rx & URXD_PRERR)
 				sport->port.icount.parity++;
 			else if (rx & URXD_FRMERR)
 				sport->port.icount.frame++;
 			rx &= sport->port.read_status_mask;
-			if (rx & URXD_PRERR)
+			if (rx & URXD_BRK)
+				flg = TTY_BREAK;
+			else if (rx & URXD_PRERR)
 				flg = TTY_PARITY;
 			else if (rx & URXD_FRMERR)
 				flg = TTY_FRAME;

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

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	*/	13	*/
14	#include <linux/errno.h>	14	#include <linux/errno.h>
15	#include <linux/tty.h>	15	#include <linux/tty.h>
		16	#include <linux/tty_flip.h>
16	#include <linux/serial.h>	17	#include <linux/serial.h>
17	#include <linux/circ_buf.h>	18	#include <linux/circ_buf.h>
18	#include <linux/serial_reg.h>	19	#include <linux/serial_reg.h>

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

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	*/	14	*/
15	#include <linux/errno.h>	15	#include <linux/errno.h>
16	#include <linux/tty.h>	16	#include <linux/tty.h>
		17	#include <linux/tty_flip.h>
17	#include <linux/serial.h>	18	#include <linux/serial.h>
18	#include <linux/serialP.h>	19	#include <linux/serialP.h>
19	#include <linux/circ_buf.h>	20	#include <linux/circ_buf.h>

drivers/tty/serial/jsm/jsm.h+0−10

 /* 4 extra for alignment play space */
 #define WRITEBUFLEN	((4096) + 4)
-#define MYFLIPLEN	N_TTY_BUF_SIZE
 #define JSM_VERSION	"jsm: 1.2-1-INKERNEL"
 #define JSM_PARTNUM	"40002438_A-INKERNEL"
 	u32		bd_uart_offset;	/* Space between each UART */
 	struct jsm_channel *channels[MAXPORTS]; /* array of pointers to our channels. */
-	char		*flipbuf;	/* Our flip buffer, alloced if board is found */
 	u32		bd_dividend;	/* Board/UARTs specific dividend */
 #define CH_TX_FIFO_LWM	0x0800		/* TX Fifo is below Low Water	*/
 #define CH_BREAK_SENDING 0x1000		/* Break is being sent		*/
 #define CH_LOOPBACK 0x2000		/* Channel is in lookback mode	*/
-#define CH_FLIPBUF_IN_USE 0x4000	/* Channel's flipbuf is in use	*/
 #define CH_BAUD0	0x08000		/* Used for checking B0 transitions */
 /* Our Read/Error/Write queue sizes */
 #define RQUEUEMASK	0x1FFF		/* 8 K - 1 */
 #define EQUEUEMASK	0x1FFF		/* 8 K - 1 */
-#define WQUEUEMASK	0x0FFF		/* 4 K - 1 */
 #define RQUEUESIZE	(RQUEUEMASK + 1)
 #define EQUEUESIZE	RQUEUESIZE
-#define WQUEUESIZE	(WQUEUEMASK + 1)
 /************************************************************************
 	u16		ch_e_head;	/* Head location of the error queue */
 	u16		ch_e_tail;	/* Tail location of the error queue */
-	u8		*ch_wqueue;	/* Our write queue buffer - malloc'ed */
-	u16		ch_w_head;	/* Head location of the write queue */
-	u16		ch_w_tail;	/* Tail location of the write queue */
 	u64		ch_rxcount;	/* total of data received so far */
 	u64		ch_txcount;	/* total of data transmitted so far */
  * Prototypes for non-static functions used in more than one module
  *
  *************************************************************************/
-int jsm_tty_write(struct uart_port *port);
 int jsm_tty_init(struct jsm_board *);
 int jsm_uart_port_init(struct jsm_board *);
 int jsm_remove_uart_port(struct jsm_board *);

drivers/tty/serial/jsm/jsm_driver.c+0−19

 	dev_info(&pdev->dev, "board %d: Digi Neo (rev %d), irq %d\n",
 			adapter_count, brd->rev, brd->irq);
-	/*
-	 * allocate flip buffer for board.
-	 *
-	 * Okay to malloc with GFP_KERNEL, we are not at interrupt
-	 * context, and there are no locks held.
-	 */
-	brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL);
-	if (!brd->flipbuf) {
-		/* XXX: leaking all resources from jsm_tty_init and
-		 	jsm_uart_port_init here! */
-		dev_err(&pdev->dev, "memory allocation for flipbuf failed\n");
-		rc = -ENOMEM;
-		goto out_free_uart;
-	}
 	pci_set_drvdata(pdev, brd);
 	pci_save_state(pdev);
 	return 0;
- out_free_uart:
-	jsm_remove_uart_port(brd);
  out_free_irq:
 	jsm_remove_uart_port(brd);
 	free_irq(brd->irq, brd);
 		if (brd->channels[i]) {
 			kfree(brd->channels[i]->ch_rqueue);
 			kfree(brd->channels[i]->ch_equeue);
-			kfree(brd->channels[i]->ch_wqueue);
 			kfree(brd->channels[i]);
 		}
 	}
 	pci_release_regions(pdev);
 	pci_disable_device(pdev);
-	kfree(brd->flipbuf);
 	kfree(brd);
 }

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

 	int s;
 	int qlen;
 	u32 len_written = 0;
+	struct circ_buf *circ;
 	if (!ch)
 		return;
+	circ = &ch->uart_port.state->xmit;
 	/* No data to write to the UART */
-	if (ch->ch_w_tail == ch->ch_w_head)
+	if (uart_circ_empty(circ))
 		return;
 	/* If port is "stopped", don't send any data to the UART */
 		if (ch->ch_cached_lsr & UART_LSR_THRE) {
 			ch->ch_cached_lsr &= ~(UART_LSR_THRE);
-			writeb(ch->ch_wqueue[ch->ch_w_tail], &ch->ch_neo_uart->txrx);
+			writeb(circ->buf[circ->tail], &ch->ch_neo_uart->txrx);
 			jsm_printk(WRITE, INFO, &ch->ch_bd->pci_dev,
-					"Tx data: %x\n", ch->ch_wqueue[ch->ch_w_head]);
+					"Tx data: %x\n", circ->buf[circ->tail]);
-			ch->ch_w_tail++;
+			circ->tail = (circ->tail + 1) & (UART_XMIT_SIZE - 1);
-			ch->ch_w_tail &= WQUEUEMASK;
 			ch->ch_txcount++;
 		}
 		return;
 	n = UART_17158_TX_FIFOSIZE - ch->ch_t_tlevel;
 	/* cache head and tail of queue */
-	head = ch->ch_w_head & WQUEUEMASK;
+	head = circ->head & (UART_XMIT_SIZE - 1);
-	tail = ch->ch_w_tail & WQUEUEMASK;
+	tail = circ->tail & (UART_XMIT_SIZE - 1);
-	qlen = (head - tail) & WQUEUEMASK;
+	qlen = uart_circ_chars_pending(circ);
 	/* Find minimum of the FIFO space, versus queue length */
 	n = min(n, qlen);
 	while (n > 0) {
-		s = ((head >= tail) ? head : WQUEUESIZE) - tail;
+		s = ((head >= tail) ? head : UART_XMIT_SIZE) - tail;
 		s = min(s, n);
 		if (s <= 0)
 			break;
-		memcpy_toio(&ch->ch_neo_uart->txrxburst, ch->ch_wqueue + tail, s);
+		memcpy_toio(&ch->ch_neo_uart->txrxburst, circ->buf + tail, s);
 		/* Add and flip queue if needed */
-		tail = (tail + s) & WQUEUEMASK;
+		tail = (tail + s) & (UART_XMIT_SIZE - 1);
 		n -= s;
 		ch->ch_txcount += s;
 		len_written += s;
 	}
 	/* Update the final tail */
-	ch->ch_w_tail = tail & WQUEUEMASK;
+	circ->tail = tail & (UART_XMIT_SIZE - 1);
 	if (len_written >= ch->ch_t_tlevel)
 		ch->ch_flags &= ~(CH_TX_FIFO_EMPTY | CH_TX_FIFO_LWM);
-	if (!jsm_tty_write(&ch->uart_port))
+	if (uart_circ_empty(circ))
 		uart_write_wakeup(&ch->uart_port);
 }
 	if ((ch->ch_c_cflag & (CBAUD)) == 0) {
 		ch->ch_r_head = ch->ch_r_tail = 0;
 		ch->ch_e_head = ch->ch_e_tail = 0;
-		ch->ch_w_head = ch->ch_w_tail = 0;
 		neo_flush_uart_write(ch);
 		neo_flush_uart_read(ch);

drivers/tty/serial/jsm/jsm_tty.c+13−81

@@ -118,6 +118,19 @@ static void jsm_tty_set_mctrl(struct uart_port *port, unsigned int mctrl) · 117 unmodified lines
118	udelay(10);	118	udelay(10);
119	}	119	}
120		120
		121	/*
		122	* jsm_tty_write()
		123	*
		124	* Take data from the user or kernel and send it out to the FEP.
		125	* In here exists all the Transparent Print magic as well.
		126	*/
		127	static void jsm_tty_write(struct uart_port *port)
		128	{
		129	struct jsm_channel *channel;
		130	channel = container_of(port, struct jsm_channel, uart_port);
		131	channel->ch_bd->bd_ops->copy_data_from_queue_to_uart(channel);
		132	}
		133
121	static void jsm_tty_start_tx(struct uart_port *port)	134	static void jsm_tty_start_tx(struct uart_port *port)
122	{	135	{
123	struct jsm_channel channel = (struct jsm_channel )port;	136	struct jsm_channel channel = (struct jsm_channel )port;
@@ -216,14 +229,6 @@ static int jsm_tty_open(struct uart_port *port) · 92 unmodified lines
216	return -ENOMEM;	229	return -ENOMEM;
217	}	230	}
218	}	231	}
219	if (!channel->ch_wqueue) {
220	channel->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL);
221	if (!channel->ch_wqueue) {
222	jsm_printk(INIT, ERR, &channel->ch_bd->pci_dev,
223	"unable to allocate write queue buf");
224	return -ENOMEM;
225	}
226	}
227		232
228	channel->ch_flags &= ~(CH_OPENING);	233	channel->ch_flags &= ~(CH_OPENING);
229	/*	234	/*
@@ -237,7 +242,6 @@ static int jsm_tty_open(struct uart_port *port) · 7 unmodified lines
237	*/	242	*/
238	channel->ch_r_head = channel->ch_r_tail = 0;	243	channel->ch_r_head = channel->ch_r_tail = 0;
239	channel->ch_e_head = channel->ch_e_tail = 0;	244	channel->ch_e_head = channel->ch_e_tail = 0;
240	channel->ch_w_head = channel->ch_w_tail = 0;
241		245
242	brd->bd_ops->flush_uart_write(channel);	246	brd->bd_ops->flush_uart_write(channel);
243	brd->bd_ops->flush_uart_read(channel);	247	brd->bd_ops->flush_uart_read(channel);
@@ -836,75 +840,3 @@ void jsm_check_queue_flow_control(struct jsm_channel *ch) · 592 unmodified lines
836	}	840	}
837	}	841	}
838	}	842	}
839
840	/*
841	* jsm_tty_write()
842	*
843	* Take data from the user or kernel and send it out to the FEP.
844	* In here exists all the Transparent Print magic as well.
845	*/
846	int jsm_tty_write(struct uart_port *port)
847	{
848	int bufcount;
849	int data_count = 0,data_count1 =0;
850	u16 head;
851	u16 tail;
852	u16 tmask;
853	u32 remain;
854	int temp_tail = port->state->xmit.tail;
855	struct jsm_channel channel = (struct jsm_channel )port;
856
857	tmask = WQUEUEMASK;
858	head = (channel->ch_w_head) & tmask;
859	tail = (channel->ch_w_tail) & tmask;
860
861	if ((bufcount = tail - head - 1) < 0)
862	bufcount += WQUEUESIZE;
863
864	bufcount = min(bufcount, 56);
865	remain = WQUEUESIZE - head;
866
867	data_count = 0;
868	if (bufcount >= remain) {
869	bufcount -= remain;
870	while ((port->state->xmit.head != temp_tail) &&
871	(data_count < remain)) {
872	channel->ch_wqueue[head++] =
873	port->state->xmit.buf[temp_tail];
874
875	temp_tail++;
876	temp_tail &= (UART_XMIT_SIZE - 1);
877	data_count++;
878	}
879	if (data_count == remain) head = 0;
880	}
881
882	data_count1 = 0;
883	if (bufcount > 0) {
884	remain = bufcount;
885	while ((port->state->xmit.head != temp_tail) &&
886	(data_count1 < remain)) {
887	channel->ch_wqueue[head++] =
888	port->state->xmit.buf[temp_tail];
889
890	temp_tail++;
891	temp_tail &= (UART_XMIT_SIZE - 1);
892	data_count1++;
893
894	}
895	}
896
897	port->state->xmit.tail = temp_tail;
898
899	data_count += data_count1;
900	if (data_count) {
901	head &= tmask;
902	channel->ch_w_head = head;
903	}
904
905	if (data_count) {
906	channel->ch_bd->bd_ops->copy_data_from_queue_to_uart(channel);
907	}
908
909	return data_count;
910	}

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

@@ -338,21 +338,21 @@ lqasc_startup(struct uart_port *port) · 337 unmodified lines
338	ASCCON_ROEN, port->membase + LTQ_ASC_CON);	338	ASCCON_ROEN, port->membase + LTQ_ASC_CON);
339		339
340	retval = request_irq(ltq_port->tx_irq, lqasc_tx_int,	340	retval = request_irq(ltq_port->tx_irq, lqasc_tx_int,
341	IRQF_DISABLED, "asc_tx", port);	341	0, "asc_tx", port);
342	if (retval) {	342	if (retval) {
343	pr_err("failed to request lqasc_tx_int\n");	343	pr_err("failed to request lqasc_tx_int\n");
344	return retval;	344	return retval;
345	}	345	}
346		346
347	retval = request_irq(ltq_port->rx_irq, lqasc_rx_int,	347	retval = request_irq(ltq_port->rx_irq, lqasc_rx_int,
348	IRQF_DISABLED, "asc_rx", port);	348	0, "asc_rx", port);
349	if (retval) {	349	if (retval) {
350	pr_err("failed to request lqasc_rx_int\n");	350	pr_err("failed to request lqasc_rx_int\n");
351	goto err1;	351	goto err1;
352	}	352	}
353		353
354	retval = request_irq(ltq_port->err_irq, lqasc_err_int,	354	retval = request_irq(ltq_port->err_irq, lqasc_err_int,
355	IRQF_DISABLED, "asc_err", port);	355	0, "asc_err", port);
356	if (retval) {	356	if (retval) {
357	pr_err("failed to request lqasc_err_int\n");	357	pr_err("failed to request lqasc_err_int\n");
358	goto err2;	358	goto err2;

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

@@ -32,6 +32,7 @@ · 31 unmodified lines
32		32
33	#include <linux/module.h>	33	#include <linux/module.h>
34	#include <linux/tty.h>	34	#include <linux/tty.h>
		35	#include <linux/tty_flip.h>
35	#include <linux/ioport.h>	36	#include <linux/ioport.h>
36	#include <linux/init.h>	37	#include <linux/init.h>
37	#include <linux/console.h>	38	#include <linux/console.h>

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

@@ -47,6 +47,8 @@ · 46 unmodified lines
47	#include <linux/serial.h>	47	#include <linux/serial.h>
48	#include <linux/spi/spi.h>	48	#include <linux/spi/spi.h>
49	#include <linux/freezer.h>	49	#include <linux/freezer.h>
		50	#include <linux/tty.h>
		51	#include <linux/tty_flip.h>
50		52
51	#include <linux/serial_max3100.h>	53	#include <linux/serial_max3100.h>
52		54

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

 #include <linux/device.h>
 #include <linux/serial_core.h>
 #include <linux/serial.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/gpio.h>
 #include <linux/spi/spi.h>
 #include <linux/freezer.h>

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

@@ -380,7 +380,7 @@ static void mcf_config_port(struct uart_port *port, int flags) · 379 unmodified lines
380	/* Clear mask, so no surprise interrupts. */	380	/* Clear mask, so no surprise interrupts. */
381	writeb(0, port->membase + MCFUART_UIMR);	381	writeb(0, port->membase + MCFUART_UIMR);
382		382
383	if (request_irq(port->irq, mcf_interrupt, IRQF_DISABLED, "UART", port))	383	if (request_irq(port->irq, mcf_interrupt, 0, "UART", port))
384	printk(KERN_ERR "MCF: unable to attach ColdFire UART %d "	384	printk(KERN_ERR "MCF: unable to attach ColdFire UART %d "
385	"interrupt vector=%d\n", port->line, port->irq);	385	"interrupt vector=%d\n", port->line, port->irq);
386	}	386	}

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

 #include <linux/pci.h>
 #include <linux/io.h>
 #include <linux/debugfs.h>
+#include <linux/pm_runtime.h>
 #define HSU_DMA_BUF_SIZE	2048
 		container_of(port, struct uart_hsu_port, port);
 	unsigned long flags;
+	pm_runtime_get_sync(up->dev);
 	/*
 	 * Clear the FIFO buffers and disable them.
 	 * (they will be reenabled in set_termios())
 				  UART_FCR_CLEAR_RCVR |
 				  UART_FCR_CLEAR_XMIT);
 	serial_out(up, UART_FCR, 0);
+	pm_runtime_put(up->dev);
 }
 static void
 #define serial_hsu_resume	NULL
 #endif
+#ifdef CONFIG_PM_RUNTIME
+static int serial_hsu_runtime_idle(struct device *dev)
+{
+	int err;
+	err = pm_schedule_suspend(dev, 500);
+	if (err)
+		return -EBUSY;
+	return 0;
+}
+static int serial_hsu_runtime_suspend(struct device *dev)
+{
+	return 0;
+}
+static int serial_hsu_runtime_resume(struct device *dev)
+{
+	return 0;
+}
+#else
+#define serial_hsu_runtime_idle		NULL
+#define serial_hsu_runtime_suspend	NULL
+#define serial_hsu_runtime_resume	NULL
+#endif
+static const struct dev_pm_ops serial_hsu_pm_ops = {
+	.runtime_suspend = serial_hsu_runtime_suspend,
+	.runtime_resume = serial_hsu_runtime_resume,
+	.runtime_idle = serial_hsu_runtime_idle,
+};
 /* temp global pointer before we settle down on using one or four PCI dev */
 static struct hsu_port *phsu;
 		pci_set_drvdata(pdev, uport);
 	}
+	pm_runtime_put_noidle(&pdev->dev);
+	pm_runtime_allow(&pdev->dev);
 	return 0;
 err_disable:
 	if (!priv)
 		return;
+	pm_runtime_forbid(&pdev->dev);
+	pm_runtime_get_noresume(&pdev->dev);
 	/* For port 0/1/2, priv is the address of uart_hsu_port */
 	if (pdev->device != 0x081E) {
 		up = priv;
 }
 /* First 3 are UART ports, and the 4th is the DMA */
-static const struct pci_device_id pci_ids[] __devinitdata = {
+static const struct pci_device_id pci_ids[] __devinitconst = {
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x081B) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x081C) },
 	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x081D) },
 	.remove =	__devexit_p(serial_hsu_remove),
 	.suspend =	serial_hsu_suspend,
 	.resume	=	serial_hsu_resume,
+	.driver = {
+		.pm = &serial_hsu_pm_ops,
+	},
 };
 static int __init hsu_pci_init(void)

drivers/tty/serial/mpc52xx_uart.c+2−1

 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/serial.h>
 #include <linux/sysrq.h>
 #include <linux/console.h>
 static void mpc52xx_psc_get_irq(struct uart_port *port, struct device_node *np)
 {
-	port->irqflags = IRQF_DISABLED;
+	port->irqflags = 0;
 	port->irq = irq_of_parse_and_map(np, 0);
 }

drivers/tty/serial/mrst_max3110.c+54−61

  *    interrupt for a low speed UART device
  */
+#ifdef CONFIG_MAGIC_SYSRQ
+#define SUPPORT_SYSRQ
+#endif
 #include <linux/module.h>
 #include <linux/ioport.h>
 #include <linux/irq.h>
 /* global data structure, may need be removed */
 static struct uart_max3110 *pmax;
-static void receive_chars(struct uart_max3110 *max,
+static int receive_chars(struct uart_max3110 *max,
-				unsigned char *str, int len);
+				unsigned short *str, int len);
-static int max3110_read_multi(struct uart_max3110 *max, u8 *buf);
+static int max3110_read_multi(struct uart_max3110 *max);
 static void max3110_con_receive(struct uart_max3110 *max);
 static int max3110_write_then_read(struct uart_max3110 *max,
 {
 	void *buf;
 	u16 *obuf, *ibuf;
-	u8  ch;
 	int ret;
 	buf = kzalloc(8, GFP_KERNEL | GFP_DMA);
 		goto exit;
 	}
-	/* If some valid data is read back */
+	receive_chars(max, ibuf, 1);
-	if (*ibuf & MAX3110_READ_DATA_AVAILABLE) {
-		ch = *ibuf & 0xff;
-		receive_chars(max, &ch, 1);
-	}
 exit:
 	kfree(buf);
  *
  * Return how many valide bytes are read back
  */
-static int max3110_read_multi(struct uart_max3110 *max, u8 *rxbuf)
+static int max3110_read_multi(struct uart_max3110 *max)
 {
 	void *buf;
 	u16 *obuf, *ibuf;
-	u8 *pbuf, valid_str[M3110_RX_FIFO_DEPTH];
+	int ret, blen;
-	int i, j, blen;
 	blen = M3110_RX_FIFO_DEPTH * sizeof(u16);
 	buf = kzalloc(blen * 2, GFP_KERNEL | GFP_DMA);
 		return 0;
 	}
-	/* If caller doesn't provide a buffer, then handle received char */
+	ret = receive_chars(max, ibuf, M3110_RX_FIFO_DEPTH);
-	pbuf = rxbuf ? rxbuf : valid_str;
-	for (i = 0, j = 0; i < M3110_RX_FIFO_DEPTH; i++) {
-		if (ibuf[i] & MAX3110_READ_DATA_AVAILABLE)
-			pbuf[j++] = ibuf[i] & 0xff;
-	}
-	if (j && (pbuf == valid_str))
-		receive_chars(max, valid_str, j);
 	kfree(buf);
-	return j;
+	return ret;
 }
 static void serial_m3110_con_putchar(struct uart_port *port, int ch)
 	uart_console_write(&pmax->port, s, count, serial_m3110_con_putchar);
 	if (!test_and_set_bit(CON_TX_NEEDED, &pmax->uart_flags))
-		wake_up_process(pmax->main_thread);
+		wake_up(&pmax->wq);
 }
 static int __init
 {
 	void *buf;
 	u16 *obuf, *ibuf;
-	u8 valid_str[WORDS_PER_XFER];
+	int i, len, blen, dma_size, left, ret = 0;
-	int i, j, len, blen, dma_size, left, ret = 0;
 	dma_size = WORDS_PER_XFER * sizeof(u16) * 2;
 			}
 			/* Fail to send msg to console is not very critical */
 			ret = max3110_write_then_read(max, obuf, ibuf, blen, 0);
 			if (ret)
 				pr_warning(PR_FMT "%s(): get err msg %d\n",
 						__func__, ret);
-			for (i = 0, j = 0; i < len; i++) {
+			receive_chars(max, ibuf, len);
-				if (ibuf[i] & MAX3110_READ_DATA_AVAILABLE)
-					valid_str[j++] = ibuf[i] & 0xff;
-			}
-			if (j)
-				receive_chars(max, valid_str, j);
 			max->port.icount.tx += len;
 			left -= len;
 		container_of(port, struct uart_max3110, port);
 	if (!test_and_set_bit(UART_TX_NEEDED, &max->uart_flags))
-		wake_up_process(max->main_thread);
+		wake_up(&max->wq);
 }
-static void receive_chars(struct uart_max3110 *max, unsigned char *str, int len)
+static int
+receive_chars(struct uart_max3110 *max, unsigned short *str, int len)
 {
 	struct uart_port *port = &max->port;
 	struct tty_struct *tty;
-	int usable;
+	char buf[M3110_RX_FIFO_DEPTH];
+	int r, w, usable;
 	/* If uart is not opened, just return */
 	if (!port->state)
-		return;
+		return 0;
-	tty = port->state->port.tty;
+	tty = tty_port_tty_get(&port->state->port);
 	if (!tty)
-		return;
+		return 0;
+	for (r = 0, w = 0; r < len; r++) {
+		if (str[r] & MAX3110_BREAK &&
+		    uart_handle_break(port))
+			continue;
+		if (str[r] & MAX3110_READ_DATA_AVAILABLE) {
+			if (uart_handle_sysrq_char(port, str[r] & 0xff))
+				continue;
+			buf[w++] = str[r] & 0xff;
+		}
+	}
+	if (!w) {
+		tty_kref_put(tty);
+		return 0;
+	}
-	while (len) {
+	for (r = 0; w; r += usable, w -= usable) {
-		usable = tty_buffer_request_room(tty, len);
+		usable = tty_buffer_request_room(tty, w);
 		if (usable) {
-			tty_insert_flip_string(tty, str, usable);
+			tty_insert_flip_string(tty, buf + r, usable);
-			str += usable;
 			port->icount.rx += usable;
 		}
-		len -= usable;
 	}
 	tty_flip_buffer_push(tty);
+	tty_kref_put(tty);
+	return r;
 }
 /*
  */
 static void max3110_con_receive(struct uart_max3110 *max)
 {
-	int loop = 1, num, total = 0;
+	int loop = 1, num;
-	u8 recv_buf[512], *pbuf;
-	pbuf = recv_buf;
 	do {
-		num = max3110_read_multi(max, pbuf);
+		num = max3110_read_multi(max);
 		if (num) {
 			loop = 5;
-			pbuf += num;
-			total += num;
-			if (total >= 504) {
-				receive_chars(max, recv_buf, total);
-				pbuf = recv_buf;
-				total = 0;
-			}
 		}
 	} while (--loop);
-	if (total)
-		receive_chars(max, recv_buf, total);
 }
 static int max3110_main_thread(void *_max)
 	pr_info(PR_FMT "start main thread\n");
 	do {
-		wait_event_interruptible(*wq, max->uart_flags || kthread_should_stop());
+		wait_event_interruptible(*wq,
+				max->uart_flags || kthread_should_stop());
 		mutex_lock(&max->thread_mutex);
 	/* max3110's irq is a falling edge, not level triggered,
 	 * so no need to disable the irq */
 	if (!test_and_set_bit(BIT_IRQ_PENDING, &max->uart_flags))
-		wake_up_process(max->main_thread);
+		wake_up(&max->wq);
 	return IRQ_HANDLED;
 }

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

@@ -7,6 +7,7 @@ · 6 unmodified lines
7	/* status bits for all 4 MAX3110 operate modes */	7	/* status bits for all 4 MAX3110 operate modes */
8	#define MAX3110_READ_DATA_AVAILABLE (1 << 15)	8	#define MAX3110_READ_DATA_AVAILABLE (1 << 15)
9	#define MAX3110_WRITE_BUF_EMPTY (1 << 14)	9	#define MAX3110_WRITE_BUF_EMPTY (1 << 14)
		10	#define MAX3110_BREAK (1 << 10)
10		11
11	#define WC_TAG (3 << 14)	12	#define WC_TAG (3 << 14)
12	#define RC_TAG (1 << 14)	13	#define RC_TAG (1 << 14)

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

@@ -804,8 +804,6 @@ static int __init msm_console_setup(struct console co, char options) · 803 unmodified lines
804	if (unlikely(!port->membase))	804	if (unlikely(!port->membase))
805	return -ENXIO;	805	return -ENXIO;
806		806
807	port->cons = co;
808
809	msm_init_clock(port);	807	msm_init_clock(port);
810		808
811	if (options)	809	if (options)

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

@@ -30,6 +30,8 @@ · 29 unmodified lines
30		30
31	#include <linux/serial.h>	31	#include <linux/serial.h>
32	#include <linux/serial_core.h>	32	#include <linux/serial_core.h>
		33	#include <linux/tty.h>
		34	#include <linux/tty_flip.h>
33	#include <linux/slab.h>	35	#include <linux/slab.h>
34	#include <linux/init.h>	36	#include <linux/init.h>
35	#include <linux/interrupt.h>	37	#include <linux/interrupt.h>

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

 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/serial.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/console.h>
 #include <linux/delay.h> /* for udelay */
 #include <linux/device.h>

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

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/serial_reg.h>	15	#include <linux/serial_reg.h>
16	#include <linux/serial_core.h>	16	#include <linux/serial_core.h>
17	#include <linux/tty.h>	17	#include <linux/tty.h>
		18	#include <linux/tty_flip.h>
18	#include <linux/irqreturn.h>	19	#include <linux/irqreturn.h>
19	#include <linux/mutex.h>	20	#include <linux/mutex.h>
20	#include <linux/of_platform.h>	21	#include <linux/of_platform.h>

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

 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/serial_core.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/dmi.h>

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

@@ -100,6 +100,16 @@ static inline void receive_chars(struct uart_pxa_port up, int status) · 99 unmodified lines
100	int max_count = 256;	100	int max_count = 256;
101		101
102	do {	102	do {
		103	/* work around Errata #20 according to
		104	* Intel(R) PXA27x Processor Family
		105	* Specification Update (May 2005)
		106	*
		107	* Step 2
		108	* Disable the Reciever Time Out Interrupt via IER[RTOEI]
		109	*/
		110	up->ier &= ~UART_IER_RTOIE;
		111	serial_out(up, UART_IER, up->ier);
		112
103	ch = serial_in(up, UART_RX);	113	ch = serial_in(up, UART_RX);
104	flag = TTY_NORMAL;	114	flag = TTY_NORMAL;
105	up->port.icount.rx++;	115	up->port.icount.rx++;
@@ -156,6 +166,16 @@ static inline void receive_chars(struct uart_pxa_port up, int status) · 50 unmodified lines
156	*status = serial_in(up, UART_LSR);	166	*status = serial_in(up, UART_LSR);
157	} while ((*status & UART_LSR_DR) && (max_count-- > 0));	167	} while ((*status & UART_LSR_DR) && (max_count-- > 0));
158	tty_flip_buffer_push(tty);	168	tty_flip_buffer_push(tty);
		169
		170	/* work around Errata #20 according to
		171	* Intel(R) PXA27x Processor Family
		172	* Specification Update (May 2005)
		173	*
		174	* Step 6:
		175	* No more data in FIFO: Re-enable RTO interrupt via IER[RTOIE]
		176	*/
		177	up->ier \|= UART_IER_RTOIE;
		178	serial_out(up, UART_IER, up->ier);
159	}	179	}
160		180
161	static void transmit_chars(struct uart_pxa_port *up)	181	static void transmit_chars(struct uart_pxa_port *up)

drivers/tty/serial/samsung.c+95−12

 	return (rd_regl(port, S3C2410_UTRSTAT) & S3C2410_UTRSTAT_TXE);
 }
+/*
+ * s3c64xx and later SoC's include the interrupt mask and status registers in
+ * the controller itself, unlike the s3c24xx SoC's which have these registers
+ * in the interrupt controller. Check if the port type is s3c64xx or higher.
+ */
+static int s3c24xx_serial_has_interrupt_mask(struct uart_port *port)
+{
+	return to_ourport(port)->info->type == PORT_S3C6400;
+}
 static void s3c24xx_serial_rx_enable(struct uart_port *port)
 {
 	unsigned long flags;
 	struct s3c24xx_uart_port *ourport = to_ourport(port);
 	if (tx_enabled(port)) {
-		disable_irq_nosync(ourport->tx_irq);
+		if (s3c24xx_serial_has_interrupt_mask(port))
+			__set_bit(S3C64XX_UINTM_TXD,
+				portaddrl(port, S3C64XX_UINTM));
+		else
+			disable_irq_nosync(ourport->tx_irq);
 		tx_enabled(port) = 0;
 		if (port->flags & UPF_CONS_FLOW)
 			s3c24xx_serial_rx_enable(port);
 		if (port->flags & UPF_CONS_FLOW)
 			s3c24xx_serial_rx_disable(port);
-		enable_irq(ourport->tx_irq);
+		if (s3c24xx_serial_has_interrupt_mask(port))
+			__clear_bit(S3C64XX_UINTM_TXD,
+				portaddrl(port, S3C64XX_UINTM));
+		else
+			enable_irq(ourport->tx_irq);
 		tx_enabled(port) = 1;
 	}
 }
 static void s3c24xx_serial_stop_rx(struct uart_port *port)
 {
 	struct s3c24xx_uart_port *ourport = to_ourport(port);
 	if (rx_enabled(port)) {
 		dbg("s3c24xx_serial_stop_rx: port=%p\n", port);
-		disable_irq_nosync(ourport->rx_irq);
+		if (s3c24xx_serial_has_interrupt_mask(port))
+			__set_bit(S3C64XX_UINTM_RXD,
+				portaddrl(port, S3C64XX_UINTM));
+		else
+			disable_irq_nosync(ourport->rx_irq);
 		rx_enabled(port) = 0;
 	}
 }
 	return IRQ_HANDLED;
 }
+/* interrupt handler for s3c64xx and later SoC's.*/
+static irqreturn_t s3c64xx_serial_handle_irq(int irq, void *id)
+{
+	struct s3c24xx_uart_port *ourport = id;
+	struct uart_port *port = &ourport->port;
+	unsigned int pend = rd_regl(port, S3C64XX_UINTP);
+	unsigned long flags;
+	irqreturn_t ret = IRQ_HANDLED;
+	spin_lock_irqsave(&port->lock, flags);
+	if (pend & S3C64XX_UINTM_RXD_MSK) {
+		ret = s3c24xx_serial_rx_chars(irq, id);
+		wr_regl(port, S3C64XX_UINTP, S3C64XX_UINTM_RXD_MSK);
+	}
+	if (pend & S3C64XX_UINTM_TXD_MSK) {
+		ret = s3c24xx_serial_tx_chars(irq, id);
+		wr_regl(port, S3C64XX_UINTP, S3C64XX_UINTM_TXD_MSK);
+	}
+	spin_unlock_irqrestore(&port->lock, flags);
+	return ret;
+}
 static unsigned int s3c24xx_serial_tx_empty(struct uart_port *port)
 {
 	struct s3c24xx_uart_info *info = s3c24xx_port_to_info(port);
 	struct s3c24xx_uart_port *ourport = to_ourport(port);
 	if (ourport->tx_claimed) {
-		free_irq(ourport->tx_irq, ourport);
+		if (!s3c24xx_serial_has_interrupt_mask(port))
+			free_irq(ourport->tx_irq, ourport);
 		tx_enabled(port) = 0;
 		ourport->tx_claimed = 0;
 	}
 	if (ourport->rx_claimed) {
-		free_irq(ourport->rx_irq, ourport);
+		if (!s3c24xx_serial_has_interrupt_mask(port))
+			free_irq(ourport->rx_irq, ourport);
 		ourport->rx_claimed = 0;
 		rx_enabled(port) = 0;
 	}
-}
+	/* Clear pending interrupts and mask all interrupts */
+	if (s3c24xx_serial_has_interrupt_mask(port)) {
+		wr_regl(port, S3C64XX_UINTP, 0xf);
+		wr_regl(port, S3C64XX_UINTM, 0xf);
+	}
+}
 static int s3c24xx_serial_startup(struct uart_port *port)
 {
 	return ret;
 }
+static int s3c64xx_serial_startup(struct uart_port *port)
+{
+	struct s3c24xx_uart_port *ourport = to_ourport(port);
+	int ret;
+	dbg("s3c64xx_serial_startup: port=%p (%08lx,%p)\n",
+	    port->mapbase, port->membase);
+	ret = request_irq(port->irq, s3c64xx_serial_handle_irq, IRQF_SHARED,
+			  s3c24xx_serial_portname(port), ourport);
+	if (ret) {
+		printk(KERN_ERR "cannot get irq %d\n", port->irq);
+		return ret;
+	}
+	/* For compatibility with s3c24xx Soc's */
+	rx_enabled(port) = 1;
+	ourport->rx_claimed = 1;
+	tx_enabled(port) = 0;
+	ourport->tx_claimed = 1;
+	/* Enable Rx Interrupt */
+	__clear_bit(S3C64XX_UINTM_RXD, portaddrl(port, S3C64XX_UINTM));
+	dbg("s3c64xx_serial_startup ok\n");
+	return ret;
+}
 /* power power management control */
 static void s3c24xx_serial_pm(struct uart_port *port, unsigned int level,
 	.verify_port	= s3c24xx_serial_verify_port,
 };
 static struct uart_driver s3c24xx_uart_drv = {
 	.owner		= THIS_MODULE,
 	.driver_name	= "s3c2410_serial",
 		.port = {
 			.lock		= __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[0].port.lock),
 			.iotype		= UPIO_MEM,
-			.irq		= IRQ_S3CUART_RX0,
 			.uartclk	= 0,
 			.fifosize	= 16,
 			.ops		= &s3c24xx_serial_ops,
 		.port = {
 			.lock		= __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[1].port.lock),
 			.iotype		= UPIO_MEM,
-			.irq		= IRQ_S3CUART_RX1,
 			.uartclk	= 0,
 			.fifosize	= 16,
 			.ops		= &s3c24xx_serial_ops,
 		.port = {
 			.lock		= __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[2].port.lock),
 			.iotype		= UPIO_MEM,
-			.irq		= IRQ_S3CUART_RX2,
 			.uartclk	= 0,
 			.fifosize	= 16,
 			.ops		= &s3c24xx_serial_ops,
 		.port = {
 			.lock		= __SPIN_LOCK_UNLOCKED(s3c24xx_serial_ports[3].port.lock),
 			.iotype		= UPIO_MEM,
-			.irq		= IRQ_S3CUART_RX3,
 			.uartclk	= 0,
 			.fifosize	= 16,
 			.ops		= &s3c24xx_serial_ops,
 	port->dev	= &platdev->dev;
 	ourport->info	= info;
+	/* Startup sequence is different for s3c64xx and higher SoC's */
+	if (s3c24xx_serial_has_interrupt_mask(port))
+		s3c24xx_serial_ops.startup = s3c64xx_serial_startup;
 	/* copy the info in from provided structure */
 	ourport->port.fifosize = info->fifosize;
 	ourport->clk	= clk_get(&platdev->dev, "uart");
+	/* Keep all interrupts masked and cleared */
+	if (s3c24xx_serial_has_interrupt_mask(port)) {
+		wr_regl(port, S3C64XX_UINTM, 0xf);
+		wr_regl(port, S3C64XX_UINTP, 0xf);
+		wr_regl(port, S3C64XX_UINTSP, 0xf);
+	}
 	dbg("port: map=%08x, mem=%08x, irq=%d (%d,%d), clock=%ld\n",
 	    port->mapbase, port->membase, port->irq,
 	    ourport->rx_irq, ourport->tx_irq, port->uartclk);

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

@@ -61,6 +61,7 @@ struct s3c24xx_uart_port { · 60 unmodified lines
61	/* register access controls */	61	/* register access controls */
62		62
63	#define portaddr(port, reg) ((port)->membase + (reg))	63	#define portaddr(port, reg) ((port)->membase + (reg))
		64	#define portaddrl(port, reg) ((unsigned long *)((port)->membase + (reg)))
64		65
65	#define rd_regb(port, reg) (__raw_readb(portaddr(port, reg)))	66	#define rd_regb(port, reg) (__raw_readb(portaddr(port, reg)))
66	#define rd_regl(port, reg) (__raw_readl(portaddr(port, reg)))	67	#define rd_regl(port, reg) (__raw_readl(portaddr(port, reg)))

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

@@ -37,6 +37,7 @@ · 36 unmodified lines
37	#include <linux/spinlock.h>	37	#include <linux/spinlock.h>
38	#include <linux/sysrq.h>	38	#include <linux/sysrq.h>
39	#include <linux/tty.h>	39	#include <linux/tty.h>
		40	#include <linux/tty_flip.h>
40	#include <linux/types.h>	41	#include <linux/types.h>
41		42
42	#include <linux/atomic.h>	43	#include <linux/atomic.h>

drivers/tty/serial/serial_core.c+21−51

 static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
 					struct ktermios *old_termios);
-static void __uart_wait_until_sent(struct uart_port *port, int timeout);
+static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
 static void uart_change_pm(struct uart_state *state, int pm_state);
 /*
 	 * closed.  No cookie for you.
 	 */
 	BUG_ON(!state);
-	tasklet_schedule(&state->tlet);
+	tty_wakeup(state->port.tty);
 }
 static void uart_stop(struct tty_struct *tty)
 	spin_unlock_irqrestore(&port->lock, flags);
 }
-static void uart_tasklet_action(unsigned long data)
-{
-	struct uart_state *state = (struct uart_state *)data;
-	tty_wakeup(state->port.tty);
-}
 static inline void
 uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
 {
 	}
 	/*
-	 * kill off our tasklet
+	 * It's possible for shutdown to be called after suspend if we get
+	 * a DCD drop (hangup) at just the right time.  Clear suspended bit so
+	 * we don't try to resume a port that has been shutdown.
 	 */
-	tasklet_kill(&state->tlet);
+	clear_bit(ASYNCB_SUSPENDED, &port->flags);
 	/*
 	 * Free the transmit buffer page.
 	struct uart_port *uport;
 	unsigned long flags;
-	BUG_ON(!tty_locked());
 	if (!state)
 		return;
 	pr_debug("uart_close(%d) called\n", uport->line);
-	mutex_lock(&port->mutex);
 	spin_lock_irqsave(&port->lock, flags);
 	if (tty_hung_up_p(filp)) {
 		spin_unlock_irqrestore(&port->lock, flags);
-		goto done;
+		return;
 	}
 	if ((tty->count == 1) && (port->count != 1)) {
 	}
 	if (port->count) {
 		spin_unlock_irqrestore(&port->lock, flags);
-		goto done;
+		return;
 	}
 	/*
 	 * the line discipline to only process XON/XOFF characters by
 	 * setting tty->closing.
 	 */
+	set_bit(ASYNCB_CLOSING, &port->flags);
 	tty->closing = 1;
 	spin_unlock_irqrestore(&port->lock, flags);
-	if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) {
+	if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
-		/*
+		tty_wait_until_sent_from_close(tty,
-		 * hack: open-coded tty_wait_until_sent to avoid
+				msecs_to_jiffies(port->closing_wait));
-		 * recursive tty_lock
-		 */
-		long timeout = msecs_to_jiffies(port->closing_wait);
-		if (wait_event_interruptible_timeout(tty->write_wait,
-				!tty_chars_in_buffer(tty), timeout) >= 0)
-			__uart_wait_until_sent(uport, timeout);
-	}
 	/*
 	 * At this point, we stop accepting input.  To do this, we
 		 * has completely drained; this is especially
 		 * important if there is a transmit FIFO!
 		 */
-		__uart_wait_until_sent(uport, uport->timeout);
+		uart_wait_until_sent(tty, uport->timeout);
 	}
+	mutex_lock(&port->mutex);
 	uart_shutdown(tty, state);
 	uart_flush_buffer(tty);
 	 * Wake up anyone trying to open this port.
 	 */
 	clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
+	clear_bit(ASYNCB_CLOSING, &port->flags);
 	spin_unlock_irqrestore(&port->lock, flags);
 	wake_up_interruptible(&port->open_wait);
+	wake_up_interruptible(&port->close_wait);
-done:
 	mutex_unlock(&port->mutex);
 }
-static void __uart_wait_until_sent(struct uart_port *port, int timeout)
+static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
 {
+	struct uart_state *state = tty->driver_data;
+	struct uart_port *port = state->uart_port;
 	unsigned long char_time, expire;
 	if (port->type == PORT_UNKNOWN || port->fifosize == 0)
 	}
 }
-static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
-{
-	struct uart_state *state = tty->driver_data;
-	struct uart_port *port = state->uart_port;
-	tty_lock();
-	__uart_wait_until_sent(port, timeout);
-	tty_unlock();
-}
 /*
  * This is called with the BKL held in
  *  linux/drivers/char/tty_io.c:do_tty_hangup()
 	struct tty_port *port = &state->port;
 	unsigned long flags;
-	BUG_ON(!tty_locked());
 	pr_debug("uart_hangup(%d)\n", state->uart_port->line);
 	mutex_lock(&port->mutex);
 	struct tty_port *port;
 	int retval, line = tty->index;
-	BUG_ON(!tty_locked());
 	pr_debug("uart_open(%d) called\n", line);
 	/*
 		if (port->tty && port->tty->termios && termios.c_cflag == 0)
 			termios = *(port->tty->termios);
+		if (console_suspend_enabled)
+			uart_change_pm(state, 0);
 		uport->ops->set_termios(uport, &termios, NULL);
 		if (console_suspend_enabled)
 			console_start(uport->cons);
 	case UPIO_MEM32:
 	case UPIO_AU:
 	case UPIO_TSI:
-	case UPIO_DWAPB:
-	case UPIO_DWAPB32:
 		snprintf(address, sizeof(address),
 			 "MMIO 0x%llx", (unsigned long long)port->mapbase);
 		break;
 		port->ops = &uart_port_ops;
 		port->close_delay     = 500;	/* .5 seconds */
 		port->closing_wait    = 30000;	/* 30 seconds */
-		tasklet_init(&state->tlet, uart_tasklet_action,
-			     (unsigned long)state);
 	}
 	retval = tty_register_driver(normal);
 	 */
 	uport->type = PORT_UNKNOWN;
-	/*
-	 * Kill the tasklet, and free resources.
-	 */
-	tasklet_kill(&state->tlet);
 	state->uart_port = NULL;
 	mutex_unlock(&port_mutex);
 	case UPIO_MEM32:
 	case UPIO_AU:
 	case UPIO_TSI:
-	case UPIO_DWAPB:
-	case UPIO_DWAPB32:
 		return (port1->mapbase == port2->mapbase);
 	}
 	return 0;

drivers/tty/serial/serial_ks8695.c+5−4

  */
 #include <linux/module.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/serial.h>
 	/*
 	 * Allocate the IRQ
 	 */
-	retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, IRQF_DISABLED, "UART TX", port);
+	retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, 0, "UART TX", port);
 	if (retval)
 		goto err_tx;
-	retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, IRQF_DISABLED, "UART RX", port);
+	retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, 0, "UART RX", port);
 	if (retval)
 		goto err_rx;
-	retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, IRQF_DISABLED, "UART LineStatus", port);
+	retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, 0, "UART LineStatus", port);
 	if (retval)
 		goto err_ls;
-	retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, IRQF_DISABLED, "UART ModemStatus", port);
+	retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, 0, "UART ModemStatus", port);
 	if (retval)
 		goto err_ms;

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

@@ -28,6 +28,8 @@ · 27 unmodified lines
28	#include <linux/pci.h>	28	#include <linux/pci.h>
29	#include <linux/serial_core.h>	29	#include <linux/serial_core.h>
30	#include <linux/serial.h>	30	#include <linux/serial.h>
		31	#include <linux/tty.h>
		32	#include <linux/tty_flip.h>
31		33
32	#include <asm/io.h>	34	#include <asm/io.h>
33		35

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

@@ -1976,7 +1976,7 @@ static int __devinit sci_init_single(struct platform_device *dev, · 1975 unmodified lines
1976	* For the muxed case there's nothing more to do.	1976	* For the muxed case there's nothing more to do.
1977	*/	1977	*/
1978	port->irq = p->irqs[SCIx_RXI_IRQ];	1978	port->irq = p->irqs[SCIx_RXI_IRQ];
1979	port->irqflags = IRQF_DISABLED;	1979	port->irqflags = 0;
1980		1980
1981	port->serial_in = sci_serial_in;	1981	port->serial_in = sci_serial_in;
1982	port->serial_out = sci_serial_out;	1982	port->serial_out = sci_serial_out;

drivers/tty/serial/sn_console.c+2−1

 #include <linux/interrupt.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/serial.h>
 #include <linux/console.h>
 #include <linux/module.h>
 		DPRINTF("sn_console: switching to interrupt driven console\n");
 		if (request_irq(SGI_UART_VECTOR, sn_sal_interrupt,
-				IRQF_DISABLED | IRQF_SHARED,
+				IRQF_SHARED,
 				"SAL console driver", port) >= 0) {
 			spin_lock_irqsave(&port->sc_port.lock, flags);
 			port->sc_port.irq = SGI_UART_VECTOR;

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

 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/serial_core.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/ioport.h>

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

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include <linux/serial.h>	15	#include <linux/serial.h>
16	#include <linux/serial_core.h>	16	#include <linux/serial_core.h>
17	#include <linux/tty.h>	17	#include <linux/tty.h>
		18	#include <linux/tty_flip.h>
18	#include <linux/delay.h>	19	#include <linux/delay.h>
19	#include <linux/interrupt.h>	20	#include <linux/interrupt.h>
20	#include <linux/init.h>	21	#include <linux/init.h>

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

 #include <linux/module.h>
 #include <linux/serial.h>
-#include <linux/slab.h>
 #include <linux/serial_core.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/io.h>
 #include <linux/of_platform.h>
 #include <linux/dma-mapping.h>

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

  */
 #include <linux/platform_device.h>
+#include <linux/serial.h>
 #include <linux/serial_core.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/console.h>
-#include <linux/serial.h>
 #include <linux/irq.h>
 #include <linux/io.h>
 #include <linux/of.h>

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

@@ -63,6 +63,7 @@ · 62 unmodified lines
63	#include <linux/spinlock.h>	63	#include <linux/spinlock.h>
64	#include <linux/sysrq.h>	64	#include <linux/sysrq.h>
65	#include <linux/tty.h>	65	#include <linux/tty.h>
		66	#include <linux/tty_flip.h>
66	#include <linux/types.h>	67	#include <linux/types.h>
67		68
68	#include <linux/atomic.h>	69	#include <linux/atomic.h>

drivers/tty/synclink.c+0−1

@@ -2124,7 +2124,6 @@ static int mgsl_write(struct tty_struct * tty, · 2123 unmodified lines
2124	if ( info->params.mode == MGSL_MODE_HDLC \|\|	2124	if ( info->params.mode == MGSL_MODE_HDLC \|\|
2125	info->params.mode == MGSL_MODE_RAW ) {	2125	info->params.mode == MGSL_MODE_RAW ) {
2126	/* operating in synchronous (frame oriented) mode */	2126	/* operating in synchronous (frame oriented) mode */
2127	/* operating in synchronous (frame oriented) mode */
2128	if (info->tx_active) {	2127	if (info->tx_active) {
2129		2128
2130	if ( info->params.mode == MGSL_MODE_HDLC ) {	2129	if ( info->params.mode == MGSL_MODE_HDLC ) {

drivers/tty/synclinkmp.c+3−3

@@ -4950,7 +4950,7 @@ CheckAgain: · 4949 unmodified lines
4950		4950
4951	if ( debug_level >= DEBUG_LEVEL_DATA )	4951	if ( debug_level >= DEBUG_LEVEL_DATA )
4952	trace_block(info,info->rx_buf_list_ex[StartIndex].virt_addr,	4952	trace_block(info,info->rx_buf_list_ex[StartIndex].virt_addr,
4953	min_t(int, framesize,SCABUFSIZE),0);	4953	min_t(unsigned int, framesize, SCABUFSIZE), 0);
4954		4954
4955	if (framesize) {	4955	if (framesize) {
4956	if (framesize > info->max_frame_size)	4956	if (framesize > info->max_frame_size)
@@ -5015,14 +5015,14 @@ static void tx_load_dma_buffer(SLMP_INFO info, const char buf, unsigned int co · 58 unmodified lines
5015	SCADESC_EX *desc_ex;	5015	SCADESC_EX *desc_ex;
5016		5016
5017	if ( debug_level >= DEBUG_LEVEL_DATA )	5017	if ( debug_level >= DEBUG_LEVEL_DATA )
5018	trace_block(info,buf, min_t(int, count,SCABUFSIZE), 1);	5018	trace_block(info, buf, min_t(unsigned int, count, SCABUFSIZE), 1);
5019		5019
5020	/* Copy source buffer to one or more DMA buffers, starting with	5020	/* Copy source buffer to one or more DMA buffers, starting with
5021	* the first transmit dma buffer.	5021	* the first transmit dma buffer.
5022	*/	5022	*/
5023	for(i=0;;)	5023	for(i=0;;)
5024	{	5024	{
5025	copy_count = min_t(unsigned short,count,SCABUFSIZE);	5025	copy_count = min_t(unsigned int, count, SCABUFSIZE);
5026		5026
5027	desc = &info->tx_buf_list[i];	5027	desc = &info->tx_buf_list[i];
5028	desc_ex = &info->tx_buf_list_ex[i];	5028	desc_ex = &info->tx_buf_list_ex[i];

drivers/tty/tty_io.c+38−12

 	return ((struct tty_file_private *)file->private_data)->tty;
 }
-/* Associate a new file with the tty structure */
+int tty_alloc_file(struct file *file)
-int tty_add_file(struct tty_struct *tty, struct file *file)
 {
 	struct tty_file_private *priv;
 	if (!priv)
 		return -ENOMEM;
+	file->private_data = priv;
+	return 0;
+}
+/* Associate a new file with the tty structure */
+void tty_add_file(struct tty_struct *tty, struct file *file)
+{
+	struct tty_file_private *priv = file->private_data;
 	priv->tty = tty;
 	priv->file = file;
-	file->private_data = priv;
 	spin_lock(&tty_files_lock);
 	list_add(&priv->list, &tty->tty_files);
 	spin_unlock(&tty_files_lock);
+}
-	return 0;
+/**
+ * tty_free_file - free file->private_data
+ *
+ * This shall be used only for fail path handling when tty_add_file was not
+ * called yet.
+ */
+void tty_free_file(struct file *file)
+{
+	struct tty_file_private *priv = file->private_data;
+	file->private_data = NULL;
+	kfree(priv);
 }
 /* Delete file from its tty */
 	spin_lock(&tty_files_lock);
 	list_del(&priv->list);
 	spin_unlock(&tty_files_lock);
-	file->private_data = NULL;
+	tty_free_file(file);
-	kfree(priv);
 }
 	nonseekable_open(inode, filp);
 retry_open:
+	retval = tty_alloc_file(filp);
+	if (retval)
+		return -ENOMEM;
 	noctty = filp->f_flags & O_NOCTTY;
 	index  = -1;
 	retval = 0;
 		if (!tty) {
 			tty_unlock();
 			mutex_unlock(&tty_mutex);
+			tty_free_file(filp);
 			return -ENXIO;
 		}
 		driver = tty_driver_kref_get(tty->driver);
 		}
 		tty_unlock();
 		mutex_unlock(&tty_mutex);
+		tty_free_file(filp);
 		return -ENODEV;
 	}
 	if (!driver) {
 		tty_unlock();
 		mutex_unlock(&tty_mutex);
+		tty_free_file(filp);
 		return -ENODEV;
 	}
 got_driver:
 		if (IS_ERR(tty)) {
 			tty_unlock();
 			mutex_unlock(&tty_mutex);
+			tty_driver_kref_put(driver);
+			tty_free_file(filp);
 			return PTR_ERR(tty);
 		}
 	}
 	tty_driver_kref_put(driver);
 	if (IS_ERR(tty)) {
 		tty_unlock();
+		tty_free_file(filp);
 		return PTR_ERR(tty);
 	}
-	retval = tty_add_file(tty, filp);
+	tty_add_file(tty, filp);
-	if (retval) {
-		tty_unlock();
-		tty_release(inode, filp);
-		return retval;
-	}
 	check_tty_count(tty, "tty_open");
 	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 	ld = tty_ldisc_ref_wait(tty);
 	if (ld->ops->compat_ioctl)
 		retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
+	else
+		retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
 	tty_ldisc_deref(ld);
 	return retval;

drivers/tty/tty_ioctl.c+17−0

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	#include <linux/module.h>	19	#include <linux/module.h>
20	#include <linux/bitops.h>	20	#include <linux/bitops.h>
21	#include <linux/mutex.h>	21	#include <linux/mutex.h>
		22	#include <linux/compat.h>
22		23
23	#include <asm/io.h>	24	#include <asm/io.h>
24	#include <asm/uaccess.h>	25	#include <asm/uaccess.h>
@@ -1179,3 +1180,19 @@ int n_tty_ioctl_helper(struct tty_struct tty, struct file file, · 1154 unmodified lines
1179	}	1180	}
1180	}	1181	}
1181	EXPORT_SYMBOL(n_tty_ioctl_helper);	1182	EXPORT_SYMBOL(n_tty_ioctl_helper);
		1183
		1184	#ifdef CONFIG_COMPAT
		1185	long n_tty_compat_ioctl_helper(struct tty_struct tty, struct file file,
		1186	unsigned int cmd, unsigned long arg)
		1187	{
		1188	switch (cmd) {
		1189	case TIOCGLCKTRMIOS:
		1190	case TIOCSLCKTRMIOS:
		1191	return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
		1192	default:
		1193	return -ENOIOCTLCMD;
		1194	}
		1195	}
		1196	EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
		1197	#endif
		1198

drivers/tty/tty_ldisc.c+0−1

@@ -450,7 +450,6 @@ static int tty_ldisc_open(struct tty_struct tty, struct tty_ldisc ld) · 449 unmodified lines
450	if (ld->ops->open) {	450	if (ld->ops->open) {
451	int ret;	451	int ret;
452	/* BTM here locks versus a hangup event */	452	/* BTM here locks versus a hangup event */
453	WARN_ON(!tty_locked());
454	ret = ld->ops->open(tty);	453	ret = ld->ops->open(tty);
455	if (ret)	454	if (ret)
456	clear_bit(TTY_LDISC_OPEN, &tty->flags);	455	clear_bit(TTY_LDISC_OPEN, &tty->flags);

drivers/tty/tty_mutex.c+0−12

  * Don't use in new code.
  */
 static DEFINE_MUTEX(big_tty_mutex);
-struct task_struct *__big_tty_mutex_owner;
-EXPORT_SYMBOL_GPL(__big_tty_mutex_owner);
 /*
  * Getting the big tty mutex.
  */
 void __lockfunc tty_lock(void)
 {
-	struct task_struct *task = current;
-	WARN_ON(__big_tty_mutex_owner == task);
 	mutex_lock(&big_tty_mutex);
-	__big_tty_mutex_owner = task;
 }
 EXPORT_SYMBOL(tty_lock);
 void __lockfunc tty_unlock(void)
 {
-	struct task_struct *task = current;
-	WARN_ON(__big_tty_mutex_owner != task);
-	__big_tty_mutex_owner = NULL;
 	mutex_unlock(&big_tty_mutex);
 }
 EXPORT_SYMBOL(tty_unlock);

drivers/tty/tty_port.c+1−1

@@ -350,7 +350,7 @@ int tty_port_close_start(struct tty_port *port, · 349 unmodified lines
350	tty_driver_flush_buffer(tty);	350	tty_driver_flush_buffer(tty);
351	if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&	351	if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
352	port->closing_wait != ASYNC_CLOSING_WAIT_NONE)	352	port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
353	tty_wait_until_sent(tty, port->closing_wait);	353	tty_wait_until_sent_from_close(tty, port->closing_wait);
354	if (port->drain_delay) {	354	if (port->drain_delay) {
355	unsigned int bps = tty_get_baud_rate(tty);	355	unsigned int bps = tty_get_baud_rate(tty);
356	long timeout;	356	long timeout;

drivers/tty/vt/keyboard.c+2−1

 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <linux/irq.h>
 #include <linux/kbd_kern.h>
 #include <linux/kbd_diacr.h>
 #include <linux/notifier.h>
 #include <linux/jiffies.h>
+#include <asm/irq_regs.h>
 extern void ctrl_alt_del(void);
 /*

drivers/tty/vt/selection.c+2−2

 /* Insert the contents of the selection buffer into the
  * queue of the tty associated with the current console.
  * Invoked by ioctl().
+ *
+ * Locking: always called with BTM from vt_ioctl
  */
 int paste_selection(struct tty_struct *tty)
 {
 	struct  tty_ldisc *ld;
 	DECLARE_WAITQUEUE(wait, current);
-	/* always called with BTM from vt_ioctl */
-	WARN_ON(!tty_locked());
 	console_lock();
 	poke_blanked_console();

drivers/tty/vt/vt.c+1−1

@@ -259,7 +259,7 @@ EXPORT_SYMBOL_GPL(unregister_vt_notifier); · 258 unmodified lines
259		259
260	static void notify_write(struct vc_data *vc, unsigned int unicode)	260	static void notify_write(struct vc_data *vc, unsigned int unicode)
261	{	261	{
262	struct vt_notifier_param param = { .vc = vc, unicode = unicode };	262	struct vt_notifier_param param = { .vc = vc, .c = unicode };
263	atomic_notifier_call_chain(&vt_notifier_list, VT_WRITE, &param);	263	atomic_notifier_call_chain(&vt_notifier_list, VT_WRITE, &param);
264	}	264	}
265		265

include/linux/serial.h+1−0

@@ -211,6 +211,7 @@ struct serial_rs485 { · 210 unmodified lines
211	#define SER_RS485_RTS_ON_SEND (1 << 1)	211	#define SER_RS485_RTS_ON_SEND (1 << 1)
212	#define SER_RS485_RTS_AFTER_SEND (1 << 2)	212	#define SER_RS485_RTS_AFTER_SEND (1 << 2)
213	#define SER_RS485_RTS_BEFORE_SEND (1 << 3)	213	#define SER_RS485_RTS_BEFORE_SEND (1 << 3)
		214	#define SER_RS485_RX_DURING_TX (1 << 4)
214	__u32 delay_rts_before_send; /* Milliseconds */	215	__u32 delay_rts_before_send; /* Milliseconds */
215	__u32 delay_rts_after_send; /* Milliseconds */	216	__u32 delay_rts_after_send; /* Milliseconds */
216	__u32 padding[5]; /* Memory is cheap, new structs	217	__u32 padding[5]; /* Memory is cheap, new structs

include/linux/serial_8250.h+2−0

 	void		(*set_termios)(struct uart_port *,
 			               struct ktermios *new,
 			               struct ktermios *old);
+	int		(*handle_irq)(struct uart_port *);
 	void		(*pm)(struct uart_port *, unsigned int state,
 			      unsigned old);
 };
 		struct ktermios *termios, struct ktermios *old);
 extern void serial8250_do_pm(struct uart_port *port, unsigned int state,
 			     unsigned int oldstate);
+int serial8250_handle_irq(struct uart_port *port, unsigned int iir);
 extern void serial8250_set_isa_configurator(void (*v)
 					(int port, struct uart_port *up,

include/linux/serial_core.h+5−5

 #define PORT_AR7	18	/* Texas Instruments AR7 internal UART */
 #define PORT_U6_16550A	19	/* ST-Ericsson U6xxx internal UART */
 #define PORT_TEGRA	20	/* NVIDIA Tegra internal UART */
-#define PORT_MAX_8250	20	/* max port ID */
+#define PORT_XR17D15X	21	/* Exar XR17D15x UART */
+#define PORT_MAX_8250	21	/* max port ID */
 /*
  * ARM specific type numbers.  These are not currently guaranteed
 	void			(*set_termios)(struct uart_port *,
 				               struct ktermios *new,
 				               struct ktermios *old);
+	int			(*handle_irq)(struct uart_port *);
 	void			(*pm)(struct uart_port *, unsigned int state,
 				      unsigned int old);
 	unsigned int		irq;			/* irq number */
 #define UPIO_MEM32		(3)
 #define UPIO_AU			(4)			/* Au1x00 type IO */
 #define UPIO_TSI		(5)			/* Tsi108/109 type IO */
-#define UPIO_DWAPB		(6)			/* DesignWare APB UART */
+#define UPIO_RM9000		(6)			/* RM9000 type IO */
-#define UPIO_RM9000		(7)			/* RM9000 type IO */
-#define UPIO_DWAPB32		(8)			/* DesignWare APB UART (32 bit accesses) */
 	unsigned int		read_status_mask;	/* driver specific */
 	unsigned int		ignore_status_mask;	/* driver specific */
 #define UPF_MAGIC_MULTIPLIER	((__force upf_t) (1 << 16))
 #define UPF_CONS_FLOW		((__force upf_t) (1 << 23))
 #define UPF_SHARE_IRQ		((__force upf_t) (1 << 24))
+#define UPF_EXAR_EFR		((__force upf_t) (1 << 25))
 /* The exact UART type is known and should not be probed.  */
 #define UPF_FIXED_TYPE		((__force upf_t) (1 << 27))
 #define UPF_BOOT_AUTOCONF	((__force upf_t) (1 << 28))
 	int			pm_state;
 	struct circ_buf		xmit;
-	struct tasklet_struct	tlet;
 	struct uart_port	*uart_port;
 };

include/linux/serial_reg.h+1−0

@@ -152,6 +152,7 @@ · 151 unmodified lines
152	* LCR=0xBF (or DLAB=1 for 16C660)	152	* LCR=0xBF (or DLAB=1 for 16C660)
153	*/	153	*/
154	#define UART_EFR 2 /* I/O: Extended Features Register */	154	#define UART_EFR 2 /* I/O: Extended Features Register */
		155	#define UART_XR_EFR 9 /* I/O: Extended Features Register (XR17D15x) */
155	#define UART_EFR_CTS 0x80 /* CTS flow control */	156	#define UART_EFR_CTS 0x80 /* CTS flow control */
156	#define UART_EFR_RTS 0x40 /* RTS flow control */	157	#define UART_EFR_RTS 0x40 /* RTS flow control */
157	#define UART_EFR_SCD 0x20 /* Special character detect */	158	#define UART_EFR_SCD 0x20 /* Special character detect */

include/linux/tty.h+23−3

@@ -473,7 +473,9 @@ extern void proc_clear_tty(struct task_struct *p); · 472 unmodified lines
473	extern struct tty_struct *get_current_tty(void);	473	extern struct tty_struct *get_current_tty(void);
474	extern void tty_default_fops(struct file_operations *fops);	474	extern void tty_default_fops(struct file_operations *fops);
475	extern struct tty_struct *alloc_tty_struct(void);	475	extern struct tty_struct *alloc_tty_struct(void);
476	extern int tty_add_file(struct tty_struct tty, struct file file);	476	extern int tty_alloc_file(struct file *file);
		477	extern void tty_add_file(struct tty_struct tty, struct file file);
		478	extern void tty_free_file(struct file *file);
477	extern void free_tty_struct(struct tty_struct *tty);	479	extern void free_tty_struct(struct tty_struct *tty);
478	extern void initialize_tty_struct(struct tty_struct *tty,	480	extern void initialize_tty_struct(struct tty_struct *tty,
479	struct tty_driver *driver, int idx);	481	struct tty_driver *driver, int idx);
@@ -581,6 +583,8 @@ extern int __init tty_init(void); · 101 unmodified lines
581	/* tty_ioctl.c */	583	/* tty_ioctl.c */
582	extern int n_tty_ioctl_helper(struct tty_struct tty, struct file file,	584	extern int n_tty_ioctl_helper(struct tty_struct tty, struct file file,
583	unsigned int cmd, unsigned long arg);	585	unsigned int cmd, unsigned long arg);
		586	extern long n_tty_compat_ioctl_helper(struct tty_struct tty, struct file file,
		587	unsigned int cmd, unsigned long arg);
584		588
585	/* serial.c */	589	/* serial.c */
586		590
@@ -602,8 +606,24 @@ extern long vt_compat_ioctl(struct tty_struct *tty, · 15 unmodified lines
602	/* functions for preparation of BKL removal */	606	/* functions for preparation of BKL removal */
603	extern void __lockfunc tty_lock(void) __acquires(tty_lock);	607	extern void __lockfunc tty_lock(void) __acquires(tty_lock);
604	extern void __lockfunc tty_unlock(void) __releases(tty_lock);	608	extern void __lockfunc tty_unlock(void) __releases(tty_lock);
605	extern struct task_struct *__big_tty_mutex_owner;	609
606	#define tty_locked() (current == __big_tty_mutex_owner)	610	/*
		611	* this shall be called only from where BTM is held (like close)
		612	*
		613	* We need this to ensure nobody waits for us to finish while we are waiting.
		614	* Without this we were encountering system stalls.
		615	*
		616	* This should be indeed removed with BTM removal later.
		617	*
		618	* Locking: BTM required. Nobody is allowed to hold port->mutex.
		619	*/
		620	static inline void tty_wait_until_sent_from_close(struct tty_struct *tty,
		621	long timeout)
		622	{
		623	tty_unlock(); /* tty->ops->close holds the BTM, drop it while waiting */
		624	tty_wait_until_sent(tty, timeout);
		625	tty_lock();
		626	}
607		627
608	/*	628	/*
609	* wait_event_interruptible_tty -- wait for a condition with the tty lock held	629	* wait_event_interruptible_tty -- wait for a condition with the tty lock held

net/irda/ircomm/ircomm_tty.c+1−1

@@ -551,7 +551,7 @@ static void ircomm_tty_close(struct tty_struct tty, struct file filp) · 550 unmodified lines
551	*/	551	*/
552	tty->closing = 1;	552	tty->closing = 1;
553	if (self->closing_wait != ASYNC_CLOSING_WAIT_NONE)	553	if (self->closing_wait != ASYNC_CLOSING_WAIT_NONE)
554	tty_wait_until_sent(tty, self->closing_wait);	554	tty_wait_until_sent_from_close(tty, self->closing_wait);
555		555
556	ircomm_tty_shutdown(self);	556	ircomm_tty_shutdown(self);
557		557