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