[GitHub/mt8127/android_kernel_alcatel_ttab.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);
	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(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;
		}
		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(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) {
5fc5b42a JS	234	wait_event_interruptible(port->close_wait,
5fc5b42a JS	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	}
	297	schedule();
	298	}
3e3b5c08	299	finish_wait(&port->open_wait, &wait);
36c621d8 AC	300
	301	/* Update counts. A parallel hangup will have set count to zero and
	302	we must not mess that up further */
	303	spin_lock_irqsave(&port->lock, flags);
	304	if (!tty_hung_up_p(filp))
	305	port->count++;
	306	port->blocked_open--;
	307	if (retval == 0)
	308	port->flags \|= ASYNC_NORMAL_ACTIVE;
	309	spin_unlock_irqrestore(&port->lock, flags);
ecc2e05e	310	return retval;
36c621d8 AC	311	}
	312	EXPORT_SYMBOL(tty_port_block_til_ready);
	313
d774a56d AC	314	int tty_port_close_start(struct tty_port *port,
d774a56d AC	315	struct tty_struct tty, struct file filp)
a6614999 AC	316	{
	317	unsigned long flags;
	318
	319	spin_lock_irqsave(&port->lock, flags);
	320	if (tty_hung_up_p(filp)) {
	321	spin_unlock_irqrestore(&port->lock, flags);
	322	return 0;
	323	}
	324
d774a56d	325	if (tty->count == 1 && port->count != 1) {
a6614999 AC	326	printk(KERN_WARNING
	327	"tty_port_close_start: tty->count = 1 port count = %d.\n",
	328	port->count);
	329	port->count = 1;
	330	}
	331	if (--port->count < 0) {
	332	printk(KERN_WARNING "tty_port_close_start: count = %d\n",
	333	port->count);
	334	port->count = 0;
	335	}
	336
	337	if (port->count) {
	338	spin_unlock_irqrestore(&port->lock, flags);
7ca0ff9a AC	339	if (port->ops->drop)
7ca0ff9a AC	340	port->ops->drop(port);
a6614999 AC	341	return 0;
a6614999 AC	342	}
1f5c13fa	343	set_bit(ASYNCB_CLOSING, &port->flags);
a6614999 AC	344	tty->closing = 1;
a6614999 AC	345	spin_unlock_irqrestore(&port->lock, flags);
fba85e01 AC	346	/* Don't block on a stalled port, just pull the chain */
	347	if (tty->flow_stopped)
	348	tty_driver_flush_buffer(tty);
7ca0ff9a	349	if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
6ed1dbae	350	port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
a6614999	351	tty_wait_until_sent(tty, port->closing_wait);
1ec739be AC	352	if (port->drain_delay) {
	353	unsigned int bps = tty_get_baud_rate(tty);
	354	long timeout;
	355
	356	if (bps > 1200)
d774a56d AC	357	timeout = max_t(long,
d774a56d AC	358	(HZ * 10 * port->drain_delay) / bps, HZ / 10);
1ec739be AC	359	else
	360	timeout = 2 * HZ;
	361	schedule_timeout_interruptible(timeout);
	362	}
e707c35c AC	363	/* Flush the ldisc buffering */
	364	tty_ldisc_flush(tty);
	365
	366	/* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
	367	hang up the line */
	368	if (tty->termios->c_cflag & HUPCL)
	369	tty_port_lower_dtr_rts(port);
	370
7ca0ff9a AC	371	/* Don't call port->drop for the last reference. Callers will want
	372	to drop the last active reference in ->shutdown() or the tty
	373	shutdown path */
a6614999 AC	374	return 1;
	375	}
	376	EXPORT_SYMBOL(tty_port_close_start);
	377
	378	void tty_port_close_end(struct tty_port port, struct tty_struct tty)
	379	{
	380	unsigned long flags;
	381
a6614999 AC	382	spin_lock_irqsave(&port->lock, flags);
	383	tty->closing = 0;
	384
	385	if (port->blocked_open) {
	386	spin_unlock_irqrestore(&port->lock, flags);
	387	if (port->close_delay) {
	388	msleep_interruptible(
	389	jiffies_to_msecs(port->close_delay));
	390	}
	391	spin_lock_irqsave(&port->lock, flags);
	392	wake_up_interruptible(&port->open_wait);
	393	}
	394	port->flags &= ~(ASYNC_NORMAL_ACTIVE \| ASYNC_CLOSING);
	395	wake_up_interruptible(&port->close_wait);
	396	spin_unlock_irqrestore(&port->lock, flags);
	397	}
	398	EXPORT_SYMBOL(tty_port_close_end);
7ca0ff9a AC	399
	400	void tty_port_close(struct tty_port port, struct tty_struct tty,
	401	struct file *filp)
	402	{
	403	if (tty_port_close_start(port, tty, filp) == 0)
	404	return;
	405	tty_port_shutdown(port);
d74e8286	406	set_bit(TTY_IO_ERROR, &tty->flags);
7ca0ff9a AC	407	tty_port_close_end(port, tty);
	408	tty_port_tty_set(port, NULL);
	409	}
	410	EXPORT_SYMBOL(tty_port_close);
64bc3979 AC	411
64bc3979 AC	412	int tty_port_open(struct tty_port port, struct tty_struct tty,
d774a56d	413	struct file *filp)
64bc3979 AC	414	{
	415	spin_lock_irq(&port->lock);
	416	if (!tty_hung_up_p(filp))
	417	++port->count;
	418	spin_unlock_irq(&port->lock);
	419	tty_port_tty_set(port, tty);
	420
	421	/*
	422	* Do the device-specific open only if the hardware isn't
	423	* already initialized. Serialize open and shutdown using the
	424	* port mutex.
	425	*/
	426
	427	mutex_lock(&port->mutex);
	428
	429	if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
a9a37ec3	430	clear_bit(TTY_IO_ERROR, &tty->flags);
64bc3979 AC	431	if (port->ops->activate) {
	432	int retval = port->ops->activate(port, tty);
	433	if (retval) {
d774a56d AC	434	mutex_unlock(&port->mutex);
	435	return retval;
	436	}
	437	}
64bc3979 AC	438	set_bit(ASYNCB_INITIALIZED, &port->flags);
	439	}
	440	mutex_unlock(&port->mutex);
	441	return tty_port_block_til_ready(port, tty, filp);
	442	}
	443
	444	EXPORT_SYMBOL(tty_port_open);