Eric Lee / smarc-fsl-linux-kernel

Commit 922f9cfa79b52c85b6002d96cb0eefd13437c58c

Authored by Denis Cheng 18 years ago

Committed by Linus Torvalds 18 years ago

Exists in master and in 41 other branches

fs/char_dev.c: chrdev_open marked static and removed from fs.h

There is an outdated comment in serial_core.c also fixed.

Signed-off-by: Denis Cheng <crquan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 3 changed files with 3 additions and 4 deletions Inline Diff

drivers/serial/serial_core.c
fs/char_dev.c
include/linux/fs.h

drivers/serial/serial_core.c

Diff comments View file @ 922f9cf

1	/*	1	/*
2	* linux/drivers/char/core.c	2	* linux/drivers/char/core.c
3	*	3	*
4	* Driver core for serial ports	4	* Driver core for serial ports
5	*	5	*
6	* Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.	6	* Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
7	*	7	*
8	* Copyright 1999 ARM Limited	8	* Copyright 1999 ARM Limited
9	* Copyright (C) 2000-2001 Deep Blue Solutions Ltd.	9	* Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
10	*	10	*
11	* This program is free software; you can redistribute it and/or modify	11	* This program is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by	12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or	13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.	14	* (at your option) any later version.
15	*	15	*
16	* This program is distributed in the hope that it will be useful,	16	* This program is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.	19	* GNU General Public License for more details.
20	*	20	*
21	* You should have received a copy of the GNU General Public License	21	* You should have received a copy of the GNU General Public License
22	* along with this program; if not, write to the Free Software	22	* along with this program; if not, write to the Free Software
23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24	*/	24	*/
25	#include <linux/module.h>	25	#include <linux/module.h>
26	#include <linux/tty.h>	26	#include <linux/tty.h>
27	#include <linux/slab.h>	27	#include <linux/slab.h>
28	#include <linux/init.h>	28	#include <linux/init.h>
29	#include <linux/console.h>	29	#include <linux/console.h>
30	#include <linux/serial_core.h>	30	#include <linux/serial_core.h>
31	#include <linux/smp_lock.h>	31	#include <linux/smp_lock.h>
32	#include <linux/device.h>	32	#include <linux/device.h>
33	#include <linux/serial.h> /* for serial_state and serial_icounter_struct */	33	#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
34	#include <linux/delay.h>	34	#include <linux/delay.h>
35	#include <linux/mutex.h>	35	#include <linux/mutex.h>
36		36
37	#include <asm/irq.h>	37	#include <asm/irq.h>
38	#include <asm/uaccess.h>	38	#include <asm/uaccess.h>
39		39
40	/*	40	/*
41	* This is used to lock changes in serial line configuration.	41	* This is used to lock changes in serial line configuration.
42	*/	42	*/
43	static DEFINE_MUTEX(port_mutex);	43	static DEFINE_MUTEX(port_mutex);
44		44
45	/*	45	/*
46	* lockdep: port->lock is initialized in two places, but we	46	* lockdep: port->lock is initialized in two places, but we
47	* want only one lock-class:	47	* want only one lock-class:
48	*/	48	*/
49	static struct lock_class_key port_lock_key;	49	static struct lock_class_key port_lock_key;
50		50
51	#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)	51	#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
52		52
53	#define uart_users(state) ((state)->count + ((state)->info ? (state)->info->blocked_open : 0))	53	#define uart_users(state) ((state)->count + ((state)->info ? (state)->info->blocked_open : 0))
54		54
55	#ifdef CONFIG_SERIAL_CORE_CONSOLE	55	#ifdef CONFIG_SERIAL_CORE_CONSOLE
56	#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)	56	#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)
57	#else	57	#else
58	#define uart_console(port) (0)	58	#define uart_console(port) (0)
59	#endif	59	#endif
60		60
61	static void uart_change_speed(struct uart_state *state,	61	static void uart_change_speed(struct uart_state *state,
62	struct ktermios *old_termios);	62	struct ktermios *old_termios);
63	static void uart_wait_until_sent(struct tty_struct *tty, int timeout);	63	static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
64	static void uart_change_pm(struct uart_state *state, int pm_state);	64	static void uart_change_pm(struct uart_state *state, int pm_state);
65		65
66	/*	66	/*
67	* This routine is used by the interrupt handler to schedule processing in	67	* This routine is used by the interrupt handler to schedule processing in
68	* the software interrupt portion of the driver.	68	* the software interrupt portion of the driver.
69	*/	69	*/
70	void uart_write_wakeup(struct uart_port *port)	70	void uart_write_wakeup(struct uart_port *port)
71	{	71	{
72	struct uart_info *info = port->info;	72	struct uart_info *info = port->info;
73	/*	73	/*
74	* This means you called this function _after_ the port was	74	* This means you called this function _after_ the port was
75	* closed. No cookie for you.	75	* closed. No cookie for you.
76	*/	76	*/
77	BUG_ON(!info);	77	BUG_ON(!info);
78	tasklet_schedule(&info->tlet);	78	tasklet_schedule(&info->tlet);
79	}	79	}
80		80
81	static void uart_stop(struct tty_struct *tty)	81	static void uart_stop(struct tty_struct *tty)
82	{	82	{
83	struct uart_state *state = tty->driver_data;	83	struct uart_state *state = tty->driver_data;
84	struct uart_port *port = state->port;	84	struct uart_port *port = state->port;
85	unsigned long flags;	85	unsigned long flags;
86		86
87	spin_lock_irqsave(&port->lock, flags);	87	spin_lock_irqsave(&port->lock, flags);
88	port->ops->stop_tx(port);	88	port->ops->stop_tx(port);
89	spin_unlock_irqrestore(&port->lock, flags);	89	spin_unlock_irqrestore(&port->lock, flags);
90	}	90	}
91		91
92	static void __uart_start(struct tty_struct *tty)	92	static void __uart_start(struct tty_struct *tty)
93	{	93	{
94	struct uart_state *state = tty->driver_data;	94	struct uart_state *state = tty->driver_data;
95	struct uart_port *port = state->port;	95	struct uart_port *port = state->port;
96		96
97	if (!uart_circ_empty(&state->info->xmit) && state->info->xmit.buf &&	97	if (!uart_circ_empty(&state->info->xmit) && state->info->xmit.buf &&
98	!tty->stopped && !tty->hw_stopped)	98	!tty->stopped && !tty->hw_stopped)
99	port->ops->start_tx(port);	99	port->ops->start_tx(port);
100	}	100	}
101		101
102	static void uart_start(struct tty_struct *tty)	102	static void uart_start(struct tty_struct *tty)
103	{	103	{
104	struct uart_state *state = tty->driver_data;	104	struct uart_state *state = tty->driver_data;
105	struct uart_port *port = state->port;	105	struct uart_port *port = state->port;
106	unsigned long flags;	106	unsigned long flags;
107		107
108	spin_lock_irqsave(&port->lock, flags);	108	spin_lock_irqsave(&port->lock, flags);
109	__uart_start(tty);	109	__uart_start(tty);
110	spin_unlock_irqrestore(&port->lock, flags);	110	spin_unlock_irqrestore(&port->lock, flags);
111	}	111	}
112		112
113	static void uart_tasklet_action(unsigned long data)	113	static void uart_tasklet_action(unsigned long data)
114	{	114	{
115	struct uart_state state = (struct uart_state )data;	115	struct uart_state state = (struct uart_state )data;
116	tty_wakeup(state->info->tty);	116	tty_wakeup(state->info->tty);
117	}	117	}
118		118
119	static inline void	119	static inline void
120	uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)	120	uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
121	{	121	{
122	unsigned long flags;	122	unsigned long flags;
123	unsigned int old;	123	unsigned int old;
124		124
125	spin_lock_irqsave(&port->lock, flags);	125	spin_lock_irqsave(&port->lock, flags);
126	old = port->mctrl;	126	old = port->mctrl;
127	port->mctrl = (old & ~clear) \| set;	127	port->mctrl = (old & ~clear) \| set;
128	if (old != port->mctrl)	128	if (old != port->mctrl)
129	port->ops->set_mctrl(port, port->mctrl);	129	port->ops->set_mctrl(port, port->mctrl);
130	spin_unlock_irqrestore(&port->lock, flags);	130	spin_unlock_irqrestore(&port->lock, flags);
131	}	131	}
132		132
133	#define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0)	133	#define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0)
134	#define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear)	134	#define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear)
135		135
136	/*	136	/*
137	* Startup the port. This will be called once per open. All calls	137	* Startup the port. This will be called once per open. All calls
138	* will be serialised by the per-port semaphore.	138	* will be serialised by the per-port semaphore.
139	*/	139	*/
140	static int uart_startup(struct uart_state *state, int init_hw)	140	static int uart_startup(struct uart_state *state, int init_hw)
141	{	141	{
142	struct uart_info *info = state->info;	142	struct uart_info *info = state->info;
143	struct uart_port *port = state->port;	143	struct uart_port *port = state->port;
144	unsigned long page;	144	unsigned long page;
145	int retval = 0;	145	int retval = 0;
146		146
147	if (info->flags & UIF_INITIALIZED)	147	if (info->flags & UIF_INITIALIZED)
148	return 0;	148	return 0;
149		149
150	/*	150	/*
151	* Set the TTY IO error marker - we will only clear this	151	* Set the TTY IO error marker - we will only clear this
152	* once we have successfully opened the port. Also set	152	* once we have successfully opened the port. Also set
153	* up the tty->alt_speed kludge	153	* up the tty->alt_speed kludge
154	*/	154	*/
155	set_bit(TTY_IO_ERROR, &info->tty->flags);	155	set_bit(TTY_IO_ERROR, &info->tty->flags);
156		156
157	if (port->type == PORT_UNKNOWN)	157	if (port->type == PORT_UNKNOWN)
158	return 0;	158	return 0;
159		159
160	/*	160	/*
161	* Initialise and allocate the transmit and temporary	161	* Initialise and allocate the transmit and temporary
162	* buffer.	162	* buffer.
163	*/	163	*/
164	if (!info->xmit.buf) {	164	if (!info->xmit.buf) {
165	page = get_zeroed_page(GFP_KERNEL);	165	page = get_zeroed_page(GFP_KERNEL);
166	if (!page)	166	if (!page)
167	return -ENOMEM;	167	return -ENOMEM;
168		168
169	info->xmit.buf = (unsigned char *) page;	169	info->xmit.buf = (unsigned char *) page;
170	uart_circ_clear(&info->xmit);	170	uart_circ_clear(&info->xmit);
171	}	171	}
172		172
173	retval = port->ops->startup(port);	173	retval = port->ops->startup(port);
174	if (retval == 0) {	174	if (retval == 0) {
175	if (init_hw) {	175	if (init_hw) {
176	/*	176	/*
177	* Initialise the hardware port settings.	177	* Initialise the hardware port settings.
178	*/	178	*/
179	uart_change_speed(state, NULL);	179	uart_change_speed(state, NULL);
180		180
181	/*	181	/*
182	* Setup the RTS and DTR signals once the	182	* Setup the RTS and DTR signals once the
183	* port is open and ready to respond.	183	* port is open and ready to respond.
184	*/	184	*/
185	if (info->tty->termios->c_cflag & CBAUD)	185	if (info->tty->termios->c_cflag & CBAUD)
186	uart_set_mctrl(port, TIOCM_RTS \| TIOCM_DTR);	186	uart_set_mctrl(port, TIOCM_RTS \| TIOCM_DTR);
187	}	187	}
188		188
189	if (info->flags & UIF_CTS_FLOW) {	189	if (info->flags & UIF_CTS_FLOW) {
190	spin_lock_irq(&port->lock);	190	spin_lock_irq(&port->lock);
191	if (!(port->ops->get_mctrl(port) & TIOCM_CTS))	191	if (!(port->ops->get_mctrl(port) & TIOCM_CTS))
192	info->tty->hw_stopped = 1;	192	info->tty->hw_stopped = 1;
193	spin_unlock_irq(&port->lock);	193	spin_unlock_irq(&port->lock);
194	}	194	}
195		195
196	info->flags \|= UIF_INITIALIZED;	196	info->flags \|= UIF_INITIALIZED;
197		197
198	clear_bit(TTY_IO_ERROR, &info->tty->flags);	198	clear_bit(TTY_IO_ERROR, &info->tty->flags);
199	}	199	}
200		200
201	if (retval && capable(CAP_SYS_ADMIN))	201	if (retval && capable(CAP_SYS_ADMIN))
202	retval = 0;	202	retval = 0;
203		203
204	return retval;	204	return retval;
205	}	205	}
206		206
207	/*	207	/*
208	* This routine will shutdown a serial port; interrupts are disabled, and	208	* This routine will shutdown a serial port; interrupts are disabled, and
209	* DTR is dropped if the hangup on close termio flag is on. Calls to	209	* DTR is dropped if the hangup on close termio flag is on. Calls to
210	* uart_shutdown are serialised by the per-port semaphore.	210	* uart_shutdown are serialised by the per-port semaphore.
211	*/	211	*/
212	static void uart_shutdown(struct uart_state *state)	212	static void uart_shutdown(struct uart_state *state)
213	{	213	{
214	struct uart_info *info = state->info;	214	struct uart_info *info = state->info;
215	struct uart_port *port = state->port;	215	struct uart_port *port = state->port;
216		216
217	/*	217	/*
218	* Set the TTY IO error marker	218	* Set the TTY IO error marker
219	*/	219	*/
220	if (info->tty)	220	if (info->tty)
221	set_bit(TTY_IO_ERROR, &info->tty->flags);	221	set_bit(TTY_IO_ERROR, &info->tty->flags);
222		222
223	if (info->flags & UIF_INITIALIZED) {	223	if (info->flags & UIF_INITIALIZED) {
224	info->flags &= ~UIF_INITIALIZED;	224	info->flags &= ~UIF_INITIALIZED;
225		225
226	/*	226	/*
227	* Turn off DTR and RTS early.	227	* Turn off DTR and RTS early.
228	*/	228	*/
229	if (!info->tty \|\| (info->tty->termios->c_cflag & HUPCL))	229	if (!info->tty \|\| (info->tty->termios->c_cflag & HUPCL))
230	uart_clear_mctrl(port, TIOCM_DTR \| TIOCM_RTS);	230	uart_clear_mctrl(port, TIOCM_DTR \| TIOCM_RTS);
231		231
232	/*	232	/*
233	* clear delta_msr_wait queue to avoid mem leaks: we may free	233	* clear delta_msr_wait queue to avoid mem leaks: we may free
234	* the irq here so the queue might never be woken up. Note	234	* the irq here so the queue might never be woken up. Note
235	* that we won't end up waiting on delta_msr_wait again since	235	* that we won't end up waiting on delta_msr_wait again since
236	* any outstanding file descriptors should be pointing at	236	* any outstanding file descriptors should be pointing at
237	* hung_up_tty_fops now.	237	* hung_up_tty_fops now.
238	*/	238	*/
239	wake_up_interruptible(&info->delta_msr_wait);	239	wake_up_interruptible(&info->delta_msr_wait);
240		240
241	/*	241	/*
242	* Free the IRQ and disable the port.	242	* Free the IRQ and disable the port.
243	*/	243	*/
244	port->ops->shutdown(port);	244	port->ops->shutdown(port);
245		245
246	/*	246	/*
247	* Ensure that the IRQ handler isn't running on another CPU.	247	* Ensure that the IRQ handler isn't running on another CPU.
248	*/	248	*/
249	synchronize_irq(port->irq);	249	synchronize_irq(port->irq);
250	}	250	}
251		251
252	/*	252	/*
253	* kill off our tasklet	253	* kill off our tasklet
254	*/	254	*/
255	tasklet_kill(&info->tlet);	255	tasklet_kill(&info->tlet);
256		256
257	/*	257	/*
258	* Free the transmit buffer page.	258	* Free the transmit buffer page.
259	*/	259	*/
260	if (info->xmit.buf) {	260	if (info->xmit.buf) {
261	free_page((unsigned long)info->xmit.buf);	261	free_page((unsigned long)info->xmit.buf);
262	info->xmit.buf = NULL;	262	info->xmit.buf = NULL;
263	}	263	}
264	}	264	}
265		265
266	/**	266	/**
267	* uart_update_timeout - update per-port FIFO timeout.	267	* uart_update_timeout - update per-port FIFO timeout.
268	* @port: uart_port structure describing the port	268	* @port: uart_port structure describing the port
269	* @cflag: termios cflag value	269	* @cflag: termios cflag value
270	* @baud: speed of the port	270	* @baud: speed of the port
271	*	271	*
272	* Set the port FIFO timeout value. The @cflag value should	272	* Set the port FIFO timeout value. The @cflag value should
273	* reflect the actual hardware settings.	273	* reflect the actual hardware settings.
274	*/	274	*/
275	void	275	void
276	uart_update_timeout(struct uart_port *port, unsigned int cflag,	276	uart_update_timeout(struct uart_port *port, unsigned int cflag,
277	unsigned int baud)	277	unsigned int baud)
278	{	278	{
279	unsigned int bits;	279	unsigned int bits;
280		280
281	/* byte size and parity */	281	/* byte size and parity */
282	switch (cflag & CSIZE) {	282	switch (cflag & CSIZE) {
283	case CS5:	283	case CS5:
284	bits = 7;	284	bits = 7;
285	break;	285	break;
286	case CS6:	286	case CS6:
287	bits = 8;	287	bits = 8;
288	break;	288	break;
289	case CS7:	289	case CS7:
290	bits = 9;	290	bits = 9;
291	break;	291	break;
292	default:	292	default:
293	bits = 10;	293	bits = 10;
294	break; /* CS8 */	294	break; /* CS8 */
295	}	295	}
296		296
297	if (cflag & CSTOPB)	297	if (cflag & CSTOPB)
298	bits++;	298	bits++;
299	if (cflag & PARENB)	299	if (cflag & PARENB)
300	bits++;	300	bits++;
301		301
302	/*	302	/*
303	* The total number of bits to be transmitted in the fifo.	303	* The total number of bits to be transmitted in the fifo.
304	*/	304	*/
305	bits = bits * port->fifosize;	305	bits = bits * port->fifosize;
306		306
307	/*	307	/*
308	* Figure the timeout to send the above number of bits.	308	* Figure the timeout to send the above number of bits.
309	* Add .02 seconds of slop	309	* Add .02 seconds of slop
310	*/	310	*/
311	port->timeout = (HZ * bits) / baud + HZ/50;	311	port->timeout = (HZ * bits) / baud + HZ/50;
312	}	312	}
313		313
314	EXPORT_SYMBOL(uart_update_timeout);	314	EXPORT_SYMBOL(uart_update_timeout);
315		315
316	/**	316	/**
317	* uart_get_baud_rate - return baud rate for a particular port	317	* uart_get_baud_rate - return baud rate for a particular port
318	* @port: uart_port structure describing the port in question.	318	* @port: uart_port structure describing the port in question.
319	* @termios: desired termios settings.	319	* @termios: desired termios settings.
320	* @old: old termios (or NULL)	320	* @old: old termios (or NULL)
321	* @min: minimum acceptable baud rate	321	* @min: minimum acceptable baud rate
322	* @max: maximum acceptable baud rate	322	* @max: maximum acceptable baud rate
323	*	323	*
324	* Decode the termios structure into a numeric baud rate,	324	* Decode the termios structure into a numeric baud rate,
325	* taking account of the magic 38400 baud rate (with spd_*	325	* taking account of the magic 38400 baud rate (with spd_*
326	* flags), and mapping the %B0 rate to 9600 baud.	326	* flags), and mapping the %B0 rate to 9600 baud.
327	*	327	*
328	* If the new baud rate is invalid, try the old termios setting.	328	* If the new baud rate is invalid, try the old termios setting.
329	* If it's still invalid, we try 9600 baud.	329	* If it's still invalid, we try 9600 baud.
330	*	330	*
331	* Update the @termios structure to reflect the baud rate	331	* Update the @termios structure to reflect the baud rate
332	* we're actually going to be using.	332	* we're actually going to be using.
333	*/	333	*/
334	unsigned int	334	unsigned int
335	uart_get_baud_rate(struct uart_port port, struct ktermios termios,	335	uart_get_baud_rate(struct uart_port port, struct ktermios termios,
336	struct ktermios *old, unsigned int min, unsigned int max)	336	struct ktermios *old, unsigned int min, unsigned int max)
337	{	337	{
338	unsigned int try, baud, altbaud = 38400;	338	unsigned int try, baud, altbaud = 38400;
339	upf_t flags = port->flags & UPF_SPD_MASK;	339	upf_t flags = port->flags & UPF_SPD_MASK;
340		340
341	if (flags == UPF_SPD_HI)	341	if (flags == UPF_SPD_HI)
342	altbaud = 57600;	342	altbaud = 57600;
343	if (flags == UPF_SPD_VHI)	343	if (flags == UPF_SPD_VHI)
344	altbaud = 115200;	344	altbaud = 115200;
345	if (flags == UPF_SPD_SHI)	345	if (flags == UPF_SPD_SHI)
346	altbaud = 230400;	346	altbaud = 230400;
347	if (flags == UPF_SPD_WARP)	347	if (flags == UPF_SPD_WARP)
348	altbaud = 460800;	348	altbaud = 460800;
349		349
350	for (try = 0; try < 2; try++) {	350	for (try = 0; try < 2; try++) {
351	baud = tty_termios_baud_rate(termios);	351	baud = tty_termios_baud_rate(termios);
352		352
353	/*	353	/*
354	* The spd_hi, spd_vhi, spd_shi, spd_warp kludge...	354	* The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
355	* Die! Die! Die!	355	* Die! Die! Die!
356	*/	356	*/
357	if (baud == 38400)	357	if (baud == 38400)
358	baud = altbaud;	358	baud = altbaud;
359		359
360	/*	360	/*
361	* Special case: B0 rate.	361	* Special case: B0 rate.
362	*/	362	*/
363	if (baud == 0)	363	if (baud == 0)
364	baud = 9600;	364	baud = 9600;
365		365
366	if (baud >= min && baud <= max)	366	if (baud >= min && baud <= max)
367	return baud;	367	return baud;
368		368
369	/*	369	/*
370	* Oops, the quotient was zero. Try again with	370	* Oops, the quotient was zero. Try again with
371	* the old baud rate if possible.	371	* the old baud rate if possible.
372	*/	372	*/
373	termios->c_cflag &= ~CBAUD;	373	termios->c_cflag &= ~CBAUD;
374	if (old) {	374	if (old) {
375	baud = tty_termios_baud_rate(old);	375	baud = tty_termios_baud_rate(old);
376	tty_termios_encode_baud_rate(termios, baud, baud);	376	tty_termios_encode_baud_rate(termios, baud, baud);
377	old = NULL;	377	old = NULL;
378	continue;	378	continue;
379	}	379	}
380		380
381	/*	381	/*
382	* As a last resort, if the quotient is zero,	382	* As a last resort, if the quotient is zero,
383	* default to 9600 bps	383	* default to 9600 bps
384	*/	384	*/
385	tty_termios_encode_baud_rate(termios, 9600, 9600);	385	tty_termios_encode_baud_rate(termios, 9600, 9600);
386	}	386	}
387		387
388	return 0;	388	return 0;
389	}	389	}
390		390
391	EXPORT_SYMBOL(uart_get_baud_rate);	391	EXPORT_SYMBOL(uart_get_baud_rate);
392		392
393	/**	393	/**
394	* uart_get_divisor - return uart clock divisor	394	* uart_get_divisor - return uart clock divisor
395	* @port: uart_port structure describing the port.	395	* @port: uart_port structure describing the port.
396	* @baud: desired baud rate	396	* @baud: desired baud rate
397	*	397	*
398	* Calculate the uart clock divisor for the port.	398	* Calculate the uart clock divisor for the port.
399	*/	399	*/
400	unsigned int	400	unsigned int
401	uart_get_divisor(struct uart_port *port, unsigned int baud)	401	uart_get_divisor(struct uart_port *port, unsigned int baud)
402	{	402	{
403	unsigned int quot;	403	unsigned int quot;
404		404
405	/*	405	/*
406	* Old custom speed handling.	406	* Old custom speed handling.
407	*/	407	*/
408	if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)	408	if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
409	quot = port->custom_divisor;	409	quot = port->custom_divisor;
410	else	410	else
411	quot = (port->uartclk + (8 * baud)) / (16 * baud);	411	quot = (port->uartclk + (8 * baud)) / (16 * baud);
412		412
413	return quot;	413	return quot;
414	}	414	}
415		415
416	EXPORT_SYMBOL(uart_get_divisor);	416	EXPORT_SYMBOL(uart_get_divisor);
417		417
418	static void	418	static void
419	uart_change_speed(struct uart_state state, struct ktermios old_termios)	419	uart_change_speed(struct uart_state state, struct ktermios old_termios)
420	{	420	{
421	struct tty_struct *tty = state->info->tty;	421	struct tty_struct *tty = state->info->tty;
422	struct uart_port *port = state->port;	422	struct uart_port *port = state->port;
423	struct ktermios *termios;	423	struct ktermios *termios;
424		424
425	/*	425	/*
426	* If we have no tty, termios, or the port does not exist,	426	* If we have no tty, termios, or the port does not exist,
427	* then we can't set the parameters for this port.	427	* then we can't set the parameters for this port.
428	*/	428	*/
429	if (!tty \|\| !tty->termios \|\| port->type == PORT_UNKNOWN)	429	if (!tty \|\| !tty->termios \|\| port->type == PORT_UNKNOWN)
430	return;	430	return;
431		431
432	termios = tty->termios;	432	termios = tty->termios;
433		433
434	/*	434	/*
435	* Set flags based on termios cflag	435	* Set flags based on termios cflag
436	*/	436	*/
437	if (termios->c_cflag & CRTSCTS)	437	if (termios->c_cflag & CRTSCTS)
438	state->info->flags \|= UIF_CTS_FLOW;	438	state->info->flags \|= UIF_CTS_FLOW;
439	else	439	else
440	state->info->flags &= ~UIF_CTS_FLOW;	440	state->info->flags &= ~UIF_CTS_FLOW;
441		441
442	if (termios->c_cflag & CLOCAL)	442	if (termios->c_cflag & CLOCAL)
443	state->info->flags &= ~UIF_CHECK_CD;	443	state->info->flags &= ~UIF_CHECK_CD;
444	else	444	else
445	state->info->flags \|= UIF_CHECK_CD;	445	state->info->flags \|= UIF_CHECK_CD;
446		446
447	port->ops->set_termios(port, termios, old_termios);	447	port->ops->set_termios(port, termios, old_termios);
448	}	448	}
449		449
450	static inline void	450	static inline void
451	__uart_put_char(struct uart_port port, struct circ_buf circ, unsigned char c)	451	__uart_put_char(struct uart_port port, struct circ_buf circ, unsigned char c)
452	{	452	{
453	unsigned long flags;	453	unsigned long flags;
454		454
455	if (!circ->buf)	455	if (!circ->buf)
456	return;	456	return;
457		457
458	spin_lock_irqsave(&port->lock, flags);	458	spin_lock_irqsave(&port->lock, flags);
459	if (uart_circ_chars_free(circ) != 0) {	459	if (uart_circ_chars_free(circ) != 0) {
460	circ->buf[circ->head] = c;	460	circ->buf[circ->head] = c;
461	circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);	461	circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
462	}	462	}
463	spin_unlock_irqrestore(&port->lock, flags);	463	spin_unlock_irqrestore(&port->lock, flags);
464	}	464	}
465		465
466	static void uart_put_char(struct tty_struct *tty, unsigned char ch)	466	static void uart_put_char(struct tty_struct *tty, unsigned char ch)
467	{	467	{
468	struct uart_state *state = tty->driver_data;	468	struct uart_state *state = tty->driver_data;
469		469
470	__uart_put_char(state->port, &state->info->xmit, ch);	470	__uart_put_char(state->port, &state->info->xmit, ch);
471	}	471	}
472		472
473	static void uart_flush_chars(struct tty_struct *tty)	473	static void uart_flush_chars(struct tty_struct *tty)
474	{	474	{
475	uart_start(tty);	475	uart_start(tty);
476	}	476	}
477		477
478	static int	478	static int
479	uart_write(struct tty_struct tty, const unsigned char buf, int count)	479	uart_write(struct tty_struct tty, const unsigned char buf, int count)
480	{	480	{
481	struct uart_state *state = tty->driver_data;	481	struct uart_state *state = tty->driver_data;
482	struct uart_port *port;	482	struct uart_port *port;
483	struct circ_buf *circ;	483	struct circ_buf *circ;
484	unsigned long flags;	484	unsigned long flags;
485	int c, ret = 0;	485	int c, ret = 0;
486		486
487	/*	487	/*
488	* This means you called this function _after_ the port was	488	* This means you called this function _after_ the port was
489	* closed. No cookie for you.	489	* closed. No cookie for you.
490	*/	490	*/
491	if (!state \|\| !state->info) {	491	if (!state \|\| !state->info) {
492	WARN_ON(1);	492	WARN_ON(1);
493	return -EL3HLT;	493	return -EL3HLT;
494	}	494	}
495		495
496	port = state->port;	496	port = state->port;
497	circ = &state->info->xmit;	497	circ = &state->info->xmit;
498		498
499	if (!circ->buf)	499	if (!circ->buf)
500	return 0;	500	return 0;
501		501
502	spin_lock_irqsave(&port->lock, flags);	502	spin_lock_irqsave(&port->lock, flags);
503	while (1) {	503	while (1) {
504	c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);	504	c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
505	if (count < c)	505	if (count < c)
506	c = count;	506	c = count;
507	if (c <= 0)	507	if (c <= 0)
508	break;	508	break;
509	memcpy(circ->buf + circ->head, buf, c);	509	memcpy(circ->buf + circ->head, buf, c);
510	circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);	510	circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
511	buf += c;	511	buf += c;
512	count -= c;	512	count -= c;
513	ret += c;	513	ret += c;
514	}	514	}
515	spin_unlock_irqrestore(&port->lock, flags);	515	spin_unlock_irqrestore(&port->lock, flags);
516		516
517	uart_start(tty);	517	uart_start(tty);
518	return ret;	518	return ret;
519	}	519	}
520		520
521	static int uart_write_room(struct tty_struct *tty)	521	static int uart_write_room(struct tty_struct *tty)
522	{	522	{
523	struct uart_state *state = tty->driver_data;	523	struct uart_state *state = tty->driver_data;
524		524
525	return uart_circ_chars_free(&state->info->xmit);	525	return uart_circ_chars_free(&state->info->xmit);
526	}	526	}
527		527
528	static int uart_chars_in_buffer(struct tty_struct *tty)	528	static int uart_chars_in_buffer(struct tty_struct *tty)
529	{	529	{
530	struct uart_state *state = tty->driver_data;	530	struct uart_state *state = tty->driver_data;
531		531
532	return uart_circ_chars_pending(&state->info->xmit);	532	return uart_circ_chars_pending(&state->info->xmit);
533	}	533	}
534		534
535	static void uart_flush_buffer(struct tty_struct *tty)	535	static void uart_flush_buffer(struct tty_struct *tty)
536	{	536	{
537	struct uart_state *state = tty->driver_data;	537	struct uart_state *state = tty->driver_data;
538	struct uart_port *port = state->port;	538	struct uart_port *port = state->port;
539	unsigned long flags;	539	unsigned long flags;
540		540
541	/*	541	/*
542	* This means you called this function _after_ the port was	542	* This means you called this function _after_ the port was
543	* closed. No cookie for you.	543	* closed. No cookie for you.
544	*/	544	*/
545	if (!state \|\| !state->info) {	545	if (!state \|\| !state->info) {
546	WARN_ON(1);	546	WARN_ON(1);
547	return;	547	return;
548	}	548	}
549		549
550	pr_debug("uart_flush_buffer(%d) called\n", tty->index);	550	pr_debug("uart_flush_buffer(%d) called\n", tty->index);
551		551
552	spin_lock_irqsave(&port->lock, flags);	552	spin_lock_irqsave(&port->lock, flags);
553	uart_circ_clear(&state->info->xmit);	553	uart_circ_clear(&state->info->xmit);
554	spin_unlock_irqrestore(&port->lock, flags);	554	spin_unlock_irqrestore(&port->lock, flags);
555	tty_wakeup(tty);	555	tty_wakeup(tty);
556	}	556	}
557		557
558	/*	558	/*
559	* This function is used to send a high-priority XON/XOFF character to	559	* This function is used to send a high-priority XON/XOFF character to
560	* the device	560	* the device
561	*/	561	*/
562	static void uart_send_xchar(struct tty_struct *tty, char ch)	562	static void uart_send_xchar(struct tty_struct *tty, char ch)
563	{	563	{
564	struct uart_state *state = tty->driver_data;	564	struct uart_state *state = tty->driver_data;
565	struct uart_port *port = state->port;	565	struct uart_port *port = state->port;
566	unsigned long flags;	566	unsigned long flags;
567		567
568	if (port->ops->send_xchar)	568	if (port->ops->send_xchar)
569	port->ops->send_xchar(port, ch);	569	port->ops->send_xchar(port, ch);
570	else {	570	else {
571	port->x_char = ch;	571	port->x_char = ch;
572	if (ch) {	572	if (ch) {
573	spin_lock_irqsave(&port->lock, flags);	573	spin_lock_irqsave(&port->lock, flags);
574	port->ops->start_tx(port);	574	port->ops->start_tx(port);
575	spin_unlock_irqrestore(&port->lock, flags);	575	spin_unlock_irqrestore(&port->lock, flags);
576	}	576	}
577	}	577	}
578	}	578	}
579		579
580	static void uart_throttle(struct tty_struct *tty)	580	static void uart_throttle(struct tty_struct *tty)
581	{	581	{
582	struct uart_state *state = tty->driver_data;	582	struct uart_state *state = tty->driver_data;
583		583
584	if (I_IXOFF(tty))	584	if (I_IXOFF(tty))
585	uart_send_xchar(tty, STOP_CHAR(tty));	585	uart_send_xchar(tty, STOP_CHAR(tty));
586		586
587	if (tty->termios->c_cflag & CRTSCTS)	587	if (tty->termios->c_cflag & CRTSCTS)
588	uart_clear_mctrl(state->port, TIOCM_RTS);	588	uart_clear_mctrl(state->port, TIOCM_RTS);
589	}	589	}
590		590
591	static void uart_unthrottle(struct tty_struct *tty)	591	static void uart_unthrottle(struct tty_struct *tty)
592	{	592	{
593	struct uart_state *state = tty->driver_data;	593	struct uart_state *state = tty->driver_data;
594	struct uart_port *port = state->port;	594	struct uart_port *port = state->port;
595		595
596	if (I_IXOFF(tty)) {	596	if (I_IXOFF(tty)) {
597	if (port->x_char)	597	if (port->x_char)
598	port->x_char = 0;	598	port->x_char = 0;
599	else	599	else
600	uart_send_xchar(tty, START_CHAR(tty));	600	uart_send_xchar(tty, START_CHAR(tty));
601	}	601	}
602		602
603	if (tty->termios->c_cflag & CRTSCTS)	603	if (tty->termios->c_cflag & CRTSCTS)
604	uart_set_mctrl(port, TIOCM_RTS);	604	uart_set_mctrl(port, TIOCM_RTS);
605	}	605	}
606		606
607	static int uart_get_info(struct uart_state *state,	607	static int uart_get_info(struct uart_state *state,
608	struct serial_struct __user *retinfo)	608	struct serial_struct __user *retinfo)
609	{	609	{
610	struct uart_port *port = state->port;	610	struct uart_port *port = state->port;
611	struct serial_struct tmp;	611	struct serial_struct tmp;
612		612
613	memset(&tmp, 0, sizeof(tmp));	613	memset(&tmp, 0, sizeof(tmp));
614	tmp.type = port->type;	614	tmp.type = port->type;
615	tmp.line = port->line;	615	tmp.line = port->line;
616	tmp.port = port->iobase;	616	tmp.port = port->iobase;
617	if (HIGH_BITS_OFFSET)	617	if (HIGH_BITS_OFFSET)
618	tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET;	618	tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET;
619	tmp.irq = port->irq;	619	tmp.irq = port->irq;
620	tmp.flags = port->flags;	620	tmp.flags = port->flags;
621	tmp.xmit_fifo_size = port->fifosize;	621	tmp.xmit_fifo_size = port->fifosize;
622	tmp.baud_base = port->uartclk / 16;	622	tmp.baud_base = port->uartclk / 16;
623	tmp.close_delay = state->close_delay / 10;	623	tmp.close_delay = state->close_delay / 10;
624	tmp.closing_wait = state->closing_wait == USF_CLOSING_WAIT_NONE ?	624	tmp.closing_wait = state->closing_wait == USF_CLOSING_WAIT_NONE ?
625	ASYNC_CLOSING_WAIT_NONE :	625	ASYNC_CLOSING_WAIT_NONE :
626	state->closing_wait / 10;	626	state->closing_wait / 10;
627	tmp.custom_divisor = port->custom_divisor;	627	tmp.custom_divisor = port->custom_divisor;
628	tmp.hub6 = port->hub6;	628	tmp.hub6 = port->hub6;
629	tmp.io_type = port->iotype;	629	tmp.io_type = port->iotype;
630	tmp.iomem_reg_shift = port->regshift;	630	tmp.iomem_reg_shift = port->regshift;
631	tmp.iomem_base = (void *)(unsigned long)port->mapbase;	631	tmp.iomem_base = (void *)(unsigned long)port->mapbase;
632		632
633	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))	633	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
634	return -EFAULT;	634	return -EFAULT;
635	return 0;	635	return 0;
636	}	636	}
637		637
638	static int uart_set_info(struct uart_state *state,	638	static int uart_set_info(struct uart_state *state,
639	struct serial_struct __user *newinfo)	639	struct serial_struct __user *newinfo)
640	{	640	{
641	struct serial_struct new_serial;	641	struct serial_struct new_serial;
642	struct uart_port *port = state->port;	642	struct uart_port *port = state->port;
643	unsigned long new_port;	643	unsigned long new_port;
644	unsigned int change_irq, change_port, closing_wait;	644	unsigned int change_irq, change_port, closing_wait;
645	unsigned int old_custom_divisor, close_delay;	645	unsigned int old_custom_divisor, close_delay;
646	upf_t old_flags, new_flags;	646	upf_t old_flags, new_flags;
647	int retval = 0;	647	int retval = 0;
648		648
649	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))	649	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
650	return -EFAULT;	650	return -EFAULT;
651		651
652	new_port = new_serial.port;	652	new_port = new_serial.port;
653	if (HIGH_BITS_OFFSET)	653	if (HIGH_BITS_OFFSET)
654	new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET;	654	new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET;
655		655
656	new_serial.irq = irq_canonicalize(new_serial.irq);	656	new_serial.irq = irq_canonicalize(new_serial.irq);
657	close_delay = new_serial.close_delay * 10;	657	close_delay = new_serial.close_delay * 10;
658	closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?	658	closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
659	USF_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;	659	USF_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
660		660
661	/*	661	/*
662	* This semaphore protects state->count. It is also	662	* This semaphore protects state->count. It is also
663	* very useful to prevent opens. Also, take the	663	* very useful to prevent opens. Also, take the
664	* port configuration semaphore to make sure that a	664	* port configuration semaphore to make sure that a
665	* module insertion/removal doesn't change anything	665	* module insertion/removal doesn't change anything
666	* under us.	666	* under us.
667	*/	667	*/
668	mutex_lock(&state->mutex);	668	mutex_lock(&state->mutex);
669		669
670	change_irq = !(port->flags & UPF_FIXED_PORT)	670	change_irq = !(port->flags & UPF_FIXED_PORT)
671	&& new_serial.irq != port->irq;	671	&& new_serial.irq != port->irq;
672		672
673	/*	673	/*
674	* Since changing the 'type' of the port changes its resource	674	* Since changing the 'type' of the port changes its resource
675	* allocations, we should treat type changes the same as	675	* allocations, we should treat type changes the same as
676	* IO port changes.	676	* IO port changes.
677	*/	677	*/
678	change_port = !(port->flags & UPF_FIXED_PORT)	678	change_port = !(port->flags & UPF_FIXED_PORT)
679	&& (new_port != port->iobase \|\|	679	&& (new_port != port->iobase \|\|
680	(unsigned long)new_serial.iomem_base != port->mapbase \|\|	680	(unsigned long)new_serial.iomem_base != port->mapbase \|\|
681	new_serial.hub6 != port->hub6 \|\|	681	new_serial.hub6 != port->hub6 \|\|
682	new_serial.io_type != port->iotype \|\|	682	new_serial.io_type != port->iotype \|\|
683	new_serial.iomem_reg_shift != port->regshift \|\|	683	new_serial.iomem_reg_shift != port->regshift \|\|
684	new_serial.type != port->type);	684	new_serial.type != port->type);
685		685
686	old_flags = port->flags;	686	old_flags = port->flags;
687	new_flags = new_serial.flags;	687	new_flags = new_serial.flags;
688	old_custom_divisor = port->custom_divisor;	688	old_custom_divisor = port->custom_divisor;
689		689
690	if (!capable(CAP_SYS_ADMIN)) {	690	if (!capable(CAP_SYS_ADMIN)) {
691	retval = -EPERM;	691	retval = -EPERM;
692	if (change_irq \|\| change_port \|\|	692	if (change_irq \|\| change_port \|\|
693	(new_serial.baud_base != port->uartclk / 16) \|\|	693	(new_serial.baud_base != port->uartclk / 16) \|\|
694	(close_delay != state->close_delay) \|\|	694	(close_delay != state->close_delay) \|\|
695	(closing_wait != state->closing_wait) \|\|	695	(closing_wait != state->closing_wait) \|\|
696	(new_serial.xmit_fifo_size &&	696	(new_serial.xmit_fifo_size &&
697	new_serial.xmit_fifo_size != port->fifosize) \|\|	697	new_serial.xmit_fifo_size != port->fifosize) \|\|
698	(((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))	698	(((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
699	goto exit;	699	goto exit;
700	port->flags = ((port->flags & ~UPF_USR_MASK) \|	700	port->flags = ((port->flags & ~UPF_USR_MASK) \|
701	(new_flags & UPF_USR_MASK));	701	(new_flags & UPF_USR_MASK));
702	port->custom_divisor = new_serial.custom_divisor;	702	port->custom_divisor = new_serial.custom_divisor;
703	goto check_and_exit;	703	goto check_and_exit;
704	}	704	}
705		705
706	/*	706	/*
707	* Ask the low level driver to verify the settings.	707	* Ask the low level driver to verify the settings.
708	*/	708	*/
709	if (port->ops->verify_port)	709	if (port->ops->verify_port)
710	retval = port->ops->verify_port(port, &new_serial);	710	retval = port->ops->verify_port(port, &new_serial);
711		711
712	if ((new_serial.irq >= NR_IRQS) \|\| (new_serial.irq < 0) \|\|	712	if ((new_serial.irq >= NR_IRQS) \|\| (new_serial.irq < 0) \|\|
713	(new_serial.baud_base < 9600))	713	(new_serial.baud_base < 9600))
714	retval = -EINVAL;	714	retval = -EINVAL;
715		715
716	if (retval)	716	if (retval)
717	goto exit;	717	goto exit;
718		718
719	if (change_port \|\| change_irq) {	719	if (change_port \|\| change_irq) {
720	retval = -EBUSY;	720	retval = -EBUSY;
721		721
722	/*	722	/*
723	* Make sure that we are the sole user of this port.	723	* Make sure that we are the sole user of this port.
724	*/	724	*/
725	if (uart_users(state) > 1)	725	if (uart_users(state) > 1)
726	goto exit;	726	goto exit;
727		727
728	/*	728	/*
729	* We need to shutdown the serial port at the old	729	* We need to shutdown the serial port at the old
730	* port/type/irq combination.	730	* port/type/irq combination.
731	*/	731	*/
732	uart_shutdown(state);	732	uart_shutdown(state);
733	}	733	}
734		734
735	if (change_port) {	735	if (change_port) {
736	unsigned long old_iobase, old_mapbase;	736	unsigned long old_iobase, old_mapbase;
737	unsigned int old_type, old_iotype, old_hub6, old_shift;	737	unsigned int old_type, old_iotype, old_hub6, old_shift;
738		738
739	old_iobase = port->iobase;	739	old_iobase = port->iobase;
740	old_mapbase = port->mapbase;	740	old_mapbase = port->mapbase;
741	old_type = port->type;	741	old_type = port->type;
742	old_hub6 = port->hub6;	742	old_hub6 = port->hub6;
743	old_iotype = port->iotype;	743	old_iotype = port->iotype;
744	old_shift = port->regshift;	744	old_shift = port->regshift;
745		745
746	/*	746	/*
747	* Free and release old regions	747	* Free and release old regions
748	*/	748	*/
749	if (old_type != PORT_UNKNOWN)	749	if (old_type != PORT_UNKNOWN)
750	port->ops->release_port(port);	750	port->ops->release_port(port);
751		751
752	port->iobase = new_port;	752	port->iobase = new_port;
753	port->type = new_serial.type;	753	port->type = new_serial.type;
754	port->hub6 = new_serial.hub6;	754	port->hub6 = new_serial.hub6;
755	port->iotype = new_serial.io_type;	755	port->iotype = new_serial.io_type;
756	port->regshift = new_serial.iomem_reg_shift;	756	port->regshift = new_serial.iomem_reg_shift;
757	port->mapbase = (unsigned long)new_serial.iomem_base;	757	port->mapbase = (unsigned long)new_serial.iomem_base;
758		758
759	/*	759	/*
760	* Claim and map the new regions	760	* Claim and map the new regions
761	*/	761	*/
762	if (port->type != PORT_UNKNOWN) {	762	if (port->type != PORT_UNKNOWN) {
763	retval = port->ops->request_port(port);	763	retval = port->ops->request_port(port);
764	} else {	764	} else {
765	/* Always success - Jean II */	765	/* Always success - Jean II */
766	retval = 0;	766	retval = 0;
767	}	767	}
768		768
769	/*	769	/*
770	* If we fail to request resources for the	770	* If we fail to request resources for the
771	* new port, try to restore the old settings.	771	* new port, try to restore the old settings.
772	*/	772	*/
773	if (retval && old_type != PORT_UNKNOWN) {	773	if (retval && old_type != PORT_UNKNOWN) {
774	port->iobase = old_iobase;	774	port->iobase = old_iobase;
775	port->type = old_type;	775	port->type = old_type;
776	port->hub6 = old_hub6;	776	port->hub6 = old_hub6;
777	port->iotype = old_iotype;	777	port->iotype = old_iotype;
778	port->regshift = old_shift;	778	port->regshift = old_shift;
779	port->mapbase = old_mapbase;	779	port->mapbase = old_mapbase;
780	retval = port->ops->request_port(port);	780	retval = port->ops->request_port(port);
781	/*	781	/*
782	* If we failed to restore the old settings,	782	* If we failed to restore the old settings,
783	* we fail like this.	783	* we fail like this.
784	*/	784	*/
785	if (retval)	785	if (retval)
786	port->type = PORT_UNKNOWN;	786	port->type = PORT_UNKNOWN;
787		787
788	/*	788	/*
789	* We failed anyway.	789	* We failed anyway.
790	*/	790	*/
791	retval = -EBUSY;	791	retval = -EBUSY;
792	/* Added to return the correct error -Ram Gupta */	792	/* Added to return the correct error -Ram Gupta */
793	goto exit;	793	goto exit;
794	}	794	}
795	}	795	}
796		796
797	if (change_irq)	797	if (change_irq)
798	port->irq = new_serial.irq;	798	port->irq = new_serial.irq;
799	if (!(port->flags & UPF_FIXED_PORT))	799	if (!(port->flags & UPF_FIXED_PORT))
800	port->uartclk = new_serial.baud_base * 16;	800	port->uartclk = new_serial.baud_base * 16;
801	port->flags = (port->flags & ~UPF_CHANGE_MASK) \|	801	port->flags = (port->flags & ~UPF_CHANGE_MASK) \|
802	(new_flags & UPF_CHANGE_MASK);	802	(new_flags & UPF_CHANGE_MASK);
803	port->custom_divisor = new_serial.custom_divisor;	803	port->custom_divisor = new_serial.custom_divisor;
804	state->close_delay = close_delay;	804	state->close_delay = close_delay;
805	state->closing_wait = closing_wait;	805	state->closing_wait = closing_wait;
806	if (new_serial.xmit_fifo_size)	806	if (new_serial.xmit_fifo_size)
807	port->fifosize = new_serial.xmit_fifo_size;	807	port->fifosize = new_serial.xmit_fifo_size;
808	if (state->info->tty)	808	if (state->info->tty)
809	state->info->tty->low_latency =	809	state->info->tty->low_latency =
810	(port->flags & UPF_LOW_LATENCY) ? 1 : 0;	810	(port->flags & UPF_LOW_LATENCY) ? 1 : 0;
811		811
812	check_and_exit:	812	check_and_exit:
813	retval = 0;	813	retval = 0;
814	if (port->type == PORT_UNKNOWN)	814	if (port->type == PORT_UNKNOWN)
815	goto exit;	815	goto exit;
816	if (state->info->flags & UIF_INITIALIZED) {	816	if (state->info->flags & UIF_INITIALIZED) {
817	if (((old_flags ^ port->flags) & UPF_SPD_MASK) \|\|	817	if (((old_flags ^ port->flags) & UPF_SPD_MASK) \|\|
818	old_custom_divisor != port->custom_divisor) {	818	old_custom_divisor != port->custom_divisor) {
819	/*	819	/*
820	* If they're setting up a custom divisor or speed,	820	* If they're setting up a custom divisor or speed,
821	* instead of clearing it, then bitch about it. No	821	* instead of clearing it, then bitch about it. No
822	* need to rate-limit; it's CAP_SYS_ADMIN only.	822	* need to rate-limit; it's CAP_SYS_ADMIN only.
823	*/	823	*/
824	if (port->flags & UPF_SPD_MASK) {	824	if (port->flags & UPF_SPD_MASK) {
825	char buf[64];	825	char buf[64];
826	printk(KERN_NOTICE	826	printk(KERN_NOTICE
827	"%s sets custom speed on %s. This "	827	"%s sets custom speed on %s. This "
828	"is deprecated.\n", current->comm,	828	"is deprecated.\n", current->comm,
829	tty_name(state->info->tty, buf));	829	tty_name(state->info->tty, buf));
830	}	830	}
831	uart_change_speed(state, NULL);	831	uart_change_speed(state, NULL);
832	}	832	}
833	} else	833	} else
834	retval = uart_startup(state, 1);	834	retval = uart_startup(state, 1);
835	exit:	835	exit:
836	mutex_unlock(&state->mutex);	836	mutex_unlock(&state->mutex);
837	return retval;	837	return retval;
838	}	838	}
839		839
840		840
841	/*	841	/*
842	* uart_get_lsr_info - get line status register info.	842	* uart_get_lsr_info - get line status register info.
843	* Note: uart_ioctl protects us against hangups.	843	* Note: uart_ioctl protects us against hangups.
844	*/	844	*/
845	static int uart_get_lsr_info(struct uart_state *state,	845	static int uart_get_lsr_info(struct uart_state *state,
846	unsigned int __user *value)	846	unsigned int __user *value)
847	{	847	{
848	struct uart_port *port = state->port;	848	struct uart_port *port = state->port;
849	unsigned int result;	849	unsigned int result;
850		850
851	result = port->ops->tx_empty(port);	851	result = port->ops->tx_empty(port);
852		852
853	/*	853	/*
854	* If we're about to load something into the transmit	854	* If we're about to load something into the transmit
855	* register, we'll pretend the transmitter isn't empty to	855	* register, we'll pretend the transmitter isn't empty to
856	* avoid a race condition (depending on when the transmit	856	* avoid a race condition (depending on when the transmit
857	* interrupt happens).	857	* interrupt happens).
858	*/	858	*/
859	if (port->x_char \|\|	859	if (port->x_char \|\|
860	((uart_circ_chars_pending(&state->info->xmit) > 0) &&	860	((uart_circ_chars_pending(&state->info->xmit) > 0) &&
861	!state->info->tty->stopped && !state->info->tty->hw_stopped))	861	!state->info->tty->stopped && !state->info->tty->hw_stopped))
862	result &= ~TIOCSER_TEMT;	862	result &= ~TIOCSER_TEMT;
863		863
864	return put_user(result, value);	864	return put_user(result, value);
865	}	865	}
866		866
867	static int uart_tiocmget(struct tty_struct tty, struct file file)	867	static int uart_tiocmget(struct tty_struct tty, struct file file)
868	{	868	{
869	struct uart_state *state = tty->driver_data;	869	struct uart_state *state = tty->driver_data;
870	struct uart_port *port = state->port;	870	struct uart_port *port = state->port;
871	int result = -EIO;	871	int result = -EIO;
872		872
873	mutex_lock(&state->mutex);	873	mutex_lock(&state->mutex);
874	if ((!file \|\| !tty_hung_up_p(file)) &&	874	if ((!file \|\| !tty_hung_up_p(file)) &&
875	!(tty->flags & (1 << TTY_IO_ERROR))) {	875	!(tty->flags & (1 << TTY_IO_ERROR))) {
876	result = port->mctrl;	876	result = port->mctrl;
877		877
878	spin_lock_irq(&port->lock);	878	spin_lock_irq(&port->lock);
879	result \|= port->ops->get_mctrl(port);	879	result \|= port->ops->get_mctrl(port);
880	spin_unlock_irq(&port->lock);	880	spin_unlock_irq(&port->lock);
881	}	881	}
882	mutex_unlock(&state->mutex);	882	mutex_unlock(&state->mutex);
883		883
884	return result;	884	return result;
885	}	885	}
886		886
887	static int	887	static int
888	uart_tiocmset(struct tty_struct tty, struct file file,	888	uart_tiocmset(struct tty_struct tty, struct file file,
889	unsigned int set, unsigned int clear)	889	unsigned int set, unsigned int clear)
890	{	890	{
891	struct uart_state *state = tty->driver_data;	891	struct uart_state *state = tty->driver_data;
892	struct uart_port *port = state->port;	892	struct uart_port *port = state->port;
893	int ret = -EIO;	893	int ret = -EIO;
894		894
895	mutex_lock(&state->mutex);	895	mutex_lock(&state->mutex);
896	if ((!file \|\| !tty_hung_up_p(file)) &&	896	if ((!file \|\| !tty_hung_up_p(file)) &&
897	!(tty->flags & (1 << TTY_IO_ERROR))) {	897	!(tty->flags & (1 << TTY_IO_ERROR))) {
898	uart_update_mctrl(port, set, clear);	898	uart_update_mctrl(port, set, clear);
899	ret = 0;	899	ret = 0;
900	}	900	}
901	mutex_unlock(&state->mutex);	901	mutex_unlock(&state->mutex);
902	return ret;	902	return ret;
903	}	903	}
904		904
905	static void uart_break_ctl(struct tty_struct *tty, int break_state)	905	static void uart_break_ctl(struct tty_struct *tty, int break_state)
906	{	906	{
907	struct uart_state *state = tty->driver_data;	907	struct uart_state *state = tty->driver_data;
908	struct uart_port *port = state->port;	908	struct uart_port *port = state->port;
909		909
910	BUG_ON(!kernel_locked());	910	BUG_ON(!kernel_locked());
911		911
912	mutex_lock(&state->mutex);	912	mutex_lock(&state->mutex);
913		913
914	if (port->type != PORT_UNKNOWN)	914	if (port->type != PORT_UNKNOWN)
915	port->ops->break_ctl(port, break_state);	915	port->ops->break_ctl(port, break_state);
916		916
917	mutex_unlock(&state->mutex);	917	mutex_unlock(&state->mutex);
918	}	918	}
919		919
920	static int uart_do_autoconfig(struct uart_state *state)	920	static int uart_do_autoconfig(struct uart_state *state)
921	{	921	{
922	struct uart_port *port = state->port;	922	struct uart_port *port = state->port;
923	int flags, ret;	923	int flags, ret;
924		924
925	if (!capable(CAP_SYS_ADMIN))	925	if (!capable(CAP_SYS_ADMIN))
926	return -EPERM;	926	return -EPERM;
927		927
928	/*	928	/*
929	* Take the per-port semaphore. This prevents count from	929	* Take the per-port semaphore. This prevents count from
930	* changing, and hence any extra opens of the port while	930	* changing, and hence any extra opens of the port while
931	* we're auto-configuring.	931	* we're auto-configuring.
932	*/	932	*/
933	if (mutex_lock_interruptible(&state->mutex))	933	if (mutex_lock_interruptible(&state->mutex))
934	return -ERESTARTSYS;	934	return -ERESTARTSYS;
935		935
936	ret = -EBUSY;	936	ret = -EBUSY;
937	if (uart_users(state) == 1) {	937	if (uart_users(state) == 1) {
938	uart_shutdown(state);	938	uart_shutdown(state);
939		939
940	/*	940	/*
941	* If we already have a port type configured,	941	* If we already have a port type configured,
942	* we must release its resources.	942	* we must release its resources.
943	*/	943	*/
944	if (port->type != PORT_UNKNOWN)	944	if (port->type != PORT_UNKNOWN)
945	port->ops->release_port(port);	945	port->ops->release_port(port);
946		946
947	flags = UART_CONFIG_TYPE;	947	flags = UART_CONFIG_TYPE;
948	if (port->flags & UPF_AUTO_IRQ)	948	if (port->flags & UPF_AUTO_IRQ)
949	flags \|= UART_CONFIG_IRQ;	949	flags \|= UART_CONFIG_IRQ;
950		950
951	/*	951	/*
952	* This will claim the ports resources if	952	* This will claim the ports resources if
953	* a port is found.	953	* a port is found.
954	*/	954	*/
955	port->ops->config_port(port, flags);	955	port->ops->config_port(port, flags);
956		956
957	ret = uart_startup(state, 1);	957	ret = uart_startup(state, 1);
958	}	958	}
959	mutex_unlock(&state->mutex);	959	mutex_unlock(&state->mutex);
960	return ret;	960	return ret;
961	}	961	}
962		962
963	/*	963	/*
964	* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change	964	* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
965	* - mask passed in arg for lines of interest	965	* - mask passed in arg for lines of interest
966	* (use \|'ed TIOCM_RNG/DSR/CD/CTS for masking)	966	* (use \|'ed TIOCM_RNG/DSR/CD/CTS for masking)
967	* Caller should use TIOCGICOUNT to see which one it was	967	* Caller should use TIOCGICOUNT to see which one it was
968	*/	968	*/
969	static int	969	static int
970	uart_wait_modem_status(struct uart_state *state, unsigned long arg)	970	uart_wait_modem_status(struct uart_state *state, unsigned long arg)
971	{	971	{
972	struct uart_port *port = state->port;	972	struct uart_port *port = state->port;
973	DECLARE_WAITQUEUE(wait, current);	973	DECLARE_WAITQUEUE(wait, current);
974	struct uart_icount cprev, cnow;	974	struct uart_icount cprev, cnow;
975	int ret;	975	int ret;
976		976
977	/*	977	/*
978	* note the counters on entry	978	* note the counters on entry
979	*/	979	*/
980	spin_lock_irq(&port->lock);	980	spin_lock_irq(&port->lock);
981	memcpy(&cprev, &port->icount, sizeof(struct uart_icount));	981	memcpy(&cprev, &port->icount, sizeof(struct uart_icount));
982		982
983	/*	983	/*
984	* Force modem status interrupts on	984	* Force modem status interrupts on
985	*/	985	*/
986	port->ops->enable_ms(port);	986	port->ops->enable_ms(port);
987	spin_unlock_irq(&port->lock);	987	spin_unlock_irq(&port->lock);
988		988
989	add_wait_queue(&state->info->delta_msr_wait, &wait);	989	add_wait_queue(&state->info->delta_msr_wait, &wait);
990	for (;;) {	990	for (;;) {
991	spin_lock_irq(&port->lock);	991	spin_lock_irq(&port->lock);
992	memcpy(&cnow, &port->icount, sizeof(struct uart_icount));	992	memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
993	spin_unlock_irq(&port->lock);	993	spin_unlock_irq(&port->lock);
994		994
995	set_current_state(TASK_INTERRUPTIBLE);	995	set_current_state(TASK_INTERRUPTIBLE);
996		996
997	if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) \|\|	997	if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) \|\|
998	((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) \|\|	998	((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) \|\|
999	((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) \|\|	999	((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) \|\|
1000	((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {	1000	((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1001	ret = 0;	1001	ret = 0;
1002	break;	1002	break;
1003	}	1003	}
1004		1004
1005	schedule();	1005	schedule();
1006		1006
1007	/* see if a signal did it */	1007	/* see if a signal did it */
1008	if (signal_pending(current)) {	1008	if (signal_pending(current)) {
1009	ret = -ERESTARTSYS;	1009	ret = -ERESTARTSYS;
1010	break;	1010	break;
1011	}	1011	}
1012		1012
1013	cprev = cnow;	1013	cprev = cnow;
1014	}	1014	}
1015		1015
1016	current->state = TASK_RUNNING;	1016	current->state = TASK_RUNNING;
1017	remove_wait_queue(&state->info->delta_msr_wait, &wait);	1017	remove_wait_queue(&state->info->delta_msr_wait, &wait);
1018		1018
1019	return ret;	1019	return ret;
1020	}	1020	}
1021		1021
1022	/*	1022	/*
1023	* Get counter of input serial line interrupts (DCD,RI,DSR,CTS)	1023	* Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1024	* Return: write counters to the user passed counter struct	1024	* Return: write counters to the user passed counter struct
1025	* NB: both 1->0 and 0->1 transitions are counted except for	1025	* NB: both 1->0 and 0->1 transitions are counted except for
1026	* RI where only 0->1 is counted.	1026	* RI where only 0->1 is counted.
1027	*/	1027	*/
1028	static int uart_get_count(struct uart_state *state,	1028	static int uart_get_count(struct uart_state *state,
1029	struct serial_icounter_struct __user *icnt)	1029	struct serial_icounter_struct __user *icnt)
1030	{	1030	{
1031	struct serial_icounter_struct icount;	1031	struct serial_icounter_struct icount;
1032	struct uart_icount cnow;	1032	struct uart_icount cnow;
1033	struct uart_port *port = state->port;	1033	struct uart_port *port = state->port;
1034		1034
1035	spin_lock_irq(&port->lock);	1035	spin_lock_irq(&port->lock);
1036	memcpy(&cnow, &port->icount, sizeof(struct uart_icount));	1036	memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
1037	spin_unlock_irq(&port->lock);	1037	spin_unlock_irq(&port->lock);
1038		1038
1039	icount.cts = cnow.cts;	1039	icount.cts = cnow.cts;
1040	icount.dsr = cnow.dsr;	1040	icount.dsr = cnow.dsr;
1041	icount.rng = cnow.rng;	1041	icount.rng = cnow.rng;
1042	icount.dcd = cnow.dcd;	1042	icount.dcd = cnow.dcd;
1043	icount.rx = cnow.rx;	1043	icount.rx = cnow.rx;
1044	icount.tx = cnow.tx;	1044	icount.tx = cnow.tx;
1045	icount.frame = cnow.frame;	1045	icount.frame = cnow.frame;
1046	icount.overrun = cnow.overrun;	1046	icount.overrun = cnow.overrun;
1047	icount.parity = cnow.parity;	1047	icount.parity = cnow.parity;
1048	icount.brk = cnow.brk;	1048	icount.brk = cnow.brk;
1049	icount.buf_overrun = cnow.buf_overrun;	1049	icount.buf_overrun = cnow.buf_overrun;
1050		1050
1051	return copy_to_user(icnt, &icount, sizeof(icount)) ? -EFAULT : 0;	1051	return copy_to_user(icnt, &icount, sizeof(icount)) ? -EFAULT : 0;
1052	}	1052	}
1053		1053
1054	/*	1054	/*
1055	* Called via sys_ioctl under the BKL. We can use spin_lock_irq() here.	1055	* Called via sys_ioctl under the BKL. We can use spin_lock_irq() here.
1056	*/	1056	*/
1057	static int	1057	static int
1058	uart_ioctl(struct tty_struct tty, struct file filp, unsigned int cmd,	1058	uart_ioctl(struct tty_struct tty, struct file filp, unsigned int cmd,
1059	unsigned long arg)	1059	unsigned long arg)
1060	{	1060	{
1061	struct uart_state *state = tty->driver_data;	1061	struct uart_state *state = tty->driver_data;
1062	void __user uarg = (void __user )arg;	1062	void __user uarg = (void __user )arg;
1063	int ret = -ENOIOCTLCMD;	1063	int ret = -ENOIOCTLCMD;
1064		1064
1065	BUG_ON(!kernel_locked());	1065	BUG_ON(!kernel_locked());
1066		1066
1067	/*	1067	/*
1068	* These ioctls don't rely on the hardware to be present.	1068	* These ioctls don't rely on the hardware to be present.
1069	*/	1069	*/
1070	switch (cmd) {	1070	switch (cmd) {
1071	case TIOCGSERIAL:	1071	case TIOCGSERIAL:
1072	ret = uart_get_info(state, uarg);	1072	ret = uart_get_info(state, uarg);
1073	break;	1073	break;
1074		1074
1075	case TIOCSSERIAL:	1075	case TIOCSSERIAL:
1076	ret = uart_set_info(state, uarg);	1076	ret = uart_set_info(state, uarg);
1077	break;	1077	break;
1078		1078
1079	case TIOCSERCONFIG:	1079	case TIOCSERCONFIG:
1080	ret = uart_do_autoconfig(state);	1080	ret = uart_do_autoconfig(state);
1081	break;	1081	break;
1082		1082
1083	case TIOCSERGWILD: /* obsolete */	1083	case TIOCSERGWILD: /* obsolete */
1084	case TIOCSERSWILD: /* obsolete */	1084	case TIOCSERSWILD: /* obsolete */
1085	ret = 0;	1085	ret = 0;
1086	break;	1086	break;
1087	}	1087	}
1088		1088
1089	if (ret != -ENOIOCTLCMD)	1089	if (ret != -ENOIOCTLCMD)
1090	goto out;	1090	goto out;
1091		1091
1092	if (tty->flags & (1 << TTY_IO_ERROR)) {	1092	if (tty->flags & (1 << TTY_IO_ERROR)) {
1093	ret = -EIO;	1093	ret = -EIO;
1094	goto out;	1094	goto out;
1095	}	1095	}
1096		1096
1097	/*	1097	/*
1098	* The following should only be used when hardware is present.	1098	* The following should only be used when hardware is present.
1099	*/	1099	*/
1100	switch (cmd) {	1100	switch (cmd) {
1101	case TIOCMIWAIT:	1101	case TIOCMIWAIT:
1102	ret = uart_wait_modem_status(state, arg);	1102	ret = uart_wait_modem_status(state, arg);
1103	break;	1103	break;
1104		1104
1105	case TIOCGICOUNT:	1105	case TIOCGICOUNT:
1106	ret = uart_get_count(state, uarg);	1106	ret = uart_get_count(state, uarg);
1107	break;	1107	break;
1108	}	1108	}
1109		1109
1110	if (ret != -ENOIOCTLCMD)	1110	if (ret != -ENOIOCTLCMD)
1111	goto out;	1111	goto out;
1112		1112
1113	mutex_lock(&state->mutex);	1113	mutex_lock(&state->mutex);
1114		1114
1115	if (tty_hung_up_p(filp)) {	1115	if (tty_hung_up_p(filp)) {
1116	ret = -EIO;	1116	ret = -EIO;
1117	goto out_up;	1117	goto out_up;
1118	}	1118	}
1119		1119
1120	/*	1120	/*
1121	* All these rely on hardware being present and need to be	1121	* All these rely on hardware being present and need to be
1122	* protected against the tty being hung up.	1122	* protected against the tty being hung up.
1123	*/	1123	*/
1124	switch (cmd) {	1124	switch (cmd) {
1125	case TIOCSERGETLSR: /* Get line status register */	1125	case TIOCSERGETLSR: /* Get line status register */
1126	ret = uart_get_lsr_info(state, uarg);	1126	ret = uart_get_lsr_info(state, uarg);
1127	break;	1127	break;
1128		1128
1129	default: {	1129	default: {
1130	struct uart_port *port = state->port;	1130	struct uart_port *port = state->port;
1131	if (port->ops->ioctl)	1131	if (port->ops->ioctl)
1132	ret = port->ops->ioctl(port, cmd, arg);	1132	ret = port->ops->ioctl(port, cmd, arg);
1133	break;	1133	break;
1134	}	1134	}
1135	}	1135	}
1136	out_up:	1136	out_up:
1137	mutex_unlock(&state->mutex);	1137	mutex_unlock(&state->mutex);
1138	out:	1138	out:
1139	return ret;	1139	return ret;
1140	}	1140	}
1141		1141
1142	static void uart_set_termios(struct tty_struct *tty,	1142	static void uart_set_termios(struct tty_struct *tty,
1143	struct ktermios *old_termios)	1143	struct ktermios *old_termios)
1144	{	1144	{
1145	struct uart_state *state = tty->driver_data;	1145	struct uart_state *state = tty->driver_data;
1146	unsigned long flags;	1146	unsigned long flags;
1147	unsigned int cflag = tty->termios->c_cflag;	1147	unsigned int cflag = tty->termios->c_cflag;
1148		1148
1149	BUG_ON(!kernel_locked());	1149	BUG_ON(!kernel_locked());
1150		1150
1151	/*	1151	/*
1152	* These are the bits that are used to setup various	1152	* These are the bits that are used to setup various
1153	* flags in the low level driver. We can ignore the Bfoo	1153	* flags in the low level driver. We can ignore the Bfoo
1154	* bits in c_cflag; c_[io]speed will always be set	1154	* bits in c_cflag; c_[io]speed will always be set
1155	* appropriately by set_termios() in tty_ioctl.c	1155	* appropriately by set_termios() in tty_ioctl.c
1156	*/	1156	*/
1157	#define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK\|BRKINT\|IGNPAR\|PARMRK\|INPCK))	1157	#define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK\|BRKINT\|IGNPAR\|PARMRK\|INPCK))
1158	if ((cflag ^ old_termios->c_cflag) == 0 &&	1158	if ((cflag ^ old_termios->c_cflag) == 0 &&
1159	tty->termios->c_ospeed == old_termios->c_ospeed &&	1159	tty->termios->c_ospeed == old_termios->c_ospeed &&
1160	tty->termios->c_ispeed == old_termios->c_ispeed &&	1160	tty->termios->c_ispeed == old_termios->c_ispeed &&
1161	RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)	1161	RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
1162	return;	1162	return;
1163		1163
1164	uart_change_speed(state, old_termios);	1164	uart_change_speed(state, old_termios);
1165		1165
1166	/* Handle transition to B0 status */	1166	/* Handle transition to B0 status */
1167	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))	1167	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1168	uart_clear_mctrl(state->port, TIOCM_RTS \| TIOCM_DTR);	1168	uart_clear_mctrl(state->port, TIOCM_RTS \| TIOCM_DTR);
1169		1169
1170	/* Handle transition away from B0 status */	1170	/* Handle transition away from B0 status */
1171	if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {	1171	if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1172	unsigned int mask = TIOCM_DTR;	1172	unsigned int mask = TIOCM_DTR;
1173	if (!(cflag & CRTSCTS) \|\|	1173	if (!(cflag & CRTSCTS) \|\|
1174	!test_bit(TTY_THROTTLED, &tty->flags))	1174	!test_bit(TTY_THROTTLED, &tty->flags))
1175	mask \|= TIOCM_RTS;	1175	mask \|= TIOCM_RTS;
1176	uart_set_mctrl(state->port, mask);	1176	uart_set_mctrl(state->port, mask);
1177	}	1177	}
1178		1178
1179	/* Handle turning off CRTSCTS */	1179	/* Handle turning off CRTSCTS */
1180	if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {	1180	if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1181	spin_lock_irqsave(&state->port->lock, flags);	1181	spin_lock_irqsave(&state->port->lock, flags);
1182	tty->hw_stopped = 0;	1182	tty->hw_stopped = 0;
1183	__uart_start(tty);	1183	__uart_start(tty);
1184	spin_unlock_irqrestore(&state->port->lock, flags);	1184	spin_unlock_irqrestore(&state->port->lock, flags);
1185	}	1185	}
1186		1186
1187	/* Handle turning on CRTSCTS */	1187	/* Handle turning on CRTSCTS */
1188	if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {	1188	if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1189	spin_lock_irqsave(&state->port->lock, flags);	1189	spin_lock_irqsave(&state->port->lock, flags);
1190	if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {	1190	if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {
1191	tty->hw_stopped = 1;	1191	tty->hw_stopped = 1;
1192	state->port->ops->stop_tx(state->port);	1192	state->port->ops->stop_tx(state->port);
1193	}	1193	}
1194	spin_unlock_irqrestore(&state->port->lock, flags);	1194	spin_unlock_irqrestore(&state->port->lock, flags);
1195	}	1195	}
1196		1196
1197	#if 0	1197	#if 0
1198	/*	1198	/*
1199	* No need to wake up processes in open wait, since they	1199	* No need to wake up processes in open wait, since they
1200	* sample the CLOCAL flag once, and don't recheck it.	1200	* sample the CLOCAL flag once, and don't recheck it.
1201	* XXX It's not clear whether the current behavior is correct	1201	* XXX It's not clear whether the current behavior is correct
1202	* or not. Hence, this may change.....	1202	* or not. Hence, this may change.....
1203	*/	1203	*/
1204	if (!(old_termios->c_cflag & CLOCAL) &&	1204	if (!(old_termios->c_cflag & CLOCAL) &&
1205	(tty->termios->c_cflag & CLOCAL))	1205	(tty->termios->c_cflag & CLOCAL))
1206	wake_up_interruptible(&state->info->open_wait);	1206	wake_up_interruptible(&state->info->open_wait);
1207	#endif	1207	#endif
1208	}	1208	}
1209		1209
1210	/*	1210	/*
1211	* In 2.4.5, calls to this will be serialized via the BKL in	1211	* In 2.4.5, calls to this will be serialized via the BKL in
1212	* linux/drivers/char/tty_io.c:tty_release()	1212	* linux/drivers/char/tty_io.c:tty_release()
1213	* linux/drivers/char/tty_io.c:do_tty_handup()	1213	* linux/drivers/char/tty_io.c:do_tty_handup()
1214	*/	1214	*/
1215	static void uart_close(struct tty_struct tty, struct file filp)	1215	static void uart_close(struct tty_struct tty, struct file filp)
1216	{	1216	{
1217	struct uart_state *state = tty->driver_data;	1217	struct uart_state *state = tty->driver_data;
1218	struct uart_port *port;	1218	struct uart_port *port;
1219		1219
1220	BUG_ON(!kernel_locked());	1220	BUG_ON(!kernel_locked());
1221		1221
1222	if (!state \|\| !state->port)	1222	if (!state \|\| !state->port)
1223	return;	1223	return;
1224		1224
1225	port = state->port;	1225	port = state->port;
1226		1226
1227	pr_debug("uart_close(%d) called\n", port->line);	1227	pr_debug("uart_close(%d) called\n", port->line);
1228		1228
1229	mutex_lock(&state->mutex);	1229	mutex_lock(&state->mutex);
1230		1230
1231	if (tty_hung_up_p(filp))	1231	if (tty_hung_up_p(filp))
1232	goto done;	1232	goto done;
1233		1233
1234	if ((tty->count == 1) && (state->count != 1)) {	1234	if ((tty->count == 1) && (state->count != 1)) {
1235	/*	1235	/*
1236	* Uh, oh. tty->count is 1, which means that the tty	1236	* Uh, oh. tty->count is 1, which means that the tty
1237	* structure will be freed. state->count should always	1237	* structure will be freed. state->count should always
1238	* be one in these conditions. If it's greater than	1238	* be one in these conditions. If it's greater than
1239	* one, we've got real problems, since it means the	1239	* one, we've got real problems, since it means the
1240	* serial port won't be shutdown.	1240	* serial port won't be shutdown.
1241	*/	1241	*/
1242	printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, "	1242	printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, "
1243	"state->count is %d\n", state->count);	1243	"state->count is %d\n", state->count);
1244	state->count = 1;	1244	state->count = 1;
1245	}	1245	}
1246	if (--state->count < 0) {	1246	if (--state->count < 0) {
1247	printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n",	1247	printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n",
1248	tty->name, state->count);	1248	tty->name, state->count);
1249	state->count = 0;	1249	state->count = 0;
1250	}	1250	}
1251	if (state->count)	1251	if (state->count)
1252	goto done;	1252	goto done;
1253		1253
1254	/*	1254	/*
1255	* Now we wait for the transmit buffer to clear; and we notify	1255	* Now we wait for the transmit buffer to clear; and we notify
1256	* the line discipline to only process XON/XOFF characters by	1256	* the line discipline to only process XON/XOFF characters by
1257	* setting tty->closing.	1257	* setting tty->closing.
1258	*/	1258	*/
1259	tty->closing = 1;	1259	tty->closing = 1;
1260		1260
1261	if (state->closing_wait != USF_CLOSING_WAIT_NONE)	1261	if (state->closing_wait != USF_CLOSING_WAIT_NONE)
1262	tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait));	1262	tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait));
1263		1263
1264	/*	1264	/*
1265	* At this point, we stop accepting input. To do this, we	1265	* At this point, we stop accepting input. To do this, we
1266	* disable the receive line status interrupts.	1266	* disable the receive line status interrupts.
1267	*/	1267	*/
1268	if (state->info->flags & UIF_INITIALIZED) {	1268	if (state->info->flags & UIF_INITIALIZED) {
1269	unsigned long flags;	1269	unsigned long flags;
1270	spin_lock_irqsave(&port->lock, flags);	1270	spin_lock_irqsave(&port->lock, flags);
1271	port->ops->stop_rx(port);	1271	port->ops->stop_rx(port);
1272	spin_unlock_irqrestore(&port->lock, flags);	1272	spin_unlock_irqrestore(&port->lock, flags);
1273	/*	1273	/*
1274	* Before we drop DTR, make sure the UART transmitter	1274	* Before we drop DTR, make sure the UART transmitter
1275	* has completely drained; this is especially	1275	* has completely drained; this is especially
1276	* important if there is a transmit FIFO!	1276	* important if there is a transmit FIFO!
1277	*/	1277	*/
1278	uart_wait_until_sent(tty, port->timeout);	1278	uart_wait_until_sent(tty, port->timeout);
1279	}	1279	}
1280		1280
1281	uart_shutdown(state);	1281	uart_shutdown(state);
1282	uart_flush_buffer(tty);	1282	uart_flush_buffer(tty);
1283		1283
1284	tty_ldisc_flush(tty);	1284	tty_ldisc_flush(tty);
1285		1285
1286	tty->closing = 0;	1286	tty->closing = 0;
1287	state->info->tty = NULL;	1287	state->info->tty = NULL;
1288		1288
1289	if (state->info->blocked_open) {	1289	if (state->info->blocked_open) {
1290	if (state->close_delay)	1290	if (state->close_delay)
1291	msleep_interruptible(state->close_delay);	1291	msleep_interruptible(state->close_delay);
1292	} else if (!uart_console(port)) {	1292	} else if (!uart_console(port)) {
1293	uart_change_pm(state, 3);	1293	uart_change_pm(state, 3);
1294	}	1294	}
1295		1295
1296	/*	1296	/*
1297	* Wake up anyone trying to open this port.	1297	* Wake up anyone trying to open this port.
1298	*/	1298	*/
1299	state->info->flags &= ~UIF_NORMAL_ACTIVE;	1299	state->info->flags &= ~UIF_NORMAL_ACTIVE;
1300	wake_up_interruptible(&state->info->open_wait);	1300	wake_up_interruptible(&state->info->open_wait);
1301		1301
1302	done:	1302	done:
1303	mutex_unlock(&state->mutex);	1303	mutex_unlock(&state->mutex);
1304	}	1304	}
1305		1305
1306	static void uart_wait_until_sent(struct tty_struct *tty, int timeout)	1306	static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1307	{	1307	{
1308	struct uart_state *state = tty->driver_data;	1308	struct uart_state *state = tty->driver_data;
1309	struct uart_port *port = state->port;	1309	struct uart_port *port = state->port;
1310	unsigned long char_time, expire;	1310	unsigned long char_time, expire;
1311		1311
1312	BUG_ON(!kernel_locked());	1312	BUG_ON(!kernel_locked());
1313		1313
1314	if (port->type == PORT_UNKNOWN \|\| port->fifosize == 0)	1314	if (port->type == PORT_UNKNOWN \|\| port->fifosize == 0)
1315	return;	1315	return;
1316		1316
1317	/*	1317	/*
1318	* Set the check interval to be 1/5 of the estimated time to	1318	* Set the check interval to be 1/5 of the estimated time to
1319	* send a single character, and make it at least 1. The check	1319	* send a single character, and make it at least 1. The check
1320	* interval should also be less than the timeout.	1320	* interval should also be less than the timeout.
1321	*	1321	*
1322	* Note: we have to use pretty tight timings here to satisfy	1322	* Note: we have to use pretty tight timings here to satisfy
1323	* the NIST-PCTS.	1323	* the NIST-PCTS.
1324	*/	1324	*/
1325	char_time = (port->timeout - HZ/50) / port->fifosize;	1325	char_time = (port->timeout - HZ/50) / port->fifosize;
1326	char_time = char_time / 5;	1326	char_time = char_time / 5;
1327	if (char_time == 0)	1327	if (char_time == 0)
1328	char_time = 1;	1328	char_time = 1;
1329	if (timeout && timeout < char_time)	1329	if (timeout && timeout < char_time)
1330	char_time = timeout;	1330	char_time = timeout;
1331		1331
1332	/*	1332	/*
1333	* If the transmitter hasn't cleared in twice the approximate	1333	* If the transmitter hasn't cleared in twice the approximate
1334	* amount of time to send the entire FIFO, it probably won't	1334	* amount of time to send the entire FIFO, it probably won't
1335	* ever clear. This assumes the UART isn't doing flow	1335	* ever clear. This assumes the UART isn't doing flow
1336	* control, which is currently the case. Hence, if it ever	1336	* control, which is currently the case. Hence, if it ever
1337	* takes longer than port->timeout, this is probably due to a	1337	* takes longer than port->timeout, this is probably due to a
1338	* UART bug of some kind. So, we clamp the timeout parameter at	1338	* UART bug of some kind. So, we clamp the timeout parameter at
1339	* 2*port->timeout.	1339	* 2*port->timeout.
1340	*/	1340	*/
1341	if (timeout == 0 \|\| timeout > 2 * port->timeout)	1341	if (timeout == 0 \|\| timeout > 2 * port->timeout)
1342	timeout = 2 * port->timeout;	1342	timeout = 2 * port->timeout;
1343		1343
1344	expire = jiffies + timeout;	1344	expire = jiffies + timeout;
1345		1345
1346	pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",	1346	pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1347	port->line, jiffies, expire);	1347	port->line, jiffies, expire);
1348		1348
1349	/*	1349	/*
1350	* Check whether the transmitter is empty every 'char_time'.	1350	* Check whether the transmitter is empty every 'char_time'.
1351	* 'timeout' / 'expire' give us the maximum amount of time	1351	* 'timeout' / 'expire' give us the maximum amount of time
1352	* we wait.	1352	* we wait.
1353	*/	1353	*/
1354	while (!port->ops->tx_empty(port)) {	1354	while (!port->ops->tx_empty(port)) {
1355	msleep_interruptible(jiffies_to_msecs(char_time));	1355	msleep_interruptible(jiffies_to_msecs(char_time));
1356	if (signal_pending(current))	1356	if (signal_pending(current))
1357	break;	1357	break;
1358	if (time_after(jiffies, expire))	1358	if (time_after(jiffies, expire))
1359	break;	1359	break;
1360	}	1360	}
1361	set_current_state(TASK_RUNNING); /* might not be needed */	1361	set_current_state(TASK_RUNNING); /* might not be needed */
1362	}	1362	}
1363		1363
1364	/*	1364	/*
1365	* This is called with the BKL held in	1365	* This is called with the BKL held in
1366	* linux/drivers/char/tty_io.c:do_tty_hangup()	1366	* linux/drivers/char/tty_io.c:do_tty_hangup()
1367	* We're called from the eventd thread, so we can sleep for	1367	* We're called from the eventd thread, so we can sleep for
1368	* a _short_ time only.	1368	* a _short_ time only.
1369	*/	1369	*/
1370	static void uart_hangup(struct tty_struct *tty)	1370	static void uart_hangup(struct tty_struct *tty)
1371	{	1371	{
1372	struct uart_state *state = tty->driver_data;	1372	struct uart_state *state = tty->driver_data;
1373		1373
1374	BUG_ON(!kernel_locked());	1374	BUG_ON(!kernel_locked());
1375	pr_debug("uart_hangup(%d)\n", state->port->line);	1375	pr_debug("uart_hangup(%d)\n", state->port->line);
1376		1376
1377	mutex_lock(&state->mutex);	1377	mutex_lock(&state->mutex);
1378	if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) {	1378	if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) {
1379	uart_flush_buffer(tty);	1379	uart_flush_buffer(tty);
1380	uart_shutdown(state);	1380	uart_shutdown(state);
1381	state->count = 0;	1381	state->count = 0;
1382	state->info->flags &= ~UIF_NORMAL_ACTIVE;	1382	state->info->flags &= ~UIF_NORMAL_ACTIVE;
1383	state->info->tty = NULL;	1383	state->info->tty = NULL;
1384	wake_up_interruptible(&state->info->open_wait);	1384	wake_up_interruptible(&state->info->open_wait);
1385	wake_up_interruptible(&state->info->delta_msr_wait);	1385	wake_up_interruptible(&state->info->delta_msr_wait);
1386	}	1386	}
1387	mutex_unlock(&state->mutex);	1387	mutex_unlock(&state->mutex);
1388	}	1388	}
1389		1389
1390	/*	1390	/*
1391	* Copy across the serial console cflag setting into the termios settings	1391	* Copy across the serial console cflag setting into the termios settings
1392	* for the initial open of the port. This allows continuity between the	1392	* for the initial open of the port. This allows continuity between the
1393	* kernel settings, and the settings init adopts when it opens the port	1393	* kernel settings, and the settings init adopts when it opens the port
1394	* for the first time.	1394	* for the first time.
1395	*/	1395	*/
1396	static void uart_update_termios(struct uart_state *state)	1396	static void uart_update_termios(struct uart_state *state)
1397	{	1397	{
1398	struct tty_struct *tty = state->info->tty;	1398	struct tty_struct *tty = state->info->tty;
1399	struct uart_port *port = state->port;	1399	struct uart_port *port = state->port;
1400		1400
1401	if (uart_console(port) && port->cons->cflag) {	1401	if (uart_console(port) && port->cons->cflag) {
1402	tty->termios->c_cflag = port->cons->cflag;	1402	tty->termios->c_cflag = port->cons->cflag;
1403	port->cons->cflag = 0;	1403	port->cons->cflag = 0;
1404	}	1404	}
1405		1405
1406	/*	1406	/*
1407	* If the device failed to grab its irq resources,	1407	* If the device failed to grab its irq resources,
1408	* or some other error occurred, don't try to talk	1408	* or some other error occurred, don't try to talk
1409	* to the port hardware.	1409	* to the port hardware.
1410	*/	1410	*/
1411	if (!(tty->flags & (1 << TTY_IO_ERROR))) {	1411	if (!(tty->flags & (1 << TTY_IO_ERROR))) {
1412	/*	1412	/*
1413	* Make termios settings take effect.	1413	* Make termios settings take effect.
1414	*/	1414	*/
1415	uart_change_speed(state, NULL);	1415	uart_change_speed(state, NULL);
1416		1416
1417	/*	1417	/*
1418	* And finally enable the RTS and DTR signals.	1418	* And finally enable the RTS and DTR signals.
1419	*/	1419	*/
1420	if (tty->termios->c_cflag & CBAUD)	1420	if (tty->termios->c_cflag & CBAUD)
1421	uart_set_mctrl(port, TIOCM_DTR \| TIOCM_RTS);	1421	uart_set_mctrl(port, TIOCM_DTR \| TIOCM_RTS);
1422	}	1422	}
1423	}	1423	}
1424		1424
1425	/*	1425	/*
1426	* Block the open until the port is ready. We must be called with	1426	* Block the open until the port is ready. We must be called with
1427	* the per-port semaphore held.	1427	* the per-port semaphore held.
1428	*/	1428	*/
1429	static int	1429	static int
1430	uart_block_til_ready(struct file filp, struct uart_state state)	1430	uart_block_til_ready(struct file filp, struct uart_state state)
1431	{	1431	{
1432	DECLARE_WAITQUEUE(wait, current);	1432	DECLARE_WAITQUEUE(wait, current);
1433	struct uart_info *info = state->info;	1433	struct uart_info *info = state->info;
1434	struct uart_port *port = state->port;	1434	struct uart_port *port = state->port;
1435	unsigned int mctrl;	1435	unsigned int mctrl;
1436		1436
1437	info->blocked_open++;	1437	info->blocked_open++;
1438	state->count--;	1438	state->count--;
1439		1439
1440	add_wait_queue(&info->open_wait, &wait);	1440	add_wait_queue(&info->open_wait, &wait);
1441	while (1) {	1441	while (1) {
1442	set_current_state(TASK_INTERRUPTIBLE);	1442	set_current_state(TASK_INTERRUPTIBLE);
1443		1443
1444	/*	1444	/*
1445	* If we have been hung up, tell userspace/restart open.	1445	* If we have been hung up, tell userspace/restart open.
1446	*/	1446	*/
1447	if (tty_hung_up_p(filp) \|\| info->tty == NULL)	1447	if (tty_hung_up_p(filp) \|\| info->tty == NULL)
1448	break;	1448	break;
1449		1449
1450	/*	1450	/*
1451	* If the port has been closed, tell userspace/restart open.	1451	* If the port has been closed, tell userspace/restart open.
1452	*/	1452	*/
1453	if (!(info->flags & UIF_INITIALIZED))	1453	if (!(info->flags & UIF_INITIALIZED))
1454	break;	1454	break;
1455		1455
1456	/*	1456	/*
1457	* If non-blocking mode is set, or CLOCAL mode is set,	1457	* If non-blocking mode is set, or CLOCAL mode is set,
1458	* we don't want to wait for the modem status lines to	1458	* we don't want to wait for the modem status lines to
1459	* indicate that the port is ready.	1459	* indicate that the port is ready.
1460	*	1460	*
1461	* Also, if the port is not enabled/configured, we want	1461	* Also, if the port is not enabled/configured, we want
1462	* to allow the open to succeed here. Note that we will	1462	* to allow the open to succeed here. Note that we will
1463	* have set TTY_IO_ERROR for a non-existant port.	1463	* have set TTY_IO_ERROR for a non-existant port.
1464	*/	1464	*/
1465	if ((filp->f_flags & O_NONBLOCK) \|\|	1465	if ((filp->f_flags & O_NONBLOCK) \|\|
1466	(info->tty->termios->c_cflag & CLOCAL) \|\|	1466	(info->tty->termios->c_cflag & CLOCAL) \|\|
1467	(info->tty->flags & (1 << TTY_IO_ERROR)))	1467	(info->tty->flags & (1 << TTY_IO_ERROR)))
1468	break;	1468	break;
1469		1469
1470	/*	1470	/*
1471	* Set DTR to allow modem to know we're waiting. Do	1471	* Set DTR to allow modem to know we're waiting. Do
1472	* not set RTS here - we want to make sure we catch	1472	* not set RTS here - we want to make sure we catch
1473	* the data from the modem.	1473	* the data from the modem.
1474	*/	1474	*/
1475	if (info->tty->termios->c_cflag & CBAUD)	1475	if (info->tty->termios->c_cflag & CBAUD)
1476	uart_set_mctrl(port, TIOCM_DTR);	1476	uart_set_mctrl(port, TIOCM_DTR);
1477		1477
1478	/*	1478	/*
1479	* and wait for the carrier to indicate that the	1479	* and wait for the carrier to indicate that the
1480	* modem is ready for us.	1480	* modem is ready for us.
1481	*/	1481	*/
1482	spin_lock_irq(&port->lock);	1482	spin_lock_irq(&port->lock);
1483	port->ops->enable_ms(port);	1483	port->ops->enable_ms(port);
1484	mctrl = port->ops->get_mctrl(port);	1484	mctrl = port->ops->get_mctrl(port);
1485	spin_unlock_irq(&port->lock);	1485	spin_unlock_irq(&port->lock);
1486	if (mctrl & TIOCM_CAR)	1486	if (mctrl & TIOCM_CAR)
1487	break;	1487	break;
1488		1488
1489	mutex_unlock(&state->mutex);	1489	mutex_unlock(&state->mutex);
1490	schedule();	1490	schedule();
1491	mutex_lock(&state->mutex);	1491	mutex_lock(&state->mutex);
1492		1492
1493	if (signal_pending(current))	1493	if (signal_pending(current))
1494	break;	1494	break;
1495	}	1495	}
1496	set_current_state(TASK_RUNNING);	1496	set_current_state(TASK_RUNNING);
1497	remove_wait_queue(&info->open_wait, &wait);	1497	remove_wait_queue(&info->open_wait, &wait);
1498		1498
1499	state->count++;	1499	state->count++;
1500	info->blocked_open--;	1500	info->blocked_open--;
1501		1501
1502	if (signal_pending(current))	1502	if (signal_pending(current))
1503	return -ERESTARTSYS;	1503	return -ERESTARTSYS;
1504		1504
1505	if (!info->tty \|\| tty_hung_up_p(filp))	1505	if (!info->tty \|\| tty_hung_up_p(filp))
1506	return -EAGAIN;	1506	return -EAGAIN;
1507		1507
1508	return 0;	1508	return 0;
1509	}	1509	}
1510		1510
1511	static struct uart_state uart_get(struct uart_driver drv, int line)	1511	static struct uart_state uart_get(struct uart_driver drv, int line)
1512	{	1512	{
1513	struct uart_state *state;	1513	struct uart_state *state;
1514	int ret = 0;	1514	int ret = 0;
1515		1515
1516	state = drv->state + line;	1516	state = drv->state + line;
1517	if (mutex_lock_interruptible(&state->mutex)) {	1517	if (mutex_lock_interruptible(&state->mutex)) {
1518	ret = -ERESTARTSYS;	1518	ret = -ERESTARTSYS;
1519	goto err;	1519	goto err;
1520	}	1520	}
1521		1521
1522	state->count++;	1522	state->count++;
1523	if (!state->port \|\| state->port->flags & UPF_DEAD) {	1523	if (!state->port \|\| state->port->flags & UPF_DEAD) {
1524	ret = -ENXIO;	1524	ret = -ENXIO;
1525	goto err_unlock;	1525	goto err_unlock;
1526	}	1526	}
1527		1527
1528	if (!state->info) {	1528	if (!state->info) {
1529	state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);	1529	state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);
1530	if (state->info) {	1530	if (state->info) {
1531	init_waitqueue_head(&state->info->open_wait);	1531	init_waitqueue_head(&state->info->open_wait);
1532	init_waitqueue_head(&state->info->delta_msr_wait);	1532	init_waitqueue_head(&state->info->delta_msr_wait);
1533		1533
1534	/*	1534	/*
1535	* Link the info into the other structures.	1535	* Link the info into the other structures.
1536	*/	1536	*/
1537	state->port->info = state->info;	1537	state->port->info = state->info;
1538		1538
1539	tasklet_init(&state->info->tlet, uart_tasklet_action,	1539	tasklet_init(&state->info->tlet, uart_tasklet_action,
1540	(unsigned long)state);	1540	(unsigned long)state);
1541	} else {	1541	} else {
1542	ret = -ENOMEM;	1542	ret = -ENOMEM;
1543	goto err_unlock;	1543	goto err_unlock;
1544	}	1544	}
1545	}	1545	}
1546	return state;	1546	return state;
1547		1547
1548	err_unlock:	1548	err_unlock:
1549	state->count--;	1549	state->count--;
1550	mutex_unlock(&state->mutex);	1550	mutex_unlock(&state->mutex);
1551	err:	1551	err:
1552	return ERR_PTR(ret);	1552	return ERR_PTR(ret);
1553	}	1553	}
1554		1554
1555	/*	1555	/*
1556	* In 2.4.5, calls to uart_open are serialised by the BKL in	1556	* calls to uart_open are serialised by the BKL in
1557	* linux/fs/devices.c:chrdev_open()	1557	* fs/char_dev.c:chrdev_open()
1558	* Note that if this fails, then uart_close() _will_ be called.	1558	* Note that if this fails, then uart_close() _will_ be called.
1559	*	1559	*
1560	* In time, we want to scrap the "opening nonpresent ports"	1560	* In time, we want to scrap the "opening nonpresent ports"
1561	* behaviour and implement an alternative way for setserial	1561	* behaviour and implement an alternative way for setserial
1562	* to set base addresses/ports/types. This will allow us to	1562	* to set base addresses/ports/types. This will allow us to
1563	* get rid of a certain amount of extra tests.	1563	* get rid of a certain amount of extra tests.
1564	*/	1564	*/
1565	static int uart_open(struct tty_struct tty, struct file filp)	1565	static int uart_open(struct tty_struct tty, struct file filp)
1566	{	1566	{
1567	struct uart_driver drv = (struct uart_driver )tty->driver->driver_state;	1567	struct uart_driver drv = (struct uart_driver )tty->driver->driver_state;
1568	struct uart_state *state;	1568	struct uart_state *state;
1569	int retval, line = tty->index;	1569	int retval, line = tty->index;
1570		1570
1571	BUG_ON(!kernel_locked());	1571	BUG_ON(!kernel_locked());
1572	pr_debug("uart_open(%d) called\n", line);	1572	pr_debug("uart_open(%d) called\n", line);
1573		1573
1574	/*	1574	/*
1575	* tty->driver->num won't change, so we won't fail here with	1575	* tty->driver->num won't change, so we won't fail here with
1576	* tty->driver_data set to something non-NULL (and therefore	1576	* tty->driver_data set to something non-NULL (and therefore
1577	* we won't get caught by uart_close()).	1577	* we won't get caught by uart_close()).
1578	*/	1578	*/
1579	retval = -ENODEV;	1579	retval = -ENODEV;
1580	if (line >= tty->driver->num)	1580	if (line >= tty->driver->num)
1581	goto fail;	1581	goto fail;
1582		1582
1583	/*	1583	/*
1584	* We take the semaphore inside uart_get to guarantee that we won't	1584	* We take the semaphore inside uart_get to guarantee that we won't
1585	* be re-entered while allocating the info structure, or while we	1585	* be re-entered while allocating the info structure, or while we
1586	* request any IRQs that the driver may need. This also has the nice	1586	* request any IRQs that the driver may need. This also has the nice
1587	* side-effect that it delays the action of uart_hangup, so we can	1587	* side-effect that it delays the action of uart_hangup, so we can
1588	* guarantee that info->tty will always contain something reasonable.	1588	* guarantee that info->tty will always contain something reasonable.
1589	*/	1589	*/
1590	state = uart_get(drv, line);	1590	state = uart_get(drv, line);
1591	if (IS_ERR(state)) {	1591	if (IS_ERR(state)) {
1592	retval = PTR_ERR(state);	1592	retval = PTR_ERR(state);
1593	goto fail;	1593	goto fail;
1594	}	1594	}
1595		1595
1596	/*	1596	/*
1597	* Once we set tty->driver_data here, we are guaranteed that	1597	* Once we set tty->driver_data here, we are guaranteed that
1598	* uart_close() will decrement the driver module use count.	1598	* uart_close() will decrement the driver module use count.
1599	* Any failures from here onwards should not touch the count.	1599	* Any failures from here onwards should not touch the count.
1600	*/	1600	*/
1601	tty->driver_data = state;	1601	tty->driver_data = state;
1602	tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;	1602	tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1603	tty->alt_speed = 0;	1603	tty->alt_speed = 0;
1604	state->info->tty = tty;	1604	state->info->tty = tty;
1605		1605
1606	/*	1606	/*
1607	* If the port is in the middle of closing, bail out now.	1607	* If the port is in the middle of closing, bail out now.
1608	*/	1608	*/
1609	if (tty_hung_up_p(filp)) {	1609	if (tty_hung_up_p(filp)) {
1610	retval = -EAGAIN;	1610	retval = -EAGAIN;
1611	state->count--;	1611	state->count--;
1612	mutex_unlock(&state->mutex);	1612	mutex_unlock(&state->mutex);
1613	goto fail;	1613	goto fail;
1614	}	1614	}
1615		1615
1616	/*	1616	/*
1617	* Make sure the device is in D0 state.	1617	* Make sure the device is in D0 state.
1618	*/	1618	*/
1619	if (state->count == 1)	1619	if (state->count == 1)
1620	uart_change_pm(state, 0);	1620	uart_change_pm(state, 0);
1621		1621
1622	/*	1622	/*
1623	* Start up the serial port.	1623	* Start up the serial port.
1624	*/	1624	*/
1625	retval = uart_startup(state, 0);	1625	retval = uart_startup(state, 0);
1626		1626
1627	/*	1627	/*
1628	* If we succeeded, wait until the port is ready.	1628	* If we succeeded, wait until the port is ready.
1629	*/	1629	*/
1630	if (retval == 0)	1630	if (retval == 0)
1631	retval = uart_block_til_ready(filp, state);	1631	retval = uart_block_til_ready(filp, state);
1632	mutex_unlock(&state->mutex);	1632	mutex_unlock(&state->mutex);
1633		1633
1634	/*	1634	/*
1635	* If this is the first open to succeed, adjust things to suit.	1635	* If this is the first open to succeed, adjust things to suit.
1636	*/	1636	*/
1637	if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) {	1637	if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) {
1638	state->info->flags \|= UIF_NORMAL_ACTIVE;	1638	state->info->flags \|= UIF_NORMAL_ACTIVE;
1639		1639
1640	uart_update_termios(state);	1640	uart_update_termios(state);
1641	}	1641	}
1642		1642
1643	fail:	1643	fail:
1644	return retval;	1644	return retval;
1645	}	1645	}
1646		1646
1647	static const char uart_type(struct uart_port port)	1647	static const char uart_type(struct uart_port port)
1648	{	1648	{
1649	const char *str = NULL;	1649	const char *str = NULL;
1650		1650
1651	if (port->ops->type)	1651	if (port->ops->type)
1652	str = port->ops->type(port);	1652	str = port->ops->type(port);
1653		1653
1654	if (!str)	1654	if (!str)
1655	str = "unknown";	1655	str = "unknown";
1656		1656
1657	return str;	1657	return str;
1658	}	1658	}
1659		1659
1660	#ifdef CONFIG_PROC_FS	1660	#ifdef CONFIG_PROC_FS
1661		1661
1662	static int uart_line_info(char buf, struct uart_driver drv, int i)	1662	static int uart_line_info(char buf, struct uart_driver drv, int i)
1663	{	1663	{
1664	struct uart_state *state = drv->state + i;	1664	struct uart_state *state = drv->state + i;
1665	int pm_state;	1665	int pm_state;
1666	struct uart_port *port = state->port;	1666	struct uart_port *port = state->port;
1667	char stat_buf[32];	1667	char stat_buf[32];
1668	unsigned int status;	1668	unsigned int status;
1669	int mmio, ret;	1669	int mmio, ret;
1670		1670
1671	if (!port)	1671	if (!port)
1672	return 0;	1672	return 0;
1673		1673
1674	mmio = port->iotype >= UPIO_MEM;	1674	mmio = port->iotype >= UPIO_MEM;
1675	ret = sprintf(buf, "%d: uart:%s %s%08llX irq:%d",	1675	ret = sprintf(buf, "%d: uart:%s %s%08llX irq:%d",
1676	port->line, uart_type(port),	1676	port->line, uart_type(port),
1677	mmio ? "mmio:0x" : "port:",	1677	mmio ? "mmio:0x" : "port:",
1678	mmio ? (unsigned long long)port->mapbase	1678	mmio ? (unsigned long long)port->mapbase
1679	: (unsigned long long) port->iobase,	1679	: (unsigned long long) port->iobase,
1680	port->irq);	1680	port->irq);
1681		1681
1682	if (port->type == PORT_UNKNOWN) {	1682	if (port->type == PORT_UNKNOWN) {
1683	strcat(buf, "\n");	1683	strcat(buf, "\n");
1684	return ret + 1;	1684	return ret + 1;
1685	}	1685	}
1686		1686
1687	if (capable(CAP_SYS_ADMIN)) {	1687	if (capable(CAP_SYS_ADMIN)) {
1688	mutex_lock(&state->mutex);	1688	mutex_lock(&state->mutex);
1689	pm_state = state->pm_state;	1689	pm_state = state->pm_state;
1690	if (pm_state)	1690	if (pm_state)
1691	uart_change_pm(state, 0);	1691	uart_change_pm(state, 0);
1692	spin_lock_irq(&port->lock);	1692	spin_lock_irq(&port->lock);
1693	status = port->ops->get_mctrl(port);	1693	status = port->ops->get_mctrl(port);
1694	spin_unlock_irq(&port->lock);	1694	spin_unlock_irq(&port->lock);
1695	if (pm_state)	1695	if (pm_state)
1696	uart_change_pm(state, pm_state);	1696	uart_change_pm(state, pm_state);
1697	mutex_unlock(&state->mutex);	1697	mutex_unlock(&state->mutex);
1698		1698
1699	ret += sprintf(buf + ret, " tx:%d rx:%d",	1699	ret += sprintf(buf + ret, " tx:%d rx:%d",
1700	port->icount.tx, port->icount.rx);	1700	port->icount.tx, port->icount.rx);
1701	if (port->icount.frame)	1701	if (port->icount.frame)
1702	ret += sprintf(buf + ret, " fe:%d",	1702	ret += sprintf(buf + ret, " fe:%d",
1703	port->icount.frame);	1703	port->icount.frame);
1704	if (port->icount.parity)	1704	if (port->icount.parity)
1705	ret += sprintf(buf + ret, " pe:%d",	1705	ret += sprintf(buf + ret, " pe:%d",
1706	port->icount.parity);	1706	port->icount.parity);
1707	if (port->icount.brk)	1707	if (port->icount.brk)
1708	ret += sprintf(buf + ret, " brk:%d",	1708	ret += sprintf(buf + ret, " brk:%d",
1709	port->icount.brk);	1709	port->icount.brk);
1710	if (port->icount.overrun)	1710	if (port->icount.overrun)
1711	ret += sprintf(buf + ret, " oe:%d",	1711	ret += sprintf(buf + ret, " oe:%d",
1712	port->icount.overrun);	1712	port->icount.overrun);
1713		1713
1714	#define INFOBIT(bit, str) \	1714	#define INFOBIT(bit, str) \
1715	if (port->mctrl & (bit)) \	1715	if (port->mctrl & (bit)) \
1716	strncat(stat_buf, (str), sizeof(stat_buf) - \	1716	strncat(stat_buf, (str), sizeof(stat_buf) - \
1717	strlen(stat_buf) - 2)	1717	strlen(stat_buf) - 2)
1718	#define STATBIT(bit, str) \	1718	#define STATBIT(bit, str) \
1719	if (status & (bit)) \	1719	if (status & (bit)) \
1720	strncat(stat_buf, (str), sizeof(stat_buf) - \	1720	strncat(stat_buf, (str), sizeof(stat_buf) - \
1721	strlen(stat_buf) - 2)	1721	strlen(stat_buf) - 2)
1722		1722
1723	stat_buf[0] = '\0';	1723	stat_buf[0] = '\0';
1724	stat_buf[1] = '\0';	1724	stat_buf[1] = '\0';
1725	INFOBIT(TIOCM_RTS, "\|RTS");	1725	INFOBIT(TIOCM_RTS, "\|RTS");
1726	STATBIT(TIOCM_CTS, "\|CTS");	1726	STATBIT(TIOCM_CTS, "\|CTS");
1727	INFOBIT(TIOCM_DTR, "\|DTR");	1727	INFOBIT(TIOCM_DTR, "\|DTR");
1728	STATBIT(TIOCM_DSR, "\|DSR");	1728	STATBIT(TIOCM_DSR, "\|DSR");
1729	STATBIT(TIOCM_CAR, "\|CD");	1729	STATBIT(TIOCM_CAR, "\|CD");
1730	STATBIT(TIOCM_RNG, "\|RI");	1730	STATBIT(TIOCM_RNG, "\|RI");
1731	if (stat_buf[0])	1731	if (stat_buf[0])
1732	stat_buf[0] = ' ';	1732	stat_buf[0] = ' ';
1733	strcat(stat_buf, "\n");	1733	strcat(stat_buf, "\n");
1734		1734
1735	ret += sprintf(buf + ret, stat_buf);	1735	ret += sprintf(buf + ret, stat_buf);
1736	} else {	1736	} else {
1737	strcat(buf, "\n");	1737	strcat(buf, "\n");
1738	ret++;	1738	ret++;
1739	}	1739	}
1740	#undef STATBIT	1740	#undef STATBIT
1741	#undef INFOBIT	1741	#undef INFOBIT
1742	return ret;	1742	return ret;
1743	}	1743	}
1744		1744
1745	static int uart_read_proc(char page, char *start, off_t off,	1745	static int uart_read_proc(char page, char *start, off_t off,
1746	int count, int eof, void data)	1746	int count, int eof, void data)
1747	{	1747	{
1748	struct tty_driver *ttydrv = data;	1748	struct tty_driver *ttydrv = data;
1749	struct uart_driver *drv = ttydrv->driver_state;	1749	struct uart_driver *drv = ttydrv->driver_state;
1750	int i, len = 0, l;	1750	int i, len = 0, l;
1751	off_t begin = 0;	1751	off_t begin = 0;
1752		1752
1753	len += sprintf(page, "serinfo:1.0 driver%s%s revision:%s\n",	1753	len += sprintf(page, "serinfo:1.0 driver%s%s revision:%s\n",
1754	"", "", "");	1754	"", "", "");
1755	for (i = 0; i < drv->nr && len < PAGE_SIZE - 96; i++) {	1755	for (i = 0; i < drv->nr && len < PAGE_SIZE - 96; i++) {
1756	l = uart_line_info(page + len, drv, i);	1756	l = uart_line_info(page + len, drv, i);
1757	len += l;	1757	len += l;
1758	if (len + begin > off + count)	1758	if (len + begin > off + count)
1759	goto done;	1759	goto done;
1760	if (len + begin < off) {	1760	if (len + begin < off) {
1761	begin += len;	1761	begin += len;
1762	len = 0;	1762	len = 0;
1763	}	1763	}
1764	}	1764	}
1765	*eof = 1;	1765	*eof = 1;
1766	done:	1766	done:
1767	if (off >= len + begin)	1767	if (off >= len + begin)
1768	return 0;	1768	return 0;
1769	*start = page + (off - begin);	1769	*start = page + (off - begin);
1770	return (count < begin + len - off) ? count : (begin + len - off);	1770	return (count < begin + len - off) ? count : (begin + len - off);
1771	}	1771	}
1772	#endif	1772	#endif
1773		1773
1774	#ifdef CONFIG_SERIAL_CORE_CONSOLE	1774	#ifdef CONFIG_SERIAL_CORE_CONSOLE
1775	/*	1775	/*
1776	* uart_console_write - write a console message to a serial port	1776	* uart_console_write - write a console message to a serial port
1777	* @port: the port to write the message	1777	* @port: the port to write the message
1778	* @s: array of characters	1778	* @s: array of characters
1779	* @count: number of characters in string to write	1779	* @count: number of characters in string to write
1780	* @write: function to write character to port	1780	* @write: function to write character to port
1781	*/	1781	*/
1782	void uart_console_write(struct uart_port port, const char s,	1782	void uart_console_write(struct uart_port port, const char s,
1783	unsigned int count,	1783	unsigned int count,
1784	void (putchar)(struct uart_port , int))	1784	void (putchar)(struct uart_port , int))
1785	{	1785	{
1786	unsigned int i;	1786	unsigned int i;
1787		1787
1788	for (i = 0; i < count; i++, s++) {	1788	for (i = 0; i < count; i++, s++) {
1789	if (*s == '\n')	1789	if (*s == '\n')
1790	putchar(port, '\r');	1790	putchar(port, '\r');
1791	putchar(port, *s);	1791	putchar(port, *s);
1792	}	1792	}
1793	}	1793	}
1794	EXPORT_SYMBOL_GPL(uart_console_write);	1794	EXPORT_SYMBOL_GPL(uart_console_write);
1795		1795
1796	/*	1796	/*
1797	* Check whether an invalid uart number has been specified, and	1797	* Check whether an invalid uart number has been specified, and
1798	* if so, search for the first available port that does have	1798	* if so, search for the first available port that does have
1799	* console support.	1799	* console support.
1800	*/	1800	*/
1801	struct uart_port * __init	1801	struct uart_port * __init
1802	uart_get_console(struct uart_port ports, int nr, struct console co)	1802	uart_get_console(struct uart_port ports, int nr, struct console co)
1803	{	1803	{
1804	int idx = co->index;	1804	int idx = co->index;
1805		1805
1806	if (idx < 0 \|\| idx >= nr \|\| (ports[idx].iobase == 0 &&	1806	if (idx < 0 \|\| idx >= nr \|\| (ports[idx].iobase == 0 &&
1807	ports[idx].membase == NULL))	1807	ports[idx].membase == NULL))
1808	for (idx = 0; idx < nr; idx++)	1808	for (idx = 0; idx < nr; idx++)
1809	if (ports[idx].iobase != 0 \|\|	1809	if (ports[idx].iobase != 0 \|\|
1810	ports[idx].membase != NULL)	1810	ports[idx].membase != NULL)
1811	break;	1811	break;
1812		1812
1813	co->index = idx;	1813	co->index = idx;
1814		1814
1815	return ports + idx;	1815	return ports + idx;
1816	}	1816	}
1817		1817
1818	/**	1818	/**
1819	* uart_parse_options - Parse serial port baud/parity/bits/flow contro.	1819	* uart_parse_options - Parse serial port baud/parity/bits/flow contro.
1820	* @options: pointer to option string	1820	* @options: pointer to option string
1821	* @baud: pointer to an 'int' variable for the baud rate.	1821	* @baud: pointer to an 'int' variable for the baud rate.
1822	* @parity: pointer to an 'int' variable for the parity.	1822	* @parity: pointer to an 'int' variable for the parity.
1823	* @bits: pointer to an 'int' variable for the number of data bits.	1823	* @bits: pointer to an 'int' variable for the number of data bits.
1824	* @flow: pointer to an 'int' variable for the flow control character.	1824	* @flow: pointer to an 'int' variable for the flow control character.
1825	*	1825	*
1826	* uart_parse_options decodes a string containing the serial console	1826	* uart_parse_options decodes a string containing the serial console
1827	* options. The format of the string is <baud><parity><bits><flow>,	1827	* options. The format of the string is <baud><parity><bits><flow>,
1828	* eg: 115200n8r	1828	* eg: 115200n8r
1829	*/	1829	*/
1830	void __init	1830	void __init
1831	uart_parse_options(char options, int baud, int parity, int bits, int *flow)	1831	uart_parse_options(char options, int baud, int parity, int bits, int *flow)
1832	{	1832	{
1833	char *s = options;	1833	char *s = options;
1834		1834
1835	*baud = simple_strtoul(s, NULL, 10);	1835	*baud = simple_strtoul(s, NULL, 10);
1836	while (s >= '0' && s <= '9')	1836	while (s >= '0' && s <= '9')
1837	s++;	1837	s++;
1838	if (*s)	1838	if (*s)
1839	parity = s++;	1839	parity = s++;
1840	if (*s)	1840	if (*s)
1841	bits = s++ - '0';	1841	bits = s++ - '0';
1842	if (*s)	1842	if (*s)
1843	flow = s;	1843	flow = s;
1844	}	1844	}
1845		1845
1846	struct baud_rates {	1846	struct baud_rates {
1847	unsigned int rate;	1847	unsigned int rate;
1848	unsigned int cflag;	1848	unsigned int cflag;
1849	};	1849	};
1850		1850
1851	static const struct baud_rates baud_rates[] = {	1851	static const struct baud_rates baud_rates[] = {
1852	{ 921600, B921600 },	1852	{ 921600, B921600 },
1853	{ 460800, B460800 },	1853	{ 460800, B460800 },
1854	{ 230400, B230400 },	1854	{ 230400, B230400 },
1855	{ 115200, B115200 },	1855	{ 115200, B115200 },
1856	{ 57600, B57600 },	1856	{ 57600, B57600 },
1857	{ 38400, B38400 },	1857	{ 38400, B38400 },
1858	{ 19200, B19200 },	1858	{ 19200, B19200 },
1859	{ 9600, B9600 },	1859	{ 9600, B9600 },
1860	{ 4800, B4800 },	1860	{ 4800, B4800 },
1861	{ 2400, B2400 },	1861	{ 2400, B2400 },
1862	{ 1200, B1200 },	1862	{ 1200, B1200 },
1863	{ 0, B38400 }	1863	{ 0, B38400 }
1864	};	1864	};
1865		1865
1866	/**	1866	/**
1867	* uart_set_options - setup the serial console parameters	1867	* uart_set_options - setup the serial console parameters
1868	* @port: pointer to the serial ports uart_port structure	1868	* @port: pointer to the serial ports uart_port structure
1869	* @co: console pointer	1869	* @co: console pointer
1870	* @baud: baud rate	1870	* @baud: baud rate
1871	* @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)	1871	* @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
1872	* @bits: number of data bits	1872	* @bits: number of data bits
1873	* @flow: flow control character - 'r' (rts)	1873	* @flow: flow control character - 'r' (rts)
1874	*/	1874	*/
1875	int __init	1875	int __init
1876	uart_set_options(struct uart_port port, struct console co,	1876	uart_set_options(struct uart_port port, struct console co,
1877	int baud, int parity, int bits, int flow)	1877	int baud, int parity, int bits, int flow)
1878	{	1878	{
1879	struct ktermios termios;	1879	struct ktermios termios;
1880	static struct ktermios dummy;	1880	static struct ktermios dummy;
1881	int i;	1881	int i;
1882		1882
1883	/*	1883	/*
1884	* Ensure that the serial console lock is initialised	1884	* Ensure that the serial console lock is initialised
1885	* early.	1885	* early.
1886	*/	1886	*/
1887	spin_lock_init(&port->lock);	1887	spin_lock_init(&port->lock);
1888	lockdep_set_class(&port->lock, &port_lock_key);	1888	lockdep_set_class(&port->lock, &port_lock_key);
1889		1889
1890	memset(&termios, 0, sizeof(struct ktermios));	1890	memset(&termios, 0, sizeof(struct ktermios));
1891		1891
1892	termios.c_cflag = CREAD \| HUPCL \| CLOCAL;	1892	termios.c_cflag = CREAD \| HUPCL \| CLOCAL;
1893		1893
1894	/*	1894	/*
1895	* Construct a cflag setting.	1895	* Construct a cflag setting.
1896	*/	1896	*/
1897	for (i = 0; baud_rates[i].rate; i++)	1897	for (i = 0; baud_rates[i].rate; i++)
1898	if (baud_rates[i].rate <= baud)	1898	if (baud_rates[i].rate <= baud)
1899	break;	1899	break;
1900		1900
1901	termios.c_cflag \|= baud_rates[i].cflag;	1901	termios.c_cflag \|= baud_rates[i].cflag;
1902		1902
1903	if (bits == 7)	1903	if (bits == 7)
1904	termios.c_cflag \|= CS7;	1904	termios.c_cflag \|= CS7;
1905	else	1905	else
1906	termios.c_cflag \|= CS8;	1906	termios.c_cflag \|= CS8;
1907		1907
1908	switch (parity) {	1908	switch (parity) {
1909	case 'o': case 'O':	1909	case 'o': case 'O':
1910	termios.c_cflag \|= PARODD;	1910	termios.c_cflag \|= PARODD;
1911	/fall through/	1911	/fall through/
1912	case 'e': case 'E':	1912	case 'e': case 'E':
1913	termios.c_cflag \|= PARENB;	1913	termios.c_cflag \|= PARENB;
1914	break;	1914	break;
1915	}	1915	}
1916		1916
1917	if (flow == 'r')	1917	if (flow == 'r')
1918	termios.c_cflag \|= CRTSCTS;	1918	termios.c_cflag \|= CRTSCTS;
1919		1919
1920	/*	1920	/*
1921	* some uarts on other side don't support no flow control.	1921	* some uarts on other side don't support no flow control.
1922	* So we set * DTR in host uart to make them happy	1922	* So we set * DTR in host uart to make them happy
1923	*/	1923	*/
1924	port->mctrl \|= TIOCM_DTR;	1924	port->mctrl \|= TIOCM_DTR;
1925		1925
1926	port->ops->set_termios(port, &termios, &dummy);	1926	port->ops->set_termios(port, &termios, &dummy);
1927	co->cflag = termios.c_cflag;	1927	co->cflag = termios.c_cflag;
1928		1928
1929	return 0;	1929	return 0;
1930	}	1930	}
1931	#endif /* CONFIG_SERIAL_CORE_CONSOLE */	1931	#endif /* CONFIG_SERIAL_CORE_CONSOLE */
1932		1932
1933	static void uart_change_pm(struct uart_state *state, int pm_state)	1933	static void uart_change_pm(struct uart_state *state, int pm_state)
1934	{	1934	{
1935	struct uart_port *port = state->port;	1935	struct uart_port *port = state->port;
1936		1936
1937	if (state->pm_state != pm_state) {	1937	if (state->pm_state != pm_state) {
1938	if (port->ops->pm)	1938	if (port->ops->pm)
1939	port->ops->pm(port, pm_state, state->pm_state);	1939	port->ops->pm(port, pm_state, state->pm_state);
1940	state->pm_state = pm_state;	1940	state->pm_state = pm_state;
1941	}	1941	}
1942	}	1942	}
1943		1943
1944	struct uart_match {	1944	struct uart_match {
1945	struct uart_port *port;	1945	struct uart_port *port;
1946	struct uart_driver *driver;	1946	struct uart_driver *driver;
1947	};	1947	};
1948		1948
1949	static int serial_match_port(struct device dev, void data)	1949	static int serial_match_port(struct device dev, void data)
1950	{	1950	{
1951	struct uart_match *match = data;	1951	struct uart_match *match = data;
1952	dev_t devt = MKDEV(match->driver->major, match->driver->minor) + match->port->line;	1952	dev_t devt = MKDEV(match->driver->major, match->driver->minor) + match->port->line;
1953		1953
1954	return dev->devt == devt; /* Actually, only one tty per port */	1954	return dev->devt == devt; /* Actually, only one tty per port */
1955	}	1955	}
1956		1956
1957	int uart_suspend_port(struct uart_driver drv, struct uart_port port)	1957	int uart_suspend_port(struct uart_driver drv, struct uart_port port)
1958	{	1958	{
1959	struct uart_state *state = drv->state + port->line;	1959	struct uart_state *state = drv->state + port->line;
1960	struct device *tty_dev;	1960	struct device *tty_dev;
1961	struct uart_match match = {port, drv};	1961	struct uart_match match = {port, drv};
1962		1962
1963	mutex_lock(&state->mutex);	1963	mutex_lock(&state->mutex);
1964		1964
1965	if (!console_suspend_enabled && uart_console(port)) {	1965	if (!console_suspend_enabled && uart_console(port)) {
1966	/* we're going to avoid suspending serial console */	1966	/* we're going to avoid suspending serial console */
1967	mutex_unlock(&state->mutex);	1967	mutex_unlock(&state->mutex);
1968	return 0;	1968	return 0;
1969	}	1969	}
1970		1970
1971	tty_dev = device_find_child(port->dev, &match, serial_match_port);	1971	tty_dev = device_find_child(port->dev, &match, serial_match_port);
1972	if (device_may_wakeup(tty_dev)) {	1972	if (device_may_wakeup(tty_dev)) {
1973	enable_irq_wake(port->irq);	1973	enable_irq_wake(port->irq);
1974	put_device(tty_dev);	1974	put_device(tty_dev);
1975	mutex_unlock(&state->mutex);	1975	mutex_unlock(&state->mutex);
1976	return 0;	1976	return 0;
1977	}	1977	}
1978	port->suspended = 1;	1978	port->suspended = 1;
1979		1979
1980	if (state->info && state->info->flags & UIF_INITIALIZED) {	1980	if (state->info && state->info->flags & UIF_INITIALIZED) {
1981	const struct uart_ops *ops = port->ops;	1981	const struct uart_ops *ops = port->ops;
1982	int tries;	1982	int tries;
1983		1983
1984	state->info->flags = (state->info->flags & ~UIF_INITIALIZED)	1984	state->info->flags = (state->info->flags & ~UIF_INITIALIZED)
1985	\| UIF_SUSPENDED;	1985	\| UIF_SUSPENDED;
1986		1986
1987	spin_lock_irq(&port->lock);	1987	spin_lock_irq(&port->lock);
1988	ops->stop_tx(port);	1988	ops->stop_tx(port);
1989	ops->set_mctrl(port, 0);	1989	ops->set_mctrl(port, 0);
1990	ops->stop_rx(port);	1990	ops->stop_rx(port);
1991	spin_unlock_irq(&port->lock);	1991	spin_unlock_irq(&port->lock);
1992		1992
1993	/*	1993	/*
1994	* Wait for the transmitter to empty.	1994	* Wait for the transmitter to empty.
1995	*/	1995	*/
1996	for (tries = 3; !ops->tx_empty(port) && tries; tries--)	1996	for (tries = 3; !ops->tx_empty(port) && tries; tries--)
1997	msleep(10);	1997	msleep(10);
1998	if (!tries)	1998	if (!tries)
1999	printk(KERN_ERR "%s%s%s%d: Unable to drain "	1999	printk(KERN_ERR "%s%s%s%d: Unable to drain "
2000	"transmitter\n",	2000	"transmitter\n",
2001	port->dev ? port->dev->bus_id : "",	2001	port->dev ? port->dev->bus_id : "",
2002	port->dev ? ": " : "",	2002	port->dev ? ": " : "",
2003	drv->dev_name, port->line);	2003	drv->dev_name, port->line);
2004		2004
2005	ops->shutdown(port);	2005	ops->shutdown(port);
2006	}	2006	}
2007		2007
2008	/*	2008	/*
2009	* Disable the console device before suspending.	2009	* Disable the console device before suspending.
2010	*/	2010	*/
2011	if (uart_console(port))	2011	if (uart_console(port))
2012	console_stop(port->cons);	2012	console_stop(port->cons);
2013		2013
2014	uart_change_pm(state, 3);	2014	uart_change_pm(state, 3);
2015		2015
2016	mutex_unlock(&state->mutex);	2016	mutex_unlock(&state->mutex);
2017		2017
2018	return 0;	2018	return 0;
2019	}	2019	}
2020		2020
2021	int uart_resume_port(struct uart_driver drv, struct uart_port port)	2021	int uart_resume_port(struct uart_driver drv, struct uart_port port)
2022	{	2022	{
2023	struct uart_state *state = drv->state + port->line;	2023	struct uart_state *state = drv->state + port->line;
2024		2024
2025	mutex_lock(&state->mutex);	2025	mutex_lock(&state->mutex);
2026		2026
2027	if (!console_suspend_enabled && uart_console(port)) {	2027	if (!console_suspend_enabled && uart_console(port)) {
2028	/* no need to resume serial console, it wasn't suspended */	2028	/* no need to resume serial console, it wasn't suspended */
2029	mutex_unlock(&state->mutex);	2029	mutex_unlock(&state->mutex);
2030	return 0;	2030	return 0;
2031	}	2031	}
2032		2032
2033	if (!port->suspended) {	2033	if (!port->suspended) {
2034	disable_irq_wake(port->irq);	2034	disable_irq_wake(port->irq);
2035	mutex_unlock(&state->mutex);	2035	mutex_unlock(&state->mutex);
2036	return 0;	2036	return 0;
2037	}	2037	}
2038	port->suspended = 0;	2038	port->suspended = 0;
2039		2039
2040	/*	2040	/*
2041	* Re-enable the console device after suspending.	2041	* Re-enable the console device after suspending.
2042	*/	2042	*/
2043	if (uart_console(port)) {	2043	if (uart_console(port)) {
2044	struct ktermios termios;	2044	struct ktermios termios;
2045		2045
2046	/*	2046	/*
2047	* First try to use the console cflag setting.	2047	* First try to use the console cflag setting.
2048	*/	2048	*/
2049	memset(&termios, 0, sizeof(struct ktermios));	2049	memset(&termios, 0, sizeof(struct ktermios));
2050	termios.c_cflag = port->cons->cflag;	2050	termios.c_cflag = port->cons->cflag;
2051		2051
2052	/*	2052	/*
2053	* If that's unset, use the tty termios setting.	2053	* If that's unset, use the tty termios setting.
2054	*/	2054	*/
2055	if (state->info && state->info->tty && termios.c_cflag == 0)	2055	if (state->info && state->info->tty && termios.c_cflag == 0)
2056	termios = *state->info->tty->termios;	2056	termios = *state->info->tty->termios;
2057		2057
2058	uart_change_pm(state, 0);	2058	uart_change_pm(state, 0);
2059	port->ops->set_termios(port, &termios, NULL);	2059	port->ops->set_termios(port, &termios, NULL);
2060	console_start(port->cons);	2060	console_start(port->cons);
2061	}	2061	}
2062		2062
2063	if (state->info && state->info->flags & UIF_SUSPENDED) {	2063	if (state->info && state->info->flags & UIF_SUSPENDED) {
2064	const struct uart_ops *ops = port->ops;	2064	const struct uart_ops *ops = port->ops;
2065	int ret;	2065	int ret;
2066		2066
2067	uart_change_pm(state, 0);	2067	uart_change_pm(state, 0);
2068	ops->set_mctrl(port, 0);	2068	ops->set_mctrl(port, 0);
2069	ret = ops->startup(port);	2069	ret = ops->startup(port);
2070	if (ret == 0) {	2070	if (ret == 0) {
2071	uart_change_speed(state, NULL);	2071	uart_change_speed(state, NULL);
2072	spin_lock_irq(&port->lock);	2072	spin_lock_irq(&port->lock);
2073	ops->set_mctrl(port, port->mctrl);	2073	ops->set_mctrl(port, port->mctrl);
2074	ops->start_tx(port);	2074	ops->start_tx(port);
2075	spin_unlock_irq(&port->lock);	2075	spin_unlock_irq(&port->lock);
2076	state->info->flags \|= UIF_INITIALIZED;	2076	state->info->flags \|= UIF_INITIALIZED;
2077	} else {	2077	} else {
2078	/*	2078	/*
2079	* Failed to resume - maybe hardware went away?	2079	* Failed to resume - maybe hardware went away?
2080	* Clear the "initialized" flag so we won't try	2080	* Clear the "initialized" flag so we won't try
2081	* to call the low level drivers shutdown method.	2081	* to call the low level drivers shutdown method.
2082	*/	2082	*/
2083	uart_shutdown(state);	2083	uart_shutdown(state);
2084	}	2084	}
2085		2085
2086	state->info->flags &= ~UIF_SUSPENDED;	2086	state->info->flags &= ~UIF_SUSPENDED;
2087	}	2087	}
2088		2088
2089	mutex_unlock(&state->mutex);	2089	mutex_unlock(&state->mutex);
2090		2090
2091	return 0;	2091	return 0;
2092	}	2092	}
2093		2093
2094	static inline void	2094	static inline void
2095	uart_report_port(struct uart_driver drv, struct uart_port port)	2095	uart_report_port(struct uart_driver drv, struct uart_port port)
2096	{	2096	{
2097	char address[64];	2097	char address[64];
2098		2098
2099	switch (port->iotype) {	2099	switch (port->iotype) {
2100	case UPIO_PORT:	2100	case UPIO_PORT:
2101	snprintf(address, sizeof(address),	2101	snprintf(address, sizeof(address),
2102	"I/O 0x%x", port->iobase);	2102	"I/O 0x%x", port->iobase);
2103	break;	2103	break;
2104	case UPIO_HUB6:	2104	case UPIO_HUB6:
2105	snprintf(address, sizeof(address),	2105	snprintf(address, sizeof(address),
2106	"I/O 0x%x offset 0x%x", port->iobase, port->hub6);	2106	"I/O 0x%x offset 0x%x", port->iobase, port->hub6);
2107	break;	2107	break;
2108	case UPIO_MEM:	2108	case UPIO_MEM:
2109	case UPIO_MEM32:	2109	case UPIO_MEM32:
2110	case UPIO_AU:	2110	case UPIO_AU:
2111	case UPIO_TSI:	2111	case UPIO_TSI:
2112	case UPIO_DWAPB:	2112	case UPIO_DWAPB:
2113	snprintf(address, sizeof(address),	2113	snprintf(address, sizeof(address),
2114	"MMIO 0x%llx", (unsigned long long)port->mapbase);	2114	"MMIO 0x%llx", (unsigned long long)port->mapbase);
2115	break;	2115	break;
2116	default:	2116	default:
2117	strlcpy(address, "unknown", sizeof(address));	2117	strlcpy(address, "unknown", sizeof(address));
2118	break;	2118	break;
2119	}	2119	}
2120		2120
2121	printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",	2121	printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
2122	port->dev ? port->dev->bus_id : "",	2122	port->dev ? port->dev->bus_id : "",
2123	port->dev ? ": " : "",	2123	port->dev ? ": " : "",
2124	drv->dev_name, port->line, address, port->irq, uart_type(port));	2124	drv->dev_name, port->line, address, port->irq, uart_type(port));
2125	}	2125	}
2126		2126
2127	static void	2127	static void
2128	uart_configure_port(struct uart_driver drv, struct uart_state state,	2128	uart_configure_port(struct uart_driver drv, struct uart_state state,
2129	struct uart_port *port)	2129	struct uart_port *port)
2130	{	2130	{
2131	unsigned int flags;	2131	unsigned int flags;
2132		2132
2133	/*	2133	/*
2134	* If there isn't a port here, don't do anything further.	2134	* If there isn't a port here, don't do anything further.
2135	*/	2135	*/
2136	if (!port->iobase && !port->mapbase && !port->membase)	2136	if (!port->iobase && !port->mapbase && !port->membase)
2137	return;	2137	return;
2138		2138
2139	/*	2139	/*
2140	* Now do the auto configuration stuff. Note that config_port	2140	* Now do the auto configuration stuff. Note that config_port
2141	* is expected to claim the resources and map the port for us.	2141	* is expected to claim the resources and map the port for us.
2142	*/	2142	*/
2143	flags = UART_CONFIG_TYPE;	2143	flags = UART_CONFIG_TYPE;
2144	if (port->flags & UPF_AUTO_IRQ)	2144	if (port->flags & UPF_AUTO_IRQ)
2145	flags \|= UART_CONFIG_IRQ;	2145	flags \|= UART_CONFIG_IRQ;
2146	if (port->flags & UPF_BOOT_AUTOCONF) {	2146	if (port->flags & UPF_BOOT_AUTOCONF) {
2147	port->type = PORT_UNKNOWN;	2147	port->type = PORT_UNKNOWN;
2148	port->ops->config_port(port, flags);	2148	port->ops->config_port(port, flags);
2149	}	2149	}
2150		2150
2151	if (port->type != PORT_UNKNOWN) {	2151	if (port->type != PORT_UNKNOWN) {
2152	unsigned long flags;	2152	unsigned long flags;
2153		2153
2154	uart_report_port(drv, port);	2154	uart_report_port(drv, port);
2155		2155
2156	/* Power up port for set_mctrl() */	2156	/* Power up port for set_mctrl() */
2157	uart_change_pm(state, 0);	2157	uart_change_pm(state, 0);
2158		2158
2159	/*	2159	/*
2160	* Ensure that the modem control lines are de-activated.	2160	* Ensure that the modem control lines are de-activated.
2161	* keep the DTR setting that is set in uart_set_options()	2161	* keep the DTR setting that is set in uart_set_options()
2162	* We probably don't need a spinlock around this, but	2162	* We probably don't need a spinlock around this, but
2163	*/	2163	*/
2164	spin_lock_irqsave(&port->lock, flags);	2164	spin_lock_irqsave(&port->lock, flags);
2165	port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);	2165	port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
2166	spin_unlock_irqrestore(&port->lock, flags);	2166	spin_unlock_irqrestore(&port->lock, flags);
2167		2167
2168	/*	2168	/*
2169	* If this driver supports console, and it hasn't been	2169	* If this driver supports console, and it hasn't been
2170	* successfully registered yet, try to re-register it.	2170	* successfully registered yet, try to re-register it.
2171	* It may be that the port was not available.	2171	* It may be that the port was not available.
2172	*/	2172	*/
2173	if (port->cons && !(port->cons->flags & CON_ENABLED))	2173	if (port->cons && !(port->cons->flags & CON_ENABLED))
2174	register_console(port->cons);	2174	register_console(port->cons);
2175		2175
2176	/*	2176	/*
2177	* Power down all ports by default, except the	2177	* Power down all ports by default, except the
2178	* console if we have one.	2178	* console if we have one.
2179	*/	2179	*/
2180	if (!uart_console(port))	2180	if (!uart_console(port))
2181	uart_change_pm(state, 3);	2181	uart_change_pm(state, 3);
2182	}	2182	}
2183	}	2183	}
2184		2184
2185	static const struct tty_operations uart_ops = {	2185	static const struct tty_operations uart_ops = {
2186	.open = uart_open,	2186	.open = uart_open,
2187	.close = uart_close,	2187	.close = uart_close,
2188	.write = uart_write,	2188	.write = uart_write,
2189	.put_char = uart_put_char,	2189	.put_char = uart_put_char,
2190	.flush_chars = uart_flush_chars,	2190	.flush_chars = uart_flush_chars,
2191	.write_room = uart_write_room,	2191	.write_room = uart_write_room,
2192	.chars_in_buffer= uart_chars_in_buffer,	2192	.chars_in_buffer= uart_chars_in_buffer,
2193	.flush_buffer = uart_flush_buffer,	2193	.flush_buffer = uart_flush_buffer,
2194	.ioctl = uart_ioctl,	2194	.ioctl = uart_ioctl,
2195	.throttle = uart_throttle,	2195	.throttle = uart_throttle,
2196	.unthrottle = uart_unthrottle,	2196	.unthrottle = uart_unthrottle,
2197	.send_xchar = uart_send_xchar,	2197	.send_xchar = uart_send_xchar,
2198	.set_termios = uart_set_termios,	2198	.set_termios = uart_set_termios,
2199	.stop = uart_stop,	2199	.stop = uart_stop,
2200	.start = uart_start,	2200	.start = uart_start,
2201	.hangup = uart_hangup,	2201	.hangup = uart_hangup,
2202	.break_ctl = uart_break_ctl,	2202	.break_ctl = uart_break_ctl,
2203	.wait_until_sent= uart_wait_until_sent,	2203	.wait_until_sent= uart_wait_until_sent,
2204	#ifdef CONFIG_PROC_FS	2204	#ifdef CONFIG_PROC_FS
2205	.read_proc = uart_read_proc,	2205	.read_proc = uart_read_proc,
2206	#endif	2206	#endif
2207	.tiocmget = uart_tiocmget,	2207	.tiocmget = uart_tiocmget,
2208	.tiocmset = uart_tiocmset,	2208	.tiocmset = uart_tiocmset,
2209	};	2209	};
2210		2210
2211	/**	2211	/**
2212	* uart_register_driver - register a driver with the uart core layer	2212	* uart_register_driver - register a driver with the uart core layer
2213	* @drv: low level driver structure	2213	* @drv: low level driver structure
2214	*	2214	*
2215	* Register a uart driver with the core driver. We in turn register	2215	* Register a uart driver with the core driver. We in turn register
2216	* with the tty layer, and initialise the core driver per-port state.	2216	* with the tty layer, and initialise the core driver per-port state.
2217	*	2217	*
2218	* We have a proc file in /proc/tty/driver which is named after the	2218	* We have a proc file in /proc/tty/driver which is named after the
2219	* normal driver.	2219	* normal driver.
2220	*	2220	*
2221	* drv->port should be NULL, and the per-port structures should be	2221	* drv->port should be NULL, and the per-port structures should be
2222	* registered using uart_add_one_port after this call has succeeded.	2222	* registered using uart_add_one_port after this call has succeeded.
2223	*/	2223	*/
2224	int uart_register_driver(struct uart_driver *drv)	2224	int uart_register_driver(struct uart_driver *drv)
2225	{	2225	{
2226	struct tty_driver *normal = NULL;	2226	struct tty_driver *normal = NULL;
2227	int i, retval;	2227	int i, retval;
2228		2228
2229	BUG_ON(drv->state);	2229	BUG_ON(drv->state);
2230		2230
2231	/*	2231	/*
2232	* Maybe we should be using a slab cache for this, especially if	2232	* Maybe we should be using a slab cache for this, especially if
2233	* we have a large number of ports to handle.	2233	* we have a large number of ports to handle.
2234	*/	2234	*/
2235	drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);	2235	drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
2236	retval = -ENOMEM;	2236	retval = -ENOMEM;
2237	if (!drv->state)	2237	if (!drv->state)
2238	goto out;	2238	goto out;
2239		2239
2240	normal = alloc_tty_driver(drv->nr);	2240	normal = alloc_tty_driver(drv->nr);
2241	if (!normal)	2241	if (!normal)
2242	goto out;	2242	goto out;
2243		2243
2244	drv->tty_driver = normal;	2244	drv->tty_driver = normal;
2245		2245
2246	normal->owner = drv->owner;	2246	normal->owner = drv->owner;
2247	normal->driver_name = drv->driver_name;	2247	normal->driver_name = drv->driver_name;
2248	normal->name = drv->dev_name;	2248	normal->name = drv->dev_name;
2249	normal->major = drv->major;	2249	normal->major = drv->major;
2250	normal->minor_start = drv->minor;	2250	normal->minor_start = drv->minor;
2251	normal->type = TTY_DRIVER_TYPE_SERIAL;	2251	normal->type = TTY_DRIVER_TYPE_SERIAL;
2252	normal->subtype = SERIAL_TYPE_NORMAL;	2252	normal->subtype = SERIAL_TYPE_NORMAL;
2253	normal->init_termios = tty_std_termios;	2253	normal->init_termios = tty_std_termios;
2254	normal->init_termios.c_cflag = B9600 \| CS8 \| CREAD \| HUPCL \| CLOCAL;	2254	normal->init_termios.c_cflag = B9600 \| CS8 \| CREAD \| HUPCL \| CLOCAL;
2255	normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;	2255	normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2256	normal->flags = TTY_DRIVER_REAL_RAW \| TTY_DRIVER_DYNAMIC_DEV;	2256	normal->flags = TTY_DRIVER_REAL_RAW \| TTY_DRIVER_DYNAMIC_DEV;
2257	normal->driver_state = drv;	2257	normal->driver_state = drv;
2258	tty_set_operations(normal, &uart_ops);	2258	tty_set_operations(normal, &uart_ops);
2259		2259
2260	/*	2260	/*
2261	* Initialise the UART state(s).	2261	* Initialise the UART state(s).
2262	*/	2262	*/
2263	for (i = 0; i < drv->nr; i++) {	2263	for (i = 0; i < drv->nr; i++) {
2264	struct uart_state *state = drv->state + i;	2264	struct uart_state *state = drv->state + i;
2265		2265
2266	state->close_delay = 500; /* .5 seconds */	2266	state->close_delay = 500; /* .5 seconds */
2267	state->closing_wait = 30000; /* 30 seconds */	2267	state->closing_wait = 30000; /* 30 seconds */
2268		2268
2269	mutex_init(&state->mutex);	2269	mutex_init(&state->mutex);
2270	}	2270	}
2271		2271
2272	retval = tty_register_driver(normal);	2272	retval = tty_register_driver(normal);
2273	out:	2273	out:
2274	if (retval < 0) {	2274	if (retval < 0) {
2275	put_tty_driver(normal);	2275	put_tty_driver(normal);
2276	kfree(drv->state);	2276	kfree(drv->state);
2277	}	2277	}
2278	return retval;	2278	return retval;
2279	}	2279	}
2280		2280
2281	/**	2281	/**
2282	* uart_unregister_driver - remove a driver from the uart core layer	2282	* uart_unregister_driver - remove a driver from the uart core layer
2283	* @drv: low level driver structure	2283	* @drv: low level driver structure
2284	*	2284	*
2285	* Remove all references to a driver from the core driver. The low	2285	* Remove all references to a driver from the core driver. The low
2286	* level driver must have removed all its ports via the	2286	* level driver must have removed all its ports via the
2287	* uart_remove_one_port() if it registered them with uart_add_one_port().	2287	* uart_remove_one_port() if it registered them with uart_add_one_port().
2288	* (ie, drv->port == NULL)	2288	* (ie, drv->port == NULL)
2289	*/	2289	*/
2290	void uart_unregister_driver(struct uart_driver *drv)	2290	void uart_unregister_driver(struct uart_driver *drv)
2291	{	2291	{
2292	struct tty_driver *p = drv->tty_driver;	2292	struct tty_driver *p = drv->tty_driver;
2293	tty_unregister_driver(p);	2293	tty_unregister_driver(p);
2294	put_tty_driver(p);	2294	put_tty_driver(p);
2295	kfree(drv->state);	2295	kfree(drv->state);
2296	drv->tty_driver = NULL;	2296	drv->tty_driver = NULL;
2297	}	2297	}
2298		2298
2299	struct tty_driver uart_console_device(struct console co, int *index)	2299	struct tty_driver uart_console_device(struct console co, int *index)
2300	{	2300	{
2301	struct uart_driver *p = co->data;	2301	struct uart_driver *p = co->data;
2302	*index = co->index;	2302	*index = co->index;
2303	return p->tty_driver;	2303	return p->tty_driver;
2304	}	2304	}
2305		2305
2306	/**	2306	/**
2307	* uart_add_one_port - attach a driver-defined port structure	2307	* uart_add_one_port - attach a driver-defined port structure
2308	* @drv: pointer to the uart low level driver structure for this port	2308	* @drv: pointer to the uart low level driver structure for this port
2309	* @port: uart port structure to use for this port.	2309	* @port: uart port structure to use for this port.
2310	*	2310	*
2311	* This allows the driver to register its own uart_port structure	2311	* This allows the driver to register its own uart_port structure
2312	* with the core driver. The main purpose is to allow the low	2312	* with the core driver. The main purpose is to allow the low
2313	* level uart drivers to expand uart_port, rather than having yet	2313	* level uart drivers to expand uart_port, rather than having yet
2314	* more levels of structures.	2314	* more levels of structures.
2315	*/	2315	*/
2316	int uart_add_one_port(struct uart_driver drv, struct uart_port port)	2316	int uart_add_one_port(struct uart_driver drv, struct uart_port port)
2317	{	2317	{
2318	struct uart_state *state;	2318	struct uart_state *state;
2319	int ret = 0;	2319	int ret = 0;
2320	struct device *tty_dev;	2320	struct device *tty_dev;
2321		2321
2322	BUG_ON(in_interrupt());	2322	BUG_ON(in_interrupt());
2323		2323
2324	if (port->line >= drv->nr)	2324	if (port->line >= drv->nr)
2325	return -EINVAL;	2325	return -EINVAL;
2326		2326
2327	state = drv->state + port->line;	2327	state = drv->state + port->line;
2328		2328
2329	mutex_lock(&port_mutex);	2329	mutex_lock(&port_mutex);
2330	mutex_lock(&state->mutex);	2330	mutex_lock(&state->mutex);
2331	if (state->port) {	2331	if (state->port) {
2332	ret = -EINVAL;	2332	ret = -EINVAL;
2333	goto out;	2333	goto out;
2334	}	2334	}
2335		2335
2336	state->port = port;	2336	state->port = port;
2337	state->pm_state = -1;	2337	state->pm_state = -1;
2338		2338
2339	port->cons = drv->cons;	2339	port->cons = drv->cons;
2340	port->info = state->info;	2340	port->info = state->info;
2341		2341
2342	/*	2342	/*
2343	* If this port is a console, then the spinlock is already	2343	* If this port is a console, then the spinlock is already
2344	* initialised.	2344	* initialised.
2345	*/	2345	*/
2346	if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {	2346	if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
2347	spin_lock_init(&port->lock);	2347	spin_lock_init(&port->lock);
2348	lockdep_set_class(&port->lock, &port_lock_key);	2348	lockdep_set_class(&port->lock, &port_lock_key);
2349	}	2349	}
2350		2350
2351	uart_configure_port(drv, state, port);	2351	uart_configure_port(drv, state, port);
2352		2352
2353	/*	2353	/*
2354	* Register the port whether it's detected or not. This allows	2354	* Register the port whether it's detected or not. This allows
2355	* setserial to be used to alter this ports parameters.	2355	* setserial to be used to alter this ports parameters.
2356	*/	2356	*/
2357	tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev);	2357	tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev);
2358	if (likely(!IS_ERR(tty_dev))) {	2358	if (likely(!IS_ERR(tty_dev))) {
2359	device_can_wakeup(tty_dev) = 1;	2359	device_can_wakeup(tty_dev) = 1;
2360	device_set_wakeup_enable(tty_dev, 0);	2360	device_set_wakeup_enable(tty_dev, 0);
2361	} else	2361	} else
2362	printk(KERN_ERR "Cannot register tty device on line %d\n",	2362	printk(KERN_ERR "Cannot register tty device on line %d\n",
2363	port->line);	2363	port->line);
2364		2364
2365	/*	2365	/*
2366	* Ensure UPF_DEAD is not set.	2366	* Ensure UPF_DEAD is not set.
2367	*/	2367	*/
2368	port->flags &= ~UPF_DEAD;	2368	port->flags &= ~UPF_DEAD;
2369		2369
2370	out:	2370	out:
2371	mutex_unlock(&state->mutex);	2371	mutex_unlock(&state->mutex);
2372	mutex_unlock(&port_mutex);	2372	mutex_unlock(&port_mutex);
2373		2373
2374	return ret;	2374	return ret;
2375	}	2375	}
2376		2376
2377	/**	2377	/**
2378	* uart_remove_one_port - detach a driver defined port structure	2378	* uart_remove_one_port - detach a driver defined port structure
2379	* @drv: pointer to the uart low level driver structure for this port	2379	* @drv: pointer to the uart low level driver structure for this port
2380	* @port: uart port structure for this port	2380	* @port: uart port structure for this port
2381	*	2381	*
2382	* This unhooks (and hangs up) the specified port structure from the	2382	* This unhooks (and hangs up) the specified port structure from the
2383	* core driver. No further calls will be made to the low-level code	2383	* core driver. No further calls will be made to the low-level code
2384	* for this port.	2384	* for this port.
2385	*/	2385	*/
2386	int uart_remove_one_port(struct uart_driver drv, struct uart_port port)	2386	int uart_remove_one_port(struct uart_driver drv, struct uart_port port)
2387	{	2387	{
2388	struct uart_state *state = drv->state + port->line;	2388	struct uart_state *state = drv->state + port->line;
2389	struct uart_info *info;	2389	struct uart_info *info;
2390		2390
2391	BUG_ON(in_interrupt());	2391	BUG_ON(in_interrupt());
2392		2392
2393	if (state->port != port)	2393	if (state->port != port)
2394	printk(KERN_ALERT "Removing wrong port: %p != %p\n",	2394	printk(KERN_ALERT "Removing wrong port: %p != %p\n",
2395	state->port, port);	2395	state->port, port);
2396		2396
2397	mutex_lock(&port_mutex);	2397	mutex_lock(&port_mutex);
2398		2398
2399	/*	2399	/*
2400	* Mark the port "dead" - this prevents any opens from	2400	* Mark the port "dead" - this prevents any opens from
2401	* succeeding while we shut down the port.	2401	* succeeding while we shut down the port.
2402	*/	2402	*/
2403	mutex_lock(&state->mutex);	2403	mutex_lock(&state->mutex);
2404	port->flags \|= UPF_DEAD;	2404	port->flags \|= UPF_DEAD;
2405	mutex_unlock(&state->mutex);	2405	mutex_unlock(&state->mutex);
2406		2406
2407	/*	2407	/*
2408	* Remove the devices from the tty layer	2408	* Remove the devices from the tty layer
2409	*/	2409	*/
2410	tty_unregister_device(drv->tty_driver, port->line);	2410	tty_unregister_device(drv->tty_driver, port->line);
2411		2411
2412	info = state->info;	2412	info = state->info;
2413	if (info && info->tty)	2413	if (info && info->tty)
2414	tty_vhangup(info->tty);	2414	tty_vhangup(info->tty);
2415		2415
2416	/*	2416	/*
2417	* All users of this port should now be disconnected from	2417	* All users of this port should now be disconnected from
2418	* this driver, and the port shut down. We should be the	2418	* this driver, and the port shut down. We should be the
2419	* only thread fiddling with this port from now on.	2419	* only thread fiddling with this port from now on.
2420	*/	2420	*/
2421	state->info = NULL;	2421	state->info = NULL;
2422		2422
2423	/*	2423	/*
2424	* Free the port IO and memory resources, if any.	2424	* Free the port IO and memory resources, if any.
2425	*/	2425	*/
2426	if (port->type != PORT_UNKNOWN)	2426	if (port->type != PORT_UNKNOWN)
2427	port->ops->release_port(port);	2427	port->ops->release_port(port);
2428		2428
2429	/*	2429	/*
2430	* Indicate that there isn't a port here anymore.	2430	* Indicate that there isn't a port here anymore.
2431	*/	2431	*/
2432	port->type = PORT_UNKNOWN;	2432	port->type = PORT_UNKNOWN;
2433		2433
2434	/*	2434	/*
2435	* Kill the tasklet, and free resources.	2435	* Kill the tasklet, and free resources.
2436	*/	2436	*/
2437	if (info) {	2437	if (info) {
2438	tasklet_kill(&info->tlet);	2438	tasklet_kill(&info->tlet);
2439	kfree(info);	2439	kfree(info);
2440	}	2440	}
2441		2441
2442	state->port = NULL;	2442	state->port = NULL;
2443	mutex_unlock(&port_mutex);	2443	mutex_unlock(&port_mutex);
2444		2444
2445	return 0;	2445	return 0;
2446	}	2446	}
2447		2447
2448	/*	2448	/*
2449	* Are the two ports equivalent?	2449	* Are the two ports equivalent?
2450	*/	2450	*/
2451	int uart_match_port(struct uart_port port1, struct uart_port port2)	2451	int uart_match_port(struct uart_port port1, struct uart_port port2)
2452	{	2452	{
2453	if (port1->iotype != port2->iotype)	2453	if (port1->iotype != port2->iotype)
2454	return 0;	2454	return 0;
2455		2455
2456	switch (port1->iotype) {	2456	switch (port1->iotype) {
2457	case UPIO_PORT:	2457	case UPIO_PORT:
2458	return (port1->iobase == port2->iobase);	2458	return (port1->iobase == port2->iobase);
2459	case UPIO_HUB6:	2459	case UPIO_HUB6:
2460	return (port1->iobase == port2->iobase) &&	2460	return (port1->iobase == port2->iobase) &&
2461	(port1->hub6 == port2->hub6);	2461	(port1->hub6 == port2->hub6);
2462	case UPIO_MEM:	2462	case UPIO_MEM:
2463	case UPIO_MEM32:	2463	case UPIO_MEM32:
2464	case UPIO_AU:	2464	case UPIO_AU:
2465	case UPIO_TSI:	2465	case UPIO_TSI:
2466	case UPIO_DWAPB:	2466	case UPIO_DWAPB:
2467	return (port1->mapbase == port2->mapbase);	2467	return (port1->mapbase == port2->mapbase);
2468	}	2468	}
2469	return 0;	2469	return 0;
2470	}	2470	}
2471	EXPORT_SYMBOL(uart_match_port);	2471	EXPORT_SYMBOL(uart_match_port);
2472		2472
2473	EXPORT_SYMBOL(uart_write_wakeup);	2473	EXPORT_SYMBOL(uart_write_wakeup);
2474	EXPORT_SYMBOL(uart_register_driver);	2474	EXPORT_SYMBOL(uart_register_driver);
2475	EXPORT_SYMBOL(uart_unregister_driver);	2475	EXPORT_SYMBOL(uart_unregister_driver);
2476	EXPORT_SYMBOL(uart_suspend_port);	2476	EXPORT_SYMBOL(uart_suspend_port);
2477	EXPORT_SYMBOL(uart_resume_port);	2477	EXPORT_SYMBOL(uart_resume_port);
2478	EXPORT_SYMBOL(uart_add_one_port);	2478	EXPORT_SYMBOL(uart_add_one_port);
2479	EXPORT_SYMBOL(uart_remove_one_port);	2479	EXPORT_SYMBOL(uart_remove_one_port);
2480		2480
2481	MODULE_DESCRIPTION("Serial driver core");	2481	MODULE_DESCRIPTION("Serial driver core");
2482	MODULE_LICENSE("GPL");	2482	MODULE_LICENSE("GPL");
2483		2483

fs/char_dev.c

Diff comments View file @ 922f9cf

1	/*	1	/*
2	* linux/fs/char_dev.c	2	* linux/fs/char_dev.c
3	*	3	*
4	* Copyright (C) 1991, 1992 Linus Torvalds	4	* Copyright (C) 1991, 1992 Linus Torvalds
5	*/	5	*/
6		6
7	#include <linux/init.h>	7	#include <linux/init.h>
8	#include <linux/fs.h>	8	#include <linux/fs.h>
9	#include <linux/kdev_t.h>	9	#include <linux/kdev_t.h>
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/string.h>	11	#include <linux/string.h>
12		12
13	#include <linux/major.h>	13	#include <linux/major.h>
14	#include <linux/errno.h>	14	#include <linux/errno.h>
15	#include <linux/module.h>	15	#include <linux/module.h>
16	#include <linux/smp_lock.h>	16	#include <linux/smp_lock.h>
17	#include <linux/seq_file.h>	17	#include <linux/seq_file.h>
18		18
19	#include <linux/kobject.h>	19	#include <linux/kobject.h>
20	#include <linux/kobj_map.h>	20	#include <linux/kobj_map.h>
21	#include <linux/cdev.h>	21	#include <linux/cdev.h>
22	#include <linux/mutex.h>	22	#include <linux/mutex.h>
23	#include <linux/backing-dev.h>	23	#include <linux/backing-dev.h>
24		24
25	#ifdef CONFIG_KMOD	25	#ifdef CONFIG_KMOD
26	#include <linux/kmod.h>	26	#include <linux/kmod.h>
27	#endif	27	#endif
28	#include "internal.h"	28	#include "internal.h"
29		29
30	/*	30	/*
31	* capabilities for /dev/mem, /dev/kmem and similar directly mappable character	31	* capabilities for /dev/mem, /dev/kmem and similar directly mappable character
32	* devices	32	* devices
33	* - permits shared-mmap for read, write and/or exec	33	* - permits shared-mmap for read, write and/or exec
34	* - does not permit private mmap in NOMMU mode (can't do COW)	34	* - does not permit private mmap in NOMMU mode (can't do COW)
35	* - no readahead or I/O queue unplugging required	35	* - no readahead or I/O queue unplugging required
36	*/	36	*/
37	struct backing_dev_info directly_mappable_cdev_bdi = {	37	struct backing_dev_info directly_mappable_cdev_bdi = {
38	.capabilities = (	38	.capabilities = (
39	#ifdef CONFIG_MMU	39	#ifdef CONFIG_MMU
40	/* permit private copies of the data to be taken */	40	/* permit private copies of the data to be taken */
41	BDI_CAP_MAP_COPY \|	41	BDI_CAP_MAP_COPY \|
42	#endif	42	#endif
43	/* permit direct mmap, for read, write or exec */	43	/* permit direct mmap, for read, write or exec */
44	BDI_CAP_MAP_DIRECT \|	44	BDI_CAP_MAP_DIRECT \|
45	BDI_CAP_READ_MAP \| BDI_CAP_WRITE_MAP \| BDI_CAP_EXEC_MAP),	45	BDI_CAP_READ_MAP \| BDI_CAP_WRITE_MAP \| BDI_CAP_EXEC_MAP),
46	};	46	};
47		47
48	static struct kobj_map *cdev_map;	48	static struct kobj_map *cdev_map;
49		49
50	static DEFINE_MUTEX(chrdevs_lock);	50	static DEFINE_MUTEX(chrdevs_lock);
51		51
52	static struct char_device_struct {	52	static struct char_device_struct {
53	struct char_device_struct *next;	53	struct char_device_struct *next;
54	unsigned int major;	54	unsigned int major;
55	unsigned int baseminor;	55	unsigned int baseminor;
56	int minorct;	56	int minorct;
57	char name[64];	57	char name[64];
58	struct file_operations *fops;	58	struct file_operations *fops;
59	struct cdev cdev; / will die */	59	struct cdev cdev; / will die */
60	} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];	60	} *chrdevs[CHRDEV_MAJOR_HASH_SIZE];
61		61
62	/* index in the above */	62	/* index in the above */
63	static inline int major_to_index(int major)	63	static inline int major_to_index(int major)
64	{	64	{
65	return major % CHRDEV_MAJOR_HASH_SIZE;	65	return major % CHRDEV_MAJOR_HASH_SIZE;
66	}	66	}
67		67
68	#ifdef CONFIG_PROC_FS	68	#ifdef CONFIG_PROC_FS
69		69
70	void chrdev_show(struct seq_file *f, off_t offset)	70	void chrdev_show(struct seq_file *f, off_t offset)
71	{	71	{
72	struct char_device_struct *cd;	72	struct char_device_struct *cd;
73		73
74	if (offset < CHRDEV_MAJOR_HASH_SIZE) {	74	if (offset < CHRDEV_MAJOR_HASH_SIZE) {
75	mutex_lock(&chrdevs_lock);	75	mutex_lock(&chrdevs_lock);
76	for (cd = chrdevs[offset]; cd; cd = cd->next)	76	for (cd = chrdevs[offset]; cd; cd = cd->next)
77	seq_printf(f, "%3d %s\n", cd->major, cd->name);	77	seq_printf(f, "%3d %s\n", cd->major, cd->name);
78	mutex_unlock(&chrdevs_lock);	78	mutex_unlock(&chrdevs_lock);
79	}	79	}
80	}	80	}
81		81
82	#endif /* CONFIG_PROC_FS */	82	#endif /* CONFIG_PROC_FS */
83		83
84	/*	84	/*
85	* Register a single major with a specified minor range.	85	* Register a single major with a specified minor range.
86	*	86	*
87	* If major == 0 this functions will dynamically allocate a major and return	87	* If major == 0 this functions will dynamically allocate a major and return
88	* its number.	88	* its number.
89	*	89	*
90	* If major > 0 this function will attempt to reserve the passed range of	90	* If major > 0 this function will attempt to reserve the passed range of
91	* minors and will return zero on success.	91	* minors and will return zero on success.
92	*	92	*
93	* Returns a -ve errno on failure.	93	* Returns a -ve errno on failure.
94	*/	94	*/
95	static struct char_device_struct *	95	static struct char_device_struct *
96	__register_chrdev_region(unsigned int major, unsigned int baseminor,	96	__register_chrdev_region(unsigned int major, unsigned int baseminor,
97	int minorct, const char *name)	97	int minorct, const char *name)
98	{	98	{
99	struct char_device_struct cd, *cp;	99	struct char_device_struct cd, *cp;
100	int ret = 0;	100	int ret = 0;
101	int i;	101	int i;
102		102
103	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);	103	cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);
104	if (cd == NULL)	104	if (cd == NULL)
105	return ERR_PTR(-ENOMEM);	105	return ERR_PTR(-ENOMEM);
106		106
107	mutex_lock(&chrdevs_lock);	107	mutex_lock(&chrdevs_lock);
108		108
109	/* temporary */	109	/* temporary */
110	if (major == 0) {	110	if (major == 0) {
111	for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {	111	for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {
112	if (chrdevs[i] == NULL)	112	if (chrdevs[i] == NULL)
113	break;	113	break;
114	}	114	}
115		115
116	if (i == 0) {	116	if (i == 0) {
117	ret = -EBUSY;	117	ret = -EBUSY;
118	goto out;	118	goto out;
119	}	119	}
120	major = i;	120	major = i;
121	ret = major;	121	ret = major;
122	}	122	}
123		123
124	cd->major = major;	124	cd->major = major;
125	cd->baseminor = baseminor;	125	cd->baseminor = baseminor;
126	cd->minorct = minorct;	126	cd->minorct = minorct;
127	strncpy(cd->name,name, 64);	127	strncpy(cd->name,name, 64);
128		128
129	i = major_to_index(major);	129	i = major_to_index(major);
130		130
131	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)	131	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)
132	if ((*cp)->major > major \|\|	132	if ((*cp)->major > major \|\|
133	((*cp)->major == major &&	133	((*cp)->major == major &&
134	(((*cp)->baseminor >= baseminor) \|\|	134	(((*cp)->baseminor >= baseminor) \|\|
135	((cp)->baseminor + (cp)->minorct > baseminor))))	135	((cp)->baseminor + (cp)->minorct > baseminor))))
136	break;	136	break;
137		137
138	/* Check for overlapping minor ranges. */	138	/* Check for overlapping minor ranges. */
139	if (cp && (cp)->major == major) {	139	if (cp && (cp)->major == major) {
140	int old_min = (*cp)->baseminor;	140	int old_min = (*cp)->baseminor;
141	int old_max = (cp)->baseminor + (cp)->minorct - 1;	141	int old_max = (cp)->baseminor + (cp)->minorct - 1;
142	int new_min = baseminor;	142	int new_min = baseminor;
143	int new_max = baseminor + minorct - 1;	143	int new_max = baseminor + minorct - 1;
144		144
145	/* New driver overlaps from the left. */	145	/* New driver overlaps from the left. */
146	if (new_max >= old_min && new_max <= old_max) {	146	if (new_max >= old_min && new_max <= old_max) {
147	ret = -EBUSY;	147	ret = -EBUSY;
148	goto out;	148	goto out;
149	}	149	}
150		150
151	/* New driver overlaps from the right. */	151	/* New driver overlaps from the right. */
152	if (new_min <= old_max && new_min >= old_min) {	152	if (new_min <= old_max && new_min >= old_min) {
153	ret = -EBUSY;	153	ret = -EBUSY;
154	goto out;	154	goto out;
155	}	155	}
156	}	156	}
157		157
158	cd->next = *cp;	158	cd->next = *cp;
159	*cp = cd;	159	*cp = cd;
160	mutex_unlock(&chrdevs_lock);	160	mutex_unlock(&chrdevs_lock);
161	return cd;	161	return cd;
162	out:	162	out:
163	mutex_unlock(&chrdevs_lock);	163	mutex_unlock(&chrdevs_lock);
164	kfree(cd);	164	kfree(cd);
165	return ERR_PTR(ret);	165	return ERR_PTR(ret);
166	}	166	}
167		167
168	static struct char_device_struct *	168	static struct char_device_struct *
169	__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)	169	__unregister_chrdev_region(unsigned major, unsigned baseminor, int minorct)
170	{	170	{
171	struct char_device_struct cd = NULL, *cp;	171	struct char_device_struct cd = NULL, *cp;
172	int i = major_to_index(major);	172	int i = major_to_index(major);
173		173
174	mutex_lock(&chrdevs_lock);	174	mutex_lock(&chrdevs_lock);
175	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)	175	for (cp = &chrdevs[i]; cp; cp = &(cp)->next)
176	if ((*cp)->major == major &&	176	if ((*cp)->major == major &&
177	(*cp)->baseminor == baseminor &&	177	(*cp)->baseminor == baseminor &&
178	(*cp)->minorct == minorct)	178	(*cp)->minorct == minorct)
179	break;	179	break;
180	if (*cp) {	180	if (*cp) {
181	cd = *cp;	181	cd = *cp;
182	*cp = cd->next;	182	*cp = cd->next;
183	}	183	}
184	mutex_unlock(&chrdevs_lock);	184	mutex_unlock(&chrdevs_lock);
185	return cd;	185	return cd;
186	}	186	}
187		187
188	/**	188	/**
189	* register_chrdev_region() - register a range of device numbers	189	* register_chrdev_region() - register a range of device numbers
190	* @from: the first in the desired range of device numbers; must include	190	* @from: the first in the desired range of device numbers; must include
191	* the major number.	191	* the major number.
192	* @count: the number of consecutive device numbers required	192	* @count: the number of consecutive device numbers required
193	* @name: the name of the device or driver.	193	* @name: the name of the device or driver.
194	*	194	*
195	* Return value is zero on success, a negative error code on failure.	195	* Return value is zero on success, a negative error code on failure.
196	*/	196	*/
197	int register_chrdev_region(dev_t from, unsigned count, const char *name)	197	int register_chrdev_region(dev_t from, unsigned count, const char *name)
198	{	198	{
199	struct char_device_struct *cd;	199	struct char_device_struct *cd;
200	dev_t to = from + count;	200	dev_t to = from + count;
201	dev_t n, next;	201	dev_t n, next;
202		202
203	for (n = from; n < to; n = next) {	203	for (n = from; n < to; n = next) {
204	next = MKDEV(MAJOR(n)+1, 0);	204	next = MKDEV(MAJOR(n)+1, 0);
205	if (next > to)	205	if (next > to)
206	next = to;	206	next = to;
207	cd = __register_chrdev_region(MAJOR(n), MINOR(n),	207	cd = __register_chrdev_region(MAJOR(n), MINOR(n),
208	next - n, name);	208	next - n, name);
209	if (IS_ERR(cd))	209	if (IS_ERR(cd))
210	goto fail;	210	goto fail;
211	}	211	}
212	return 0;	212	return 0;
213	fail:	213	fail:
214	to = n;	214	to = n;
215	for (n = from; n < to; n = next) {	215	for (n = from; n < to; n = next) {
216	next = MKDEV(MAJOR(n)+1, 0);	216	next = MKDEV(MAJOR(n)+1, 0);
217	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));	217	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
218	}	218	}
219	return PTR_ERR(cd);	219	return PTR_ERR(cd);
220	}	220	}
221		221
222	/**	222	/**
223	* alloc_chrdev_region() - register a range of char device numbers	223	* alloc_chrdev_region() - register a range of char device numbers
224	* @dev: output parameter for first assigned number	224	* @dev: output parameter for first assigned number
225	* @baseminor: first of the requested range of minor numbers	225	* @baseminor: first of the requested range of minor numbers
226	* @count: the number of minor numbers required	226	* @count: the number of minor numbers required
227	* @name: the name of the associated device or driver	227	* @name: the name of the associated device or driver
228	*	228	*
229	* Allocates a range of char device numbers. The major number will be	229	* Allocates a range of char device numbers. The major number will be
230	* chosen dynamically, and returned (along with the first minor number)	230	* chosen dynamically, and returned (along with the first minor number)
231	* in @dev. Returns zero or a negative error code.	231	* in @dev. Returns zero or a negative error code.
232	*/	232	*/
233	int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,	233	int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
234	const char *name)	234	const char *name)
235	{	235	{
236	struct char_device_struct *cd;	236	struct char_device_struct *cd;
237	cd = __register_chrdev_region(0, baseminor, count, name);	237	cd = __register_chrdev_region(0, baseminor, count, name);
238	if (IS_ERR(cd))	238	if (IS_ERR(cd))
239	return PTR_ERR(cd);	239	return PTR_ERR(cd);
240	*dev = MKDEV(cd->major, cd->baseminor);	240	*dev = MKDEV(cd->major, cd->baseminor);
241	return 0;	241	return 0;
242	}	242	}
243		243
244	/**	244	/**
245	* register_chrdev() - Register a major number for character devices.	245	* register_chrdev() - Register a major number for character devices.
246	* @major: major device number or 0 for dynamic allocation	246	* @major: major device number or 0 for dynamic allocation
247	* @name: name of this range of devices	247	* @name: name of this range of devices
248	* @fops: file operations associated with this devices	248	* @fops: file operations associated with this devices
249	*	249	*
250	* If @major == 0 this functions will dynamically allocate a major and return	250	* If @major == 0 this functions will dynamically allocate a major and return
251	* its number.	251	* its number.
252	*	252	*
253	* If @major > 0 this function will attempt to reserve a device with the given	253	* If @major > 0 this function will attempt to reserve a device with the given
254	* major number and will return zero on success.	254	* major number and will return zero on success.
255	*	255	*
256	* Returns a -ve errno on failure.	256	* Returns a -ve errno on failure.
257	*	257	*
258	* The name of this device has nothing to do with the name of the device in	258	* The name of this device has nothing to do with the name of the device in
259	* /dev. It only helps to keep track of the different owners of devices. If	259	* /dev. It only helps to keep track of the different owners of devices. If
260	* your module name has only one type of devices it's ok to use e.g. the name	260	* your module name has only one type of devices it's ok to use e.g. the name
261	* of the module here.	261	* of the module here.
262	*	262	*
263	* This function registers a range of 256 minor numbers. The first minor number	263	* This function registers a range of 256 minor numbers. The first minor number
264	* is 0.	264	* is 0.
265	*/	265	*/
266	int register_chrdev(unsigned int major, const char *name,	266	int register_chrdev(unsigned int major, const char *name,
267	const struct file_operations *fops)	267	const struct file_operations *fops)
268	{	268	{
269	struct char_device_struct *cd;	269	struct char_device_struct *cd;
270	struct cdev *cdev;	270	struct cdev *cdev;
271	char *s;	271	char *s;
272	int err = -ENOMEM;	272	int err = -ENOMEM;
273		273
274	cd = __register_chrdev_region(major, 0, 256, name);	274	cd = __register_chrdev_region(major, 0, 256, name);
275	if (IS_ERR(cd))	275	if (IS_ERR(cd))
276	return PTR_ERR(cd);	276	return PTR_ERR(cd);
277		277
278	cdev = cdev_alloc();	278	cdev = cdev_alloc();
279	if (!cdev)	279	if (!cdev)
280	goto out2;	280	goto out2;
281		281
282	cdev->owner = fops->owner;	282	cdev->owner = fops->owner;
283	cdev->ops = fops;	283	cdev->ops = fops;
284	kobject_set_name(&cdev->kobj, "%s", name);	284	kobject_set_name(&cdev->kobj, "%s", name);
285	for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))	285	for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))
286	*s = '!';	286	*s = '!';
287		287
288	err = cdev_add(cdev, MKDEV(cd->major, 0), 256);	288	err = cdev_add(cdev, MKDEV(cd->major, 0), 256);
289	if (err)	289	if (err)
290	goto out;	290	goto out;
291		291
292	cd->cdev = cdev;	292	cd->cdev = cdev;
293		293
294	return major ? 0 : cd->major;	294	return major ? 0 : cd->major;
295	out:	295	out:
296	kobject_put(&cdev->kobj);	296	kobject_put(&cdev->kobj);
297	out2:	297	out2:
298	kfree(__unregister_chrdev_region(cd->major, 0, 256));	298	kfree(__unregister_chrdev_region(cd->major, 0, 256));
299	return err;	299	return err;
300	}	300	}
301		301
302	/**	302	/**
303	* unregister_chrdev_region() - return a range of device numbers	303	* unregister_chrdev_region() - return a range of device numbers
304	* @from: the first in the range of numbers to unregister	304	* @from: the first in the range of numbers to unregister
305	* @count: the number of device numbers to unregister	305	* @count: the number of device numbers to unregister
306	*	306	*
307	* This function will unregister a range of @count device numbers,	307	* This function will unregister a range of @count device numbers,
308	* starting with @from. The caller should normally be the one who	308	* starting with @from. The caller should normally be the one who
309	* allocated those numbers in the first place...	309	* allocated those numbers in the first place...
310	*/	310	*/
311	void unregister_chrdev_region(dev_t from, unsigned count)	311	void unregister_chrdev_region(dev_t from, unsigned count)
312	{	312	{
313	dev_t to = from + count;	313	dev_t to = from + count;
314	dev_t n, next;	314	dev_t n, next;
315		315
316	for (n = from; n < to; n = next) {	316	for (n = from; n < to; n = next) {
317	next = MKDEV(MAJOR(n)+1, 0);	317	next = MKDEV(MAJOR(n)+1, 0);
318	if (next > to)	318	if (next > to)
319	next = to;	319	next = to;
320	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));	320	kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));
321	}	321	}
322	}	322	}
323		323
324	void unregister_chrdev(unsigned int major, const char *name)	324	void unregister_chrdev(unsigned int major, const char *name)
325	{	325	{
326	struct char_device_struct *cd;	326	struct char_device_struct *cd;
327	cd = __unregister_chrdev_region(major, 0, 256);	327	cd = __unregister_chrdev_region(major, 0, 256);
328	if (cd && cd->cdev)	328	if (cd && cd->cdev)
329	cdev_del(cd->cdev);	329	cdev_del(cd->cdev);
330	kfree(cd);	330	kfree(cd);
331	}	331	}
332		332
333	static DEFINE_SPINLOCK(cdev_lock);	333	static DEFINE_SPINLOCK(cdev_lock);
334		334
335	static struct kobject cdev_get(struct cdev p)	335	static struct kobject cdev_get(struct cdev p)
336	{	336	{
337	struct module *owner = p->owner;	337	struct module *owner = p->owner;
338	struct kobject *kobj;	338	struct kobject *kobj;
339		339
340	if (owner && !try_module_get(owner))	340	if (owner && !try_module_get(owner))
341	return NULL;	341	return NULL;
342	kobj = kobject_get(&p->kobj);	342	kobj = kobject_get(&p->kobj);
343	if (!kobj)	343	if (!kobj)
344	module_put(owner);	344	module_put(owner);
345	return kobj;	345	return kobj;
346	}	346	}
347		347
348	void cdev_put(struct cdev *p)	348	void cdev_put(struct cdev *p)
349	{	349	{
350	if (p) {	350	if (p) {
351	struct module *owner = p->owner;	351	struct module *owner = p->owner;
352	kobject_put(&p->kobj);	352	kobject_put(&p->kobj);
353	module_put(owner);	353	module_put(owner);
354	}	354	}
355	}	355	}
356		356
357	/*	357	/*
358	* Called every time a character special file is opened	358	* Called every time a character special file is opened
359	*/	359	*/
360	int chrdev_open(struct inode * inode, struct file * filp)	360	static int chrdev_open(struct inode inode, struct file filp)
361	{	361	{
362	struct cdev *p;	362	struct cdev *p;
363	struct cdev *new = NULL;	363	struct cdev *new = NULL;
364	int ret = 0;	364	int ret = 0;
365		365
366	spin_lock(&cdev_lock);	366	spin_lock(&cdev_lock);
367	p = inode->i_cdev;	367	p = inode->i_cdev;
368	if (!p) {	368	if (!p) {
369	struct kobject *kobj;	369	struct kobject *kobj;
370	int idx;	370	int idx;
371	spin_unlock(&cdev_lock);	371	spin_unlock(&cdev_lock);
372	kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);	372	kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
373	if (!kobj)	373	if (!kobj)
374	return -ENXIO;	374	return -ENXIO;
375	new = container_of(kobj, struct cdev, kobj);	375	new = container_of(kobj, struct cdev, kobj);
376	spin_lock(&cdev_lock);	376	spin_lock(&cdev_lock);
377	p = inode->i_cdev;	377	p = inode->i_cdev;
378	if (!p) {	378	if (!p) {
379	inode->i_cdev = p = new;	379	inode->i_cdev = p = new;
380	inode->i_cindex = idx;	380	inode->i_cindex = idx;
381	list_add(&inode->i_devices, &p->list);	381	list_add(&inode->i_devices, &p->list);
382	new = NULL;	382	new = NULL;
383	} else if (!cdev_get(p))	383	} else if (!cdev_get(p))
384	ret = -ENXIO;	384	ret = -ENXIO;
385	} else if (!cdev_get(p))	385	} else if (!cdev_get(p))
386	ret = -ENXIO;	386	ret = -ENXIO;
387	spin_unlock(&cdev_lock);	387	spin_unlock(&cdev_lock);
388	cdev_put(new);	388	cdev_put(new);
389	if (ret)	389	if (ret)
390	return ret;	390	return ret;
391	filp->f_op = fops_get(p->ops);	391	filp->f_op = fops_get(p->ops);
392	if (!filp->f_op) {	392	if (!filp->f_op) {
393	cdev_put(p);	393	cdev_put(p);
394	return -ENXIO;	394	return -ENXIO;
395	}	395	}
396	if (filp->f_op->open) {	396	if (filp->f_op->open) {
397	lock_kernel();	397	lock_kernel();
398	ret = filp->f_op->open(inode,filp);	398	ret = filp->f_op->open(inode,filp);
399	unlock_kernel();	399	unlock_kernel();
400	}	400	}
401	if (ret)	401	if (ret)
402	cdev_put(p);	402	cdev_put(p);
403	return ret;	403	return ret;
404	}	404	}
405		405
406	void cd_forget(struct inode *inode)	406	void cd_forget(struct inode *inode)
407	{	407	{
408	spin_lock(&cdev_lock);	408	spin_lock(&cdev_lock);
409	list_del_init(&inode->i_devices);	409	list_del_init(&inode->i_devices);
410	inode->i_cdev = NULL;	410	inode->i_cdev = NULL;
411	spin_unlock(&cdev_lock);	411	spin_unlock(&cdev_lock);
412	}	412	}
413		413
414	static void cdev_purge(struct cdev *cdev)	414	static void cdev_purge(struct cdev *cdev)
415	{	415	{
416	spin_lock(&cdev_lock);	416	spin_lock(&cdev_lock);
417	while (!list_empty(&cdev->list)) {	417	while (!list_empty(&cdev->list)) {
418	struct inode *inode;	418	struct inode *inode;
419	inode = container_of(cdev->list.next, struct inode, i_devices);	419	inode = container_of(cdev->list.next, struct inode, i_devices);
420	list_del_init(&inode->i_devices);	420	list_del_init(&inode->i_devices);
421	inode->i_cdev = NULL;	421	inode->i_cdev = NULL;
422	}	422	}
423	spin_unlock(&cdev_lock);	423	spin_unlock(&cdev_lock);
424	}	424	}
425		425
426	/*	426	/*
427	* Dummy default file-operations: the only thing this does	427	* Dummy default file-operations: the only thing this does
428	* is contain the open that then fills in the correct operations	428	* is contain the open that then fills in the correct operations
429	* depending on the special file...	429	* depending on the special file...
430	*/	430	*/
431	const struct file_operations def_chr_fops = {	431	const struct file_operations def_chr_fops = {
432	.open = chrdev_open,	432	.open = chrdev_open,
433	};	433	};
434		434
435	static struct kobject exact_match(dev_t dev, int part, void *data)	435	static struct kobject exact_match(dev_t dev, int part, void *data)
436	{	436	{
437	struct cdev *p = data;	437	struct cdev *p = data;
438	return &p->kobj;	438	return &p->kobj;
439	}	439	}
440		440
441	static int exact_lock(dev_t dev, void *data)	441	static int exact_lock(dev_t dev, void *data)
442	{	442	{
443	struct cdev *p = data;	443	struct cdev *p = data;
444	return cdev_get(p) ? 0 : -1;	444	return cdev_get(p) ? 0 : -1;
445	}	445	}
446		446
447	/**	447	/**
448	* cdev_add() - add a char device to the system	448	* cdev_add() - add a char device to the system
449	* @p: the cdev structure for the device	449	* @p: the cdev structure for the device
450	* @dev: the first device number for which this device is responsible	450	* @dev: the first device number for which this device is responsible
451	* @count: the number of consecutive minor numbers corresponding to this	451	* @count: the number of consecutive minor numbers corresponding to this
452	* device	452	* device
453	*	453	*
454	* cdev_add() adds the device represented by @p to the system, making it	454	* cdev_add() adds the device represented by @p to the system, making it
455	* live immediately. A negative error code is returned on failure.	455	* live immediately. A negative error code is returned on failure.
456	*/	456	*/
457	int cdev_add(struct cdev *p, dev_t dev, unsigned count)	457	int cdev_add(struct cdev *p, dev_t dev, unsigned count)
458	{	458	{
459	p->dev = dev;	459	p->dev = dev;
460	p->count = count;	460	p->count = count;
461	return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);	461	return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
462	}	462	}
463		463
464	static void cdev_unmap(dev_t dev, unsigned count)	464	static void cdev_unmap(dev_t dev, unsigned count)
465	{	465	{
466	kobj_unmap(cdev_map, dev, count);	466	kobj_unmap(cdev_map, dev, count);
467	}	467	}
468		468
469	/**	469	/**
470	* cdev_del() - remove a cdev from the system	470	* cdev_del() - remove a cdev from the system
471	* @p: the cdev structure to be removed	471	* @p: the cdev structure to be removed
472	*	472	*
473	* cdev_del() removes @p from the system, possibly freeing the structure	473	* cdev_del() removes @p from the system, possibly freeing the structure
474	* itself.	474	* itself.
475	*/	475	*/
476	void cdev_del(struct cdev *p)	476	void cdev_del(struct cdev *p)
477	{	477	{
478	cdev_unmap(p->dev, p->count);	478	cdev_unmap(p->dev, p->count);
479	kobject_put(&p->kobj);	479	kobject_put(&p->kobj);
480	}	480	}
481		481
482		482
483	static void cdev_default_release(struct kobject *kobj)	483	static void cdev_default_release(struct kobject *kobj)
484	{	484	{
485	struct cdev *p = container_of(kobj, struct cdev, kobj);	485	struct cdev *p = container_of(kobj, struct cdev, kobj);
486	cdev_purge(p);	486	cdev_purge(p);
487	}	487	}
488		488
489	static void cdev_dynamic_release(struct kobject *kobj)	489	static void cdev_dynamic_release(struct kobject *kobj)
490	{	490	{
491	struct cdev *p = container_of(kobj, struct cdev, kobj);	491	struct cdev *p = container_of(kobj, struct cdev, kobj);
492	cdev_purge(p);	492	cdev_purge(p);
493	kfree(p);	493	kfree(p);
494	}	494	}
495		495
496	static struct kobj_type ktype_cdev_default = {	496	static struct kobj_type ktype_cdev_default = {
497	.release = cdev_default_release,	497	.release = cdev_default_release,
498	};	498	};
499		499
500	static struct kobj_type ktype_cdev_dynamic = {	500	static struct kobj_type ktype_cdev_dynamic = {
501	.release = cdev_dynamic_release,	501	.release = cdev_dynamic_release,
502	};	502	};
503		503
504	/**	504	/**
505	* cdev_alloc() - allocate a cdev structure	505	* cdev_alloc() - allocate a cdev structure
506	*	506	*
507	* Allocates and returns a cdev structure, or NULL on failure.	507	* Allocates and returns a cdev structure, or NULL on failure.
508	*/	508	*/
509	struct cdev *cdev_alloc(void)	509	struct cdev *cdev_alloc(void)
510	{	510	{
511	struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);	511	struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
512	if (p) {	512	if (p) {
513	INIT_LIST_HEAD(&p->list);	513	INIT_LIST_HEAD(&p->list);
514	kobject_init(&p->kobj, &ktype_cdev_dynamic);	514	kobject_init(&p->kobj, &ktype_cdev_dynamic);
515	}	515	}
516	return p;	516	return p;
517	}	517	}
518		518
519	/**	519	/**
520	* cdev_init() - initialize a cdev structure	520	* cdev_init() - initialize a cdev structure
521	* @cdev: the structure to initialize	521	* @cdev: the structure to initialize
522	* @fops: the file_operations for this device	522	* @fops: the file_operations for this device
523	*	523	*
524	* Initializes @cdev, remembering @fops, making it ready to add to the	524	* Initializes @cdev, remembering @fops, making it ready to add to the
525	* system with cdev_add().	525	* system with cdev_add().
526	*/	526	*/
527	void cdev_init(struct cdev cdev, const struct file_operations fops)	527	void cdev_init(struct cdev cdev, const struct file_operations fops)
528	{	528	{
529	memset(cdev, 0, sizeof *cdev);	529	memset(cdev, 0, sizeof *cdev);
530	INIT_LIST_HEAD(&cdev->list);	530	INIT_LIST_HEAD(&cdev->list);
531	kobject_init(&cdev->kobj, &ktype_cdev_default);	531	kobject_init(&cdev->kobj, &ktype_cdev_default);
532	cdev->ops = fops;	532	cdev->ops = fops;
533	}	533	}
534		534
535	static struct kobject base_probe(dev_t dev, int part, void *data)	535	static struct kobject base_probe(dev_t dev, int part, void *data)
536	{	536	{
537	if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)	537	if (request_module("char-major-%d-%d", MAJOR(dev), MINOR(dev)) > 0)
538	/* Make old-style 2.4 aliases work */	538	/* Make old-style 2.4 aliases work */
539	request_module("char-major-%d", MAJOR(dev));	539	request_module("char-major-%d", MAJOR(dev));
540	return NULL;	540	return NULL;
541	}	541	}
542		542
543	void __init chrdev_init(void)	543	void __init chrdev_init(void)
544	{	544	{
545	cdev_map = kobj_map_init(base_probe, &chrdevs_lock);	545	cdev_map = kobj_map_init(base_probe, &chrdevs_lock);
546	bdi_init(&directly_mappable_cdev_bdi);	546	bdi_init(&directly_mappable_cdev_bdi);
547	}	547	}
548		548
549		549
550	/* Let modules do char dev stuff */	550	/* Let modules do char dev stuff */
551	EXPORT_SYMBOL(register_chrdev_region);	551	EXPORT_SYMBOL(register_chrdev_region);
552	EXPORT_SYMBOL(unregister_chrdev_region);	552	EXPORT_SYMBOL(unregister_chrdev_region);
553	EXPORT_SYMBOL(alloc_chrdev_region);	553	EXPORT_SYMBOL(alloc_chrdev_region);
554	EXPORT_SYMBOL(cdev_init);	554	EXPORT_SYMBOL(cdev_init);
555	EXPORT_SYMBOL(cdev_alloc);	555	EXPORT_SYMBOL(cdev_alloc);
556	EXPORT_SYMBOL(cdev_del);	556	EXPORT_SYMBOL(cdev_del);
557	EXPORT_SYMBOL(cdev_add);	557	EXPORT_SYMBOL(cdev_add);
558	EXPORT_SYMBOL(register_chrdev);	558	EXPORT_SYMBOL(register_chrdev);
559	EXPORT_SYMBOL(unregister_chrdev);	559	EXPORT_SYMBOL(unregister_chrdev);
560	EXPORT_SYMBOL(directly_mappable_cdev_bdi);	560	EXPORT_SYMBOL(directly_mappable_cdev_bdi);
561		561

include/linux/fs.h

Diff comments View file @ 922f9cf

 #ifndef _LINUX_FS_H
 #define _LINUX_FS_H
 /*
  * This file has definitions for some important file table
  * structures etc.
  */
 #include <linux/limits.h>
 #include <linux/ioctl.h>
 /*
  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
  * the file limit at runtime and only root can increase the per-process
  * nr_file rlimit, so it's safe to set up a ridiculously high absolute
  * upper limit on files-per-process.
  *
  * Some programs (notably those using select()) may have to be
  * recompiled to take full advantage of the new limits..
  */
 /* Fixed constants first: */
 #undef NR_OPEN
 extern int sysctl_nr_open;
 #define INR_OPEN 1024		/* Initial setting for nfile rlimits */
 #define BLOCK_SIZE_BITS 10
 #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
 #define SEEK_SET	0	/* seek relative to beginning of file */
 #define SEEK_CUR	1	/* seek relative to current file position */
 #define SEEK_END	2	/* seek relative to end of file */
 #define SEEK_MAX	SEEK_END
 /* And dynamically-tunable limits and defaults: */
 struct files_stat_struct {
 	int nr_files;		/* read only */
 	int nr_free_files;	/* read only */
 	int max_files;		/* tunable */
 };
 extern struct files_stat_struct files_stat;
 extern int get_max_files(void);
 struct inodes_stat_t {
 	int nr_inodes;
 	int nr_unused;
 	int dummy[5];		/* padding for sysctl ABI compatibility */
 };
 extern struct inodes_stat_t inodes_stat;
 extern int leases_enable, lease_break_time;
 #ifdef CONFIG_DNOTIFY
 extern int dir_notify_enable;
 #endif
 #define NR_FILE  8192	/* this can well be larger on a larger system */
 #define MAY_EXEC 1
 #define MAY_WRITE 2
 #define MAY_READ 4
 #define MAY_APPEND 8
 #define FMODE_READ 1
 #define FMODE_WRITE 2
 /* Internal kernel extensions */
 #define FMODE_LSEEK	4
 #define FMODE_PREAD	8
 #define FMODE_PWRITE	FMODE_PREAD	/* These go hand in hand */
 /* File is being opened for execution. Primary users of this flag are
    distributed filesystems that can use it to achieve correct ETXTBUSY
    behavior for cross-node execution/opening_for_writing of files */
 #define FMODE_EXEC	16
 #define RW_MASK		1
 #define RWA_MASK	2
 #define READ 0
 #define WRITE 1
 #define READA 2		/* read-ahead  - don't block if no resources */
 #define SWRITE 3	/* for ll_rw_block() - wait for buffer lock */
 #define READ_SYNC	(READ | (1 << BIO_RW_SYNC))
 #define READ_META	(READ | (1 << BIO_RW_META))
 #define WRITE_SYNC	(WRITE | (1 << BIO_RW_SYNC))
 #define WRITE_BARRIER	((1 << BIO_RW) | (1 << BIO_RW_BARRIER))
 #define SEL_IN		1
 #define SEL_OUT		2
 #define SEL_EX		4
 /* public flags for file_system_type */
 #define FS_REQUIRES_DEV 1
 #define FS_BINARY_MOUNTDATA 2
 #define FS_HAS_SUBTYPE 4
 #define FS_REVAL_DOT	16384	/* Check the paths ".", ".." for staleness */
 #define FS_RENAME_DOES_D_MOVE	32768	/* FS will handle d_move()
 					 * during rename() internally.
 					 */
 /*
  * These are the fs-independent mount-flags: up to 32 flags are supported
  */
 #define MS_RDONLY	 1	/* Mount read-only */
 #define MS_NOSUID	 2	/* Ignore suid and sgid bits */
 #define MS_NODEV	 4	/* Disallow access to device special files */
 #define MS_NOEXEC	 8	/* Disallow program execution */
 #define MS_SYNCHRONOUS	16	/* Writes are synced at once */
 #define MS_REMOUNT	32	/* Alter flags of a mounted FS */
 #define MS_MANDLOCK	64	/* Allow mandatory locks on an FS */
 #define MS_DIRSYNC	128	/* Directory modifications are synchronous */
 #define MS_NOATIME	1024	/* Do not update access times. */
 #define MS_NODIRATIME	2048	/* Do not update directory access times */
 #define MS_BIND		4096
 #define MS_MOVE		8192
 #define MS_REC		16384
 #define MS_VERBOSE	32768	/* War is peace. Verbosity is silence.
 				   MS_VERBOSE is deprecated. */
 #define MS_SILENT	32768
 #define MS_POSIXACL	(1<<16)	/* VFS does not apply the umask */
 #define MS_UNBINDABLE	(1<<17)	/* change to unbindable */
 #define MS_PRIVATE	(1<<18)	/* change to private */
 #define MS_SLAVE	(1<<19)	/* change to slave */
 #define MS_SHARED	(1<<20)	/* change to shared */
 #define MS_RELATIME	(1<<21)	/* Update atime relative to mtime/ctime. */
 #define MS_KERNMOUNT	(1<<22) /* this is a kern_mount call */
 #define MS_I_VERSION	(1<<23) /* Update inode I_version field */
 #define MS_ACTIVE	(1<<30)
 #define MS_NOUSER	(1<<31)
 /*
  * Superblock flags that can be altered by MS_REMOUNT
  */
 #define MS_RMT_MASK	(MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK)
 /*
  * Old magic mount flag and mask
  */
 #define MS_MGC_VAL 0xC0ED0000
 #define MS_MGC_MSK 0xffff0000
 /* Inode flags - they have nothing to superblock flags now */
 #define S_SYNC		1	/* Writes are synced at once */
 #define S_NOATIME	2	/* Do not update access times */
 #define S_APPEND	4	/* Append-only file */
 #define S_IMMUTABLE	8	/* Immutable file */
 #define S_DEAD		16	/* removed, but still open directory */
 #define S_NOQUOTA	32	/* Inode is not counted to quota */
 #define S_DIRSYNC	64	/* Directory modifications are synchronous */
 #define S_NOCMTIME	128	/* Do not update file c/mtime */
 #define S_SWAPFILE	256	/* Do not truncate: swapon got its bmaps */
 #define S_PRIVATE	512	/* Inode is fs-internal */
 /*
  * Note that nosuid etc flags are inode-specific: setting some file-system
  * flags just means all the inodes inherit those flags by default. It might be
  * possible to override it selectively if you really wanted to with some
  * ioctl() that is not currently implemented.
  *
  * Exception: MS_RDONLY is always applied to the entire file system.
  *
  * Unfortunately, it is possible to change a filesystems flags with it mounted
  * with files in use.  This means that all of the inodes will not have their
  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
  */
 #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
 #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
 #define IS_SYNC(inode)		(__IS_FLG(inode, MS_SYNCHRONOUS) || \
 					((inode)->i_flags & S_SYNC))
 #define IS_DIRSYNC(inode)	(__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
 					((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
 #define IS_MANDLOCK(inode)	__IS_FLG(inode, MS_MANDLOCK)
 #define IS_NOATIME(inode)   __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
 #define IS_I_VERSION(inode)   __IS_FLG(inode, MS_I_VERSION)
 #define IS_NOQUOTA(inode)	((inode)->i_flags & S_NOQUOTA)
 #define IS_APPEND(inode)	((inode)->i_flags & S_APPEND)
 #define IS_IMMUTABLE(inode)	((inode)->i_flags & S_IMMUTABLE)
 #define IS_POSIXACL(inode)	__IS_FLG(inode, MS_POSIXACL)
 #define IS_DEADDIR(inode)	((inode)->i_flags & S_DEAD)
 #define IS_NOCMTIME(inode)	((inode)->i_flags & S_NOCMTIME)
 #define IS_SWAPFILE(inode)	((inode)->i_flags & S_SWAPFILE)
 #define IS_PRIVATE(inode)	((inode)->i_flags & S_PRIVATE)
 /* the read-only stuff doesn't really belong here, but any other place is
    probably as bad and I don't want to create yet another include file. */
 #define BLKROSET   _IO(0x12,93)	/* set device read-only (0 = read-write) */
 #define BLKROGET   _IO(0x12,94)	/* get read-only status (0 = read_write) */
 #define BLKRRPART  _IO(0x12,95)	/* re-read partition table */
 #define BLKGETSIZE _IO(0x12,96)	/* return device size /512 (long *arg) */
 #define BLKFLSBUF  _IO(0x12,97)	/* flush buffer cache */
 #define BLKRASET   _IO(0x12,98)	/* set read ahead for block device */
 #define BLKRAGET   _IO(0x12,99)	/* get current read ahead setting */
 #define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
 #define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
 #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
 #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
 #define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
 #if 0
 #define BLKPG      _IO(0x12,105)/* See blkpg.h */
 /* Some people are morons.  Do not use sizeof! */
 #define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
 #define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
 /* This was here just to show that the number is taken -
    probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
 #endif
 /* A jump here: 108-111 have been used for various private purposes. */
 #define BLKBSZGET  _IOR(0x12,112,size_t)
 #define BLKBSZSET  _IOW(0x12,113,size_t)
 #define BLKGETSIZE64 _IOR(0x12,114,size_t)	/* return device size in bytes (u64 *arg) */
 #define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
 #define BLKTRACESTART _IO(0x12,116)
 #define BLKTRACESTOP _IO(0x12,117)
 #define BLKTRACETEARDOWN _IO(0x12,118)
 #define BMAP_IOCTL 1		/* obsolete - kept for compatibility */
 #define FIBMAP	   _IO(0x00,1)	/* bmap access */
 #define FIGETBSZ   _IO(0x00,2)	/* get the block size used for bmap */
 #define	FS_IOC_GETFLAGS			_IOR('f', 1, long)
 #define	FS_IOC_SETFLAGS			_IOW('f', 2, long)
 #define	FS_IOC_GETVERSION		_IOR('v', 1, long)
 #define	FS_IOC_SETVERSION		_IOW('v', 2, long)
 #define FS_IOC32_GETFLAGS		_IOR('f', 1, int)
 #define FS_IOC32_SETFLAGS		_IOW('f', 2, int)
 #define FS_IOC32_GETVERSION		_IOR('v', 1, int)
 #define FS_IOC32_SETVERSION		_IOW('v', 2, int)
 /*
  * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
  */
 #define	FS_SECRM_FL			0x00000001 /* Secure deletion */
 #define	FS_UNRM_FL			0x00000002 /* Undelete */
 #define	FS_COMPR_FL			0x00000004 /* Compress file */
 #define FS_SYNC_FL			0x00000008 /* Synchronous updates */
 #define FS_IMMUTABLE_FL			0x00000010 /* Immutable file */
 #define FS_APPEND_FL			0x00000020 /* writes to file may only append */
 #define FS_NODUMP_FL			0x00000040 /* do not dump file */
 #define FS_NOATIME_FL			0x00000080 /* do not update atime */
 /* Reserved for compression usage... */
 #define FS_DIRTY_FL			0x00000100
 #define FS_COMPRBLK_FL			0x00000200 /* One or more compressed clusters */
 #define FS_NOCOMP_FL			0x00000400 /* Don't compress */
 #define FS_ECOMPR_FL			0x00000800 /* Compression error */
 /* End compression flags --- maybe not all used */
 #define FS_BTREE_FL			0x00001000 /* btree format dir */
 #define FS_INDEX_FL			0x00001000 /* hash-indexed directory */
 #define FS_IMAGIC_FL			0x00002000 /* AFS directory */
 #define FS_JOURNAL_DATA_FL		0x00004000 /* Reserved for ext3 */
 #define FS_NOTAIL_FL			0x00008000 /* file tail should not be merged */
 #define FS_DIRSYNC_FL			0x00010000 /* dirsync behaviour (directories only) */
 #define FS_TOPDIR_FL			0x00020000 /* Top of directory hierarchies*/
 #define FS_EXTENT_FL			0x00080000 /* Extents */
 #define FS_DIRECTIO_FL			0x00100000 /* Use direct i/o */
 #define FS_RESERVED_FL			0x80000000 /* reserved for ext2 lib */
 #define FS_FL_USER_VISIBLE		0x0003DFFF /* User visible flags */
 #define FS_FL_USER_MODIFIABLE		0x000380FF /* User modifiable flags */
 #define SYNC_FILE_RANGE_WAIT_BEFORE	1
 #define SYNC_FILE_RANGE_WRITE		2
 #define SYNC_FILE_RANGE_WAIT_AFTER	4
 #ifdef __KERNEL__
 #include <linux/linkage.h>
 #include <linux/wait.h>
 #include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/dcache.h>
 #include <linux/namei.h>
 #include <linux/stat.h>
 #include <linux/cache.h>
 #include <linux/kobject.h>
 #include <linux/list.h>
 #include <linux/radix-tree.h>
 #include <linux/prio_tree.h>
 #include <linux/init.h>
 #include <linux/pid.h>
 #include <linux/mutex.h>
 #include <linux/capability.h>
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
 #include <asm/byteorder.h>
 struct export_operations;
 struct hd_geometry;
 struct iovec;
 struct nameidata;
 struct kiocb;
 struct pipe_inode_info;
 struct poll_table_struct;
 struct kstatfs;
 struct vm_area_struct;
 struct vfsmount;
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
 extern void __init mnt_init(void);
 extern void __init files_init(unsigned long);
 struct buffer_head;
 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
 			struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 			ssize_t bytes, void *private);
 /*
  * Attribute flags.  These should be or-ed together to figure out what
  * has been changed!
  */
 #define ATTR_MODE	1
 #define ATTR_UID	2
 #define ATTR_GID	4
 #define ATTR_SIZE	8
 #define ATTR_ATIME	16
 #define ATTR_MTIME	32
 #define ATTR_CTIME	64
 #define ATTR_ATIME_SET	128
 #define ATTR_MTIME_SET	256
 #define ATTR_FORCE	512	/* Not a change, but a change it */
 #define ATTR_ATTR_FLAG	1024
 #define ATTR_KILL_SUID	2048
 #define ATTR_KILL_SGID	4096
 #define ATTR_FILE	8192
 #define ATTR_KILL_PRIV	16384
 #define ATTR_OPEN	32768	/* Truncating from open(O_TRUNC) */
 /*
  * This is the Inode Attributes structure, used for notify_change().  It
  * uses the above definitions as flags, to know which values have changed.
  * Also, in this manner, a Filesystem can look at only the values it cares
  * about.  Basically, these are the attributes that the VFS layer can
  * request to change from the FS layer.
  *
  * Derek Atkins <warlord@MIT.EDU> 94-10-20
  */
 struct iattr {
 	unsigned int	ia_valid;
 	umode_t		ia_mode;
 	uid_t		ia_uid;
 	gid_t		ia_gid;
 	loff_t		ia_size;
 	struct timespec	ia_atime;
 	struct timespec	ia_mtime;
 	struct timespec	ia_ctime;
 	/*
 	 * Not an attribute, but an auxilary info for filesystems wanting to
 	 * implement an ftruncate() like method.  NOTE: filesystem should
 	 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
 	 */
 	struct file	*ia_file;
 };
 /*
  * Includes for diskquotas.
  */
 #include <linux/quota.h>
 /**
  * enum positive_aop_returns - aop return codes with specific semantics
  *
  * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
  * 			    completed, that the page is still locked, and
  * 			    should be considered active.  The VM uses this hint
  * 			    to return the page to the active list -- it won't
  * 			    be a candidate for writeback again in the near
  * 			    future.  Other callers must be careful to unlock
  * 			    the page if they get this return.  Returned by
  * 			    writepage();
  *
  * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
  *  			unlocked it and the page might have been truncated.
  *  			The caller should back up to acquiring a new page and
  *  			trying again.  The aop will be taking reasonable
  *  			precautions not to livelock.  If the caller held a page
  *  			reference, it should drop it before retrying.  Returned
  *  			by readpage().
  *
  * address_space_operation functions return these large constants to indicate
  * special semantics to the caller.  These are much larger than the bytes in a
  * page to allow for functions that return the number of bytes operated on in a
  * given page.
  */
 enum positive_aop_returns {
 	AOP_WRITEPAGE_ACTIVATE	= 0x80000,
 	AOP_TRUNCATED_PAGE	= 0x80001,
 };
 #define AOP_FLAG_UNINTERRUPTIBLE	0x0001 /* will not do a short write */
 #define AOP_FLAG_CONT_EXPAND		0x0002 /* called from cont_expand */
 /*
  * oh the beauties of C type declarations.
  */
 struct page;
 struct address_space;
 struct writeback_control;
 struct iov_iter {
 	const struct iovec *iov;
 	unsigned long nr_segs;
 	size_t iov_offset;
 	size_t count;
 };
 size_t iov_iter_copy_from_user_atomic(struct page *page,
 		struct iov_iter *i, unsigned long offset, size_t bytes);
 size_t iov_iter_copy_from_user(struct page *page,
 		struct iov_iter *i, unsigned long offset, size_t bytes);
 void iov_iter_advance(struct iov_iter *i, size_t bytes);
 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
 size_t iov_iter_single_seg_count(struct iov_iter *i);
 static inline void iov_iter_init(struct iov_iter *i,
 			const struct iovec *iov, unsigned long nr_segs,
 			size_t count, size_t written)
 {
 	i->iov = iov;
 	i->nr_segs = nr_segs;
 	i->iov_offset = 0;
 	i->count = count + written;
 	iov_iter_advance(i, written);
 }
 static inline size_t iov_iter_count(struct iov_iter *i)
 {
 	return i->count;
 }
 struct address_space_operations {
 	int (*writepage)(struct page *page, struct writeback_control *wbc);
 	int (*readpage)(struct file *, struct page *);
 	void (*sync_page)(struct page *);
 	/* Write back some dirty pages from this mapping. */
 	int (*writepages)(struct address_space *, struct writeback_control *);
 	/* Set a page dirty.  Return true if this dirtied it */
 	int (*set_page_dirty)(struct page *page);
 	int (*readpages)(struct file *filp, struct address_space *mapping,
 			struct list_head *pages, unsigned nr_pages);
 	/*
 	 * ext3 requires that a successful prepare_write() call be followed
 	 * by a commit_write() call - they must be balanced
 	 */
 	int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
 	int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
 	int (*write_begin)(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned flags,
 				struct page **pagep, void **fsdata);
 	int (*write_end)(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata);
 	/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
 	sector_t (*bmap)(struct address_space *, sector_t);
 	void (*invalidatepage) (struct page *, unsigned long);
 	int (*releasepage) (struct page *, gfp_t);
 	ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
 			loff_t offset, unsigned long nr_segs);
 	struct page* (*get_xip_page)(struct address_space *, sector_t,
 			int);
 	/* migrate the contents of a page to the specified target */
 	int (*migratepage) (struct address_space *,
 			struct page *, struct page *);
 	int (*launder_page) (struct page *);
 };
 /*
  * pagecache_write_begin/pagecache_write_end must be used by general code
  * to write into the pagecache.
  */
 int pagecache_write_begin(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned flags,
 				struct page **pagep, void **fsdata);
 int pagecache_write_end(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata);
 struct backing_dev_info;
 struct address_space {
 	struct inode		*host;		/* owner: inode, block_device */
 	struct radix_tree_root	page_tree;	/* radix tree of all pages */
 	rwlock_t		tree_lock;	/* and rwlock protecting it */
 	unsigned int		i_mmap_writable;/* count VM_SHARED mappings */
 	struct prio_tree_root	i_mmap;		/* tree of private and shared mappings */
 	struct list_head	i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
 	spinlock_t		i_mmap_lock;	/* protect tree, count, list */
 	unsigned int		truncate_count;	/* Cover race condition with truncate */
 	unsigned long		nrpages;	/* number of total pages */
 	pgoff_t			writeback_index;/* writeback starts here */
 	const struct address_space_operations *a_ops;	/* methods */
 	unsigned long		flags;		/* error bits/gfp mask */
 	struct backing_dev_info *backing_dev_info; /* device readahead, etc */
 	spinlock_t		private_lock;	/* for use by the address_space */
 	struct list_head	private_list;	/* ditto */
 	struct address_space	*assoc_mapping;	/* ditto */
 } __attribute__((aligned(sizeof(long))));
 	/*
 	 * On most architectures that alignment is already the case; but
 	 * must be enforced here for CRIS, to let the least signficant bit
 	 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
 	 */
 struct block_device {
 	dev_t			bd_dev;  /* not a kdev_t - it's a search key */
 	struct inode *		bd_inode;	/* will die */
 	int			bd_openers;
 	struct mutex		bd_mutex;	/* open/close mutex */
 	struct semaphore	bd_mount_sem;
 	struct list_head	bd_inodes;
 	void *			bd_holder;
 	int			bd_holders;
 #ifdef CONFIG_SYSFS
 	struct list_head	bd_holder_list;
 #endif
 	struct block_device *	bd_contains;
 	unsigned		bd_block_size;
 	struct hd_struct *	bd_part;
 	/* number of times partitions within this device have been opened. */
 	unsigned		bd_part_count;
 	int			bd_invalidated;
 	struct gendisk *	bd_disk;
 	struct list_head	bd_list;
 	struct backing_dev_info *bd_inode_backing_dev_info;
 	/*
 	 * Private data.  You must have bd_claim'ed the block_device
 	 * to use this.  NOTE:  bd_claim allows an owner to claim
 	 * the same device multiple times, the owner must take special
 	 * care to not mess up bd_private for that case.
 	 */
 	unsigned long		bd_private;
 };
 /*
  * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
  * radix trees
  */
 #define PAGECACHE_TAG_DIRTY	0
 #define PAGECACHE_TAG_WRITEBACK	1
 int mapping_tagged(struct address_space *mapping, int tag);
 /*
  * Might pages of this file be mapped into userspace?
  */
 static inline int mapping_mapped(struct address_space *mapping)
 {
 	return	!prio_tree_empty(&mapping->i_mmap) ||
 		!list_empty(&mapping->i_mmap_nonlinear);
 }
 /*
  * Might pages of this file have been modified in userspace?
  * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
  * marks vma as VM_SHARED if it is shared, and the file was opened for
  * writing i.e. vma may be mprotected writable even if now readonly.
  */
 static inline int mapping_writably_mapped(struct address_space *mapping)
 {
 	return mapping->i_mmap_writable != 0;
 }
 /*
  * Use sequence counter to get consistent i_size on 32-bit processors.
  */
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 #include <linux/seqlock.h>
 #define __NEED_I_SIZE_ORDERED
 #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
 #else
 #define i_size_ordered_init(inode) do { } while (0)
 #endif
 struct inode {
 	struct hlist_node	i_hash;
 	struct list_head	i_list;
 	struct list_head	i_sb_list;
 	struct list_head	i_dentry;
 	unsigned long		i_ino;
 	atomic_t		i_count;
 	unsigned int		i_nlink;
 	uid_t			i_uid;
 	gid_t			i_gid;
 	dev_t			i_rdev;
 	u64			i_version;
 	loff_t			i_size;
 #ifdef __NEED_I_SIZE_ORDERED
 	seqcount_t		i_size_seqcount;
 #endif
 	struct timespec		i_atime;
 	struct timespec		i_mtime;
 	struct timespec		i_ctime;
 	unsigned int		i_blkbits;
 	blkcnt_t		i_blocks;
 	unsigned short          i_bytes;
 	umode_t			i_mode;
 	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
 	struct mutex		i_mutex;
 	struct rw_semaphore	i_alloc_sem;
 	const struct inode_operations	*i_op;
 	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
 	struct super_block	*i_sb;
 	struct file_lock	*i_flock;
 	struct address_space	*i_mapping;
 	struct address_space	i_data;
 #ifdef CONFIG_QUOTA
 	struct dquot		*i_dquot[MAXQUOTAS];
 #endif
 	struct list_head	i_devices;
 	union {
 		struct pipe_inode_info	*i_pipe;
 		struct block_device	*i_bdev;
 		struct cdev		*i_cdev;
 	};
 	int			i_cindex;
 	__u32			i_generation;
 #ifdef CONFIG_DNOTIFY
 	unsigned long		i_dnotify_mask; /* Directory notify events */
 	struct dnotify_struct	*i_dnotify; /* for directory notifications */
 #endif
 #ifdef CONFIG_INOTIFY
 	struct list_head	inotify_watches; /* watches on this inode */
 	struct mutex		inotify_mutex;	/* protects the watches list */
 #endif
 	unsigned long		i_state;
 	unsigned long		dirtied_when;	/* jiffies of first dirtying */
 	unsigned int		i_flags;
 	atomic_t		i_writecount;
 #ifdef CONFIG_SECURITY
 	void			*i_security;
 #endif
 	void			*i_private; /* fs or device private pointer */
 };
 /*
  * inode->i_mutex nesting subclasses for the lock validator:
  *
  * 0: the object of the current VFS operation
  * 1: parent
  * 2: child/target
  * 3: quota file
  *
  * The locking order between these classes is
  * parent -> child -> normal -> xattr -> quota
  */
 enum inode_i_mutex_lock_class
 {
 	I_MUTEX_NORMAL,
 	I_MUTEX_PARENT,
 	I_MUTEX_CHILD,
 	I_MUTEX_XATTR,
 	I_MUTEX_QUOTA
 };
 extern void inode_double_lock(struct inode *inode1, struct inode *inode2);
 extern void inode_double_unlock(struct inode *inode1, struct inode *inode2);
 /*
  * NOTE: in a 32bit arch with a preemptable kernel and
  * an UP compile the i_size_read/write must be atomic
  * with respect to the local cpu (unlike with preempt disabled),
  * but they don't need to be atomic with respect to other cpus like in
  * true SMP (so they need either to either locally disable irq around
  * the read or for example on x86 they can be still implemented as a
  * cmpxchg8b without the need of the lock prefix). For SMP compiles
  * and 64bit archs it makes no difference if preempt is enabled or not.
  */
 static inline loff_t i_size_read(const struct inode *inode)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 	loff_t i_size;
 	unsigned int seq;
 	do {
 		seq = read_seqcount_begin(&inode->i_size_seqcount);
 		i_size = inode->i_size;
 	} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
 	return i_size;
 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
 	loff_t i_size;
 	preempt_disable();
 	i_size = inode->i_size;
 	preempt_enable();
 	return i_size;
 #else
 	return inode->i_size;
 #endif
 }
 /*
  * NOTE: unlike i_size_read(), i_size_write() does need locking around it
  * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
  * can be lost, resulting in subsequent i_size_read() calls spinning forever.
  */
 static inline void i_size_write(struct inode *inode, loff_t i_size)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 	write_seqcount_begin(&inode->i_size_seqcount);
 	inode->i_size = i_size;
 	write_seqcount_end(&inode->i_size_seqcount);
 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
 	preempt_disable();
 	inode->i_size = i_size;
 	preempt_enable();
 #else
 	inode->i_size = i_size;
 #endif
 }
 static inline unsigned iminor(const struct inode *inode)
 {
 	return MINOR(inode->i_rdev);
 }
 static inline unsigned imajor(const struct inode *inode)
 {
 	return MAJOR(inode->i_rdev);
 }
 extern struct block_device *I_BDEV(struct inode *inode);
 struct fown_struct {
 	rwlock_t lock;          /* protects pid, uid, euid fields */
 	struct pid *pid;	/* pid or -pgrp where SIGIO should be sent */
 	enum pid_type pid_type;	/* Kind of process group SIGIO should be sent to */
 	uid_t uid, euid;	/* uid/euid of process setting the owner */
 	int signum;		/* posix.1b rt signal to be delivered on IO */
 };
 /*
  * Track a single file's readahead state
  */
 struct file_ra_state {
 	pgoff_t start;			/* where readahead started */
 	unsigned int size;		/* # of readahead pages */
 	unsigned int async_size;	/* do asynchronous readahead when
 					   there are only # of pages ahead */
 	unsigned int ra_pages;		/* Maximum readahead window */
 	int mmap_miss;			/* Cache miss stat for mmap accesses */
 	loff_t prev_pos;		/* Cache last read() position */
 };
 /*
  * Check if @index falls in the readahead windows.
  */
 static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
 {
 	return (index >= ra->start &&
 		index <  ra->start + ra->size);
 }
 struct file {
 	/*
 	 * fu_list becomes invalid after file_free is called and queued via
 	 * fu_rcuhead for RCU freeing
 	 */
 	union {
 		struct list_head	fu_list;
 		struct rcu_head 	fu_rcuhead;
 	} f_u;
 	struct path		f_path;
 #define f_dentry	f_path.dentry
 #define f_vfsmnt	f_path.mnt
 	const struct file_operations	*f_op;
 	atomic_t		f_count;
 	unsigned int 		f_flags;
 	mode_t			f_mode;
 	loff_t			f_pos;
 	struct fown_struct	f_owner;
 	unsigned int		f_uid, f_gid;
 	struct file_ra_state	f_ra;
 	u64			f_version;
 #ifdef CONFIG_SECURITY
 	void			*f_security;
 #endif
 	/* needed for tty driver, and maybe others */
 	void			*private_data;
 #ifdef CONFIG_EPOLL
 	/* Used by fs/eventpoll.c to link all the hooks to this file */
 	struct list_head	f_ep_links;
 	spinlock_t		f_ep_lock;
 #endif /* #ifdef CONFIG_EPOLL */
 	struct address_space	*f_mapping;
 };
 extern spinlock_t files_lock;
 #define file_list_lock() spin_lock(&files_lock);
 #define file_list_unlock() spin_unlock(&files_lock);
 #define get_file(x)	atomic_inc(&(x)->f_count)
 #define file_count(x)	atomic_read(&(x)->f_count)
 #define	MAX_NON_LFS	((1UL<<31) - 1)
 /* Page cache limit. The filesystems should put that into their s_maxbytes
    limits, otherwise bad things can happen in VM. */
 #if BITS_PER_LONG==32
 #define MAX_LFS_FILESIZE	(((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
 #elif BITS_PER_LONG==64
 #define MAX_LFS_FILESIZE 	0x7fffffffffffffffUL
 #endif
 #define FL_POSIX	1
 #define FL_FLOCK	2
 #define FL_ACCESS	8	/* not trying to lock, just looking */
 #define FL_EXISTS	16	/* when unlocking, test for existence */
 #define FL_LEASE	32	/* lease held on this file */
 #define FL_CLOSE	64	/* unlock on close */
 #define FL_SLEEP	128	/* A blocking lock */
 /*
  * The POSIX file lock owner is determined by
  * the "struct files_struct" in the thread group
  * (or NULL for no owner - BSD locks).
  *
  * Lockd stuffs a "host" pointer into this.
  */
 typedef struct files_struct *fl_owner_t;
 struct file_lock_operations {
 	void (*fl_insert)(struct file_lock *);	/* lock insertion callback */
 	void (*fl_remove)(struct file_lock *);	/* lock removal callback */
 	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 	void (*fl_release_private)(struct file_lock *);
 };
 struct lock_manager_operations {
 	int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
 	void (*fl_notify)(struct file_lock *);	/* unblock callback */
 	int (*fl_grant)(struct file_lock *, struct file_lock *, int);
 	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 	void (*fl_release_private)(struct file_lock *);
 	void (*fl_break)(struct file_lock *);
 	int (*fl_mylease)(struct file_lock *, struct file_lock *);
 	int (*fl_change)(struct file_lock **, int);
 };
 /* that will die - we need it for nfs_lock_info */
 #include <linux/nfs_fs_i.h>
 struct file_lock {
 	struct file_lock *fl_next;	/* singly linked list for this inode  */
 	struct list_head fl_link;	/* doubly linked list of all locks */
 	struct list_head fl_block;	/* circular list of blocked processes */
 	fl_owner_t fl_owner;
 	unsigned int fl_pid;
 	struct pid *fl_nspid;
 	wait_queue_head_t fl_wait;
 	struct file *fl_file;
 	unsigned char fl_flags;
 	unsigned char fl_type;
 	loff_t fl_start;
 	loff_t fl_end;
 	struct fasync_struct *	fl_fasync; /* for lease break notifications */
 	unsigned long fl_break_time;	/* for nonblocking lease breaks */
 	struct file_lock_operations *fl_ops;	/* Callbacks for filesystems */
 	struct lock_manager_operations *fl_lmops;	/* Callbacks for lockmanagers */
 	union {
 		struct nfs_lock_info	nfs_fl;
 		struct nfs4_lock_info	nfs4_fl;
 		struct {
 			struct list_head link;	/* link in AFS vnode's pending_locks list */
 			int state;		/* state of grant or error if -ve */
 		} afs;
 	} fl_u;
 };
 /* The following constant reflects the upper bound of the file/locking space */
 #ifndef OFFSET_MAX
 #define INT_LIMIT(x)	(~((x)1 << (sizeof(x)*8 - 1)))
 #define OFFSET_MAX	INT_LIMIT(loff_t)
 #define OFFT_OFFSET_MAX	INT_LIMIT(off_t)
 #endif
 #include <linux/fcntl.h>
 extern int fcntl_getlk(struct file *, struct flock __user *);
 extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
 			struct flock __user *);
 #if BITS_PER_LONG == 32
 extern int fcntl_getlk64(struct file *, struct flock64 __user *);
 extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
 			struct flock64 __user *);
 #endif
 extern void send_sigio(struct fown_struct *fown, int fd, int band);
 extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
 extern int fcntl_getlease(struct file *filp);
 /* fs/sync.c */
 extern int do_sync_mapping_range(struct address_space *mapping, loff_t offset,
 			loff_t endbyte, unsigned int flags);
 /* fs/locks.c */
 extern void locks_init_lock(struct file_lock *);
 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int generic_setlease(struct file *, long, struct file_lock **);
 extern int vfs_setlease(struct file *, long, struct file_lock **);
 extern int lease_modify(struct file_lock **, int);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
 extern struct seq_operations locks_seq_operations;
 struct fasync_struct {
 	int	magic;
 	int	fa_fd;
 	struct	fasync_struct	*fa_next; /* singly linked list */
 	struct	file 		*fa_file;
 };
 #define FASYNC_MAGIC 0x4601
 /* SMP safe fasync helpers: */
 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
 /* can be called from interrupts */
 extern void kill_fasync(struct fasync_struct **, int, int);
 /* only for net: no internal synchronization */
 extern void __kill_fasync(struct fasync_struct *, int, int);
 extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
 extern int f_setown(struct file *filp, unsigned long arg, int force);
 extern void f_delown(struct file *filp);
 extern pid_t f_getown(struct file *filp);
 extern int send_sigurg(struct fown_struct *fown);
 /*
  *	Umount options
  */
 #define MNT_FORCE	0x00000001	/* Attempt to forcibily umount */
 #define MNT_DETACH	0x00000002	/* Just detach from the tree */
 #define MNT_EXPIRE	0x00000004	/* Mark for expiry */
 extern struct list_head super_blocks;
 extern spinlock_t sb_lock;
 #define S_BIAS (1<<30)
 struct super_block {
 	struct list_head	s_list;		/* Keep this first */
 	dev_t			s_dev;		/* search index; _not_ kdev_t */
 	unsigned long		s_blocksize;
 	unsigned char		s_blocksize_bits;
 	unsigned char		s_dirt;
 	unsigned long long	s_maxbytes;	/* Max file size */
 	struct file_system_type	*s_type;
 	const struct super_operations	*s_op;
 	struct dquot_operations	*dq_op;
  	struct quotactl_ops	*s_qcop;
 	const struct export_operations *s_export_op;
 	unsigned long		s_flags;
 	unsigned long		s_magic;
 	struct dentry		*s_root;
 	struct rw_semaphore	s_umount;
 	struct mutex		s_lock;
 	int			s_count;
 	int			s_syncing;
 	int			s_need_sync_fs;
 	atomic_t		s_active;
 #ifdef CONFIG_SECURITY
 	void                    *s_security;
 #endif
 	struct xattr_handler	**s_xattr;
 	struct list_head	s_inodes;	/* all inodes */
 	struct list_head	s_dirty;	/* dirty inodes */
 	struct list_head	s_io;		/* parked for writeback */
 	struct list_head	s_more_io;	/* parked for more writeback */
 	struct hlist_head	s_anon;		/* anonymous dentries for (nfs) exporting */
 	struct list_head	s_files;
 	struct block_device	*s_bdev;
 	struct mtd_info		*s_mtd;
 	struct list_head	s_instances;
 	struct quota_info	s_dquot;	/* Diskquota specific options */
 	int			s_frozen;
 	wait_queue_head_t	s_wait_unfrozen;
 	char s_id[32];				/* Informational name */
 	void 			*s_fs_info;	/* Filesystem private info */
 	/*
 	 * The next field is for VFS *only*. No filesystems have any business
 	 * even looking at it. You had been warned.
 	 */
 	struct mutex s_vfs_rename_mutex;	/* Kludge */
 	/* Granularity of c/m/atime in ns.
 	   Cannot be worse than a second */
 	u32		   s_time_gran;
 	/*
 	 * Filesystem subtype.  If non-empty the filesystem type field
 	 * in /proc/mounts will be "type.subtype"
 	 */
 	char *s_subtype;
 	/*
 	 * Saved mount options for lazy filesystems using
 	 * generic_show_options()
 	 */
 	char *s_options;
 };
 extern struct timespec current_fs_time(struct super_block *sb);
 /*
  * Snapshotting support.
  */
 enum {
 	SB_UNFROZEN = 0,
 	SB_FREEZE_WRITE	= 1,
 	SB_FREEZE_TRANS = 2,
 };
 #define vfs_check_frozen(sb, level) \
 	wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
 #define get_fs_excl() atomic_inc(&current->fs_excl)
 #define put_fs_excl() atomic_dec(&current->fs_excl)
 #define has_fs_excl() atomic_read(&current->fs_excl)
 #define is_owner_or_cap(inode)	\
 	((current->fsuid == (inode)->i_uid) || capable(CAP_FOWNER))
 /* not quite ready to be deprecated, but... */
 extern void lock_super(struct super_block *);
 extern void unlock_super(struct super_block *);
 /*
  * VFS helper functions..
  */
 extern int vfs_permission(struct nameidata *, int);
 extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
 extern int vfs_mkdir(struct inode *, struct dentry *, int);
 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
 extern int vfs_symlink(struct inode *, struct dentry *, const char *, int);
 extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
 extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 /*
  * VFS dentry helper functions.
  */
 extern void dentry_unhash(struct dentry *dentry);
 /*
  * VFS file helper functions.
  */
 extern int file_permission(struct file *, int);
 /*
  * File types
  *
  * NOTE! These match bits 12..15 of stat.st_mode
  * (ie "(i_mode >> 12) & 15").
  */
 #define DT_UNKNOWN	0
 #define DT_FIFO		1
 #define DT_CHR		2
 #define DT_DIR		4
 #define DT_BLK		6
 #define DT_REG		8
 #define DT_LNK		10
 #define DT_SOCK		12
 #define DT_WHT		14
 #define OSYNC_METADATA	(1<<0)
 #define OSYNC_DATA	(1<<1)
 #define OSYNC_INODE	(1<<2)
 int generic_osync_inode(struct inode *, struct address_space *, int);
 /*
  * This is the "filldir" function type, used by readdir() to let
  * the kernel specify what kind of dirent layout it wants to have.
  * This allows the kernel to read directories into kernel space or
  * to have different dirent layouts depending on the binary type.
  */
 typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
 struct block_device_operations {
 	int (*open) (struct inode *, struct file *);
 	int (*release) (struct inode *, struct file *);
 	int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
 	long (*unlocked_ioctl) (struct file *, unsigned, unsigned long);
 	long (*compat_ioctl) (struct file *, unsigned, unsigned long);
 	int (*direct_access) (struct block_device *, sector_t, unsigned long *);
 	int (*media_changed) (struct gendisk *);
 	int (*revalidate_disk) (struct gendisk *);
 	int (*getgeo)(struct block_device *, struct hd_geometry *);
 	struct module *owner;
 };
 /*
  * "descriptor" for what we're up to with a read.
  * This allows us to use the same read code yet
  * have multiple different users of the data that
  * we read from a file.
  *
  * The simplest case just copies the data to user
  * mode.
  */
 typedef struct {
 	size_t written;
 	size_t count;
 	union {
 		char __user * buf;
 		void *data;
 	} arg;
 	int error;
 } read_descriptor_t;
 typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
 /* These macros are for out of kernel modules to test that
  * the kernel supports the unlocked_ioctl and compat_ioctl
  * fields in struct file_operations. */
 #define HAVE_COMPAT_IOCTL 1
 #define HAVE_UNLOCKED_IOCTL 1
 /*
  * NOTE:
  * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
  * can be called without the big kernel lock held in all filesystems.
  */
 struct file_operations {
 	struct module *owner;
 	loff_t (*llseek) (struct file *, loff_t, int);
 	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 	int (*readdir) (struct file *, void *, filldir_t);
 	unsigned int (*poll) (struct file *, struct poll_table_struct *);
 	int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 	int (*mmap) (struct file *, struct vm_area_struct *);
 	int (*open) (struct inode *, struct file *);
 	int (*flush) (struct file *, fl_owner_t id);
 	int (*release) (struct inode *, struct file *);
 	int (*fsync) (struct file *, struct dentry *, int datasync);
 	int (*aio_fsync) (struct kiocb *, int datasync);
 	int (*fasync) (int, struct file *, int);
 	int (*lock) (struct file *, int, struct file_lock *);
 	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
 	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 	int (*check_flags)(int);
 	int (*dir_notify)(struct file *filp, unsigned long arg);
 	int (*flock) (struct file *, int, struct file_lock *);
 	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
 	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
 	int (*setlease)(struct file *, long, struct file_lock **);
 };
 struct inode_operations {
 	int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
 	struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
 	int (*link) (struct dentry *,struct inode *,struct dentry *);
 	int (*unlink) (struct inode *,struct dentry *);
 	int (*symlink) (struct inode *,struct dentry *,const char *);
 	int (*mkdir) (struct inode *,struct dentry *,int);
 	int (*rmdir) (struct inode *,struct dentry *);
 	int (*mknod) (struct inode *,struct dentry *,int,dev_t);
 	int (*rename) (struct inode *, struct dentry *,
 			struct inode *, struct dentry *);
 	int (*readlink) (struct dentry *, char __user *,int);
 	void * (*follow_link) (struct dentry *, struct nameidata *);
 	void (*put_link) (struct dentry *, struct nameidata *, void *);
 	void (*truncate) (struct inode *);
 	int (*permission) (struct inode *, int, struct nameidata *);
 	int (*setattr) (struct dentry *, struct iattr *);
 	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
 	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 	ssize_t (*listxattr) (struct dentry *, char *, size_t);
 	int (*removexattr) (struct dentry *, const char *);
 	void (*truncate_range)(struct inode *, loff_t, loff_t);
 	long (*fallocate)(struct inode *inode, int mode, loff_t offset,
 			  loff_t len);
 };
 struct seq_file;
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 				unsigned long nr_segs, unsigned long fast_segs,
 				struct iovec *fast_pointer,
 				struct iovec **ret_pointer);
 extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
 extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
 extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
 		unsigned long, loff_t *);
 extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
 		unsigned long, loff_t *);
 /*
  * NOTE: write_inode, delete_inode, clear_inode, put_inode can be called
  * without the big kernel lock held in all filesystems.
  */
 struct super_operations {
    	struct inode *(*alloc_inode)(struct super_block *sb);
 	void (*destroy_inode)(struct inode *);
    	void (*dirty_inode) (struct inode *);
 	int (*write_inode) (struct inode *, int);
 	void (*put_inode) (struct inode *);
 	void (*drop_inode) (struct inode *);
 	void (*delete_inode) (struct inode *);
 	void (*put_super) (struct super_block *);
 	void (*write_super) (struct super_block *);
 	int (*sync_fs)(struct super_block *sb, int wait);
 	void (*write_super_lockfs) (struct super_block *);
 	void (*unlockfs) (struct super_block *);
 	int (*statfs) (struct dentry *, struct kstatfs *);
 	int (*remount_fs) (struct super_block *, int *, char *);
 	void (*clear_inode) (struct inode *);
 	void (*umount_begin) (struct vfsmount *, int);
 	int (*show_options)(struct seq_file *, struct vfsmount *);
 	int (*show_stats)(struct seq_file *, struct vfsmount *);
 #ifdef CONFIG_QUOTA
 	ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
 	ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
 #endif
 };
 /*
  * Inode state bits.  Protected by inode_lock.
  *
  * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
  * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
  *
  * Four bits define the lifetime of an inode.  Initially, inodes are I_NEW,
  * until that flag is cleared.  I_WILL_FREE, I_FREEING and I_CLEAR are set at
  * various stages of removing an inode.
  *
  * Two bits are used for locking and completion notification, I_LOCK and I_SYNC.
  *
  * I_DIRTY_SYNC		Inode is dirty, but doesn't have to be written on
  *			fdatasync().  i_atime is the usual cause.
  * I_DIRTY_DATASYNC	Inode is dirty and must be written on fdatasync(), f.e.
  *			because i_size changed.
  * I_DIRTY_PAGES	Inode has dirty pages.  Inode itself may be clean.
  * I_NEW		get_new_inode() sets i_state to I_LOCK|I_NEW.  Both
  *			are cleared by unlock_new_inode(), called from iget().
  * I_WILL_FREE		Must be set when calling write_inode_now() if i_count
  *			is zero.  I_FREEING must be set when I_WILL_FREE is
  *			cleared.
  * I_FREEING		Set when inode is about to be freed but still has dirty
  *			pages or buffers attached or the inode itself is still
  *			dirty.
  * I_CLEAR		Set by clear_inode().  In this state the inode is clean
  *			and can be destroyed.
  *
  *			Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
  *			prohibited for many purposes.  iget() must wait for
  *			the inode to be completely released, then create it
  *			anew.  Other functions will just ignore such inodes,
  *			if appropriate.  I_LOCK is used for waiting.
  *
  * I_LOCK		Serves as both a mutex and completion notification.
  *			New inodes set I_LOCK.  If two processes both create
  *			the same inode, one of them will release its inode and
  *			wait for I_LOCK to be released before returning.
  *			Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
  *			also cause waiting on I_LOCK, without I_LOCK actually
  *			being set.  find_inode() uses this to prevent returning
  *			nearly-dead inodes.
  * I_SYNC		Similar to I_LOCK, but limited in scope to writeback
  *			of inode dirty data.  Having a separate lock for this
  *			purpose reduces latency and prevents some filesystem-
  *			specific deadlocks.
  *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  * Q: igrab() only checks on (I_FREEING|I_WILL_FREE).  Should it also check on
  *    I_CLEAR?  If not, why?
  */
 #define I_DIRTY_SYNC		1
 #define I_DIRTY_DATASYNC	2
 #define I_DIRTY_PAGES		4
 #define I_NEW			8
 #define I_WILL_FREE		16
 #define I_FREEING		32
 #define I_CLEAR			64
 #define __I_LOCK		7
 #define I_LOCK			(1 << __I_LOCK)
 #define __I_SYNC		8
 #define I_SYNC			(1 << __I_SYNC)
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 extern void __mark_inode_dirty(struct inode *, int);
 static inline void mark_inode_dirty(struct inode *inode)
 {
 	__mark_inode_dirty(inode, I_DIRTY);
 }
 static inline void mark_inode_dirty_sync(struct inode *inode)
 {
 	__mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
 /**
  * inc_nlink - directly increment an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  Currently,
  * it is only here for parity with dec_nlink().
  */
 static inline void inc_nlink(struct inode *inode)
 {
 	inode->i_nlink++;
 }
 static inline void inode_inc_link_count(struct inode *inode)
 {
 	inc_nlink(inode);
 	mark_inode_dirty(inode);
 }
 /**
  * drop_nlink - directly drop an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  In cases
  * where we are attempting to track writes to the
  * filesystem, a decrement to zero means an imminent
  * write when the file is truncated and actually unlinked
  * on the filesystem.
  */
 static inline void drop_nlink(struct inode *inode)
 {
 	inode->i_nlink--;
 }
 /**
  * clear_nlink - directly zero an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  See
  * drop_nlink() for why we care about i_nlink hitting zero.
  */
 static inline void clear_nlink(struct inode *inode)
 {
 	inode->i_nlink = 0;
 }
 static inline void inode_dec_link_count(struct inode *inode)
 {
 	drop_nlink(inode);
 	mark_inode_dirty(inode);
 }
 /**
  * inode_inc_iversion - increments i_version
  * @inode: inode that need to be updated
  *
  * Every time the inode is modified, the i_version field will be incremented.
  * The filesystem has to be mounted with i_version flag
  */
 static inline void inode_inc_iversion(struct inode *inode)
 {
        spin_lock(&inode->i_lock);
        inode->i_version++;
        spin_unlock(&inode->i_lock);
 }
 extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
 static inline void file_accessed(struct file *file)
 {
 	if (!(file->f_flags & O_NOATIME))
 		touch_atime(file->f_path.mnt, file->f_path.dentry);
 }
 int sync_inode(struct inode *inode, struct writeback_control *wbc);
 struct file_system_type {
 	const char *name;
 	int fs_flags;
 	int (*get_sb) (struct file_system_type *, int,
 		       const char *, void *, struct vfsmount *);
 	void (*kill_sb) (struct super_block *);
 	struct module *owner;
 	struct file_system_type * next;
 	struct list_head fs_supers;
 	struct lock_class_key s_lock_key;
 	struct lock_class_key s_umount_key;
 	struct lock_class_key i_lock_key;
 	struct lock_class_key i_mutex_key;
 	struct lock_class_key i_mutex_dir_key;
 	struct lock_class_key i_alloc_sem_key;
 };
 extern int get_sb_bdev(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_single(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_nodev(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 void generic_shutdown_super(struct super_block *sb);
 void kill_block_super(struct super_block *sb);
 void kill_anon_super(struct super_block *sb);
 void kill_litter_super(struct super_block *sb);
 void deactivate_super(struct super_block *sb);
 int set_anon_super(struct super_block *s, void *data);
 struct super_block *sget(struct file_system_type *type,
 			int (*test)(struct super_block *,void *),
 			int (*set)(struct super_block *,void *),
 			void *data);
 extern int get_sb_pseudo(struct file_system_type *, char *,
 	const struct super_operations *ops, unsigned long,
 	struct vfsmount *mnt);
 extern int simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
 int __put_super(struct super_block *sb);
 int __put_super_and_need_restart(struct super_block *sb);
 void unnamed_dev_init(void);
 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
 #define fops_get(fops) \
 	(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
 #define fops_put(fops) \
 	do { if (fops) module_put((fops)->owner); } while(0)
 extern int register_filesystem(struct file_system_type *);
 extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 #define kern_mount(type) kern_mount_data(type, NULL)
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
 extern void umount_tree(struct vfsmount *, int, struct list_head *);
 extern void release_mounts(struct list_head *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
 extern struct vfsmount *copy_tree(struct vfsmount *, struct dentry *, int);
 extern void mnt_set_mountpoint(struct vfsmount *, struct dentry *,
 				  struct vfsmount *);
 extern struct vfsmount *collect_mounts(struct vfsmount *, struct dentry *);
 extern void drop_collected_mounts(struct vfsmount *);
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 /* /sys/fs */
 extern struct kobject *fs_kobj;
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
 extern int locks_mandatory_locked(struct inode *);
 extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
 /*
  * Candidates for mandatory locking have the setgid bit set
  * but no group execute bit -  an otherwise meaningless combination.
  */
 static inline int __mandatory_lock(struct inode *ino)
 {
 	return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
 }
 /*
  * ... and these candidates should be on MS_MANDLOCK mounted fs,
  * otherwise these will be advisory locks
  */
 static inline int mandatory_lock(struct inode *ino)
 {
 	return IS_MANDLOCK(ino) && __mandatory_lock(ino);
 }
 static inline int locks_verify_locked(struct inode *inode)
 {
 	if (mandatory_lock(inode))
 		return locks_mandatory_locked(inode);
 	return 0;
 }
 extern int rw_verify_area(int, struct file *, loff_t *, size_t);
 static inline int locks_verify_truncate(struct inode *inode,
 				    struct file *filp,
 				    loff_t size)
 {
 	if (inode->i_flock && mandatory_lock(inode))
 		return locks_mandatory_area(
 			FLOCK_VERIFY_WRITE, inode, filp,
 			size < inode->i_size ? size : inode->i_size,
 			(size < inode->i_size ? inode->i_size - size
 			 : size - inode->i_size)
 		);
 	return 0;
 }
 static inline int break_lease(struct inode *inode, unsigned int mode)
 {
 	if (inode->i_flock)
 		return __break_lease(inode, mode);
 	return 0;
 }
 /* fs/open.c */
 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
 		       struct file *filp);
 extern long do_sys_open(int dfd, const char __user *filename, int flags,
 			int mode);
 extern struct file *filp_open(const char *, int, int);
 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
 extern int filp_close(struct file *, fl_owner_t id);
 extern char * getname(const char __user *);
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
 extern void __init vfs_caches_init(unsigned long);
 extern struct kmem_cache *names_cachep;
 #define __getname()	kmem_cache_alloc(names_cachep, GFP_KERNEL)
 #define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
 #ifndef CONFIG_AUDITSYSCALL
 #define putname(name)   __putname(name)
 #else
 extern void putname(const char *name);
 #endif
 #ifdef CONFIG_BLOCK
 extern int register_blkdev(unsigned int, const char *);
 extern void unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern void bd_set_size(struct block_device *, loff_t size);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern struct block_device *open_by_devnum(dev_t, unsigned);
 extern const struct address_space_operations def_blk_aops;
 #else
 static inline void bd_forget(struct inode *inode) {}
 #endif
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
 extern const struct file_operations bad_sock_fops;
 extern const struct file_operations def_fifo_fops;
 #ifdef CONFIG_BLOCK
 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
 extern int blkdev_ioctl(struct inode *, struct file *, unsigned, unsigned long);
 extern int blkdev_driver_ioctl(struct inode *inode, struct file *file,
 			       struct gendisk *disk, unsigned cmd,
 			       unsigned long arg);
 extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
 extern int blkdev_get(struct block_device *, mode_t, unsigned);
 extern int blkdev_put(struct block_device *);
 extern int bd_claim(struct block_device *, void *);
 extern void bd_release(struct block_device *);
 #ifdef CONFIG_SYSFS
 extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
 extern void bd_release_from_disk(struct block_device *, struct gendisk *);
 #else
 #define bd_claim_by_disk(bdev, holder, disk)	bd_claim(bdev, holder)
 #define bd_release_from_disk(bdev, disk)	bd_release(bdev)
 #endif
 #endif
 /* fs/char_dev.c */
 #define CHRDEV_MAJOR_HASH_SIZE	255
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
 extern int register_chrdev_region(dev_t, unsigned, const char *);
 extern int register_chrdev(unsigned int, const char *,
 			   const struct file_operations *);
 extern void unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
-extern int chrdev_open(struct inode *, struct file *);
 extern void chrdev_show(struct seq_file *,off_t);
 /* fs/block_dev.c */
 #define BDEVNAME_SIZE	32	/* Largest string for a blockdev identifier */
 #ifdef CONFIG_BLOCK
 #define BLKDEV_MAJOR_HASH_SIZE	255
 extern const char *__bdevname(dev_t, char *buffer);
 extern const char *bdevname(struct block_device *bdev, char *buffer);
 extern struct block_device *lookup_bdev(const char *);
 extern struct block_device *open_bdev_excl(const char *, int, void *);
 extern void close_bdev_excl(struct block_device *);
 extern void blkdev_show(struct seq_file *,off_t);
 #else
 #define BLKDEV_MAJOR_HASH_SIZE	0
 #endif
 extern void init_special_inode(struct inode *, umode_t, dev_t);
 /* Invalid inode operations -- fs/bad_inode.c */
 extern void make_bad_inode(struct inode *);
 extern int is_bad_inode(struct inode *);
 extern const struct file_operations read_fifo_fops;
 extern const struct file_operations write_fifo_fops;
 extern const struct file_operations rdwr_fifo_fops;
 extern int fs_may_remount_ro(struct super_block *);
 #ifdef CONFIG_BLOCK
 /*
  * return READ, READA, or WRITE
  */
 #define bio_rw(bio)		((bio)->bi_rw & (RW_MASK | RWA_MASK))
 /*
  * return data direction, READ or WRITE
  */
 #define bio_data_dir(bio)	((bio)->bi_rw & 1)
 extern int check_disk_change(struct block_device *);
 extern int __invalidate_device(struct block_device *);
 extern int invalidate_partition(struct gendisk *, int);
 #endif
 extern int invalidate_inodes(struct super_block *);
 unsigned long __invalidate_mapping_pages(struct address_space *mapping,
 					pgoff_t start, pgoff_t end,
 					bool be_atomic);
 unsigned long invalidate_mapping_pages(struct address_space *mapping,
 					pgoff_t start, pgoff_t end);
 static inline unsigned long __deprecated
 invalidate_inode_pages(struct address_space *mapping)
 {
 	return invalidate_mapping_pages(mapping, 0, ~0UL);
 }
 static inline void invalidate_remote_inode(struct inode *inode)
 {
 	if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 	    S_ISLNK(inode->i_mode))
 		invalidate_mapping_pages(inode->i_mapping, 0, -1);
 }
 extern int invalidate_inode_pages2(struct address_space *mapping);
 extern int invalidate_inode_pages2_range(struct address_space *mapping,
 					 pgoff_t start, pgoff_t end);
 extern int write_inode_now(struct inode *, int);
 extern int filemap_fdatawrite(struct address_space *);
 extern int filemap_flush(struct address_space *);
 extern int filemap_fdatawait(struct address_space *);
 extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
 				        loff_t lstart, loff_t lend);
 extern int wait_on_page_writeback_range(struct address_space *mapping,
 				pgoff_t start, pgoff_t end);
 extern int __filemap_fdatawrite_range(struct address_space *mapping,
 				loff_t start, loff_t end, int sync_mode);
 extern long do_fsync(struct file *file, int datasync);
 extern void sync_supers(void);
 extern void sync_filesystems(int wait);
 extern void __fsync_super(struct super_block *sb);
 extern void emergency_sync(void);
 extern void emergency_remount(void);
 extern int do_remount_sb(struct super_block *sb, int flags,
 			 void *data, int force);
 #ifdef CONFIG_BLOCK
 extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
 extern int permission(struct inode *, int, struct nameidata *);
 extern int generic_permission(struct inode *, int,
 		int (*check_acl)(struct inode *, int));
 extern int get_write_access(struct inode *);
 extern int deny_write_access(struct file *);
 static inline void put_write_access(struct inode * inode)
 {
 	atomic_dec(&inode->i_writecount);
 }
 static inline void allow_write_access(struct file *file)
 {
 	if (file)
 		atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
 }
 extern int do_pipe(int *);
 extern struct file *create_read_pipe(struct file *f);
 extern struct file *create_write_pipe(void);
 extern void free_write_pipe(struct file *);
 extern int open_namei(int dfd, const char *, int, int, struct nameidata *);
 extern int may_open(struct nameidata *, int, int);
 extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
 extern struct file * open_exec(const char *);
 /* fs/dcache.c -- generic fs support functions */
 extern int is_subdir(struct dentry *, struct dentry *);
 extern ino_t find_inode_number(struct dentry *, struct qstr *);
 #include <linux/err.h>
 /* needed for stackable file system support */
 extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
 extern void inode_init_once(struct inode *);
 extern void iput(struct inode *);
 extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 extern int inode_needs_sync(struct inode *inode);
 extern void generic_delete_inode(struct inode *inode);
 extern void generic_drop_inode(struct inode *inode);
 extern struct inode *ilookup5_nowait(struct super_block *sb,
 		unsigned long hashval, int (*test)(struct inode *, void *),
 		void *data);
 extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
 		int (*test)(struct inode *, void *), void *data);
 extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
 extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
 extern struct inode * iget_locked(struct super_block *, unsigned long);
 extern void unlock_new_inode(struct inode *);
 extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
 extern void clear_inode(struct inode *);
 extern void destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
 extern int __remove_suid(struct dentry *, int);
 extern int should_remove_suid(struct dentry *);
 extern int remove_suid(struct dentry *);
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 extern void remove_inode_hash(struct inode *);
 static inline void insert_inode_hash(struct inode *inode) {
 	__insert_inode_hash(inode, inode->i_ino);
 }
 extern struct file * get_empty_filp(void);
 extern void file_move(struct file *f, struct list_head *list);
 extern void file_kill(struct file *f);
 #ifdef CONFIG_BLOCK
 struct bio;
 extern void submit_bio(int, struct bio *);
 extern int bdev_read_only(struct block_device *);
 #endif
 extern int set_blocksize(struct block_device *, int);
 extern int sb_set_blocksize(struct super_block *, int);
 extern int sb_min_blocksize(struct super_block *, int);
 extern int sb_has_dirty_inodes(struct super_block *);
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
 extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
 int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
 extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
 extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
 extern ssize_t generic_file_aio_write_nolock(struct kiocb *, const struct iovec *,
 		unsigned long, loff_t);
 extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
 		unsigned long *, loff_t, loff_t *, size_t, size_t);
 extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
 		unsigned long, loff_t, loff_t *, size_t, ssize_t);
 extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
 extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
 extern int generic_segment_checks(const struct iovec *iov,
 		unsigned long *nr_segs, size_t *count, int access_flags);
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
 		struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
 		struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_file_splice_write_nolock(struct pipe_inode_info *,
 		struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
 		struct file *out, loff_t *, size_t len, unsigned int flags);
 extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 		size_t len, unsigned int flags);
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
 extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t remote_llseek(struct file *file, loff_t offset, int origin);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 #ifdef CONFIG_FS_XIP
 extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
 			     loff_t *ppos);
 extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
 extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
 			      size_t len, loff_t *ppos);
 extern int xip_truncate_page(struct address_space *mapping, loff_t from);
 #else
 static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
 {
 	return 0;
 }
 #endif
 #ifdef CONFIG_BLOCK
 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 	struct block_device *bdev, const struct iovec *iov, loff_t offset,
 	unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
 	int lock_type);
 enum {
 	DIO_LOCKING = 1, /* need locking between buffered and direct access */
 	DIO_NO_LOCKING,  /* bdev; no locking at all between buffered/direct */
 	DIO_OWN_LOCKING, /* filesystem locks buffered and direct internally */
 };
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, DIO_LOCKING);
 }
 static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, DIO_NO_LOCKING);
 }
 static inline ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, DIO_OWN_LOCKING);
 }
 #endif
 extern const struct file_operations generic_ro_fops;
 #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
 extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
 extern int vfs_follow_link(struct nameidata *, const char *);
 extern int page_readlink(struct dentry *, char __user *, int);
 extern void *page_follow_link_light(struct dentry *, struct nameidata *);
 extern void page_put_link(struct dentry *, struct nameidata *, void *);
 extern int __page_symlink(struct inode *inode, const char *symname, int len,
 		gfp_t gfp_mask);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern const struct inode_operations page_symlink_inode_operations;
 extern int generic_readlink(struct dentry *, char __user *, int);
 extern void generic_fillattr(struct inode *, struct kstat *);
 extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 void inode_add_bytes(struct inode *inode, loff_t bytes);
 void inode_sub_bytes(struct inode *inode, loff_t bytes);
 loff_t inode_get_bytes(struct inode *inode);
 void inode_set_bytes(struct inode *inode, loff_t bytes);
 extern int vfs_readdir(struct file *, filldir_t, void *);
 extern int vfs_stat(char __user *, struct kstat *);
 extern int vfs_lstat(char __user *, struct kstat *);
 extern int vfs_stat_fd(int dfd, char __user *, struct kstat *);
 extern int vfs_lstat_fd(int dfd, char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
 extern long vfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
 		    unsigned long arg);
 extern void get_filesystem(struct file_system_type *fs);
 extern void put_filesystem(struct file_system_type *fs);
 extern struct file_system_type *get_fs_type(const char *name);
 extern struct super_block *get_super(struct block_device *);
 extern struct super_block *user_get_super(dev_t);
 extern void drop_super(struct super_block *sb);
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
 extern int dcache_readdir(struct file *, void *, filldir_t);
 extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int simple_statfs(struct dentry *, struct kstatfs *);
 extern int simple_link(struct dentry *, struct inode *, struct dentry *);
 extern int simple_unlink(struct inode *, struct dentry *);
 extern int simple_rmdir(struct inode *, struct dentry *);
 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 extern int simple_sync_file(struct file *, struct dentry *, int);
 extern int simple_empty(struct dentry *);
 extern int simple_readpage(struct file *file, struct page *page);
 extern int simple_prepare_write(struct file *file, struct page *page,
 			unsigned offset, unsigned to);
 extern int simple_write_begin(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned flags,
 			struct page **pagep, void **fsdata);
 extern int simple_write_end(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned copied,
 			struct page *page, void *fsdata);
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
 extern const struct file_operations simple_dir_operations;
 extern const struct inode_operations simple_dir_inode_operations;
 struct tree_descr { char *name; const struct file_operations *ops; int mode; };
 struct dentry *d_alloc_name(struct dentry *, const char *);
 extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
 extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
 extern void simple_release_fs(struct vfsmount **mount, int *count);
 extern ssize_t simple_read_from_buffer(void __user *, size_t, loff_t *, const void *, size_t);
 #ifdef CONFIG_MIGRATION
 extern int buffer_migrate_page(struct address_space *,
 				struct page *, struct page *);
 #else
 #define buffer_migrate_page NULL
 #endif
 extern int inode_change_ok(struct inode *, struct iattr *);
 extern int __must_check inode_setattr(struct inode *, struct iattr *);
 extern void file_update_time(struct file *file);
 extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
 extern void save_mount_options(struct super_block *sb, char *options);
 static inline ino_t parent_ino(struct dentry *dentry)
 {
 	ino_t res;
 	spin_lock(&dentry->d_lock);
 	res = dentry->d_parent->d_inode->i_ino;
 	spin_unlock(&dentry->d_lock);
 	return res;
 }
 /* kernel/fork.c */
 extern int unshare_files(void);
 /* Transaction based IO helpers */
 /*
  * An argresp is stored in an allocated page and holds the
  * size of the argument or response, along with its content
  */
 struct simple_transaction_argresp {
 	ssize_t size;
 	char data[0];
 };
 #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
 char *simple_transaction_get(struct file *file, const char __user *buf,
 				size_t size);
 ssize_t simple_transaction_read(struct file *file, char __user *buf,
 				size_t size, loff_t *pos);
 int simple_transaction_release(struct inode *inode, struct file *file);
 static inline void simple_transaction_set(struct file *file, size_t n)
 {
 	struct simple_transaction_argresp *ar = file->private_data;
 	BUG_ON(n > SIMPLE_TRANSACTION_LIMIT);
 	/*
 	 * The barrier ensures that ar->size will really remain zero until
 	 * ar->data is ready for reading.
 	 */
 	smp_mb();
 	ar->size = n;
 }
 /*
  * simple attribute files
  *
  * These attributes behave similar to those in sysfs:
  *
  * Writing to an attribute immediately sets a value, an open file can be
  * written to multiple times.
  *
  * Reading from an attribute creates a buffer from the value that might get
  * read with multiple read calls. When the attribute has been read
  * completely, no further read calls are possible until the file is opened
  * again.
  *
  * All attributes contain a text representation of a numeric value
  * that are accessed with the get() and set() functions.
  */
 #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)		\
 static int __fops ## _open(struct inode *inode, struct file *file)	\
 {									\
 	__simple_attr_check_format(__fmt, 0ull);			\
 	return simple_attr_open(inode, file, __get, __set, __fmt);	\
 }									\
 static struct file_operations __fops = {				\
 	.owner	 = THIS_MODULE,						\
 	.open	 = __fops ## _open,					\
 	.release = simple_attr_release,					\
 	.read	 = simple_attr_read,					\
 	.write	 = simple_attr_write,					\
 };
 static inline void __attribute__((format(printf, 1, 2)))
 __simple_attr_check_format(const char *fmt, ...)
 {
 	/* don't do anything, just let the compiler check the arguments; */
 }
 int simple_attr_open(struct inode *inode, struct file *file,
 		     int (*get)(void *, u64 *), int (*set)(void *, u64),
 		     const char *fmt);
 int simple_attr_release(struct inode *inode, struct file *file);
 ssize_t simple_attr_read(struct file *file, char __user *buf,
 			 size_t len, loff_t *ppos);
 ssize_t simple_attr_write(struct file *file, const char __user *buf,
 			  size_t len, loff_t *ppos);
 #ifdef CONFIG_SECURITY
 static inline char *alloc_secdata(void)
 {
 	return (char *)get_zeroed_page(GFP_KERNEL);
 }
 static inline void free_secdata(void *secdata)
 {
 	free_page((unsigned long)secdata);
 }
 #else
 static inline char *alloc_secdata(void)
 {
 	return (char *)1;
 }
 static inline void free_secdata(void *secdata)
 { }
 #endif	/* CONFIG_SECURITY */
 struct ctl_table;
 int proc_nr_files(struct ctl_table *table, int write, struct file *filp,
 		  void __user *buffer, size_t *lenp, loff_t *ppos);
 int get_filesystem_list(char * buf);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_FS_H */