[deliverable/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));
	tty_buffer_init(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);

/**
 * tty_port_link_device - link tty and tty_port
 * @port: tty_port of the device
 * @driver: tty_driver for this device
 * @index: index of the tty
 *
 * Provide the tty layer wit ha link from a tty (specified by @index) to a
 * tty_port (@port). Use this only if neither tty_port_register_device nor
 * tty_port_install is used in the driver. If used, this has to be called before
 * tty_register_driver.
 */
void tty_port_link_device(struct tty_port *port,
		struct tty_driver *driver, unsigned index)
{
	if (WARN_ON(index >= driver->num))
		return;
	driver->ports[index] = port;
}
EXPORT_SYMBOL_GPL(tty_port_link_device);

/**
 * tty_port_register_device - register tty device
 * @port: tty_port of the device
 * @driver: tty_driver for this device
 * @index: index of the tty
 * @device: parent if exists, otherwise NULL
 *
 * It is the same as tty_register_device except the provided @port is linked to
 * a concrete tty specified by @index. Use this or tty_port_install (or both).
 * Call tty_port_link_device as a last resort.
 */
struct device *tty_port_register_device(struct tty_port *port,
		struct tty_driver *driver, unsigned index,
		struct device *device)
{
	tty_port_link_device(port, driver, index);
	return tty_register_device(driver, index, device);
}
EXPORT_SYMBOL_GPL(tty_port_register_device);

/**
 * tty_port_register_device_attr - register tty device
 * @port: tty_port of the device
 * @driver: tty_driver for this device
 * @index: index of the tty
 * @device: parent if exists, otherwise NULL
 * @drvdata: Driver data to be set to device.
 * @attr_grp: Attribute group to be set on device.
 *
 * It is the same as tty_register_device_attr except the provided @port is
 * linked to a concrete tty specified by @index. Use this or tty_port_install
 * (or both). Call tty_port_link_device as a last resort.
 */
struct device *tty_port_register_device_attr(struct tty_port *port,
		struct tty_driver *driver, unsigned index,
		struct device *device, void *drvdata,
		const struct attribute_group **attr_grp)
{
	tty_port_link_device(port, driver, index);
	return tty_register_device_attr(driver, index, device, drvdata,
			attr_grp);
}
EXPORT_SYMBOL_GPL(tty_port_register_device_attr);

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);

/**
 * tty_port_destroy -- destroy inited port
 * @port: tty port to be doestroyed
 *
 * When a port was initialized using tty_port_init, one has to destroy the
 * port by this function. Either indirectly by using tty_port refcounting
 * (tty_port_put) or directly if refcounting is not used.
 */
void tty_port_destroy(struct tty_port *port)
{
	tty_buffer_free_all(port);
}
EXPORT_SYMBOL(tty_port_destroy);

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);
	tty_port_destroy(port);
	if (port->ops && 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);

	/* block if port is in the process of being closed */
	if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
		wait_event_interruptible_tty(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
		 * tty_port_carrier_raised will always return true.
		 * Never ask drivers if CLOCAL is set, this causes troubles
		 * on some hardware.
		 */
		if (!(port->flags & ASYNC_CLOSING) &&
				(do_clocal || tty_port_carrier_raised(port)))
			break;
		if (signal_pending(current)) {
			retval = -ERESTARTSYS;
			break;
		}
		tty_unlock(tty);
		schedule();
		tty_lock(tty);
	}
	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_from_close(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);

/**
 * tty_port_install - generic tty->ops->install handler
 * @port: tty_port of the device
 * @driver: tty_driver for this device
 * @tty: tty to be installed
 *
 * It is the same as tty_standard_install except the provided @port is linked
 * to a concrete tty specified by @tty. Use this or tty_port_register_device
 * (or both). Call tty_port_link_device as a last resort.
 */
int tty_port_install(struct tty_port *port, struct tty_driver *driver,
		struct tty_struct *tty)
{
	tty->port = port;
	return tty_standard_install(driver, tty);
}
EXPORT_SYMBOL_GPL(tty_port_install);

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