tty_port.c 15.5 KB
Newer Older
A
Alan Cox 已提交
1 2 3 4 5 6 7 8 9
/*
 * 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>
10
#include <linux/serial.h>
A
Alan Cox 已提交
11 12 13 14 15 16 17 18 19 20 21 22 23
#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));
J
Jiri Slaby 已提交
24
	tty_buffer_init(port);
A
Alan Cox 已提交
25 26
	init_waitqueue_head(&port->open_wait);
	init_waitqueue_head(&port->close_wait);
27
	init_waitqueue_head(&port->delta_msr_wait);
A
Alan Cox 已提交
28
	mutex_init(&port->mutex);
29
	mutex_init(&port->buf_mutex);
A
Alan Cox 已提交
30
	spin_lock_init(&port->lock);
A
Alan Cox 已提交
31 32
	port->close_delay = (50 * HZ) / 100;
	port->closing_wait = (3000 * HZ) / 100;
33
	kref_init(&port->kref);
A
Alan Cox 已提交
34 35 36
}
EXPORT_SYMBOL(tty_port_init);

J
Jiri Slaby 已提交
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/**
 * 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);

57 58 59 60 61 62 63 64 65 66 67
/**
 * 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.
 */
68 69 70 71
struct device *tty_port_register_device(struct tty_port *port,
		struct tty_driver *driver, unsigned index,
		struct device *device)
{
J
Jiri Slaby 已提交
72
	tty_port_link_device(port, driver, index);
73 74 75 76
	return tty_register_device(driver, index, device);
}
EXPORT_SYMBOL_GPL(tty_port_register_device);

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
/**
 * 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);

A
Alan Cox 已提交
101 102 103
int tty_port_alloc_xmit_buf(struct tty_port *port)
{
	/* We may sleep in get_zeroed_page() */
104
	mutex_lock(&port->buf_mutex);
A
Alan Cox 已提交
105 106
	if (port->xmit_buf == NULL)
		port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
107
	mutex_unlock(&port->buf_mutex);
A
Alan Cox 已提交
108 109 110 111 112 113 114 115
	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)
{
116
	mutex_lock(&port->buf_mutex);
A
Alan Cox 已提交
117 118 119 120
	if (port->xmit_buf != NULL) {
		free_page((unsigned long)port->xmit_buf);
		port->xmit_buf = NULL;
	}
121
	mutex_unlock(&port->buf_mutex);
A
Alan Cox 已提交
122 123 124
}
EXPORT_SYMBOL(tty_port_free_xmit_buf);

J
Jiri Slaby 已提交
125 126 127 128 129 130 131 132 133 134
/**
 * 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)
{
135
	cancel_work_sync(&port->buf.work);
J
Jiri Slaby 已提交
136 137 138 139
	tty_buffer_free_all(port);
}
EXPORT_SYMBOL(tty_port_destroy);

140 141 142 143 144
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);
J
Jiri Slaby 已提交
145
	tty_port_destroy(port);
J
Jiri Slaby 已提交
146
	if (port->ops && port->ops->destruct)
147 148 149 150 151 152 153 154 155 156 157
		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);
A
Alan Cox 已提交
158

A
Alan Cox 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
/**
 *	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);
A
Alan Cox 已提交
195
	port->tty = tty_kref_get(tty);
A
Alan Cox 已提交
196 197 198
	spin_unlock_irqrestore(&port->lock, flags);
}
EXPORT_SYMBOL(tty_port_tty_set);
199

200
static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
A
Alan Cox 已提交
201
{
A
Alan Cox 已提交
202
	mutex_lock(&port->mutex);
J
Johan Hovold 已提交
203 204 205 206
	if (port->console)
		goto out;

	if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
207 208 209 210 211 212 213
		/*
		 * 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);

J
Johan Hovold 已提交
214
		if (port->ops->shutdown)
A
Alan Cox 已提交
215
			port->ops->shutdown(port);
J
Johan Hovold 已提交
216 217
	}
out:
A
Alan Cox 已提交
218
	mutex_unlock(&port->mutex);
A
Alan Cox 已提交
219 220
}

221 222 223 224 225 226 227 228 229 230
/**
 *	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)
{
231
	struct tty_struct *tty;
232 233 234 235 236
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	port->count = 0;
	port->flags &= ~ASYNC_NORMAL_ACTIVE;
237 238 239
	tty = port->tty;
	if (tty)
		set_bit(TTY_IO_ERROR, &tty->flags);
240 241
	port->tty = NULL;
	spin_unlock_irqrestore(&port->lock, flags);
242 243
	tty_port_shutdown(port, tty);
	tty_kref_put(tty);
244
	wake_up_interruptible(&port->open_wait);
245
	wake_up_interruptible(&port->delta_msr_wait);
246 247 248
}
EXPORT_SYMBOL(tty_port_hangup);

J
Jiri Slaby 已提交
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
/**
 * 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);

J
Jiri Slaby 已提交
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
/**
 * 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);

282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
/**
 *	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);
A
Alan Cox 已提交
298 299

/**
300
 *	tty_port_raise_dtr_rts	-	Raise DTR/RTS
A
Alan Cox 已提交
301 302 303 304 305 306 307 308 309
 *	@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)
{
310 311
	if (port->ops->dtr_rts)
		port->ops->dtr_rts(port, 1);
A
Alan Cox 已提交
312 313
}
EXPORT_SYMBOL(tty_port_raise_dtr_rts);
314

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
/**
 *	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);

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
/**
 *	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
346
 *	do carrier detect and the dtr_rts method if it supports software
347 348 349
 *	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.
 */
A
Alan Cox 已提交
350

351 352 353 354 355
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;
356
	DEFINE_WAIT(wait);
357 358 359

	/* block if port is in the process of being closed */
	if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
A
Alan Cox 已提交
360
		wait_event_interruptible_tty(tty, port->close_wait,
J
Jiri Slaby 已提交
361
				!(port->flags & ASYNC_CLOSING));
362 363 364 365 366 367 368 369
		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 */
370 371 372 373 374
	if (tty->flags & (1 << TTY_IO_ERROR)) {
		port->flags |= ASYNC_NORMAL_ACTIVE;
		return 0;
	}
	if (filp->f_flags & O_NONBLOCK) {
375
		/* Indicate we are open */
376
		if (tty->termios.c_cflag & CBAUD)
377
			tty_port_raise_dtr_rts(port);
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
		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 */
400
		if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
A
Alan Cox 已提交
401
			tty_port_raise_dtr_rts(port);
402

J
Jiri Slaby 已提交
403
		prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
A
Alan Cox 已提交
404 405
		/* Check for a hangup or uninitialised port.
							Return accordingly */
406 407 408 409 410 411 412
		if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
			if (port->flags & ASYNC_HUP_NOTIFY)
				retval = -EAGAIN;
			else
				retval = -ERESTARTSYS;
			break;
		}
413 414 415 416 417 418
		/*
		 * 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.
		 */
419
		if (!(port->flags & ASYNC_CLOSING) &&
420
				(do_clocal || tty_port_carrier_raised(port)))
421 422 423 424 425
			break;
		if (signal_pending(current)) {
			retval = -ERESTARTSYS;
			break;
		}
A
Alan Cox 已提交
426
		tty_unlock(tty);
427
		schedule();
A
Alan Cox 已提交
428
		tty_lock(tty);
429
	}
J
Jiri Slaby 已提交
430
	finish_wait(&port->open_wait, &wait);
431 432 433 434 435 436 437 438 439 440

	/* 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);
441
	return retval;
442 443 444
}
EXPORT_SYMBOL(tty_port_block_til_ready);

445 446 447 448 449 450 451 452 453 454 455 456 457 458
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);
}

A
Alan Cox 已提交
459 460
int tty_port_close_start(struct tty_port *port,
				struct tty_struct *tty, struct file *filp)
461 462 463 464 465 466 467 468 469
{
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	if (tty_hung_up_p(filp)) {
		spin_unlock_irqrestore(&port->lock, flags);
		return 0;
	}

A
Alan Cox 已提交
470
	if (tty->count == 1 && port->count != 1) {
471 472 473 474 475 476 477 478 479 480 481 482 483
		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);
A
Alan Cox 已提交
484 485
		if (port->ops->drop)
			port->ops->drop(port);
486 487
		return 0;
	}
A
Alan Stern 已提交
488
	set_bit(ASYNCB_CLOSING, &port->flags);
489 490
	tty->closing = 1;
	spin_unlock_irqrestore(&port->lock, flags);
491 492 493 494 495 496 497 498 499 500

	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_from_close(tty, port->closing_wait);
		if (port->drain_delay)
			tty_port_drain_delay(port, tty);
	}
A
Alan Cox 已提交
501 502 503
	/* Flush the ldisc buffering */
	tty_ldisc_flush(tty);

A
Alan Cox 已提交
504 505 506
	/* 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 */
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
	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);
A
Alan Cox 已提交
532 533 534 535 536 537

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;
538
	tty_port_shutdown(port, tty);
539
	set_bit(TTY_IO_ERROR, &tty->flags);
A
Alan Cox 已提交
540 541 542 543
	tty_port_close_end(port, tty);
	tty_port_tty_set(port, NULL);
}
EXPORT_SYMBOL(tty_port_close);
A
Alan Cox 已提交
544

545 546 547 548 549 550 551 552 553 554
/**
 * 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.
 */
555 556 557 558 559 560 561 562
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);

A
Alan Cox 已提交
563
int tty_port_open(struct tty_port *port, struct tty_struct *tty,
A
Alan Cox 已提交
564
							struct file *filp)
A
Alan Cox 已提交
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
{
	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)) {
A
Alan Cox 已提交
581
		clear_bit(TTY_IO_ERROR, &tty->flags);
A
Alan Cox 已提交
582 583 584
		if (port->ops->activate) {
			int retval = port->ops->activate(port, tty);
			if (retval) {
A
Alan Cox 已提交
585 586 587 588
				mutex_unlock(&port->mutex);
				return retval;
			}
		}
A
Alan Cox 已提交
589 590 591 592 593 594 595
		set_bit(ASYNCB_INITIALIZED, &port->flags);
	}
	mutex_unlock(&port->mutex);
	return tty_port_block_til_ready(port, tty, filp);
}

EXPORT_SYMBOL(tty_port_open);