5 #include <linux/types.h>
6 #include <linux/errno.h>
8 #include <linux/tty_driver.h>
9 #include <linux/tty_flip.h>
10 #include <linux/serial.h>
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>
21 void tty_port_init(struct tty_port *port)
23 memset(port, 0, sizeof(*port));
24 tty_buffer_init(port);
25 init_waitqueue_head(&port->open_wait);
26 init_waitqueue_head(&port->close_wait);
27 init_waitqueue_head(&port->delta_msr_wait);
28 mutex_init(&port->mutex);
29 mutex_init(&port->buf_mutex);
30 spin_lock_init(&port->lock);
31 port->close_delay = (50 * HZ) / 100;
32 port->closing_wait = (3000 * HZ) / 100;
33 kref_init(&port->kref);
35 EXPORT_SYMBOL(tty_port_init);
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
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.
48 void tty_port_link_device(struct tty_port *port,
49 struct tty_driver *driver, unsigned index)
51 if (WARN_ON(index >= driver->num))
53 driver->ports[index] = port;
55 EXPORT_SYMBOL_GPL(tty_port_link_device);
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
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.
68 struct device *tty_port_register_device(struct tty_port *port,
69 struct tty_driver *driver, unsigned index,
70 struct device *device)
72 tty_port_link_device(port, driver, index);
73 return tty_register_device(driver, index, device);
75 EXPORT_SYMBOL_GPL(tty_port_register_device);
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.
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.
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)
95 tty_port_link_device(port, driver, index);
96 return tty_register_device_attr(driver, index, device, drvdata,
99 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
101 int tty_port_alloc_xmit_buf(struct tty_port *port)
103 /* We may sleep in get_zeroed_page() */
104 mutex_lock(&port->buf_mutex);
105 if (port->xmit_buf == NULL)
106 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
107 mutex_unlock(&port->buf_mutex);
108 if (port->xmit_buf == NULL)
112 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
114 void tty_port_free_xmit_buf(struct tty_port *port)
116 mutex_lock(&port->buf_mutex);
117 if (port->xmit_buf != NULL) {
118 free_page((unsigned long)port->xmit_buf);
119 port->xmit_buf = NULL;
121 mutex_unlock(&port->buf_mutex);
123 EXPORT_SYMBOL(tty_port_free_xmit_buf);
126 * tty_port_destroy -- destroy inited port
127 * @port: tty port to be doestroyed
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.
133 void tty_port_destroy(struct tty_port *port)
135 cancel_work_sync(&port->buf.work);
136 tty_buffer_free_all(port);
138 EXPORT_SYMBOL(tty_port_destroy);
140 static void tty_port_destructor(struct kref *kref)
142 struct tty_port *port = container_of(kref, struct tty_port, kref);
144 /* check if last port ref was dropped before tty release */
145 if (WARN_ON(port->itty))
148 free_page((unsigned long)port->xmit_buf);
149 tty_port_destroy(port);
150 if (port->ops && port->ops->destruct)
151 port->ops->destruct(port);
156 void tty_port_put(struct tty_port *port)
159 kref_put(&port->kref, tty_port_destructor);
161 EXPORT_SYMBOL(tty_port_put);
164 * tty_port_tty_get - get a tty reference
167 * Return a refcount protected tty instance or NULL if the port is not
168 * associated with a tty (eg due to close or hangup)
171 struct tty_struct *tty_port_tty_get(struct tty_port *port)
174 struct tty_struct *tty;
176 spin_lock_irqsave(&port->lock, flags);
177 tty = tty_kref_get(port->tty);
178 spin_unlock_irqrestore(&port->lock, flags);
181 EXPORT_SYMBOL(tty_port_tty_get);
184 * tty_port_tty_set - set the tty of a port
188 * Associate the port and tty pair. Manages any internal refcounts.
189 * Pass NULL to deassociate a port
192 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
196 spin_lock_irqsave(&port->lock, flags);
198 tty_kref_put(port->tty);
199 port->tty = tty_kref_get(tty);
200 spin_unlock_irqrestore(&port->lock, flags);
202 EXPORT_SYMBOL(tty_port_tty_set);
204 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
206 mutex_lock(&port->mutex);
210 if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
212 * Drop DTR/RTS if HUPCL is set. This causes any attached
213 * modem to hang up the line.
215 if (tty && C_HUPCL(tty))
216 tty_port_lower_dtr_rts(port);
218 if (port->ops->shutdown)
219 port->ops->shutdown(port);
222 mutex_unlock(&port->mutex);
226 * tty_port_hangup - hangup helper
229 * Perform port level tty hangup flag and count changes. Drop the tty
233 void tty_port_hangup(struct tty_port *port)
235 struct tty_struct *tty;
238 spin_lock_irqsave(&port->lock, flags);
240 port->flags &= ~ASYNC_NORMAL_ACTIVE;
243 set_bit(TTY_IO_ERROR, &tty->flags);
245 spin_unlock_irqrestore(&port->lock, flags);
246 tty_port_shutdown(port, tty);
248 wake_up_interruptible(&port->open_wait);
249 wake_up_interruptible(&port->delta_msr_wait);
251 EXPORT_SYMBOL(tty_port_hangup);
254 * tty_port_tty_hangup - helper to hang up a tty
257 * @check_clocal: hang only ttys with CLOCAL unset?
259 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
261 struct tty_struct *tty = tty_port_tty_get(port);
263 if (tty && (!check_clocal || !C_CLOCAL(tty)))
267 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
270 * tty_port_tty_wakeup - helper to wake up a tty
274 void tty_port_tty_wakeup(struct tty_port *port)
276 struct tty_struct *tty = tty_port_tty_get(port);
283 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
286 * tty_port_carrier_raised - carrier raised check
289 * Wrapper for the carrier detect logic. For the moment this is used
290 * to hide some internal details. This will eventually become entirely
291 * internal to the tty port.
294 int tty_port_carrier_raised(struct tty_port *port)
296 if (port->ops->carrier_raised == NULL)
298 return port->ops->carrier_raised(port);
300 EXPORT_SYMBOL(tty_port_carrier_raised);
303 * tty_port_raise_dtr_rts - Raise DTR/RTS
306 * Wrapper for the DTR/RTS raise logic. For the moment this is used
307 * to hide some internal details. This will eventually become entirely
308 * internal to the tty port.
311 void tty_port_raise_dtr_rts(struct tty_port *port)
313 if (port->ops->dtr_rts)
314 port->ops->dtr_rts(port, 1);
316 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
319 * tty_port_lower_dtr_rts - Lower DTR/RTS
322 * Wrapper for the DTR/RTS raise logic. For the moment this is used
323 * to hide some internal details. This will eventually become entirely
324 * internal to the tty port.
327 void tty_port_lower_dtr_rts(struct tty_port *port)
329 if (port->ops->dtr_rts)
330 port->ops->dtr_rts(port, 0);
332 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
335 * tty_port_block_til_ready - Waiting logic for tty open
336 * @port: the tty port being opened
337 * @tty: the tty device being bound
338 * @filp: the file pointer of the opener
340 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
342 * - hangup (both before and during)
343 * - non blocking open
346 * - port flags and counts
348 * The passed tty_port must implement the carrier_raised method if it can
349 * do carrier detect and the dtr_rts method if it supports software
350 * management of these lines. Note that the dtr/rts raise is done each
351 * iteration as a hangup may have previously dropped them while we wait.
354 int tty_port_block_til_ready(struct tty_port *port,
355 struct tty_struct *tty, struct file *filp)
357 int do_clocal = 0, retval;
361 /* block if port is in the process of being closed */
362 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
363 wait_event_interruptible_tty(tty, port->close_wait,
364 !(port->flags & ASYNC_CLOSING));
365 if (port->flags & ASYNC_HUP_NOTIFY)
371 /* if non-blocking mode is set we can pass directly to open unless
372 the port has just hung up or is in another error state */
373 if (tty->flags & (1 << TTY_IO_ERROR)) {
374 port->flags |= ASYNC_NORMAL_ACTIVE;
377 if (filp->f_flags & O_NONBLOCK) {
378 /* Indicate we are open */
379 if (tty->termios.c_cflag & CBAUD)
380 tty_port_raise_dtr_rts(port);
381 port->flags |= ASYNC_NORMAL_ACTIVE;
388 /* Block waiting until we can proceed. We may need to wait for the
389 carrier, but we must also wait for any close that is in progress
390 before the next open may complete */
394 /* The port lock protects the port counts */
395 spin_lock_irqsave(&port->lock, flags);
396 if (!tty_hung_up_p(filp))
398 port->blocked_open++;
399 spin_unlock_irqrestore(&port->lock, flags);
402 /* Indicate we are open */
403 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
404 tty_port_raise_dtr_rts(port);
406 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
407 /* Check for a hangup or uninitialised port.
408 Return accordingly */
409 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
410 if (port->flags & ASYNC_HUP_NOTIFY)
413 retval = -ERESTARTSYS;
417 * Probe the carrier. For devices with no carrier detect
418 * tty_port_carrier_raised will always return true.
419 * Never ask drivers if CLOCAL is set, this causes troubles
422 if (!(port->flags & ASYNC_CLOSING) &&
423 (do_clocal || tty_port_carrier_raised(port)))
425 if (signal_pending(current)) {
426 retval = -ERESTARTSYS;
433 finish_wait(&port->open_wait, &wait);
435 /* Update counts. A parallel hangup will have set count to zero and
436 we must not mess that up further */
437 spin_lock_irqsave(&port->lock, flags);
438 if (!tty_hung_up_p(filp))
440 port->blocked_open--;
442 port->flags |= ASYNC_NORMAL_ACTIVE;
443 spin_unlock_irqrestore(&port->lock, flags);
446 EXPORT_SYMBOL(tty_port_block_til_ready);
448 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
450 unsigned int bps = tty_get_baud_rate(tty);
454 timeout = (HZ * 10 * port->drain_delay) / bps;
455 timeout = max_t(long, timeout, HZ / 10);
459 schedule_timeout_interruptible(timeout);
462 int tty_port_close_start(struct tty_port *port,
463 struct tty_struct *tty, struct file *filp)
467 spin_lock_irqsave(&port->lock, flags);
468 if (tty_hung_up_p(filp)) {
469 spin_unlock_irqrestore(&port->lock, flags);
473 if (tty->count == 1 && port->count != 1) {
475 "tty_port_close_start: tty->count = 1 port count = %d.\n",
479 if (--port->count < 0) {
480 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
486 spin_unlock_irqrestore(&port->lock, flags);
489 set_bit(ASYNCB_CLOSING, &port->flags);
491 spin_unlock_irqrestore(&port->lock, flags);
493 if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
494 /* Don't block on a stalled port, just pull the chain */
495 if (tty->flow_stopped)
496 tty_driver_flush_buffer(tty);
497 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
498 tty_wait_until_sent_from_close(tty, port->closing_wait);
499 if (port->drain_delay)
500 tty_port_drain_delay(port, tty);
502 /* Flush the ldisc buffering */
503 tty_ldisc_flush(tty);
505 /* Report to caller this is the last port reference */
508 EXPORT_SYMBOL(tty_port_close_start);
510 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
514 spin_lock_irqsave(&port->lock, flags);
517 if (port->blocked_open) {
518 spin_unlock_irqrestore(&port->lock, flags);
519 if (port->close_delay) {
520 msleep_interruptible(
521 jiffies_to_msecs(port->close_delay));
523 spin_lock_irqsave(&port->lock, flags);
524 wake_up_interruptible(&port->open_wait);
526 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
527 wake_up_interruptible(&port->close_wait);
528 spin_unlock_irqrestore(&port->lock, flags);
530 EXPORT_SYMBOL(tty_port_close_end);
532 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
535 if (tty_port_close_start(port, tty, filp) == 0)
537 tty_port_shutdown(port, tty);
538 set_bit(TTY_IO_ERROR, &tty->flags);
539 tty_port_close_end(port, tty);
540 tty_port_tty_set(port, NULL);
542 EXPORT_SYMBOL(tty_port_close);
545 * tty_port_install - generic tty->ops->install handler
546 * @port: tty_port of the device
547 * @driver: tty_driver for this device
548 * @tty: tty to be installed
550 * It is the same as tty_standard_install except the provided @port is linked
551 * to a concrete tty specified by @tty. Use this or tty_port_register_device
552 * (or both). Call tty_port_link_device as a last resort.
554 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
555 struct tty_struct *tty)
558 return tty_standard_install(driver, tty);
560 EXPORT_SYMBOL_GPL(tty_port_install);
562 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
565 spin_lock_irq(&port->lock);
566 if (!tty_hung_up_p(filp))
568 spin_unlock_irq(&port->lock);
569 tty_port_tty_set(port, tty);
572 * Do the device-specific open only if the hardware isn't
573 * already initialized. Serialize open and shutdown using the
577 mutex_lock(&port->mutex);
579 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
580 clear_bit(TTY_IO_ERROR, &tty->flags);
581 if (port->ops->activate) {
582 int retval = port->ops->activate(port, tty);
584 mutex_unlock(&port->mutex);
588 set_bit(ASYNCB_INITIALIZED, &port->flags);
590 mutex_unlock(&port->mutex);
591 return tty_port_block_til_ready(port, tty, filp);
594 EXPORT_SYMBOL(tty_port_open);