[linux.git] / drivers / tty / 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);
	init_waitqueue_head(&port->delta_msr_wait);
	mutex_init(&port->mutex);
	mutex_init(&port->buf_mutex);
	spin_lock_init(&port->lock);
	port->close_delay = (50 * HZ) / 100;
	port->closing_wait = (3000 * HZ) / 100;
	kref_init(&port->kref);
}
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->buf_mutex);
	if (port->xmit_buf == NULL)
		port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
	mutex_unlock(&port->buf_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->buf_mutex);
	if (port->xmit_buf != NULL) {
		free_page((unsigned long)port->xmit_buf);
		port->xmit_buf = NULL;
	}
	mutex_unlock(&port->buf_mutex);
}
EXPORT_SYMBOL(tty_port_free_xmit_buf);

static void tty_port_destructor(struct kref *kref)
{
	struct tty_port *port = container_of(kref, struct tty_port, kref);
	if (port->xmit_buf)
		free_page((unsigned long)port->xmit_buf);
	if (port->ops->destruct)
		port->ops->destruct(port);
	else
		kfree(port);
}

void tty_port_put(struct tty_port *port)
{
	if (port)
		kref_put(&port->kref, tty_port_destructor);
}
EXPORT_SYMBOL(tty_port_put);

/**
 *	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)
{
	mutex_lock(&port->mutex);
	if (port->ops->shutdown && !port->console &&
		test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
			port->ops->shutdown(port);
	mutex_unlock(&port->mutex);
}

/**
 *	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) {
		set_bit(TTY_IO_ERROR, &port->tty->flags);
		tty_kref_put(port->tty);
	}
	port->tty = NULL;
	spin_unlock_irqrestore(&port->lock, flags);
	wake_up_interruptible(&port->open_wait);
	wake_up_interruptible(&port->delta_msr_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_tty(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 (tty->flags & (1 << TTY_IO_ERROR)) {
		port->flags |= ASYNC_NORMAL_ACTIVE;
		return 0;
	}
	if (filp->f_flags & O_NONBLOCK) {
		/* Indicate we are open */
		if (tty->termios->c_cflag & CBAUD)
			tty_port_raise_dtr_rts(port);
		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;
		}
		tty_unlock();
		schedule();
		tty_lock();
	}
	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(ASYNCB_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);
	}
	/* Flush the ldisc buffering */
	tty_ldisc_flush(tty);

	/* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
	   hang up the line */
	if (tty->termios->c_cflag & HUPCL)
		tty_port_lower_dtr_rts(port);

	/* 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;

	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);
	set_bit(TTY_IO_ERROR, &tty->flags);
	tty_port_close_end(port, tty);
	tty_port_tty_set(port, NULL);
}
EXPORT_SYMBOL(tty_port_close);

int tty_port_open(struct tty_port *port, struct tty_struct *tty,
							struct file *filp)
{
	spin_lock_irq(&port->lock);
	if (!tty_hung_up_p(filp))
		++port->count;
	spin_unlock_irq(&port->lock);
	tty_port_tty_set(port, tty);

	/*
	 * Do the device-specific open only if the hardware isn't
	 * already initialized. Serialize open and shutdown using the
	 * port mutex.
	 */

	mutex_lock(&port->mutex);

	if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
		clear_bit(TTY_IO_ERROR, &tty->flags);
		if (port->ops->activate) {
			int retval = port->ops->activate(port, tty);
			if (retval) {
				mutex_unlock(&port->mutex);
				return retval;
			}
		}
		set_bit(ASYNCB_INITIALIZED, &port->flags);
	}
	mutex_unlock(&port->mutex);
	return tty_port_block_til_ready(port, tty, filp);
}

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