1 // SPDX-License-Identifier: GPL-2.0
6 #include <linux/types.h>
7 #include <linux/errno.h>
9 #include <linux/tty_driver.h>
10 #include <linux/tty_flip.h>
11 #include <linux/serial.h>
12 #include <linux/timer.h>
13 #include <linux/string.h>
14 #include <linux/slab.h>
15 #include <linux/sched/signal.h>
16 #include <linux/wait.h>
17 #include <linux/bitops.h>
18 #include <linux/delay.h>
19 #include <linux/module.h>
20 #include <linux/serdev.h>
23 static int tty_port_default_receive_buf(struct tty_port *port,
24 const unsigned char *p,
25 const unsigned char *f, size_t count)
28 struct tty_struct *tty;
29 struct tty_ldisc *disc;
31 tty = READ_ONCE(port->itty);
35 disc = tty_ldisc_ref(tty);
39 ret = tty_ldisc_receive_buf(disc, p, (char *)f, count);
41 tty_ldisc_deref(disc);
46 static void tty_port_default_wakeup(struct tty_port *port)
48 struct tty_struct *tty = tty_port_tty_get(port);
56 const struct tty_port_client_operations tty_port_default_client_ops = {
57 .receive_buf = tty_port_default_receive_buf,
58 .write_wakeup = tty_port_default_wakeup,
60 EXPORT_SYMBOL_GPL(tty_port_default_client_ops);
62 void tty_port_init(struct tty_port *port)
64 memset(port, 0, sizeof(*port));
65 tty_buffer_init(port);
66 init_waitqueue_head(&port->open_wait);
67 init_waitqueue_head(&port->delta_msr_wait);
68 mutex_init(&port->mutex);
69 mutex_init(&port->buf_mutex);
70 spin_lock_init(&port->lock);
71 port->close_delay = (50 * HZ) / 100;
72 port->closing_wait = (3000 * HZ) / 100;
73 port->client_ops = &tty_port_default_client_ops;
74 kref_init(&port->kref);
76 EXPORT_SYMBOL(tty_port_init);
79 * tty_port_link_device - link tty and tty_port
80 * @port: tty_port of the device
81 * @driver: tty_driver for this device
82 * @index: index of the tty
84 * Provide the tty layer with a link from a tty (specified by @index) to a
85 * tty_port (@port). Use this only if neither tty_port_register_device nor
86 * tty_port_install is used in the driver. If used, this has to be called before
87 * tty_register_driver.
89 void tty_port_link_device(struct tty_port *port,
90 struct tty_driver *driver, unsigned index)
92 if (WARN_ON(index >= driver->num))
94 driver->ports[index] = port;
96 EXPORT_SYMBOL_GPL(tty_port_link_device);
99 * tty_port_register_device - register tty device
100 * @port: tty_port of the device
101 * @driver: tty_driver for this device
102 * @index: index of the tty
103 * @device: parent if exists, otherwise NULL
105 * It is the same as tty_register_device except the provided @port is linked to
106 * a concrete tty specified by @index. Use this or tty_port_install (or both).
107 * Call tty_port_link_device as a last resort.
109 struct device *tty_port_register_device(struct tty_port *port,
110 struct tty_driver *driver, unsigned index,
111 struct device *device)
113 return tty_port_register_device_attr(port, driver, index, device, NULL, NULL);
115 EXPORT_SYMBOL_GPL(tty_port_register_device);
118 * tty_port_register_device_attr - register tty device
119 * @port: tty_port of the device
120 * @driver: tty_driver for this device
121 * @index: index of the tty
122 * @device: parent if exists, otherwise NULL
123 * @drvdata: Driver data to be set to device.
124 * @attr_grp: Attribute group to be set on device.
126 * It is the same as tty_register_device_attr except the provided @port is
127 * linked to a concrete tty specified by @index. Use this or tty_port_install
128 * (or both). Call tty_port_link_device as a last resort.
130 struct device *tty_port_register_device_attr(struct tty_port *port,
131 struct tty_driver *driver, unsigned index,
132 struct device *device, void *drvdata,
133 const struct attribute_group **attr_grp)
135 tty_port_link_device(port, driver, index);
136 return tty_register_device_attr(driver, index, device, drvdata,
139 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
142 * tty_port_register_device_attr_serdev - register tty or serdev device
143 * @port: tty_port of the device
144 * @driver: tty_driver for this device
145 * @index: index of the tty
146 * @device: parent if exists, otherwise NULL
147 * @drvdata: driver data for the device
148 * @attr_grp: attribute group for the device
150 * Register a serdev or tty device depending on if the parent device has any
151 * defined serdev clients or not.
153 struct device *tty_port_register_device_attr_serdev(struct tty_port *port,
154 struct tty_driver *driver, unsigned index,
155 struct device *device, void *drvdata,
156 const struct attribute_group **attr_grp)
160 tty_port_link_device(port, driver, index);
162 dev = serdev_tty_port_register(port, device, driver, index);
163 if (PTR_ERR(dev) != -ENODEV) {
164 /* Skip creating cdev if we registered a serdev device */
168 return tty_register_device_attr(driver, index, device, drvdata,
171 EXPORT_SYMBOL_GPL(tty_port_register_device_attr_serdev);
174 * tty_port_register_device_serdev - register tty or serdev device
175 * @port: tty_port of the device
176 * @driver: tty_driver for this device
177 * @index: index of the tty
178 * @device: parent if exists, otherwise NULL
180 * Register a serdev or tty device depending on if the parent device has any
181 * defined serdev clients or not.
183 struct device *tty_port_register_device_serdev(struct tty_port *port,
184 struct tty_driver *driver, unsigned index,
185 struct device *device)
187 return tty_port_register_device_attr_serdev(port, driver, index,
190 EXPORT_SYMBOL_GPL(tty_port_register_device_serdev);
193 * tty_port_unregister_device - deregister a tty or serdev device
194 * @port: tty_port of the device
195 * @driver: tty_driver for this device
196 * @index: index of the tty
198 * If a tty or serdev device is registered with a call to
199 * tty_port_register_device_serdev() then this function must be called when
200 * the device is gone.
202 void tty_port_unregister_device(struct tty_port *port,
203 struct tty_driver *driver, unsigned index)
207 ret = serdev_tty_port_unregister(port);
211 tty_unregister_device(driver, index);
213 EXPORT_SYMBOL_GPL(tty_port_unregister_device);
215 int tty_port_alloc_xmit_buf(struct tty_port *port)
217 /* We may sleep in get_zeroed_page() */
218 mutex_lock(&port->buf_mutex);
219 if (port->xmit_buf == NULL)
220 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
221 mutex_unlock(&port->buf_mutex);
222 if (port->xmit_buf == NULL)
226 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
228 void tty_port_free_xmit_buf(struct tty_port *port)
230 mutex_lock(&port->buf_mutex);
231 if (port->xmit_buf != NULL) {
232 free_page((unsigned long)port->xmit_buf);
233 port->xmit_buf = NULL;
235 mutex_unlock(&port->buf_mutex);
237 EXPORT_SYMBOL(tty_port_free_xmit_buf);
240 * tty_port_destroy -- destroy inited port
241 * @port: tty port to be destroyed
243 * When a port was initialized using tty_port_init, one has to destroy the
244 * port by this function. Either indirectly by using tty_port refcounting
245 * (tty_port_put) or directly if refcounting is not used.
247 void tty_port_destroy(struct tty_port *port)
249 tty_buffer_cancel_work(port);
250 tty_buffer_free_all(port);
252 EXPORT_SYMBOL(tty_port_destroy);
254 static void tty_port_destructor(struct kref *kref)
256 struct tty_port *port = container_of(kref, struct tty_port, kref);
258 /* check if last port ref was dropped before tty release */
259 if (WARN_ON(port->itty))
262 free_page((unsigned long)port->xmit_buf);
263 tty_port_destroy(port);
264 if (port->ops && port->ops->destruct)
265 port->ops->destruct(port);
270 void tty_port_put(struct tty_port *port)
273 kref_put(&port->kref, tty_port_destructor);
275 EXPORT_SYMBOL(tty_port_put);
278 * tty_port_tty_get - get a tty reference
281 * Return a refcount protected tty instance or NULL if the port is not
282 * associated with a tty (eg due to close or hangup)
284 struct tty_struct *tty_port_tty_get(struct tty_port *port)
287 struct tty_struct *tty;
289 spin_lock_irqsave(&port->lock, flags);
290 tty = tty_kref_get(port->tty);
291 spin_unlock_irqrestore(&port->lock, flags);
294 EXPORT_SYMBOL(tty_port_tty_get);
297 * tty_port_tty_set - set the tty of a port
301 * Associate the port and tty pair. Manages any internal refcounts.
302 * Pass NULL to deassociate a port
304 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
308 spin_lock_irqsave(&port->lock, flags);
309 tty_kref_put(port->tty);
310 port->tty = tty_kref_get(tty);
311 spin_unlock_irqrestore(&port->lock, flags);
313 EXPORT_SYMBOL(tty_port_tty_set);
315 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
317 mutex_lock(&port->mutex);
321 if (tty_port_initialized(port)) {
322 tty_port_set_initialized(port, 0);
324 * Drop DTR/RTS if HUPCL is set. This causes any attached
325 * modem to hang up the line.
327 if (tty && C_HUPCL(tty))
328 tty_port_lower_dtr_rts(port);
330 if (port->ops->shutdown)
331 port->ops->shutdown(port);
334 mutex_unlock(&port->mutex);
338 * tty_port_hangup - hangup helper
341 * Perform port level tty hangup flag and count changes. Drop the tty
344 * Caller holds tty lock.
346 void tty_port_hangup(struct tty_port *port)
348 struct tty_struct *tty;
351 spin_lock_irqsave(&port->lock, flags);
355 set_bit(TTY_IO_ERROR, &tty->flags);
357 spin_unlock_irqrestore(&port->lock, flags);
358 tty_port_set_active(port, 0);
359 tty_port_shutdown(port, tty);
361 wake_up_interruptible(&port->open_wait);
362 wake_up_interruptible(&port->delta_msr_wait);
364 EXPORT_SYMBOL(tty_port_hangup);
367 * tty_port_tty_hangup - helper to hang up a tty
370 * @check_clocal: hang only ttys with CLOCAL unset?
372 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
374 struct tty_struct *tty = tty_port_tty_get(port);
376 if (tty && (!check_clocal || !C_CLOCAL(tty)))
380 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
383 * tty_port_tty_wakeup - helper to wake up a tty
387 void tty_port_tty_wakeup(struct tty_port *port)
389 port->client_ops->write_wakeup(port);
391 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
394 * tty_port_carrier_raised - carrier raised check
397 * Wrapper for the carrier detect logic. For the moment this is used
398 * to hide some internal details. This will eventually become entirely
399 * internal to the tty port.
401 int tty_port_carrier_raised(struct tty_port *port)
403 if (port->ops->carrier_raised == NULL)
405 return port->ops->carrier_raised(port);
407 EXPORT_SYMBOL(tty_port_carrier_raised);
410 * tty_port_raise_dtr_rts - Raise DTR/RTS
413 * Wrapper for the DTR/RTS raise logic. For the moment this is used
414 * to hide some internal details. This will eventually become entirely
415 * internal to the tty port.
417 void tty_port_raise_dtr_rts(struct tty_port *port)
419 if (port->ops->dtr_rts)
420 port->ops->dtr_rts(port, 1);
422 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
425 * tty_port_lower_dtr_rts - Lower DTR/RTS
428 * Wrapper for the DTR/RTS raise logic. For the moment this is used
429 * to hide some internal details. This will eventually become entirely
430 * internal to the tty port.
432 void tty_port_lower_dtr_rts(struct tty_port *port)
434 if (port->ops->dtr_rts)
435 port->ops->dtr_rts(port, 0);
437 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
440 * tty_port_block_til_ready - Waiting logic for tty open
441 * @port: the tty port being opened
442 * @tty: the tty device being bound
443 * @filp: the file pointer of the opener or NULL
445 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
447 * - hangup (both before and during)
448 * - non blocking open
451 * - port flags and counts
453 * The passed tty_port must implement the carrier_raised method if it can
454 * do carrier detect and the dtr_rts method if it supports software
455 * management of these lines. Note that the dtr/rts raise is done each
456 * iteration as a hangup may have previously dropped them while we wait.
458 * Caller holds tty lock.
460 * NB: May drop and reacquire tty lock when blocking, so tty and tty_port
461 * may have changed state (eg., may have been hung up).
463 int tty_port_block_til_ready(struct tty_port *port,
464 struct tty_struct *tty, struct file *filp)
466 int do_clocal = 0, retval;
470 /* if non-blocking mode is set we can pass directly to open unless
471 the port has just hung up or is in another error state */
472 if (tty_io_error(tty)) {
473 tty_port_set_active(port, 1);
476 if (filp == NULL || (filp->f_flags & O_NONBLOCK)) {
477 /* Indicate we are open */
479 tty_port_raise_dtr_rts(port);
480 tty_port_set_active(port, 1);
487 /* Block waiting until we can proceed. We may need to wait for the
488 carrier, but we must also wait for any close that is in progress
489 before the next open may complete */
493 /* The port lock protects the port counts */
494 spin_lock_irqsave(&port->lock, flags);
496 port->blocked_open++;
497 spin_unlock_irqrestore(&port->lock, flags);
500 /* Indicate we are open */
501 if (C_BAUD(tty) && tty_port_initialized(port))
502 tty_port_raise_dtr_rts(port);
504 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
505 /* Check for a hangup or uninitialised port.
506 Return accordingly */
507 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
508 if (port->flags & ASYNC_HUP_NOTIFY)
511 retval = -ERESTARTSYS;
515 * Probe the carrier. For devices with no carrier detect
516 * tty_port_carrier_raised will always return true.
517 * Never ask drivers if CLOCAL is set, this causes troubles
520 if (do_clocal || tty_port_carrier_raised(port))
522 if (signal_pending(current)) {
523 retval = -ERESTARTSYS;
530 finish_wait(&port->open_wait, &wait);
532 /* Update counts. A parallel hangup will have set count to zero and
533 we must not mess that up further */
534 spin_lock_irqsave(&port->lock, flags);
535 if (!tty_hung_up_p(filp))
537 port->blocked_open--;
538 spin_unlock_irqrestore(&port->lock, flags);
540 tty_port_set_active(port, 1);
543 EXPORT_SYMBOL(tty_port_block_til_ready);
545 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
547 unsigned int bps = tty_get_baud_rate(tty);
551 timeout = (HZ * 10 * port->drain_delay) / bps;
552 timeout = max_t(long, timeout, HZ / 10);
556 schedule_timeout_interruptible(timeout);
559 /* Caller holds tty lock. */
560 int tty_port_close_start(struct tty_port *port,
561 struct tty_struct *tty, struct file *filp)
565 if (tty_hung_up_p(filp))
568 spin_lock_irqsave(&port->lock, flags);
569 if (tty->count == 1 && port->count != 1) {
570 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
574 if (--port->count < 0) {
575 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
581 spin_unlock_irqrestore(&port->lock, flags);
584 spin_unlock_irqrestore(&port->lock, flags);
588 if (tty_port_initialized(port)) {
589 /* Don't block on a stalled port, just pull the chain */
590 if (tty->flow_stopped)
591 tty_driver_flush_buffer(tty);
592 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
593 tty_wait_until_sent(tty, port->closing_wait);
594 if (port->drain_delay)
595 tty_port_drain_delay(port, tty);
597 /* Flush the ldisc buffering */
598 tty_ldisc_flush(tty);
600 /* Report to caller this is the last port reference */
603 EXPORT_SYMBOL(tty_port_close_start);
605 /* Caller holds tty lock */
606 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
610 tty_ldisc_flush(tty);
613 spin_lock_irqsave(&port->lock, flags);
615 if (port->blocked_open) {
616 spin_unlock_irqrestore(&port->lock, flags);
617 if (port->close_delay)
618 msleep_interruptible(jiffies_to_msecs(port->close_delay));
619 spin_lock_irqsave(&port->lock, flags);
620 wake_up_interruptible(&port->open_wait);
622 spin_unlock_irqrestore(&port->lock, flags);
623 tty_port_set_active(port, 0);
625 EXPORT_SYMBOL(tty_port_close_end);
630 * Caller holds tty lock
632 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
635 if (tty_port_close_start(port, tty, filp) == 0)
637 tty_port_shutdown(port, tty);
639 set_bit(TTY_IO_ERROR, &tty->flags);
640 tty_port_close_end(port, tty);
641 tty_port_tty_set(port, NULL);
643 EXPORT_SYMBOL(tty_port_close);
646 * tty_port_install - generic tty->ops->install handler
647 * @port: tty_port of the device
648 * @driver: tty_driver for this device
649 * @tty: tty to be installed
651 * It is the same as tty_standard_install except the provided @port is linked
652 * to a concrete tty specified by @tty. Use this or tty_port_register_device
653 * (or both). Call tty_port_link_device as a last resort.
655 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
656 struct tty_struct *tty)
659 return tty_standard_install(driver, tty);
661 EXPORT_SYMBOL_GPL(tty_port_install);
666 * Caller holds tty lock.
668 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
669 * tty and tty_port may have changed state (eg., may be hung up now)
671 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
674 spin_lock_irq(&port->lock);
676 spin_unlock_irq(&port->lock);
677 tty_port_tty_set(port, tty);
680 * Do the device-specific open only if the hardware isn't
681 * already initialized. Serialize open and shutdown using the
685 mutex_lock(&port->mutex);
687 if (!tty_port_initialized(port)) {
688 clear_bit(TTY_IO_ERROR, &tty->flags);
689 if (port->ops->activate) {
690 int retval = port->ops->activate(port, tty);
692 mutex_unlock(&port->mutex);
696 tty_port_set_initialized(port, 1);
698 mutex_unlock(&port->mutex);
699 return tty_port_block_til_ready(port, tty, filp);
702 EXPORT_SYMBOL(tty_port_open);