[deliverable/linux.git] / drivers / char / tty_port.c

/*
 * Tty port functions
 */

#include <linux/types.h>
#include <linux/errno.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/wait.h>
#include <linux/bitops.h>
#include <linux/delay.h>
#include <linux/module.h>

void tty_port_init(struct tty_port *port)
{
	memset(port, 0, sizeof(*port));
	init_waitqueue_head(&port->open_wait);
	init_waitqueue_head(&port->close_wait);
	mutex_init(&port->mutex);
	spin_lock_init(&port->lock);
	port->close_delay = (50 * HZ) / 100;
	port->closing_wait = (3000 * HZ) / 100;
}
EXPORT_SYMBOL(tty_port_init);

int tty_port_alloc_xmit_buf(struct tty_port *port)
{
	/* We may sleep in get_zeroed_page() */
	mutex_lock(&port->mutex);
	if (port->xmit_buf == NULL)
		port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
	mutex_unlock(&port->mutex);
	if (port->xmit_buf == NULL)
		return -ENOMEM;
	return 0;
}
EXPORT_SYMBOL(tty_port_alloc_xmit_buf);

void tty_port_free_xmit_buf(struct tty_port *port)
{
	mutex_lock(&port->mutex);
	if (port->xmit_buf != NULL) {
		free_page((unsigned long)port->xmit_buf);
		port->xmit_buf = NULL;
	}
	mutex_unlock(&port->mutex);
}
EXPORT_SYMBOL(tty_port_free_xmit_buf);


/**
 *	tty_port_tty_get	-	get a tty reference
 *	@port: tty port
 *
 *	Return a refcount protected tty instance or NULL if the port is not
 *	associated with a tty (eg due to close or hangup)
 */

struct tty_struct *tty_port_tty_get(struct tty_port *port)
{
	unsigned long flags;
	struct tty_struct *tty;

	spin_lock_irqsave(&port->lock, flags);
	tty = tty_kref_get(port->tty);
	spin_unlock_irqrestore(&port->lock, flags);
	return tty;
}
EXPORT_SYMBOL(tty_port_tty_get);

/**
 *	tty_port_tty_set	-	set the tty of a port
 *	@port: tty port
 *	@tty: the tty
 *
 *	Associate the port and tty pair. Manages any internal refcounts.
 *	Pass NULL to deassociate a port
 */

void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
{
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	if (port->tty)
		tty_kref_put(port->tty);
	port->tty = tty_kref_get(tty);
	spin_unlock_irqrestore(&port->lock, flags);
}
EXPORT_SYMBOL(tty_port_tty_set);

static void tty_port_shutdown(struct tty_port *port)
{
	if (port->ops->shutdown &&
		test_and_clear_bit(ASYNC_INITIALIZED, &port->flags))
			port->ops->shutdown(port);

}

/**
 *	tty_port_hangup		-	hangup helper
 *	@port: tty port
 *
 *	Perform port level tty hangup flag and count changes. Drop the tty
 *	reference.
 */

void tty_port_hangup(struct tty_port *port)
{
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	port->count = 0;
	port->flags &= ~ASYNC_NORMAL_ACTIVE;
	if (port->tty)
		tty_kref_put(port->tty);
	port->tty = NULL;
	spin_unlock_irqrestore(&port->lock, flags);
	wake_up_interruptible(&port->open_wait);
	tty_port_shutdown(port);
}
EXPORT_SYMBOL(tty_port_hangup);

/**
 *	tty_port_carrier_raised	-	carrier raised check
 *	@port: tty port
 *
 *	Wrapper for the carrier detect logic. For the moment this is used
 *	to hide some internal details. This will eventually become entirely
 *	internal to the tty port.
 */

int tty_port_carrier_raised(struct tty_port *port)
{
	if (port->ops->carrier_raised == NULL)
		return 1;
	return port->ops->carrier_raised(port);
}
EXPORT_SYMBOL(tty_port_carrier_raised);

/**
 *	tty_port_raise_dtr_rts	-	Raise DTR/RTS
 *	@port: tty port
 *
 *	Wrapper for the DTR/RTS raise logic. For the moment this is used
 *	to hide some internal details. This will eventually become entirely
 *	internal to the tty port.
 */

void tty_port_raise_dtr_rts(struct tty_port *port)
{
	if (port->ops->dtr_rts)
		port->ops->dtr_rts(port, 1);
}
EXPORT_SYMBOL(tty_port_raise_dtr_rts);

/**
 *	tty_port_lower_dtr_rts	-	Lower DTR/RTS
 *	@port: tty port
 *
 *	Wrapper for the DTR/RTS raise logic. For the moment this is used
 *	to hide some internal details. This will eventually become entirely
 *	internal to the tty port.
 */

void tty_port_lower_dtr_rts(struct tty_port *port)
{
	if (port->ops->dtr_rts)
		port->ops->dtr_rts(port, 0);
}
EXPORT_SYMBOL(tty_port_lower_dtr_rts);

/**
 *	tty_port_block_til_ready	-	Waiting logic for tty open
 *	@port: the tty port being opened
 *	@tty: the tty device being bound
 *	@filp: the file pointer of the opener
 *
 *	Implement the core POSIX/SuS tty behaviour when opening a tty device.
 *	Handles:
 *		- hangup (both before and during)
 *		- non blocking open
 *		- rts/dtr/dcd
 *		- signals
 *		- port flags and counts
 *
 *	The passed tty_port must implement the carrier_raised method if it can
 *	do carrier detect and the dtr_rts method if it supports software
 *	management of these lines. Note that the dtr/rts raise is done each
 *	iteration as a hangup may have previously dropped them while we wait.
 */
 
int tty_port_block_til_ready(struct tty_port *port,
				struct tty_struct *tty, struct file *filp)
{
	int do_clocal = 0, retval;
	unsigned long flags;
	DEFINE_WAIT(wait);
	int cd;

	/* block if port is in the process of being closed */
	if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
		wait_event_interruptible(port->close_wait,
				!(port->flags & ASYNC_CLOSING));
		if (port->flags & ASYNC_HUP_NOTIFY)
			return -EAGAIN;
		else
			return -ERESTARTSYS;
	}

	/* if non-blocking mode is set we can pass directly to open unless
	   the port has just hung up or is in another error state */
	if ((filp->f_flags & O_NONBLOCK) ||
			(tty->flags & (1 << TTY_IO_ERROR))) {
		port->flags |= ASYNC_NORMAL_ACTIVE;
		return 0;
	}

	if (C_CLOCAL(tty))
		do_clocal = 1;

	/* Block waiting until we can proceed. We may need to wait for the
	   carrier, but we must also wait for any close that is in progress
	   before the next open may complete */

	retval = 0;

	/* The port lock protects the port counts */
	spin_lock_irqsave(&port->lock, flags);
	if (!tty_hung_up_p(filp))
		port->count--;
	port->blocked_open++;
	spin_unlock_irqrestore(&port->lock, flags);

	while (1) {
		/* Indicate we are open */
		if (tty->termios->c_cflag & CBAUD)
			tty_port_raise_dtr_rts(port);

		prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
		/* Check for a hangup or uninitialised port. Return accordingly */
		if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
			if (port->flags & ASYNC_HUP_NOTIFY)
				retval = -EAGAIN;
			else
				retval = -ERESTARTSYS;
			break;
		}
		/* Probe the carrier. For devices with no carrier detect this
		   will always return true */
		cd = tty_port_carrier_raised(port);
		if (!(port->flags & ASYNC_CLOSING) &&
				(do_clocal || cd))
			break;
		if (signal_pending(current)) {
			retval = -ERESTARTSYS;
			break;
		}
		schedule();
	}
	finish_wait(&port->open_wait, &wait);

	/* Update counts. A parallel hangup will have set count to zero and
	   we must not mess that up further */
	spin_lock_irqsave(&port->lock, flags);
	if (!tty_hung_up_p(filp))
		port->count++;
	port->blocked_open--;
	if (retval == 0)
		port->flags |= ASYNC_NORMAL_ACTIVE;
	spin_unlock_irqrestore(&port->lock, flags);
	return retval;
	
}
EXPORT_SYMBOL(tty_port_block_til_ready);

int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct file *filp)
{
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	if (tty_hung_up_p(filp)) {
		spin_unlock_irqrestore(&port->lock, flags);
		return 0;
	}

	if( tty->count == 1 && port->count != 1) {
		printk(KERN_WARNING
		    "tty_port_close_start: tty->count = 1 port count = %d.\n",
								port->count);
		port->count = 1;
	}
	if (--port->count < 0) {
		printk(KERN_WARNING "tty_port_close_start: count = %d\n",
								port->count);
		port->count = 0;
	}

	if (port->count) {
		spin_unlock_irqrestore(&port->lock, flags);
		if (port->ops->drop)
			port->ops->drop(port);
		return 0;
	}
	set_bit(ASYNC_CLOSING, &port->flags);
	tty->closing = 1;
	spin_unlock_irqrestore(&port->lock, flags);
	/* Don't block on a stalled port, just pull the chain */
	if (tty->flow_stopped)
		tty_driver_flush_buffer(tty);
	if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
			port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
		tty_wait_until_sent(tty, port->closing_wait);
	if (port->drain_delay) {
		unsigned int bps = tty_get_baud_rate(tty);
		long timeout;

		if (bps > 1200)
			timeout = max_t(long, (HZ * 10 * port->drain_delay) / bps,
								HZ / 10);
		else
			timeout = 2 * HZ;
		schedule_timeout_interruptible(timeout);
	}
	/* Don't call port->drop for the last reference. Callers will want
	   to drop the last active reference in ->shutdown() or the tty
	   shutdown path */
	return 1;
}
EXPORT_SYMBOL(tty_port_close_start);

void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
{
	unsigned long flags;

	tty_ldisc_flush(tty);

	if (tty->termios->c_cflag & HUPCL)
		tty_port_lower_dtr_rts(port);

	spin_lock_irqsave(&port->lock, flags);
	tty->closing = 0;

	if (port->blocked_open) {
		spin_unlock_irqrestore(&port->lock, flags);
		if (port->close_delay) {
			msleep_interruptible(
				jiffies_to_msecs(port->close_delay));
		}
		spin_lock_irqsave(&port->lock, flags);
		wake_up_interruptible(&port->open_wait);
	}
	port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
	wake_up_interruptible(&port->close_wait);
	spin_unlock_irqrestore(&port->lock, flags);
}
EXPORT_SYMBOL(tty_port_close_end);

void tty_port_close(struct tty_port *port, struct tty_struct *tty,
							struct file *filp)
{
	if (tty_port_close_start(port, tty, filp) == 0)
		return;
	tty_port_shutdown(port);
	tty_port_close_end(port, tty);
	tty_port_tty_set(port, NULL);
}
EXPORT_SYMBOL(tty_port_close);
Commit	Line	Data
9e48565d AC	1	/*
	2	* Tty port functions
	3	*/
	4
	5	#include <linux/types.h>
	6	#include <linux/errno.h>
	7	#include <linux/tty.h>
	8	#include <linux/tty_driver.h>
	9	#include <linux/tty_flip.h>
3e61696b	10	#include <linux/serial.h>
9e48565d AC	11	#include <linux/timer.h>
	12	#include <linux/string.h>
	13	#include <linux/slab.h>
	14	#include <linux/sched.h>
	15	#include <linux/init.h>
	16	#include <linux/wait.h>
	17	#include <linux/bitops.h>
	18	#include <linux/delay.h>
	19	#include <linux/module.h>
	20
	21	void tty_port_init(struct tty_port *port)
	22	{
	23	memset(port, 0, sizeof(*port));
	24	init_waitqueue_head(&port->open_wait);
	25	init_waitqueue_head(&port->close_wait);
	26	mutex_init(&port->mutex);
4a90f09b	27	spin_lock_init(&port->lock);
9e48565d AC	28	port->close_delay = (50 * HZ) / 100;
	29	port->closing_wait = (3000 * HZ) / 100;
	30	}
	31	EXPORT_SYMBOL(tty_port_init);
	32
	33	int tty_port_alloc_xmit_buf(struct tty_port *port)
	34	{
	35	/* We may sleep in get_zeroed_page() */
	36	mutex_lock(&port->mutex);
	37	if (port->xmit_buf == NULL)
	38	port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
	39	mutex_unlock(&port->mutex);
	40	if (port->xmit_buf == NULL)
	41	return -ENOMEM;
	42	return 0;
	43	}
	44	EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
	45
	46	void tty_port_free_xmit_buf(struct tty_port *port)
	47	{
	48	mutex_lock(&port->mutex);
	49	if (port->xmit_buf != NULL) {
	50	free_page((unsigned long)port->xmit_buf);
	51	port->xmit_buf = NULL;
	52	}
	53	mutex_unlock(&port->mutex);
	54	}
	55	EXPORT_SYMBOL(tty_port_free_xmit_buf);
	56
	57
4a90f09b AC	58	/**
	59	* tty_port_tty_get - get a tty reference
	60	* @port: tty port
	61	*
	62	* Return a refcount protected tty instance or NULL if the port is not
	63	* associated with a tty (eg due to close or hangup)
	64	*/
	65
	66	struct tty_struct tty_port_tty_get(struct tty_port port)
	67	{
	68	unsigned long flags;
	69	struct tty_struct *tty;
	70
	71	spin_lock_irqsave(&port->lock, flags);
	72	tty = tty_kref_get(port->tty);
	73	spin_unlock_irqrestore(&port->lock, flags);
	74	return tty;
	75	}
	76	EXPORT_SYMBOL(tty_port_tty_get);
	77
	78	/**
	79	* tty_port_tty_set - set the tty of a port
	80	* @port: tty port
	81	* @tty: the tty
	82	*
	83	* Associate the port and tty pair. Manages any internal refcounts.
	84	* Pass NULL to deassociate a port
	85	*/
	86
	87	void tty_port_tty_set(struct tty_port port, struct tty_struct tty)
	88	{
	89	unsigned long flags;
	90
	91	spin_lock_irqsave(&port->lock, flags);
	92	if (port->tty)
	93	tty_kref_put(port->tty);
cb4bca35	94	port->tty = tty_kref_get(tty);
4a90f09b AC	95	spin_unlock_irqrestore(&port->lock, flags);
	96	}
	97	EXPORT_SYMBOL(tty_port_tty_set);
31f35939	98
7ca0ff9a AC	99	static void tty_port_shutdown(struct tty_port *port)
	100	{
	101	if (port->ops->shutdown &&
	102	test_and_clear_bit(ASYNC_INITIALIZED, &port->flags))
	103	port->ops->shutdown(port);
	104
	105	}
	106
3e61696b AC	107	/**
	108	* tty_port_hangup - hangup helper
	109	* @port: tty port
	110	*
	111	* Perform port level tty hangup flag and count changes. Drop the tty
	112	* reference.
	113	*/
	114
	115	void tty_port_hangup(struct tty_port *port)
	116	{
	117	unsigned long flags;
	118
	119	spin_lock_irqsave(&port->lock, flags);
	120	port->count = 0;
	121	port->flags &= ~ASYNC_NORMAL_ACTIVE;
	122	if (port->tty)
	123	tty_kref_put(port->tty);
	124	port->tty = NULL;
	125	spin_unlock_irqrestore(&port->lock, flags);
	126	wake_up_interruptible(&port->open_wait);
7ca0ff9a	127	tty_port_shutdown(port);
3e61696b AC	128	}
	129	EXPORT_SYMBOL(tty_port_hangup);
	130
31f35939 AC	131	/**
	132	* tty_port_carrier_raised - carrier raised check
	133	* @port: tty port
	134	*
	135	* Wrapper for the carrier detect logic. For the moment this is used
	136	* to hide some internal details. This will eventually become entirely
	137	* internal to the tty port.
	138	*/
	139
	140	int tty_port_carrier_raised(struct tty_port *port)
	141	{
	142	if (port->ops->carrier_raised == NULL)
	143	return 1;
	144	return port->ops->carrier_raised(port);
	145	}
	146	EXPORT_SYMBOL(tty_port_carrier_raised);
5d951fb4 AC	147
5d951fb4 AC	148	/**
fcc8ac18	149	* tty_port_raise_dtr_rts - Raise DTR/RTS
5d951fb4 AC	150	* @port: tty port
	151	*
	152	* Wrapper for the DTR/RTS raise logic. For the moment this is used
	153	* to hide some internal details. This will eventually become entirely
	154	* internal to the tty port.
	155	*/
	156
	157	void tty_port_raise_dtr_rts(struct tty_port *port)
	158	{
fcc8ac18 AC	159	if (port->ops->dtr_rts)
fcc8ac18 AC	160	port->ops->dtr_rts(port, 1);
5d951fb4 AC	161	}
5d951fb4 AC	162	EXPORT_SYMBOL(tty_port_raise_dtr_rts);
36c621d8	163
fcc8ac18 AC	164	/**
	165	* tty_port_lower_dtr_rts - Lower DTR/RTS
	166	* @port: tty port
	167	*
	168	* Wrapper for the DTR/RTS raise logic. For the moment this is used
	169	* to hide some internal details. This will eventually become entirely
	170	* internal to the tty port.
	171	*/
	172
	173	void tty_port_lower_dtr_rts(struct tty_port *port)
	174	{
	175	if (port->ops->dtr_rts)
	176	port->ops->dtr_rts(port, 0);
	177	}
	178	EXPORT_SYMBOL(tty_port_lower_dtr_rts);
	179
36c621d8 AC	180	/**
	181	* tty_port_block_til_ready - Waiting logic for tty open
	182	* @port: the tty port being opened
	183	* @tty: the tty device being bound
	184	* @filp: the file pointer of the opener
	185	*
	186	* Implement the core POSIX/SuS tty behaviour when opening a tty device.
	187	* Handles:
	188	* - hangup (both before and during)
	189	* - non blocking open
	190	* - rts/dtr/dcd
	191	* - signals
	192	* - port flags and counts
	193	*
	194	* The passed tty_port must implement the carrier_raised method if it can
fcc8ac18	195	* do carrier detect and the dtr_rts method if it supports software
36c621d8 AC	196	* management of these lines. Note that the dtr/rts raise is done each
	197	* iteration as a hangup may have previously dropped them while we wait.
	198	*/
	199
	200	int tty_port_block_til_ready(struct tty_port *port,
	201	struct tty_struct tty, struct file filp)
	202	{
	203	int do_clocal = 0, retval;
	204	unsigned long flags;
6af9a43d	205	DEFINE_WAIT(wait);
36c621d8 AC	206	int cd;
	207
	208	/* block if port is in the process of being closed */
	209	if (tty_hung_up_p(filp) \|\| port->flags & ASYNC_CLOSING) {
5fc5b42a JS	210	wait_event_interruptible(port->close_wait,
5fc5b42a JS	211	!(port->flags & ASYNC_CLOSING));
36c621d8 AC	212	if (port->flags & ASYNC_HUP_NOTIFY)
	213	return -EAGAIN;
	214	else
	215	return -ERESTARTSYS;
	216	}
	217
	218	/* if non-blocking mode is set we can pass directly to open unless
	219	the port has just hung up or is in another error state */
	220	if ((filp->f_flags & O_NONBLOCK) \|\|
	221	(tty->flags & (1 << TTY_IO_ERROR))) {
	222	port->flags \|= ASYNC_NORMAL_ACTIVE;
	223	return 0;
	224	}
	225
	226	if (C_CLOCAL(tty))
	227	do_clocal = 1;
	228
	229	/* Block waiting until we can proceed. We may need to wait for the
	230	carrier, but we must also wait for any close that is in progress
	231	before the next open may complete */
	232
	233	retval = 0;
36c621d8 AC	234
	235	/* The port lock protects the port counts */
	236	spin_lock_irqsave(&port->lock, flags);
	237	if (!tty_hung_up_p(filp))
	238	port->count--;
	239	port->blocked_open++;
	240	spin_unlock_irqrestore(&port->lock, flags);
	241
	242	while (1) {
	243	/* Indicate we are open */
7834909f AC	244	if (tty->termios->c_cflag & CBAUD)
7834909f AC	245	tty_port_raise_dtr_rts(port);
36c621d8	246
3e3b5c08	247	prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
36c621d8 AC	248	/* Check for a hangup or uninitialised port. Return accordingly */
	249	if (tty_hung_up_p(filp) \|\| !(port->flags & ASYNC_INITIALIZED)) {
	250	if (port->flags & ASYNC_HUP_NOTIFY)
	251	retval = -EAGAIN;
	252	else
	253	retval = -ERESTARTSYS;
	254	break;
	255	}
	256	/* Probe the carrier. For devices with no carrier detect this
	257	will always return true */
	258	cd = tty_port_carrier_raised(port);
	259	if (!(port->flags & ASYNC_CLOSING) &&
	260	(do_clocal \|\| cd))
	261	break;
	262	if (signal_pending(current)) {
	263	retval = -ERESTARTSYS;
	264	break;
	265	}
	266	schedule();
	267	}
3e3b5c08	268	finish_wait(&port->open_wait, &wait);
36c621d8 AC	269
	270	/* Update counts. A parallel hangup will have set count to zero and
	271	we must not mess that up further */
	272	spin_lock_irqsave(&port->lock, flags);
	273	if (!tty_hung_up_p(filp))
	274	port->count++;
	275	port->blocked_open--;
	276	if (retval == 0)
	277	port->flags \|= ASYNC_NORMAL_ACTIVE;
	278	spin_unlock_irqrestore(&port->lock, flags);
ecc2e05e	279	return retval;
36c621d8 AC	280
	281	}
	282	EXPORT_SYMBOL(tty_port_block_til_ready);
	283
a6614999 AC	284	int tty_port_close_start(struct tty_port port, struct tty_struct tty, struct file *filp)
	285	{
	286	unsigned long flags;
	287
	288	spin_lock_irqsave(&port->lock, flags);
	289	if (tty_hung_up_p(filp)) {
	290	spin_unlock_irqrestore(&port->lock, flags);
	291	return 0;
	292	}
	293
	294	if( tty->count == 1 && port->count != 1) {
	295	printk(KERN_WARNING
	296	"tty_port_close_start: tty->count = 1 port count = %d.\n",
	297	port->count);
	298	port->count = 1;
	299	}
	300	if (--port->count < 0) {
	301	printk(KERN_WARNING "tty_port_close_start: count = %d\n",
	302	port->count);
	303	port->count = 0;
	304	}
	305
	306	if (port->count) {
	307	spin_unlock_irqrestore(&port->lock, flags);
7ca0ff9a AC	308	if (port->ops->drop)
7ca0ff9a AC	309	port->ops->drop(port);
a6614999 AC	310	return 0;
a6614999 AC	311	}
7ca0ff9a	312	set_bit(ASYNC_CLOSING, &port->flags);
a6614999 AC	313	tty->closing = 1;
a6614999 AC	314	spin_unlock_irqrestore(&port->lock, flags);
fba85e01 AC	315	/* Don't block on a stalled port, just pull the chain */
	316	if (tty->flow_stopped)
	317	tty_driver_flush_buffer(tty);
7ca0ff9a	318	if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
6ed1dbae	319	port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
a6614999	320	tty_wait_until_sent(tty, port->closing_wait);
1ec739be AC	321	if (port->drain_delay) {
	322	unsigned int bps = tty_get_baud_rate(tty);
	323	long timeout;
	324
	325	if (bps > 1200)
	326	timeout = max_t(long, (HZ * 10 * port->drain_delay) / bps,
	327	HZ / 10);
	328	else
	329	timeout = 2 * HZ;
	330	schedule_timeout_interruptible(timeout);
	331	}
7ca0ff9a AC	332	/* Don't call port->drop for the last reference. Callers will want
	333	to drop the last active reference in ->shutdown() or the tty
	334	shutdown path */
a6614999 AC	335	return 1;
	336	}
	337	EXPORT_SYMBOL(tty_port_close_start);
	338
	339	void tty_port_close_end(struct tty_port port, struct tty_struct tty)
	340	{
	341	unsigned long flags;
	342
	343	tty_ldisc_flush(tty);
	344
fcc8ac18 AC	345	if (tty->termios->c_cflag & HUPCL)
	346	tty_port_lower_dtr_rts(port);
	347
a6614999 AC	348	spin_lock_irqsave(&port->lock, flags);
	349	tty->closing = 0;
	350
	351	if (port->blocked_open) {
	352	spin_unlock_irqrestore(&port->lock, flags);
	353	if (port->close_delay) {
	354	msleep_interruptible(
	355	jiffies_to_msecs(port->close_delay));
	356	}
	357	spin_lock_irqsave(&port->lock, flags);
	358	wake_up_interruptible(&port->open_wait);
	359	}
	360	port->flags &= ~(ASYNC_NORMAL_ACTIVE \| ASYNC_CLOSING);
	361	wake_up_interruptible(&port->close_wait);
	362	spin_unlock_irqrestore(&port->lock, flags);
	363	}
	364	EXPORT_SYMBOL(tty_port_close_end);
7ca0ff9a AC	365
	366	void tty_port_close(struct tty_port port, struct tty_struct tty,
	367	struct file *filp)
	368	{
	369	if (tty_port_close_start(port, tty, filp) == 0)
	370	return;
	371	tty_port_shutdown(port);
	372	tty_port_close_end(port, tty);
	373	tty_port_tty_set(port, NULL);
	374	}
	375	EXPORT_SYMBOL(tty_port_close);