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/wait.h>
16 #include <linux/bitops.h>
17 #include <linux/delay.h>
18 #include <linux/module.h>
20 void tty_port_init(struct tty_port *port)
22 memset(port, 0, sizeof(*port));
23 tty_buffer_init(port);
24 init_waitqueue_head(&port->open_wait);
25 init_waitqueue_head(&port->close_wait);
26 init_waitqueue_head(&port->delta_msr_wait);
27 mutex_init(&port->mutex);
28 mutex_init(&port->buf_mutex);
29 spin_lock_init(&port->lock);
30 port->close_delay = (50 * HZ) / 100;
31 port->closing_wait = (3000 * HZ) / 100;
32 kref_init(&port->kref);
34 EXPORT_SYMBOL(tty_port_init);
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
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.
47 void tty_port_link_device(struct tty_port *port,
48 struct tty_driver *driver, unsigned index)
50 if (WARN_ON(index >= driver->num))
52 driver->ports[index] = port;
54 EXPORT_SYMBOL_GPL(tty_port_link_device);
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
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.
67 struct device *tty_port_register_device(struct tty_port *port,
68 struct tty_driver *driver, unsigned index,
69 struct device *device)
71 tty_port_link_device(port, driver, index);
72 return tty_register_device(driver, index, device);
74 EXPORT_SYMBOL_GPL(tty_port_register_device);
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.
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.
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)
94 tty_port_link_device(port, driver, index);
95 return tty_register_device_attr(driver, index, device, drvdata,
98 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
100 int tty_port_alloc_xmit_buf(struct tty_port *port)
102 /* We may sleep in get_zeroed_page() */
103 mutex_lock(&port->buf_mutex);
104 if (port->xmit_buf == NULL)
105 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
106 mutex_unlock(&port->buf_mutex);
107 if (port->xmit_buf == NULL)
111 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
113 void tty_port_free_xmit_buf(struct tty_port *port)
115 mutex_lock(&port->buf_mutex);
116 if (port->xmit_buf != NULL) {
117 free_page((unsigned long)port->xmit_buf);
118 port->xmit_buf = NULL;
120 mutex_unlock(&port->buf_mutex);
122 EXPORT_SYMBOL(tty_port_free_xmit_buf);
125 * tty_port_destroy -- destroy inited port
126 * @port: tty port to be doestroyed
128 * When a port was initialized using tty_port_init, one has to destroy the
129 * port by this function. Either indirectly by using tty_port refcounting
130 * (tty_port_put) or directly if refcounting is not used.
132 void tty_port_destroy(struct tty_port *port)
134 cancel_work_sync(&port->buf.work);
135 tty_buffer_free_all(port);
137 EXPORT_SYMBOL(tty_port_destroy);
139 static void tty_port_destructor(struct kref *kref)
141 struct tty_port *port = container_of(kref, struct tty_port, kref);
143 /* check if last port ref was dropped before tty release */
144 if (WARN_ON(port->itty))
147 free_page((unsigned long)port->xmit_buf);
148 tty_port_destroy(port);
149 if (port->ops && port->ops->destruct)
150 port->ops->destruct(port);
155 void tty_port_put(struct tty_port *port)
158 kref_put(&port->kref, tty_port_destructor);
160 EXPORT_SYMBOL(tty_port_put);
163 * tty_port_tty_get - get a tty reference
166 * Return a refcount protected tty instance or NULL if the port is not
167 * associated with a tty (eg due to close or hangup)
170 struct tty_struct *tty_port_tty_get(struct tty_port *port)
173 struct tty_struct *tty;
175 spin_lock_irqsave(&port->lock, flags);
176 tty = tty_kref_get(port->tty);
177 spin_unlock_irqrestore(&port->lock, flags);
180 EXPORT_SYMBOL(tty_port_tty_get);
183 * tty_port_tty_set - set the tty of a port
187 * Associate the port and tty pair. Manages any internal refcounts.
188 * Pass NULL to deassociate a port
191 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
195 spin_lock_irqsave(&port->lock, flags);
197 tty_kref_put(port->tty);
198 port->tty = tty_kref_get(tty);
199 spin_unlock_irqrestore(&port->lock, flags);
201 EXPORT_SYMBOL(tty_port_tty_set);
203 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
205 mutex_lock(&port->mutex);
209 if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
211 * Drop DTR/RTS if HUPCL is set. This causes any attached
212 * modem to hang up the line.
214 if (tty && C_HUPCL(tty))
215 tty_port_lower_dtr_rts(port);
217 if (port->ops->shutdown)
218 port->ops->shutdown(port);
221 mutex_unlock(&port->mutex);
225 * tty_port_hangup - hangup helper
228 * Perform port level tty hangup flag and count changes. Drop the tty
232 void tty_port_hangup(struct tty_port *port)
234 struct tty_struct *tty;
237 spin_lock_irqsave(&port->lock, flags);
239 port->flags &= ~ASYNC_NORMAL_ACTIVE;
242 set_bit(TTY_IO_ERROR, &tty->flags);
244 spin_unlock_irqrestore(&port->lock, flags);
245 tty_port_shutdown(port, tty);
247 wake_up_interruptible(&port->open_wait);
248 wake_up_interruptible(&port->delta_msr_wait);
250 EXPORT_SYMBOL(tty_port_hangup);
253 * tty_port_tty_hangup - helper to hang up a tty
256 * @check_clocal: hang only ttys with CLOCAL unset?
258 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
260 struct tty_struct *tty = tty_port_tty_get(port);
262 if (tty && (!check_clocal || !C_CLOCAL(tty)))
266 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
269 * tty_port_tty_wakeup - helper to wake up a tty
273 void tty_port_tty_wakeup(struct tty_port *port)
275 struct tty_struct *tty = tty_port_tty_get(port);
282 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
285 * tty_port_carrier_raised - carrier raised check
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.
293 int tty_port_carrier_raised(struct tty_port *port)
295 if (port->ops->carrier_raised == NULL)
297 return port->ops->carrier_raised(port);
299 EXPORT_SYMBOL(tty_port_carrier_raised);
302 * tty_port_raise_dtr_rts - Raise DTR/RTS
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.
310 void tty_port_raise_dtr_rts(struct tty_port *port)
312 if (port->ops->dtr_rts)
313 port->ops->dtr_rts(port, 1);
315 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
318 * tty_port_lower_dtr_rts - Lower DTR/RTS
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.
326 void tty_port_lower_dtr_rts(struct tty_port *port)
328 if (port->ops->dtr_rts)
329 port->ops->dtr_rts(port, 0);
331 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
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
339 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
341 * - hangup (both before and during)
342 * - non blocking open
345 * - port flags and counts
347 * The passed tty_port must implement the carrier_raised method if it can
348 * do carrier detect and the dtr_rts method if it supports software
349 * management of these lines. Note that the dtr/rts raise is done each
350 * iteration as a hangup may have previously dropped them while we wait.
353 int tty_port_block_til_ready(struct tty_port *port,
354 struct tty_struct *tty, struct file *filp)
356 int do_clocal = 0, retval;
360 /* block if port is in the process of being closed */
361 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
362 wait_event_interruptible_tty(tty, port->close_wait,
363 !(port->flags & ASYNC_CLOSING));
364 if (port->flags & ASYNC_HUP_NOTIFY)
370 /* if non-blocking mode is set we can pass directly to open unless
371 the port has just hung up or is in another error state */
372 if (tty->flags & (1 << TTY_IO_ERROR)) {
373 port->flags |= ASYNC_NORMAL_ACTIVE;
376 if (filp->f_flags & O_NONBLOCK) {
377 /* Indicate we are open */
378 if (tty->termios.c_cflag & CBAUD)
379 tty_port_raise_dtr_rts(port);
380 port->flags |= ASYNC_NORMAL_ACTIVE;
387 /* Block waiting until we can proceed. We may need to wait for the
388 carrier, but we must also wait for any close that is in progress
389 before the next open may complete */
393 /* The port lock protects the port counts */
394 spin_lock_irqsave(&port->lock, flags);
395 if (!tty_hung_up_p(filp))
397 port->blocked_open++;
398 spin_unlock_irqrestore(&port->lock, flags);
401 /* Indicate we are open */
402 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
403 tty_port_raise_dtr_rts(port);
405 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
406 /* Check for a hangup or uninitialised port.
407 Return accordingly */
408 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
409 if (port->flags & ASYNC_HUP_NOTIFY)
412 retval = -ERESTARTSYS;
416 * Probe the carrier. For devices with no carrier detect
417 * tty_port_carrier_raised will always return true.
418 * Never ask drivers if CLOCAL is set, this causes troubles
421 if (!(port->flags & ASYNC_CLOSING) &&
422 (do_clocal || tty_port_carrier_raised(port)))
424 if (signal_pending(current)) {
425 retval = -ERESTARTSYS;
432 finish_wait(&port->open_wait, &wait);
434 /* Update counts. A parallel hangup will have set count to zero and
435 we must not mess that up further */
436 spin_lock_irqsave(&port->lock, flags);
437 if (!tty_hung_up_p(filp))
439 port->blocked_open--;
441 port->flags |= ASYNC_NORMAL_ACTIVE;
442 spin_unlock_irqrestore(&port->lock, flags);
445 EXPORT_SYMBOL(tty_port_block_til_ready);
447 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
449 unsigned int bps = tty_get_baud_rate(tty);
453 timeout = (HZ * 10 * port->drain_delay) / bps;
454 timeout = max_t(long, timeout, HZ / 10);
458 schedule_timeout_interruptible(timeout);
461 /* Caller holds tty lock.
462 * NB: may drop and reacquire tty lock (in tty_wait_until_sent_from_close())
463 * so tty and tty port may have changed state (but not hung up or reopened).
465 int tty_port_close_start(struct tty_port *port,
466 struct tty_struct *tty, struct file *filp)
470 spin_lock_irqsave(&port->lock, flags);
471 if (tty_hung_up_p(filp)) {
472 spin_unlock_irqrestore(&port->lock, flags);
476 if (tty->count == 1 && port->count != 1) {
478 "tty_port_close_start: tty->count = 1 port count = %d.\n",
482 if (--port->count < 0) {
483 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
489 spin_unlock_irqrestore(&port->lock, flags);
492 set_bit(ASYNCB_CLOSING, &port->flags);
494 spin_unlock_irqrestore(&port->lock, flags);
496 if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
497 /* Don't block on a stalled port, just pull the chain */
498 if (tty->flow_stopped)
499 tty_driver_flush_buffer(tty);
500 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
501 tty_wait_until_sent_from_close(tty, port->closing_wait);
502 if (port->drain_delay)
503 tty_port_drain_delay(port, tty);
505 /* Flush the ldisc buffering */
506 tty_ldisc_flush(tty);
508 /* Report to caller this is the last port reference */
511 EXPORT_SYMBOL(tty_port_close_start);
513 /* Caller holds tty lock */
514 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
518 spin_lock_irqsave(&port->lock, flags);
521 if (port->blocked_open) {
522 spin_unlock_irqrestore(&port->lock, flags);
523 if (port->close_delay) {
524 msleep_interruptible(
525 jiffies_to_msecs(port->close_delay));
527 spin_lock_irqsave(&port->lock, flags);
528 wake_up_interruptible(&port->open_wait);
530 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
531 wake_up_interruptible(&port->close_wait);
532 spin_unlock_irqrestore(&port->lock, flags);
534 EXPORT_SYMBOL(tty_port_close_end);
539 * Caller holds tty lock
541 * NB: may drop and reacquire tty lock (in tty_port_close_start()->
542 * tty_wait_until_sent_from_close()) so tty and tty_port may have changed
543 * state (but not hung up or reopened).
545 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
548 if (tty_port_close_start(port, tty, filp) == 0)
550 tty_port_shutdown(port, tty);
551 set_bit(TTY_IO_ERROR, &tty->flags);
552 tty_port_close_end(port, tty);
553 tty_port_tty_set(port, NULL);
555 EXPORT_SYMBOL(tty_port_close);
558 * tty_port_install - generic tty->ops->install handler
559 * @port: tty_port of the device
560 * @driver: tty_driver for this device
561 * @tty: tty to be installed
563 * It is the same as tty_standard_install except the provided @port is linked
564 * to a concrete tty specified by @tty. Use this or tty_port_register_device
565 * (or both). Call tty_port_link_device as a last resort.
567 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
568 struct tty_struct *tty)
571 return tty_standard_install(driver, tty);
573 EXPORT_SYMBOL_GPL(tty_port_install);
578 * Caller holds tty lock.
580 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
581 * tty and tty_port may have changed state (eg., may be hung up now)
583 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
586 spin_lock_irq(&port->lock);
587 if (!tty_hung_up_p(filp))
589 spin_unlock_irq(&port->lock);
590 tty_port_tty_set(port, tty);
593 * Do the device-specific open only if the hardware isn't
594 * already initialized. Serialize open and shutdown using the
598 mutex_lock(&port->mutex);
600 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
601 clear_bit(TTY_IO_ERROR, &tty->flags);
602 if (port->ops->activate) {
603 int retval = port->ops->activate(port, tty);
605 mutex_unlock(&port->mutex);
609 set_bit(ASYNCB_INITIALIZED, &port->flags);
611 mutex_unlock(&port->mutex);
612 return tty_port_block_til_ready(port, tty, filp);
615 EXPORT_SYMBOL(tty_port_open);