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
231 * Caller holds tty lock.
234 void tty_port_hangup(struct tty_port *port)
236 struct tty_struct *tty;
239 spin_lock_irqsave(&port->lock, flags);
241 port->flags &= ~ASYNC_NORMAL_ACTIVE;
244 set_bit(TTY_IO_ERROR, &tty->flags);
246 spin_unlock_irqrestore(&port->lock, flags);
247 tty_port_shutdown(port, tty);
249 wake_up_interruptible(&port->open_wait);
250 wake_up_interruptible(&port->delta_msr_wait);
252 EXPORT_SYMBOL(tty_port_hangup);
255 * tty_port_tty_hangup - helper to hang up a tty
258 * @check_clocal: hang only ttys with CLOCAL unset?
260 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
262 struct tty_struct *tty = tty_port_tty_get(port);
264 if (tty && (!check_clocal || !C_CLOCAL(tty)))
268 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
271 * tty_port_tty_wakeup - helper to wake up a tty
275 void tty_port_tty_wakeup(struct tty_port *port)
277 struct tty_struct *tty = tty_port_tty_get(port);
284 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
287 * tty_port_carrier_raised - carrier raised check
290 * Wrapper for the carrier detect logic. For the moment this is used
291 * to hide some internal details. This will eventually become entirely
292 * internal to the tty port.
295 int tty_port_carrier_raised(struct tty_port *port)
297 if (port->ops->carrier_raised == NULL)
299 return port->ops->carrier_raised(port);
301 EXPORT_SYMBOL(tty_port_carrier_raised);
304 * tty_port_raise_dtr_rts - Raise DTR/RTS
307 * Wrapper for the DTR/RTS raise logic. For the moment this is used
308 * to hide some internal details. This will eventually become entirely
309 * internal to the tty port.
312 void tty_port_raise_dtr_rts(struct tty_port *port)
314 if (port->ops->dtr_rts)
315 port->ops->dtr_rts(port, 1);
317 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
320 * tty_port_lower_dtr_rts - Lower DTR/RTS
323 * Wrapper for the DTR/RTS raise logic. For the moment this is used
324 * to hide some internal details. This will eventually become entirely
325 * internal to the tty port.
328 void tty_port_lower_dtr_rts(struct tty_port *port)
330 if (port->ops->dtr_rts)
331 port->ops->dtr_rts(port, 0);
333 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
336 * tty_port_block_til_ready - Waiting logic for tty open
337 * @port: the tty port being opened
338 * @tty: the tty device being bound
339 * @filp: the file pointer of the opener
341 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
343 * - hangup (both before and during)
344 * - non blocking open
347 * - port flags and counts
349 * The passed tty_port must implement the carrier_raised method if it can
350 * do carrier detect and the dtr_rts method if it supports software
351 * management of these lines. Note that the dtr/rts raise is done each
352 * iteration as a hangup may have previously dropped them while we wait.
354 * Caller holds tty lock.
356 * NB: May drop and reacquire tty lock when blocking, so tty and tty_port
357 * may have changed state (eg., may have been hung up).
360 int tty_port_block_til_ready(struct tty_port *port,
361 struct tty_struct *tty, struct file *filp)
363 int do_clocal = 0, retval;
367 /* block if port is in the process of being closed */
368 if (port->flags & ASYNC_CLOSING) {
369 wait_event_interruptible_tty(tty, port->close_wait,
370 !(port->flags & ASYNC_CLOSING));
371 if (port->flags & ASYNC_HUP_NOTIFY)
377 /* if non-blocking mode is set we can pass directly to open unless
378 the port has just hung up or is in another error state */
379 if (tty->flags & (1 << TTY_IO_ERROR)) {
380 port->flags |= ASYNC_NORMAL_ACTIVE;
383 if (filp->f_flags & O_NONBLOCK) {
384 /* Indicate we are open */
385 if (tty->termios.c_cflag & CBAUD)
386 tty_port_raise_dtr_rts(port);
387 port->flags |= ASYNC_NORMAL_ACTIVE;
394 /* Block waiting until we can proceed. We may need to wait for the
395 carrier, but we must also wait for any close that is in progress
396 before the next open may complete */
400 /* The port lock protects the port counts */
401 spin_lock_irqsave(&port->lock, flags);
403 port->blocked_open++;
404 spin_unlock_irqrestore(&port->lock, flags);
407 /* Indicate we are open */
408 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
409 tty_port_raise_dtr_rts(port);
411 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
412 /* Check for a hangup or uninitialised port.
413 Return accordingly */
414 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
415 if (port->flags & ASYNC_HUP_NOTIFY)
418 retval = -ERESTARTSYS;
422 * Probe the carrier. For devices with no carrier detect
423 * tty_port_carrier_raised will always return true.
424 * Never ask drivers if CLOCAL is set, this causes troubles
427 if (!(port->flags & ASYNC_CLOSING) &&
428 (do_clocal || tty_port_carrier_raised(port)))
430 if (signal_pending(current)) {
431 retval = -ERESTARTSYS;
438 finish_wait(&port->open_wait, &wait);
440 /* Update counts. A parallel hangup will have set count to zero and
441 we must not mess that up further */
442 spin_lock_irqsave(&port->lock, flags);
443 if (!tty_hung_up_p(filp))
445 port->blocked_open--;
447 port->flags |= ASYNC_NORMAL_ACTIVE;
448 spin_unlock_irqrestore(&port->lock, flags);
451 EXPORT_SYMBOL(tty_port_block_til_ready);
453 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
455 unsigned int bps = tty_get_baud_rate(tty);
459 timeout = (HZ * 10 * port->drain_delay) / bps;
460 timeout = max_t(long, timeout, HZ / 10);
464 schedule_timeout_interruptible(timeout);
467 /* Caller holds tty lock.
468 * NB: may drop and reacquire tty lock (in tty_wait_until_sent_from_close())
469 * so tty and tty port may have changed state (but not hung up or reopened).
471 int tty_port_close_start(struct tty_port *port,
472 struct tty_struct *tty, struct file *filp)
476 if (tty_hung_up_p(filp))
479 spin_lock_irqsave(&port->lock, flags);
480 if (tty->count == 1 && port->count != 1) {
482 "tty_port_close_start: tty->count = 1 port count = %d.\n",
486 if (--port->count < 0) {
487 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
493 spin_unlock_irqrestore(&port->lock, flags);
496 set_bit(ASYNCB_CLOSING, &port->flags);
497 spin_unlock_irqrestore(&port->lock, flags);
501 if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
502 /* Don't block on a stalled port, just pull the chain */
503 if (tty->flow_stopped)
504 tty_driver_flush_buffer(tty);
505 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
506 tty_wait_until_sent_from_close(tty, port->closing_wait);
507 if (port->drain_delay)
508 tty_port_drain_delay(port, tty);
510 /* Flush the ldisc buffering */
511 tty_ldisc_flush(tty);
513 /* Report to caller this is the last port reference */
516 EXPORT_SYMBOL(tty_port_close_start);
518 /* Caller holds tty lock */
519 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
523 tty_ldisc_flush(tty);
526 spin_lock_irqsave(&port->lock, flags);
528 if (port->blocked_open) {
529 spin_unlock_irqrestore(&port->lock, flags);
530 if (port->close_delay) {
531 msleep_interruptible(
532 jiffies_to_msecs(port->close_delay));
534 spin_lock_irqsave(&port->lock, flags);
535 wake_up_interruptible(&port->open_wait);
537 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
538 wake_up_interruptible(&port->close_wait);
539 spin_unlock_irqrestore(&port->lock, flags);
541 EXPORT_SYMBOL(tty_port_close_end);
546 * Caller holds tty lock
548 * NB: may drop and reacquire tty lock (in tty_port_close_start()->
549 * tty_wait_until_sent_from_close()) so tty and tty_port may have changed
550 * state (but not hung up or reopened).
552 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
555 if (tty_port_close_start(port, tty, filp) == 0)
557 tty_port_shutdown(port, tty);
558 set_bit(TTY_IO_ERROR, &tty->flags);
559 tty_port_close_end(port, tty);
560 tty_port_tty_set(port, NULL);
562 EXPORT_SYMBOL(tty_port_close);
565 * tty_port_install - generic tty->ops->install handler
566 * @port: tty_port of the device
567 * @driver: tty_driver for this device
568 * @tty: tty to be installed
570 * It is the same as tty_standard_install except the provided @port is linked
571 * to a concrete tty specified by @tty. Use this or tty_port_register_device
572 * (or both). Call tty_port_link_device as a last resort.
574 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
575 struct tty_struct *tty)
578 return tty_standard_install(driver, tty);
580 EXPORT_SYMBOL_GPL(tty_port_install);
585 * Caller holds tty lock.
587 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
588 * tty and tty_port may have changed state (eg., may be hung up now)
590 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
593 spin_lock_irq(&port->lock);
595 spin_unlock_irq(&port->lock);
596 tty_port_tty_set(port, tty);
599 * Do the device-specific open only if the hardware isn't
600 * already initialized. Serialize open and shutdown using the
604 mutex_lock(&port->mutex);
606 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
607 clear_bit(TTY_IO_ERROR, &tty->flags);
608 if (port->ops->activate) {
609 int retval = port->ops->activate(port, tty);
611 mutex_unlock(&port->mutex);
615 set_bit(ASYNCB_INITIALIZED, &port->flags);
617 mutex_unlock(&port->mutex);
618 return tty_port_block_til_ready(port, tty, filp);
621 EXPORT_SYMBOL(tty_port_open);