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