1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Tty port functions
4 */
5
6#include <linux/types.h>
7#include <linux/errno.h>
8#include <linux/tty.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>
21#include "tty.h"
22
23static size_t tty_port_default_receive_buf(struct tty_port *port, const u8 *p,
24 const u8 *f, size_t count)
25{
26 struct tty_struct *tty;
27 struct tty_ldisc *ld;
28
29 tty = READ_ONCE(port->itty);
30 if (!tty)
31 return 0;
32
33 ld = tty_ldisc_ref(tty);
34 if (!ld)
35 return 0;
36
37 count = tty_ldisc_receive_buf(ld, p, f, count);
38
39 tty_ldisc_deref(ld);
40
41 return count;
42}
43
44static void tty_port_default_lookahead_buf(struct tty_port *port, const u8 *p,
45 const u8 *f, size_t count)
46{
47 struct tty_struct *tty;
48 struct tty_ldisc *ld;
49
50 tty = READ_ONCE(port->itty);
51 if (!tty)
52 return;
53
54 ld = tty_ldisc_ref(tty);
55 if (!ld)
56 return;
57
58 if (ld->ops->lookahead_buf)
59 ld->ops->lookahead_buf(ld->tty, p, f, count);
60
61 tty_ldisc_deref(ld);
62}
63
64static void tty_port_default_wakeup(struct tty_port *port)
65{
66 struct tty_struct *tty = tty_port_tty_get(port);
67
68 if (tty) {
69 tty_wakeup(tty);
70 tty_kref_put(tty);
71 }
72}
73
74const struct tty_port_client_operations tty_port_default_client_ops = {
75 .receive_buf = tty_port_default_receive_buf,
76 .lookahead_buf = tty_port_default_lookahead_buf,
77 .write_wakeup = tty_port_default_wakeup,
78};
79EXPORT_SYMBOL_GPL(tty_port_default_client_ops);
80
81/**
82 * tty_port_init - initialize tty_port
83 * @port: tty_port to initialize
84 *
85 * Initializes the state of struct tty_port. When a port was initialized using
86 * this function, one has to destroy the port by tty_port_destroy(). Either
87 * indirectly by using &tty_port refcounting (tty_port_put()) or directly if
88 * refcounting is not used.
89 */
90void tty_port_init(struct tty_port *port)
91{
92 memset(port, 0, sizeof(*port));
93 tty_buffer_init(port);
94 init_waitqueue_head(&port->open_wait);
95 init_waitqueue_head(&port->delta_msr_wait);
96 mutex_init(&port->mutex);
97 mutex_init(&port->buf_mutex);
98 spin_lock_init(&port->lock);
99 port->close_delay = (50 * HZ) / 100;
100 port->closing_wait = (3000 * HZ) / 100;
101 port->client_ops = &tty_port_default_client_ops;
102 kref_init(kref: &port->kref);
103}
104EXPORT_SYMBOL(tty_port_init);
105
106/**
107 * tty_port_link_device - link tty and tty_port
108 * @port: tty_port of the device
109 * @driver: tty_driver for this device
110 * @index: index of the tty
111 *
112 * Provide the tty layer with a link from a tty (specified by @index) to a
113 * tty_port (@port). Use this only if neither tty_port_register_device() nor
114 * tty_port_install() is used in the driver. If used, this has to be called
115 * before tty_register_driver().
116 */
117void tty_port_link_device(struct tty_port *port,
118 struct tty_driver *driver, unsigned index)
119{
120 if (WARN_ON(index >= driver->num))
121 return;
122 driver->ports[index] = port;
123}
124EXPORT_SYMBOL_GPL(tty_port_link_device);
125
126/**
127 * tty_port_register_device - register tty device
128 * @port: tty_port of the device
129 * @driver: tty_driver for this device
130 * @index: index of the tty
131 * @device: parent if exists, otherwise NULL
132 *
133 * It is the same as tty_register_device() except the provided @port is linked
134 * to a concrete tty specified by @index. Use this or tty_port_install() (or
135 * both). Call tty_port_link_device() as a last resort.
136 */
137struct device *tty_port_register_device(struct tty_port *port,
138 struct tty_driver *driver, unsigned index,
139 struct device *device)
140{
141 return tty_port_register_device_attr(port, driver, index, device, NULL, NULL);
142}
143EXPORT_SYMBOL_GPL(tty_port_register_device);
144
145/**
146 * tty_port_register_device_attr - register tty device
147 * @port: tty_port of the device
148 * @driver: tty_driver for this device
149 * @index: index of the tty
150 * @device: parent if exists, otherwise NULL
151 * @drvdata: Driver data to be set to device.
152 * @attr_grp: Attribute group to be set on device.
153 *
154 * It is the same as tty_register_device_attr() except the provided @port is
155 * linked to a concrete tty specified by @index. Use this or tty_port_install()
156 * (or both). Call tty_port_link_device() as a last resort.
157 */
158struct device *tty_port_register_device_attr(struct tty_port *port,
159 struct tty_driver *driver, unsigned index,
160 struct device *device, void *drvdata,
161 const struct attribute_group **attr_grp)
162{
163 tty_port_link_device(port, driver, index);
164 return tty_register_device_attr(driver, index, device, drvdata,
165 attr_grp);
166}
167EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
168
169/**
170 * tty_port_register_device_attr_serdev - register tty or serdev device
171 * @port: tty_port of the device
172 * @driver: tty_driver for this device
173 * @index: index of the tty
174 * @device: parent if exists, otherwise NULL
175 * @drvdata: driver data for the device
176 * @attr_grp: attribute group for the device
177 *
178 * Register a serdev or tty device depending on if the parent device has any
179 * defined serdev clients or not.
180 */
181struct device *tty_port_register_device_attr_serdev(struct tty_port *port,
182 struct tty_driver *driver, unsigned index,
183 struct device *device, void *drvdata,
184 const struct attribute_group **attr_grp)
185{
186 struct device *dev;
187
188 tty_port_link_device(port, driver, index);
189
190 dev = serdev_tty_port_register(port, parent: device, drv: driver, idx: index);
191 if (PTR_ERR(ptr: dev) != -ENODEV) {
192 /* Skip creating cdev if we registered a serdev device */
193 return dev;
194 }
195
196 return tty_register_device_attr(driver, index, device, drvdata,
197 attr_grp);
198}
199EXPORT_SYMBOL_GPL(tty_port_register_device_attr_serdev);
200
201/**
202 * tty_port_register_device_serdev - register tty or serdev device
203 * @port: tty_port of the device
204 * @driver: tty_driver for this device
205 * @index: index of the tty
206 * @device: parent if exists, otherwise NULL
207 *
208 * Register a serdev or tty device depending on if the parent device has any
209 * defined serdev clients or not.
210 */
211struct device *tty_port_register_device_serdev(struct tty_port *port,
212 struct tty_driver *driver, unsigned index,
213 struct device *device)
214{
215 return tty_port_register_device_attr_serdev(port, driver, index,
216 device, NULL, NULL);
217}
218EXPORT_SYMBOL_GPL(tty_port_register_device_serdev);
219
220/**
221 * tty_port_unregister_device - deregister a tty or serdev device
222 * @port: tty_port of the device
223 * @driver: tty_driver for this device
224 * @index: index of the tty
225 *
226 * If a tty or serdev device is registered with a call to
227 * tty_port_register_device_serdev() then this function must be called when
228 * the device is gone.
229 */
230void tty_port_unregister_device(struct tty_port *port,
231 struct tty_driver *driver, unsigned index)
232{
233 int ret;
234
235 ret = serdev_tty_port_unregister(port);
236 if (ret == 0)
237 return;
238
239 tty_unregister_device(driver, index);
240}
241EXPORT_SYMBOL_GPL(tty_port_unregister_device);
242
243int tty_port_alloc_xmit_buf(struct tty_port *port)
244{
245 /* We may sleep in get_zeroed_page() */
246 mutex_lock(&port->buf_mutex);
247 if (port->xmit_buf == NULL) {
248 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
249 if (port->xmit_buf)
250 kfifo_init(&port->xmit_fifo, port->xmit_buf, PAGE_SIZE);
251 }
252 mutex_unlock(lock: &port->buf_mutex);
253 if (port->xmit_buf == NULL)
254 return -ENOMEM;
255 return 0;
256}
257EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
258
259void tty_port_free_xmit_buf(struct tty_port *port)
260{
261 mutex_lock(&port->buf_mutex);
262 free_page((unsigned long)port->xmit_buf);
263 port->xmit_buf = NULL;
264 INIT_KFIFO(port->xmit_fifo);
265 mutex_unlock(lock: &port->buf_mutex);
266}
267EXPORT_SYMBOL(tty_port_free_xmit_buf);
268
269/**
270 * tty_port_destroy - destroy inited port
271 * @port: tty port to be destroyed
272 *
273 * When a port was initialized using tty_port_init(), one has to destroy the
274 * port by this function. Either indirectly by using &tty_port refcounting
275 * (tty_port_put()) or directly if refcounting is not used.
276 */
277void tty_port_destroy(struct tty_port *port)
278{
279 tty_buffer_cancel_work(port);
280 tty_buffer_free_all(port);
281}
282EXPORT_SYMBOL(tty_port_destroy);
283
284static void tty_port_destructor(struct kref *kref)
285{
286 struct tty_port *port = container_of(kref, struct tty_port, kref);
287
288 /* check if last port ref was dropped before tty release */
289 if (WARN_ON(port->itty))
290 return;
291 free_page((unsigned long)port->xmit_buf);
292 tty_port_destroy(port);
293 if (port->ops && port->ops->destruct)
294 port->ops->destruct(port);
295 else
296 kfree(objp: port);
297}
298
299/**
300 * tty_port_put - drop a reference to tty_port
301 * @port: port to drop a reference of (can be NULL)
302 *
303 * The final put will destroy and free up the @port using
304 * @port->ops->destruct() hook, or using kfree() if not provided.
305 */
306void tty_port_put(struct tty_port *port)
307{
308 if (port)
309 kref_put(kref: &port->kref, release: tty_port_destructor);
310}
311EXPORT_SYMBOL(tty_port_put);
312
313/**
314 * tty_port_tty_get - get a tty reference
315 * @port: tty port
316 *
317 * Return a refcount protected tty instance or %NULL if the port is not
318 * associated with a tty (eg due to close or hangup).
319 */
320struct tty_struct *tty_port_tty_get(struct tty_port *port)
321{
322 unsigned long flags;
323 struct tty_struct *tty;
324
325 spin_lock_irqsave(&port->lock, flags);
326 tty = tty_kref_get(tty: port->tty);
327 spin_unlock_irqrestore(lock: &port->lock, flags);
328 return tty;
329}
330EXPORT_SYMBOL(tty_port_tty_get);
331
332/**
333 * tty_port_tty_set - set the tty of a port
334 * @port: tty port
335 * @tty: the tty
336 *
337 * Associate the port and tty pair. Manages any internal refcounts. Pass %NULL
338 * to deassociate a port.
339 */
340void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
341{
342 unsigned long flags;
343
344 spin_lock_irqsave(&port->lock, flags);
345 tty_kref_put(tty: port->tty);
346 port->tty = tty_kref_get(tty);
347 spin_unlock_irqrestore(lock: &port->lock, flags);
348}
349EXPORT_SYMBOL(tty_port_tty_set);
350
351/**
352 * tty_port_shutdown - internal helper to shutdown the device
353 * @port: tty port to be shut down
354 * @tty: the associated tty
355 *
356 * It is used by tty_port_hangup() and tty_port_close(). Its task is to
357 * shutdown the device if it was initialized (note consoles remain
358 * functioning). It lowers DTR/RTS (if @tty has HUPCL set) and invokes
359 * @port->ops->shutdown().
360 */
361static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
362{
363 mutex_lock(&port->mutex);
364 if (port->console)
365 goto out;
366
367 if (tty_port_initialized(port)) {
368 tty_port_set_initialized(port, val: false);
369 /*
370 * Drop DTR/RTS if HUPCL is set. This causes any attached
371 * modem to hang up the line.
372 */
373 if (tty && C_HUPCL(tty))
374 tty_port_lower_dtr_rts(port);
375
376 if (port->ops->shutdown)
377 port->ops->shutdown(port);
378 }
379out:
380 mutex_unlock(lock: &port->mutex);
381}
382
383/**
384 * tty_port_hangup - hangup helper
385 * @port: tty port
386 *
387 * Perform port level tty hangup flag and count changes. Drop the tty
388 * reference.
389 *
390 * Caller holds tty lock.
391 */
392void tty_port_hangup(struct tty_port *port)
393{
394 struct tty_struct *tty;
395 unsigned long flags;
396
397 spin_lock_irqsave(&port->lock, flags);
398 port->count = 0;
399 tty = port->tty;
400 if (tty)
401 set_bit(TTY_IO_ERROR, addr: &tty->flags);
402 port->tty = NULL;
403 spin_unlock_irqrestore(lock: &port->lock, flags);
404 tty_port_set_active(port, val: false);
405 tty_port_shutdown(port, tty);
406 tty_kref_put(tty);
407 wake_up_interruptible(&port->open_wait);
408 wake_up_interruptible(&port->delta_msr_wait);
409}
410EXPORT_SYMBOL(tty_port_hangup);
411
412/**
413 * tty_port_tty_hangup - helper to hang up a tty
414 * @port: tty port
415 * @check_clocal: hang only ttys with %CLOCAL unset?
416 */
417void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
418{
419 struct tty_struct *tty = tty_port_tty_get(port);
420
421 if (tty && (!check_clocal || !C_CLOCAL(tty)))
422 tty_hangup(tty);
423 tty_kref_put(tty);
424}
425EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
426
427/**
428 * tty_port_tty_wakeup - helper to wake up a tty
429 * @port: tty port
430 */
431void tty_port_tty_wakeup(struct tty_port *port)
432{
433 port->client_ops->write_wakeup(port);
434}
435EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
436
437/**
438 * tty_port_carrier_raised - carrier raised check
439 * @port: tty port
440 *
441 * Wrapper for the carrier detect logic. For the moment this is used
442 * to hide some internal details. This will eventually become entirely
443 * internal to the tty port.
444 */
445bool tty_port_carrier_raised(struct tty_port *port)
446{
447 if (port->ops->carrier_raised == NULL)
448 return true;
449 return port->ops->carrier_raised(port);
450}
451EXPORT_SYMBOL(tty_port_carrier_raised);
452
453/**
454 * tty_port_raise_dtr_rts - Raise DTR/RTS
455 * @port: tty port
456 *
457 * Wrapper for the DTR/RTS raise logic. For the moment this is used to hide
458 * some internal details. This will eventually become entirely internal to the
459 * tty port.
460 */
461void tty_port_raise_dtr_rts(struct tty_port *port)
462{
463 if (port->ops->dtr_rts)
464 port->ops->dtr_rts(port, true);
465}
466EXPORT_SYMBOL(tty_port_raise_dtr_rts);
467
468/**
469 * tty_port_lower_dtr_rts - Lower DTR/RTS
470 * @port: tty port
471 *
472 * Wrapper for the DTR/RTS raise logic. For the moment this is used to hide
473 * some internal details. This will eventually become entirely internal to the
474 * tty port.
475 */
476void tty_port_lower_dtr_rts(struct tty_port *port)
477{
478 if (port->ops->dtr_rts)
479 port->ops->dtr_rts(port, false);
480}
481EXPORT_SYMBOL(tty_port_lower_dtr_rts);
482
483/**
484 * tty_port_block_til_ready - Waiting logic for tty open
485 * @port: the tty port being opened
486 * @tty: the tty device being bound
487 * @filp: the file pointer of the opener or %NULL
488 *
489 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
490 * Handles:
491 *
492 * - hangup (both before and during)
493 * - non blocking open
494 * - rts/dtr/dcd
495 * - signals
496 * - port flags and counts
497 *
498 * The passed @port must implement the @port->ops->carrier_raised method if it
499 * can do carrier detect and the @port->ops->dtr_rts method if it supports
500 * software management of these lines. Note that the dtr/rts raise is done each
501 * iteration as a hangup may have previously dropped them while we wait.
502 *
503 * Caller holds tty lock.
504 *
505 * Note: May drop and reacquire tty lock when blocking, so @tty and @port may
506 * have changed state (eg., may have been hung up).
507 */
508int tty_port_block_til_ready(struct tty_port *port,
509 struct tty_struct *tty, struct file *filp)
510{
511 int do_clocal = 0, retval;
512 unsigned long flags;
513 DEFINE_WAIT(wait);
514
515 /* if non-blocking mode is set we can pass directly to open unless
516 * the port has just hung up or is in another error state.
517 */
518 if (tty_io_error(tty)) {
519 tty_port_set_active(port, val: true);
520 return 0;
521 }
522 if (filp == NULL || (filp->f_flags & O_NONBLOCK)) {
523 /* Indicate we are open */
524 if (C_BAUD(tty))
525 tty_port_raise_dtr_rts(port);
526 tty_port_set_active(port, val: true);
527 return 0;
528 }
529
530 if (C_CLOCAL(tty))
531 do_clocal = 1;
532
533 /* Block waiting until we can proceed. We may need to wait for the
534 * carrier, but we must also wait for any close that is in progress
535 * before the next open may complete.
536 */
537
538 retval = 0;
539
540 /* The port lock protects the port counts */
541 spin_lock_irqsave(&port->lock, flags);
542 port->count--;
543 port->blocked_open++;
544 spin_unlock_irqrestore(lock: &port->lock, flags);
545
546 while (1) {
547 /* Indicate we are open */
548 if (C_BAUD(tty) && tty_port_initialized(port))
549 tty_port_raise_dtr_rts(port);
550
551 prepare_to_wait(wq_head: &port->open_wait, wq_entry: &wait, TASK_INTERRUPTIBLE);
552 /* Check for a hangup or uninitialised port.
553 * Return accordingly.
554 */
555 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
556 if (port->flags & ASYNC_HUP_NOTIFY)
557 retval = -EAGAIN;
558 else
559 retval = -ERESTARTSYS;
560 break;
561 }
562 /*
563 * Probe the carrier. For devices with no carrier detect
564 * tty_port_carrier_raised will always return true.
565 * Never ask drivers if CLOCAL is set, this causes troubles
566 * on some hardware.
567 */
568 if (do_clocal || tty_port_carrier_raised(port))
569 break;
570 if (signal_pending(current)) {
571 retval = -ERESTARTSYS;
572 break;
573 }
574 tty_unlock(tty);
575 schedule();
576 tty_lock(tty);
577 }
578 finish_wait(wq_head: &port->open_wait, wq_entry: &wait);
579
580 /* Update counts. A parallel hangup will have set count to zero and
581 * we must not mess that up further.
582 */
583 spin_lock_irqsave(&port->lock, flags);
584 if (!tty_hung_up_p(filp))
585 port->count++;
586 port->blocked_open--;
587 spin_unlock_irqrestore(lock: &port->lock, flags);
588 if (retval == 0)
589 tty_port_set_active(port, val: true);
590 return retval;
591}
592EXPORT_SYMBOL(tty_port_block_til_ready);
593
594static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
595{
596 unsigned int bps = tty_get_baud_rate(tty);
597 long timeout;
598
599 if (bps > 1200) {
600 timeout = (HZ * 10 * port->drain_delay) / bps;
601 timeout = max_t(long, timeout, HZ / 10);
602 } else {
603 timeout = 2 * HZ;
604 }
605 schedule_timeout_interruptible(timeout);
606}
607
608/**
609 * tty_port_close_start - helper for tty->ops->close, part 1/2
610 * @port: tty_port of the device
611 * @tty: tty being closed
612 * @filp: passed file pointer
613 *
614 * Decrements and checks open count. Flushes the port if this is the last
615 * close. That means, dropping the data from the outpu buffer on the device and
616 * waiting for sending logic to finish. The rest of close handling is performed
617 * in tty_port_close_end().
618 *
619 * Locking: Caller holds tty lock.
620 *
621 * Return: 1 if this is the last close, otherwise 0
622 */
623int tty_port_close_start(struct tty_port *port,
624 struct tty_struct *tty, struct file *filp)
625{
626 unsigned long flags;
627
628 if (tty_hung_up_p(filp))
629 return 0;
630
631 spin_lock_irqsave(&port->lock, flags);
632 if (tty->count == 1 && port->count != 1) {
633 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
634 port->count);
635 port->count = 1;
636 }
637 if (--port->count < 0) {
638 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
639 port->count);
640 port->count = 0;
641 }
642
643 if (port->count) {
644 spin_unlock_irqrestore(lock: &port->lock, flags);
645 return 0;
646 }
647 spin_unlock_irqrestore(lock: &port->lock, flags);
648
649 tty->closing = 1;
650
651 if (tty_port_initialized(port)) {
652 /* Don't block on a stalled port, just pull the chain */
653 if (tty->flow.tco_stopped)
654 tty_driver_flush_buffer(tty);
655 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
656 tty_wait_until_sent(tty, timeout: port->closing_wait);
657 if (port->drain_delay)
658 tty_port_drain_delay(port, tty);
659 }
660 /* Flush the ldisc buffering */
661 tty_ldisc_flush(tty);
662
663 /* Report to caller this is the last port reference */
664 return 1;
665}
666EXPORT_SYMBOL(tty_port_close_start);
667
668/**
669 * tty_port_close_end - helper for tty->ops->close, part 2/2
670 * @port: tty_port of the device
671 * @tty: tty being closed
672 *
673 * This is a continuation of the first part: tty_port_close_start(). This
674 * should be called after turning off the device. It flushes the data from the
675 * line discipline and delays the close by @port->close_delay.
676 *
677 * Locking: Caller holds tty lock.
678 */
679void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
680{
681 unsigned long flags;
682
683 tty_ldisc_flush(tty);
684 tty->closing = 0;
685
686 spin_lock_irqsave(&port->lock, flags);
687
688 if (port->blocked_open) {
689 spin_unlock_irqrestore(lock: &port->lock, flags);
690 if (port->close_delay)
691 msleep_interruptible(msecs: jiffies_to_msecs(j: port->close_delay));
692 spin_lock_irqsave(&port->lock, flags);
693 wake_up_interruptible(&port->open_wait);
694 }
695 spin_unlock_irqrestore(lock: &port->lock, flags);
696 tty_port_set_active(port, val: false);
697}
698EXPORT_SYMBOL(tty_port_close_end);
699
700/**
701 * tty_port_close - generic tty->ops->close handler
702 * @port: tty_port of the device
703 * @tty: tty being closed
704 * @filp: passed file pointer
705 *
706 * It is a generic helper to be used in driver's @tty->ops->close. It wraps a
707 * sequence of tty_port_close_start(), tty_port_shutdown(), and
708 * tty_port_close_end(). The latter two are called only if this is the last
709 * close. See the respective functions for the details.
710 *
711 * Locking: Caller holds tty lock
712 */
713void tty_port_close(struct tty_port *port, struct tty_struct *tty,
714 struct file *filp)
715{
716 if (tty_port_close_start(port, tty, filp) == 0)
717 return;
718 tty_port_shutdown(port, tty);
719 if (!port->console)
720 set_bit(TTY_IO_ERROR, addr: &tty->flags);
721 tty_port_close_end(port, tty);
722 tty_port_tty_set(port, NULL);
723}
724EXPORT_SYMBOL(tty_port_close);
725
726/**
727 * tty_port_install - generic tty->ops->install handler
728 * @port: tty_port of the device
729 * @driver: tty_driver for this device
730 * @tty: tty to be installed
731 *
732 * It is the same as tty_standard_install() except the provided @port is linked
733 * to a concrete tty specified by @tty. Use this or tty_port_register_device()
734 * (or both). Call tty_port_link_device() as a last resort.
735 */
736int tty_port_install(struct tty_port *port, struct tty_driver *driver,
737 struct tty_struct *tty)
738{
739 tty->port = port;
740 return tty_standard_install(driver, tty);
741}
742EXPORT_SYMBOL_GPL(tty_port_install);
743
744/**
745 * tty_port_open - generic tty->ops->open handler
746 * @port: tty_port of the device
747 * @tty: tty to be opened
748 * @filp: passed file pointer
749 *
750 * It is a generic helper to be used in driver's @tty->ops->open. It activates
751 * the devices using @port->ops->activate if not active already. And waits for
752 * the device to be ready using tty_port_block_til_ready() (e.g. raises
753 * DTR/CTS and waits for carrier).
754 *
755 * Note that @port->ops->shutdown is not called when @port->ops->activate
756 * returns an error (on the contrary, @tty->ops->close is).
757 *
758 * Locking: Caller holds tty lock.
759 *
760 * Note: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
761 * @tty and @port may have changed state (eg., may be hung up now).
762 */
763int tty_port_open(struct tty_port *port, struct tty_struct *tty,
764 struct file *filp)
765{
766 spin_lock_irq(lock: &port->lock);
767 ++port->count;
768 spin_unlock_irq(lock: &port->lock);
769 tty_port_tty_set(port, tty);
770
771 /*
772 * Do the device-specific open only if the hardware isn't
773 * already initialized. Serialize open and shutdown using the
774 * port mutex.
775 */
776
777 mutex_lock(&port->mutex);
778
779 if (!tty_port_initialized(port)) {
780 clear_bit(TTY_IO_ERROR, addr: &tty->flags);
781 if (port->ops->activate) {
782 int retval = port->ops->activate(port, tty);
783
784 if (retval) {
785 mutex_unlock(lock: &port->mutex);
786 return retval;
787 }
788 }
789 tty_port_set_initialized(port, val: true);
790 }
791 mutex_unlock(lock: &port->mutex);
792 return tty_port_block_til_ready(port, tty, filp);
793}
794EXPORT_SYMBOL(tty_port_open);
795

source code of linux/drivers/tty/tty_port.c