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

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

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