[linux-2.6-block.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/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->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_cancel_work(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);

	/* check if last port ref was dropped before tty release */
	if (WARN_ON(port->itty))
		return;
	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);
	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, struct tty_struct *tty)
{
	mutex_lock(&port->mutex);
	if (port->console)
		goto out;

	if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
		/*
		 * Drop DTR/RTS if HUPCL is set. This causes any attached
		 * modem to hang up the line.
		 */
		if (tty && C_HUPCL(tty))
			tty_port_lower_dtr_rts(port);

		if (port->ops->shutdown)
			port->ops->shutdown(port);
	}
out:
	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.
 *
 *	Caller holds tty lock.
 */

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

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

/**
 * tty_port_tty_hangup - helper to hang up a tty
 *
 * @port: tty port
 * @check_clocal: hang only ttys with CLOCAL unset?
 */
void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
{
	struct tty_struct *tty = tty_port_tty_get(port);

	if (tty && (!check_clocal || !C_CLOCAL(tty)))
		tty_hangup(tty);
	tty_kref_put(tty);
}
EXPORT_SYMBOL_GPL(tty_port_tty_hangup);

/**
 * tty_port_tty_wakeup - helper to wake up a tty
 *
 * @port: tty port
 */
void tty_port_tty_wakeup(struct tty_port *port)
{
	struct tty_struct *tty = tty_port_tty_get(port);

	if (tty) {
		tty_wakeup(tty);
		tty_kref_put(tty);
	}
}
EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);

/**
 *	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.
 *
 *	Caller holds tty lock.
 *
 *      NB: May drop and reacquire tty lock when blocking, so tty and tty_port
 *      may have changed state (eg., may have been hung up).
 */

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

	/* 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);
	port->count--;
	port->blocked_open++;
	spin_unlock_irqrestore(&port->lock, flags);

	while (1) {
		/* Indicate we are open */
		if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
			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 (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);

static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
{
	unsigned int bps = tty_get_baud_rate(tty);
	long timeout;

	if (bps > 1200) {
		timeout = (HZ * 10 * port->drain_delay) / bps;
		timeout = max_t(long, timeout, HZ / 10);
	} else {
		timeout = 2 * HZ;
	}
	schedule_timeout_interruptible(timeout);
}

/* Caller holds tty lock. */
int tty_port_close_start(struct tty_port *port,
				struct tty_struct *tty, struct file *filp)
{
	unsigned long flags;

	if (tty_hung_up_p(filp))
		return 0;

	spin_lock_irqsave(&port->lock, flags);
	if (tty->count == 1 && port->count != 1) {
		tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
			 port->count);
		port->count = 1;
	}
	if (--port->count < 0) {
		tty_warn(tty, "%s: bad port count (%d)\n", __func__,
			 port->count);
		port->count = 0;
	}

	if (port->count) {
		spin_unlock_irqrestore(&port->lock, flags);
		return 0;
	}
	set_bit(ASYNCB_CLOSING, &port->flags);
	spin_unlock_irqrestore(&port->lock, flags);

	tty->closing = 1;

	if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
		/* Don't block on a stalled port, just pull the chain */
		if (tty->flow_stopped)
			tty_driver_flush_buffer(tty);
		if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
			tty_wait_until_sent(tty, port->closing_wait);
		if (port->drain_delay)
			tty_port_drain_delay(port, tty);
	}
	/* Flush the ldisc buffering */
	tty_ldisc_flush(tty);

	/* Report to caller this is the last port reference */
	return 1;
}
EXPORT_SYMBOL(tty_port_close_start);

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

	tty_ldisc_flush(tty);
	tty->closing = 0;

	spin_lock_irqsave(&port->lock, flags);

	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);
	spin_unlock_irqrestore(&port->lock, flags);
}
EXPORT_SYMBOL(tty_port_close_end);

/**
 * tty_port_close
 *
 * Caller holds tty lock
 */
void tty_port_close(struct tty_port *port, struct tty_struct *tty,
							struct file *filp)
{
	if (tty_port_close_start(port, tty, filp) == 0)
		return;
	tty_port_shutdown(port, tty);
	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);

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