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.
473 if (tty_io_error(tty
)) {
474 tty_port_set_active(port
, 1);
477 if (filp
== NULL
|| (filp
->f_flags
& O_NONBLOCK
)) {
478 /* Indicate we are open */
480 tty_port_raise_dtr_rts(port
);
481 tty_port_set_active(port
, 1);
488 /* Block waiting until we can proceed. We may need to wait for the
489 * carrier, but we must also wait for any close that is in progress
490 * before the next open may complete.
495 /* The port lock protects the port counts */
496 spin_lock_irqsave(&port
->lock
, flags
);
498 port
->blocked_open
++;
499 spin_unlock_irqrestore(&port
->lock
, flags
);
502 /* Indicate we are open */
503 if (C_BAUD(tty
) && tty_port_initialized(port
))
504 tty_port_raise_dtr_rts(port
);
506 prepare_to_wait(&port
->open_wait
, &wait
, TASK_INTERRUPTIBLE
);
507 /* Check for a hangup or uninitialised port.
508 * Return accordingly.
510 if (tty_hung_up_p(filp
) || !tty_port_initialized(port
)) {
511 if (port
->flags
& ASYNC_HUP_NOTIFY
)
514 retval
= -ERESTARTSYS
;
518 * Probe the carrier. For devices with no carrier detect
519 * tty_port_carrier_raised will always return true.
520 * Never ask drivers if CLOCAL is set, this causes troubles
523 if (do_clocal
|| tty_port_carrier_raised(port
))
525 if (signal_pending(current
)) {
526 retval
= -ERESTARTSYS
;
533 finish_wait(&port
->open_wait
, &wait
);
535 /* Update counts. A parallel hangup will have set count to zero and
536 * we must not mess that up further.
538 spin_lock_irqsave(&port
->lock
, flags
);
539 if (!tty_hung_up_p(filp
))
541 port
->blocked_open
--;
542 spin_unlock_irqrestore(&port
->lock
, flags
);
544 tty_port_set_active(port
, 1);
547 EXPORT_SYMBOL(tty_port_block_til_ready
);
549 static void tty_port_drain_delay(struct tty_port
*port
, struct tty_struct
*tty
)
551 unsigned int bps
= tty_get_baud_rate(tty
);
555 timeout
= (HZ
* 10 * port
->drain_delay
) / bps
;
556 timeout
= max_t(long, timeout
, HZ
/ 10);
560 schedule_timeout_interruptible(timeout
);
563 /* Caller holds tty lock. */
564 int tty_port_close_start(struct tty_port
*port
,
565 struct tty_struct
*tty
, struct file
*filp
)
569 if (tty_hung_up_p(filp
))
572 spin_lock_irqsave(&port
->lock
, flags
);
573 if (tty
->count
== 1 && port
->count
!= 1) {
574 tty_warn(tty
, "%s: tty->count = 1 port count = %d\n", __func__
,
578 if (--port
->count
< 0) {
579 tty_warn(tty
, "%s: bad port count (%d)\n", __func__
,
585 spin_unlock_irqrestore(&port
->lock
, flags
);
588 spin_unlock_irqrestore(&port
->lock
, flags
);
592 if (tty_port_initialized(port
)) {
593 /* Don't block on a stalled port, just pull the chain */
594 if (tty
->flow
.tco_stopped
)
595 tty_driver_flush_buffer(tty
);
596 if (port
->closing_wait
!= ASYNC_CLOSING_WAIT_NONE
)
597 tty_wait_until_sent(tty
, port
->closing_wait
);
598 if (port
->drain_delay
)
599 tty_port_drain_delay(port
, tty
);
601 /* Flush the ldisc buffering */
602 tty_ldisc_flush(tty
);
604 /* Report to caller this is the last port reference */
607 EXPORT_SYMBOL(tty_port_close_start
);
609 /* Caller holds tty lock */
610 void tty_port_close_end(struct tty_port
*port
, struct tty_struct
*tty
)
614 tty_ldisc_flush(tty
);
617 spin_lock_irqsave(&port
->lock
, flags
);
619 if (port
->blocked_open
) {
620 spin_unlock_irqrestore(&port
->lock
, flags
);
621 if (port
->close_delay
)
622 msleep_interruptible(jiffies_to_msecs(port
->close_delay
));
623 spin_lock_irqsave(&port
->lock
, flags
);
624 wake_up_interruptible(&port
->open_wait
);
626 spin_unlock_irqrestore(&port
->lock
, flags
);
627 tty_port_set_active(port
, 0);
629 EXPORT_SYMBOL(tty_port_close_end
);
634 * Caller holds tty lock
636 void tty_port_close(struct tty_port
*port
, struct tty_struct
*tty
,
639 if (tty_port_close_start(port
, tty
, filp
) == 0)
641 tty_port_shutdown(port
, tty
);
643 set_bit(TTY_IO_ERROR
, &tty
->flags
);
644 tty_port_close_end(port
, tty
);
645 tty_port_tty_set(port
, NULL
);
647 EXPORT_SYMBOL(tty_port_close
);
650 * tty_port_install - generic tty->ops->install handler
651 * @port: tty_port of the device
652 * @driver: tty_driver for this device
653 * @tty: tty to be installed
655 * It is the same as tty_standard_install except the provided @port is linked
656 * to a concrete tty specified by @tty. Use this or tty_port_register_device
657 * (or both). Call tty_port_link_device as a last resort.
659 int tty_port_install(struct tty_port
*port
, struct tty_driver
*driver
,
660 struct tty_struct
*tty
)
663 return tty_standard_install(driver
, tty
);
665 EXPORT_SYMBOL_GPL(tty_port_install
);
670 * Caller holds tty lock.
672 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
673 * tty and tty_port may have changed state (eg., may be hung up now)
675 int tty_port_open(struct tty_port
*port
, struct tty_struct
*tty
,
678 spin_lock_irq(&port
->lock
);
680 spin_unlock_irq(&port
->lock
);
681 tty_port_tty_set(port
, tty
);
684 * Do the device-specific open only if the hardware isn't
685 * already initialized. Serialize open and shutdown using the
689 mutex_lock(&port
->mutex
);
691 if (!tty_port_initialized(port
)) {
692 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
693 if (port
->ops
->activate
) {
694 int retval
= port
->ops
->activate(port
, tty
);
697 mutex_unlock(&port
->mutex
);
701 tty_port_set_initialized(port
, 1);
703 mutex_unlock(&port
->mutex
);
704 return tty_port_block_til_ready(port
, tty
, filp
);
706 EXPORT_SYMBOL(tty_port_open
);