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 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);
124 static void tty_port_destructor(struct kref *kref)
126 struct tty_port *port = container_of(kref, struct tty_port, kref);
128 free_page((unsigned long)port->xmit_buf);
129 if (port->ops->destruct)
130 port->ops->destruct(port);
135 void tty_port_put(struct tty_port *port)
138 kref_put(&port->kref, tty_port_destructor);
140 EXPORT_SYMBOL(tty_port_put);
143 * tty_port_tty_get - get a tty reference
146 * Return a refcount protected tty instance or NULL if the port is not
147 * associated with a tty (eg due to close or hangup)
150 struct tty_struct *tty_port_tty_get(struct tty_port *port)
153 struct tty_struct *tty;
155 spin_lock_irqsave(&port->lock, flags);
156 tty = tty_kref_get(port->tty);
157 spin_unlock_irqrestore(&port->lock, flags);
160 EXPORT_SYMBOL(tty_port_tty_get);
163 * tty_port_tty_set - set the tty of a port
167 * Associate the port and tty pair. Manages any internal refcounts.
168 * Pass NULL to deassociate a port
171 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
175 spin_lock_irqsave(&port->lock, flags);
177 tty_kref_put(port->tty);
178 port->tty = tty_kref_get(tty);
179 spin_unlock_irqrestore(&port->lock, flags);
181 EXPORT_SYMBOL(tty_port_tty_set);
183 static void tty_port_shutdown(struct tty_port *port)
185 mutex_lock(&port->mutex);
186 if (port->ops->shutdown && !port->console &&
187 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
188 port->ops->shutdown(port);
189 mutex_unlock(&port->mutex);
193 * tty_port_hangup - hangup helper
196 * Perform port level tty hangup flag and count changes. Drop the tty
200 void tty_port_hangup(struct tty_port *port)
204 spin_lock_irqsave(&port->lock, flags);
206 port->flags &= ~ASYNC_NORMAL_ACTIVE;
208 set_bit(TTY_IO_ERROR, &port->tty->flags);
209 tty_kref_put(port->tty);
212 spin_unlock_irqrestore(&port->lock, flags);
213 wake_up_interruptible(&port->open_wait);
214 wake_up_interruptible(&port->delta_msr_wait);
215 tty_port_shutdown(port);
217 EXPORT_SYMBOL(tty_port_hangup);
220 * tty_port_carrier_raised - carrier raised check
223 * Wrapper for the carrier detect logic. For the moment this is used
224 * to hide some internal details. This will eventually become entirely
225 * internal to the tty port.
228 int tty_port_carrier_raised(struct tty_port *port)
230 if (port->ops->carrier_raised == NULL)
232 return port->ops->carrier_raised(port);
234 EXPORT_SYMBOL(tty_port_carrier_raised);
237 * tty_port_raise_dtr_rts - Raise DTR/RTS
240 * Wrapper for the DTR/RTS raise logic. For the moment this is used
241 * to hide some internal details. This will eventually become entirely
242 * internal to the tty port.
245 void tty_port_raise_dtr_rts(struct tty_port *port)
247 if (port->ops->dtr_rts)
248 port->ops->dtr_rts(port, 1);
250 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
253 * tty_port_lower_dtr_rts - Lower DTR/RTS
256 * Wrapper for the DTR/RTS raise logic. For the moment this is used
257 * to hide some internal details. This will eventually become entirely
258 * internal to the tty port.
261 void tty_port_lower_dtr_rts(struct tty_port *port)
263 if (port->ops->dtr_rts)
264 port->ops->dtr_rts(port, 0);
266 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
269 * tty_port_block_til_ready - Waiting logic for tty open
270 * @port: the tty port being opened
271 * @tty: the tty device being bound
272 * @filp: the file pointer of the opener
274 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
276 * - hangup (both before and during)
277 * - non blocking open
280 * - port flags and counts
282 * The passed tty_port must implement the carrier_raised method if it can
283 * do carrier detect and the dtr_rts method if it supports software
284 * management of these lines. Note that the dtr/rts raise is done each
285 * iteration as a hangup may have previously dropped them while we wait.
288 int tty_port_block_til_ready(struct tty_port *port,
289 struct tty_struct *tty, struct file *filp)
291 int do_clocal = 0, retval;
295 /* block if port is in the process of being closed */
296 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
297 wait_event_interruptible_tty(tty, port->close_wait,
298 !(port->flags & ASYNC_CLOSING));
299 if (port->flags & ASYNC_HUP_NOTIFY)
305 /* if non-blocking mode is set we can pass directly to open unless
306 the port has just hung up or is in another error state */
307 if (tty->flags & (1 << TTY_IO_ERROR)) {
308 port->flags |= ASYNC_NORMAL_ACTIVE;
311 if (filp->f_flags & O_NONBLOCK) {
312 /* Indicate we are open */
313 if (tty->termios.c_cflag & CBAUD)
314 tty_port_raise_dtr_rts(port);
315 port->flags |= ASYNC_NORMAL_ACTIVE;
322 /* Block waiting until we can proceed. We may need to wait for the
323 carrier, but we must also wait for any close that is in progress
324 before the next open may complete */
328 /* The port lock protects the port counts */
329 spin_lock_irqsave(&port->lock, flags);
330 if (!tty_hung_up_p(filp))
332 port->blocked_open++;
333 spin_unlock_irqrestore(&port->lock, flags);
336 /* Indicate we are open */
337 if (tty->termios.c_cflag & CBAUD)
338 tty_port_raise_dtr_rts(port);
340 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
341 /* Check for a hangup or uninitialised port.
342 Return accordingly */
343 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
344 if (port->flags & ASYNC_HUP_NOTIFY)
347 retval = -ERESTARTSYS;
351 * Probe the carrier. For devices with no carrier detect
352 * tty_port_carrier_raised will always return true.
353 * Never ask drivers if CLOCAL is set, this causes troubles
356 if (!(port->flags & ASYNC_CLOSING) &&
357 (do_clocal || tty_port_carrier_raised(port)))
359 if (signal_pending(current)) {
360 retval = -ERESTARTSYS;
367 finish_wait(&port->open_wait, &wait);
369 /* Update counts. A parallel hangup will have set count to zero and
370 we must not mess that up further */
371 spin_lock_irqsave(&port->lock, flags);
372 if (!tty_hung_up_p(filp))
374 port->blocked_open--;
376 port->flags |= ASYNC_NORMAL_ACTIVE;
377 spin_unlock_irqrestore(&port->lock, flags);
380 EXPORT_SYMBOL(tty_port_block_til_ready);
382 int tty_port_close_start(struct tty_port *port,
383 struct tty_struct *tty, struct file *filp)
387 spin_lock_irqsave(&port->lock, flags);
388 if (tty_hung_up_p(filp)) {
389 spin_unlock_irqrestore(&port->lock, flags);
393 if (tty->count == 1 && port->count != 1) {
395 "tty_port_close_start: tty->count = 1 port count = %d.\n",
399 if (--port->count < 0) {
400 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
406 spin_unlock_irqrestore(&port->lock, flags);
408 port->ops->drop(port);
411 set_bit(ASYNCB_CLOSING, &port->flags);
413 spin_unlock_irqrestore(&port->lock, flags);
414 /* Don't block on a stalled port, just pull the chain */
415 if (tty->flow_stopped)
416 tty_driver_flush_buffer(tty);
417 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
418 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
419 tty_wait_until_sent_from_close(tty, port->closing_wait);
420 if (port->drain_delay) {
421 unsigned int bps = tty_get_baud_rate(tty);
425 timeout = max_t(long,
426 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
429 schedule_timeout_interruptible(timeout);
431 /* Flush the ldisc buffering */
432 tty_ldisc_flush(tty);
434 /* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
436 if (tty->termios.c_cflag & HUPCL)
437 tty_port_lower_dtr_rts(port);
439 /* Don't call port->drop for the last reference. Callers will want
440 to drop the last active reference in ->shutdown() or the tty
444 EXPORT_SYMBOL(tty_port_close_start);
446 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
450 spin_lock_irqsave(&port->lock, flags);
453 if (port->blocked_open) {
454 spin_unlock_irqrestore(&port->lock, flags);
455 if (port->close_delay) {
456 msleep_interruptible(
457 jiffies_to_msecs(port->close_delay));
459 spin_lock_irqsave(&port->lock, flags);
460 wake_up_interruptible(&port->open_wait);
462 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
463 wake_up_interruptible(&port->close_wait);
464 spin_unlock_irqrestore(&port->lock, flags);
466 EXPORT_SYMBOL(tty_port_close_end);
468 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
471 if (tty_port_close_start(port, tty, filp) == 0)
473 tty_port_shutdown(port);
474 set_bit(TTY_IO_ERROR, &tty->flags);
475 tty_port_close_end(port, tty);
476 tty_port_tty_set(port, NULL);
478 EXPORT_SYMBOL(tty_port_close);
481 * tty_port_install - generic tty->ops->install handler
482 * @port: tty_port of the device
483 * @driver: tty_driver for this device
484 * @tty: tty to be installed
486 * It is the same as tty_standard_install except the provided @port is linked
487 * to a concrete tty specified by @tty. Use this or tty_port_register_device
488 * (or both). Call tty_port_link_device as a last resort.
490 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
491 struct tty_struct *tty)
494 return tty_standard_install(driver, tty);
496 EXPORT_SYMBOL_GPL(tty_port_install);
498 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
501 spin_lock_irq(&port->lock);
502 if (!tty_hung_up_p(filp))
504 spin_unlock_irq(&port->lock);
505 tty_port_tty_set(port, tty);
508 * Do the device-specific open only if the hardware isn't
509 * already initialized. Serialize open and shutdown using the
513 mutex_lock(&port->mutex);
515 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
516 clear_bit(TTY_IO_ERROR, &tty->flags);
517 if (port->ops->activate) {
518 int retval = port->ops->activate(port, tty);
520 mutex_unlock(&port->mutex);
524 set_bit(ASYNCB_INITIALIZED, &port->flags);
526 mutex_unlock(&port->mutex);
527 return tty_port_block_til_ready(port, tty, filp);
530 EXPORT_SYMBOL(tty_port_open);