blob: 2f1061a9d926367ff1ae6c106db0cb891f067786 [file] [log] [blame]
Greg Kroah-Hartmane3b3d0f2017-11-06 18:11:51 +01001// SPDX-License-Identifier: GPL-2.0
Alan Cox9e485652008-10-13 10:37:07 +01002/*
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>
Alan Cox3e616962009-01-02 13:45:26 +000011#include <linux/serial.h>
Alan Cox9e485652008-10-13 10:37:07 +010012#include <linux/timer.h>
13#include <linux/string.h>
14#include <linux/slab.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010015#include <linux/sched/signal.h>
Alan Cox9e485652008-10-13 10:37:07 +010016#include <linux/wait.h>
17#include <linux/bitops.h>
18#include <linux/delay.h>
19#include <linux/module.h>
Johan Hovold8cde11b2017-05-18 17:33:00 +020020#include <linux/serdev.h>
Greg Kroah-Hartman98602c02021-04-08 14:51:22 +020021#include "tty.h"
Alan Cox9e485652008-10-13 10:37:07 +010022
Rob Herringc3485ee2017-02-02 13:48:05 -060023static int tty_port_default_receive_buf(struct tty_port *port,
24 const unsigned char *p,
25 const unsigned char *f, size_t count)
26{
27 int ret;
28 struct tty_struct *tty;
29 struct tty_ldisc *disc;
30
31 tty = READ_ONCE(port->itty);
32 if (!tty)
33 return 0;
34
35 disc = tty_ldisc_ref(tty);
36 if (!disc)
37 return 0;
38
39 ret = tty_ldisc_receive_buf(disc, p, (char *)f, count);
40
41 tty_ldisc_deref(disc);
42
43 return ret;
44}
45
46static void tty_port_default_wakeup(struct tty_port *port)
47{
48 struct tty_struct *tty = tty_port_tty_get(port);
49
50 if (tty) {
51 tty_wakeup(tty);
52 tty_kref_put(tty);
53 }
54}
55
Johan Hovold0c5aae52020-02-10 15:57:30 +010056const struct tty_port_client_operations tty_port_default_client_ops = {
Rob Herringc3485ee2017-02-02 13:48:05 -060057 .receive_buf = tty_port_default_receive_buf,
58 .write_wakeup = tty_port_default_wakeup,
59};
Johan Hovold0c5aae52020-02-10 15:57:30 +010060EXPORT_SYMBOL_GPL(tty_port_default_client_ops);
Rob Herringc3485ee2017-02-02 13:48:05 -060061
Alan Cox9e485652008-10-13 10:37:07 +010062void tty_port_init(struct tty_port *port)
63{
64 memset(port, 0, sizeof(*port));
Jiri Slabyecbbfd42012-10-18 22:26:47 +020065 tty_buffer_init(port);
Alan Cox9e485652008-10-13 10:37:07 +010066 init_waitqueue_head(&port->open_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -070067 init_waitqueue_head(&port->delta_msr_wait);
Alan Cox9e485652008-10-13 10:37:07 +010068 mutex_init(&port->mutex);
Alan Cox44e49092009-11-30 13:16:41 +000069 mutex_init(&port->buf_mutex);
Alan Cox4a90f092008-10-13 10:39:46 +010070 spin_lock_init(&port->lock);
Alan Cox9e485652008-10-13 10:37:07 +010071 port->close_delay = (50 * HZ) / 100;
72 port->closing_wait = (3000 * HZ) / 100;
Johan Hovold0c5aae52020-02-10 15:57:30 +010073 port->client_ops = &tty_port_default_client_ops;
Alan Cox568aafc2009-11-30 13:17:14 +000074 kref_init(&port->kref);
Alan Cox9e485652008-10-13 10:37:07 +010075}
76EXPORT_SYMBOL(tty_port_init);
77
Jiri Slaby72a33bf2012-08-07 21:47:49 +020078/**
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020079 * tty_port_link_device - link tty and tty_port
80 * @port: tty_port of the device
81 * @driver: tty_driver for this device
82 * @index: index of the tty
83 *
Antonio Borneo1926e5d2017-09-08 08:59:42 +020084 * Provide the tty layer with a link from a tty (specified by @index) to a
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020085 * tty_port (@port). Use this only if neither tty_port_register_device nor
86 * tty_port_install is used in the driver. If used, this has to be called before
87 * tty_register_driver.
88 */
89void tty_port_link_device(struct tty_port *port,
90 struct tty_driver *driver, unsigned index)
91{
92 if (WARN_ON(index >= driver->num))
93 return;
Sudip Mukherjee273f63292019-12-27 17:44:34 +000094 driver->ports[index] = port;
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020095}
96EXPORT_SYMBOL_GPL(tty_port_link_device);
97
98/**
Jiri Slaby72a33bf2012-08-07 21:47:49 +020099 * tty_port_register_device - register tty device
100 * @port: tty_port of the device
101 * @driver: tty_driver for this device
102 * @index: index of the tty
103 * @device: parent if exists, otherwise NULL
104 *
105 * It is the same as tty_register_device except the provided @port is linked to
106 * a concrete tty specified by @index. Use this or tty_port_install (or both).
107 * Call tty_port_link_device as a last resort.
108 */
Jiri Slaby057eb852012-06-04 13:35:37 +0200109struct device *tty_port_register_device(struct tty_port *port,
110 struct tty_driver *driver, unsigned index,
111 struct device *device)
112{
Rob Herring30863652017-01-16 16:54:30 -0600113 return tty_port_register_device_attr(port, driver, index, device, NULL, NULL);
Jiri Slaby057eb852012-06-04 13:35:37 +0200114}
115EXPORT_SYMBOL_GPL(tty_port_register_device);
116
Tomas Hlavacekb1b79912012-09-06 23:17:47 +0200117/**
118 * tty_port_register_device_attr - register tty device
119 * @port: tty_port of the device
120 * @driver: tty_driver for this device
121 * @index: index of the tty
122 * @device: parent if exists, otherwise NULL
123 * @drvdata: Driver data to be set to device.
124 * @attr_grp: Attribute group to be set on device.
125 *
126 * It is the same as tty_register_device_attr except the provided @port is
127 * linked to a concrete tty specified by @index. Use this or tty_port_install
128 * (or both). Call tty_port_link_device as a last resort.
129 */
130struct device *tty_port_register_device_attr(struct tty_port *port,
131 struct tty_driver *driver, unsigned index,
132 struct device *device, void *drvdata,
133 const struct attribute_group **attr_grp)
134{
135 tty_port_link_device(port, driver, index);
136 return tty_register_device_attr(driver, index, device, drvdata,
137 attr_grp);
138}
139EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
140
Johan Hovold8cde11b2017-05-18 17:33:00 +0200141/**
142 * tty_port_register_device_attr_serdev - register tty or serdev device
143 * @port: tty_port of the device
144 * @driver: tty_driver for this device
145 * @index: index of the tty
146 * @device: parent if exists, otherwise NULL
147 * @drvdata: driver data for the device
148 * @attr_grp: attribute group for the device
149 *
150 * Register a serdev or tty device depending on if the parent device has any
151 * defined serdev clients or not.
152 */
153struct device *tty_port_register_device_attr_serdev(struct tty_port *port,
154 struct tty_driver *driver, unsigned index,
155 struct device *device, void *drvdata,
156 const struct attribute_group **attr_grp)
157{
158 struct device *dev;
159
160 tty_port_link_device(port, driver, index);
161
162 dev = serdev_tty_port_register(port, device, driver, index);
163 if (PTR_ERR(dev) != -ENODEV) {
164 /* Skip creating cdev if we registered a serdev device */
165 return dev;
166 }
167
168 return tty_register_device_attr(driver, index, device, drvdata,
169 attr_grp);
170}
171EXPORT_SYMBOL_GPL(tty_port_register_device_attr_serdev);
172
173/**
174 * tty_port_register_device_serdev - register tty or serdev device
175 * @port: tty_port of the device
176 * @driver: tty_driver for this device
177 * @index: index of the tty
178 * @device: parent if exists, otherwise NULL
179 *
180 * Register a serdev or tty device depending on if the parent device has any
181 * defined serdev clients or not.
182 */
183struct device *tty_port_register_device_serdev(struct tty_port *port,
184 struct tty_driver *driver, unsigned index,
185 struct device *device)
186{
187 return tty_port_register_device_attr_serdev(port, driver, index,
188 device, NULL, NULL);
189}
190EXPORT_SYMBOL_GPL(tty_port_register_device_serdev);
191
192/**
193 * tty_port_unregister_device - deregister a tty or serdev device
194 * @port: tty_port of the device
195 * @driver: tty_driver for this device
196 * @index: index of the tty
197 *
198 * If a tty or serdev device is registered with a call to
199 * tty_port_register_device_serdev() then this function must be called when
200 * the device is gone.
201 */
202void tty_port_unregister_device(struct tty_port *port,
203 struct tty_driver *driver, unsigned index)
204{
205 int ret;
206
207 ret = serdev_tty_port_unregister(port);
208 if (ret == 0)
209 return;
210
211 tty_unregister_device(driver, index);
212}
213EXPORT_SYMBOL_GPL(tty_port_unregister_device);
214
Alan Cox9e485652008-10-13 10:37:07 +0100215int tty_port_alloc_xmit_buf(struct tty_port *port)
216{
217 /* We may sleep in get_zeroed_page() */
Alan Cox44e49092009-11-30 13:16:41 +0000218 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100219 if (port->xmit_buf == NULL)
220 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
Alan Cox44e49092009-11-30 13:16:41 +0000221 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100222 if (port->xmit_buf == NULL)
223 return -ENOMEM;
224 return 0;
225}
226EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
227
228void tty_port_free_xmit_buf(struct tty_port *port)
229{
Alan Cox44e49092009-11-30 13:16:41 +0000230 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100231 if (port->xmit_buf != NULL) {
232 free_page((unsigned long)port->xmit_buf);
233 port->xmit_buf = NULL;
234 }
Alan Cox44e49092009-11-30 13:16:41 +0000235 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100236}
237EXPORT_SYMBOL(tty_port_free_xmit_buf);
238
Jiri Slabyde274bf2012-11-15 09:49:54 +0100239/**
240 * tty_port_destroy -- destroy inited port
Antonio Borneo1926e5d2017-09-08 08:59:42 +0200241 * @port: tty port to be destroyed
Jiri Slabyde274bf2012-11-15 09:49:54 +0100242 *
243 * When a port was initialized using tty_port_init, one has to destroy the
244 * port by this function. Either indirectly by using tty_port refcounting
245 * (tty_port_put) or directly if refcounting is not used.
246 */
247void tty_port_destroy(struct tty_port *port)
248{
Peter Hurleye1760582015-10-17 16:36:23 -0400249 tty_buffer_cancel_work(port);
Jiri Slabyde274bf2012-11-15 09:49:54 +0100250 tty_buffer_free_all(port);
251}
252EXPORT_SYMBOL(tty_port_destroy);
253
Alan Cox568aafc2009-11-30 13:17:14 +0000254static void tty_port_destructor(struct kref *kref)
255{
256 struct tty_port *port = container_of(kref, struct tty_port, kref);
Peter Hurleye3bfea22013-09-18 20:42:39 -0400257
258 /* check if last port ref was dropped before tty release */
259 if (WARN_ON(port->itty))
260 return;
Alan Cox568aafc2009-11-30 13:17:14 +0000261 if (port->xmit_buf)
262 free_page((unsigned long)port->xmit_buf);
Jiri Slabyde274bf2012-11-15 09:49:54 +0100263 tty_port_destroy(port);
Jiri Slaby81c79832012-11-15 09:49:49 +0100264 if (port->ops && port->ops->destruct)
Alan Cox568aafc2009-11-30 13:17:14 +0000265 port->ops->destruct(port);
266 else
267 kfree(port);
268}
269
270void tty_port_put(struct tty_port *port)
271{
272 if (port)
273 kref_put(&port->kref, tty_port_destructor);
274}
275EXPORT_SYMBOL(tty_port_put);
Alan Cox9e485652008-10-13 10:37:07 +0100276
Alan Cox4a90f092008-10-13 10:39:46 +0100277/**
278 * tty_port_tty_get - get a tty reference
279 * @port: tty port
280 *
281 * Return a refcount protected tty instance or NULL if the port is not
282 * associated with a tty (eg due to close or hangup)
283 */
Alan Cox4a90f092008-10-13 10:39:46 +0100284struct tty_struct *tty_port_tty_get(struct tty_port *port)
285{
286 unsigned long flags;
287 struct tty_struct *tty;
288
289 spin_lock_irqsave(&port->lock, flags);
290 tty = tty_kref_get(port->tty);
291 spin_unlock_irqrestore(&port->lock, flags);
292 return tty;
293}
294EXPORT_SYMBOL(tty_port_tty_get);
295
296/**
297 * tty_port_tty_set - set the tty of a port
298 * @port: tty port
299 * @tty: the tty
300 *
301 * Associate the port and tty pair. Manages any internal refcounts.
302 * Pass NULL to deassociate a port
303 */
Alan Cox4a90f092008-10-13 10:39:46 +0100304void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
305{
306 unsigned long flags;
307
308 spin_lock_irqsave(&port->lock, flags);
Markus Elfringa211b1a2014-11-21 13:42:29 +0100309 tty_kref_put(port->tty);
Alan Coxcb4bca32008-10-21 13:47:44 +0100310 port->tty = tty_kref_get(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100311 spin_unlock_irqrestore(&port->lock, flags);
312}
313EXPORT_SYMBOL(tty_port_tty_set);
Alan Cox31f35932009-01-02 13:45:05 +0000314
Johan Hovold957daca2013-03-07 15:55:51 +0100315static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
Alan Cox7ca0ff92009-09-19 13:13:20 -0700316{
Alan Cox64bc3972009-10-06 16:06:11 +0100317 mutex_lock(&port->mutex);
Johan Hovold8bde9652013-03-07 15:55:48 +0100318 if (port->console)
319 goto out;
320
Peter Hurleyd41861c2016-04-09 17:53:25 -0700321 if (tty_port_initialized(port)) {
322 tty_port_set_initialized(port, 0);
Johan Hovold957daca2013-03-07 15:55:51 +0100323 /*
324 * Drop DTR/RTS if HUPCL is set. This causes any attached
325 * modem to hang up the line.
326 */
327 if (tty && C_HUPCL(tty))
328 tty_port_lower_dtr_rts(port);
329
Johan Hovold0d3cb6f2019-04-03 09:40:53 +0200330 if (port->ops->shutdown)
Alan Cox7ca0ff92009-09-19 13:13:20 -0700331 port->ops->shutdown(port);
Johan Hovold8bde9652013-03-07 15:55:48 +0100332 }
333out:
Alan Cox64bc3972009-10-06 16:06:11 +0100334 mutex_unlock(&port->mutex);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700335}
336
Alan Cox31f35932009-01-02 13:45:05 +0000337/**
Alan Cox3e616962009-01-02 13:45:26 +0000338 * tty_port_hangup - hangup helper
339 * @port: tty port
340 *
341 * Perform port level tty hangup flag and count changes. Drop the tty
342 * reference.
Peter Hurley9c9928b2014-06-16 09:17:02 -0400343 *
344 * Caller holds tty lock.
Alan Cox3e616962009-01-02 13:45:26 +0000345 */
Alan Cox3e616962009-01-02 13:45:26 +0000346void tty_port_hangup(struct tty_port *port)
347{
Johan Hovold957daca2013-03-07 15:55:51 +0100348 struct tty_struct *tty;
Alan Cox3e616962009-01-02 13:45:26 +0000349 unsigned long flags;
350
351 spin_lock_irqsave(&port->lock, flags);
352 port->count = 0;
Johan Hovold957daca2013-03-07 15:55:51 +0100353 tty = port->tty;
354 if (tty)
355 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox3e616962009-01-02 13:45:26 +0000356 port->tty = NULL;
357 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley807c8d812016-04-09 17:53:22 -0700358 tty_port_set_active(port, 0);
Johan Hovold957daca2013-03-07 15:55:51 +0100359 tty_port_shutdown(port, tty);
360 tty_kref_put(tty);
Alan Cox3e616962009-01-02 13:45:26 +0000361 wake_up_interruptible(&port->open_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -0700362 wake_up_interruptible(&port->delta_msr_wait);
Alan Cox3e616962009-01-02 13:45:26 +0000363}
364EXPORT_SYMBOL(tty_port_hangup);
365
366/**
Jiri Slabyaa27a092013-03-07 13:12:30 +0100367 * tty_port_tty_hangup - helper to hang up a tty
368 *
369 * @port: tty port
370 * @check_clocal: hang only ttys with CLOCAL unset?
371 */
372void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
373{
374 struct tty_struct *tty = tty_port_tty_get(port);
375
Gianluca Anzolin1d9e6892013-07-25 07:26:16 +0200376 if (tty && (!check_clocal || !C_CLOCAL(tty)))
Jiri Slabyaa27a092013-03-07 13:12:30 +0100377 tty_hangup(tty);
Gianluca Anzolin1d9e6892013-07-25 07:26:16 +0200378 tty_kref_put(tty);
Jiri Slabyaa27a092013-03-07 13:12:30 +0100379}
380EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
381
382/**
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100383 * tty_port_tty_wakeup - helper to wake up a tty
384 *
385 * @port: tty port
386 */
387void tty_port_tty_wakeup(struct tty_port *port)
388{
Rob Herringc3485ee2017-02-02 13:48:05 -0600389 port->client_ops->write_wakeup(port);
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100390}
391EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
392
393/**
Alan Cox31f35932009-01-02 13:45:05 +0000394 * tty_port_carrier_raised - carrier raised check
395 * @port: tty port
396 *
397 * Wrapper for the carrier detect logic. For the moment this is used
398 * to hide some internal details. This will eventually become entirely
399 * internal to the tty port.
400 */
Alan Cox31f35932009-01-02 13:45:05 +0000401int tty_port_carrier_raised(struct tty_port *port)
402{
Johan Hovold0d3cb6f2019-04-03 09:40:53 +0200403 if (port->ops->carrier_raised == NULL)
Alan Cox31f35932009-01-02 13:45:05 +0000404 return 1;
405 return port->ops->carrier_raised(port);
406}
407EXPORT_SYMBOL(tty_port_carrier_raised);
Alan Cox5d951fb2009-01-02 13:45:19 +0000408
409/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100410 * tty_port_raise_dtr_rts - Raise DTR/RTS
Alan Cox5d951fb2009-01-02 13:45:19 +0000411 * @port: tty port
412 *
413 * Wrapper for the DTR/RTS raise logic. For the moment this is used
414 * to hide some internal details. This will eventually become entirely
415 * internal to the tty port.
416 */
Alan Cox5d951fb2009-01-02 13:45:19 +0000417void tty_port_raise_dtr_rts(struct tty_port *port)
418{
Johan Hovold0d3cb6f2019-04-03 09:40:53 +0200419 if (port->ops->dtr_rts)
Alan Coxfcc8ac12009-06-11 12:24:17 +0100420 port->ops->dtr_rts(port, 1);
Alan Cox5d951fb2009-01-02 13:45:19 +0000421}
422EXPORT_SYMBOL(tty_port_raise_dtr_rts);
Alan Cox36c621d2009-01-02 13:46:10 +0000423
424/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100425 * tty_port_lower_dtr_rts - Lower DTR/RTS
426 * @port: tty port
427 *
428 * Wrapper for the DTR/RTS raise logic. For the moment this is used
429 * to hide some internal details. This will eventually become entirely
430 * internal to the tty port.
431 */
Alan Coxfcc8ac12009-06-11 12:24:17 +0100432void tty_port_lower_dtr_rts(struct tty_port *port)
433{
Johan Hovold0d3cb6f2019-04-03 09:40:53 +0200434 if (port->ops->dtr_rts)
Alan Coxfcc8ac12009-06-11 12:24:17 +0100435 port->ops->dtr_rts(port, 0);
436}
437EXPORT_SYMBOL(tty_port_lower_dtr_rts);
438
439/**
Alan Cox36c621d2009-01-02 13:46:10 +0000440 * tty_port_block_til_ready - Waiting logic for tty open
441 * @port: the tty port being opened
442 * @tty: the tty device being bound
Alan Coxed3f0af2017-01-16 16:54:29 -0600443 * @filp: the file pointer of the opener or NULL
Alan Cox36c621d2009-01-02 13:46:10 +0000444 *
445 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
446 * Handles:
447 * - hangup (both before and during)
448 * - non blocking open
449 * - rts/dtr/dcd
450 * - signals
451 * - port flags and counts
452 *
453 * The passed tty_port must implement the carrier_raised method if it can
Alan Coxfcc8ac12009-06-11 12:24:17 +0100454 * do carrier detect and the dtr_rts method if it supports software
Alan Cox36c621d2009-01-02 13:46:10 +0000455 * management of these lines. Note that the dtr/rts raise is done each
456 * iteration as a hangup may have previously dropped them while we wait.
Peter Hurleyc590f6b62014-06-16 09:17:01 -0400457 *
458 * Caller holds tty lock.
459 *
460 * NB: May drop and reacquire tty lock when blocking, so tty and tty_port
461 * may have changed state (eg., may have been hung up).
Alan Cox36c621d2009-01-02 13:46:10 +0000462 */
Alan Cox36c621d2009-01-02 13:46:10 +0000463int tty_port_block_til_ready(struct tty_port *port,
464 struct tty_struct *tty, struct file *filp)
465{
466 int do_clocal = 0, retval;
467 unsigned long flags;
Jiri Slaby6af9a432009-06-24 18:35:05 +0100468 DEFINE_WAIT(wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000469
Alan Cox36c621d2009-01-02 13:46:10 +0000470 /* if non-blocking mode is set we can pass directly to open unless
Xiaofei Tan1df92642021-05-12 17:26:25 +0800471 * the port has just hung up or is in another error state.
472 */
Peter Hurley18900ca2016-04-09 17:06:48 -0700473 if (tty_io_error(tty)) {
Peter Hurley807c8d812016-04-09 17:53:22 -0700474 tty_port_set_active(port, 1);
Alan Cox8627b962009-11-18 14:12:58 +0000475 return 0;
476 }
Alan Coxed3f0af2017-01-16 16:54:29 -0600477 if (filp == NULL || (filp->f_flags & O_NONBLOCK)) {
Alan Cox4175f3e2009-10-28 21:12:32 +0100478 /* Indicate we are open */
Peter Hurley9db276f2016-01-10 20:36:15 -0800479 if (C_BAUD(tty))
Alan Cox4175f3e2009-10-28 21:12:32 +0100480 tty_port_raise_dtr_rts(port);
Peter Hurley807c8d812016-04-09 17:53:22 -0700481 tty_port_set_active(port, 1);
Alan Cox36c621d2009-01-02 13:46:10 +0000482 return 0;
483 }
484
485 if (C_CLOCAL(tty))
486 do_clocal = 1;
487
488 /* Block waiting until we can proceed. We may need to wait for the
Xiaofei Tan1df92642021-05-12 17:26:25 +0800489 * carrier, but we must also wait for any close that is in progress
490 * before the next open may complete.
491 */
Alan Cox36c621d2009-01-02 13:46:10 +0000492
493 retval = 0;
Alan Cox36c621d2009-01-02 13:46:10 +0000494
495 /* The port lock protects the port counts */
496 spin_lock_irqsave(&port->lock, flags);
Peter Hurleye359a4e2014-06-16 09:17:06 -0400497 port->count--;
Alan Cox36c621d2009-01-02 13:46:10 +0000498 port->blocked_open++;
499 spin_unlock_irqrestore(&port->lock, flags);
500
501 while (1) {
502 /* Indicate we are open */
Peter Hurleyd41861c2016-04-09 17:53:25 -0700503 if (C_BAUD(tty) && tty_port_initialized(port))
Alan Cox78349092009-01-02 13:46:43 +0000504 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000505
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100506 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
Alan Coxd774a562009-10-06 16:06:21 +0100507 /* Check for a hangup or uninitialised port.
Xiaofei Tan1df92642021-05-12 17:26:25 +0800508 * Return accordingly.
509 */
Peter Hurleyd41861c2016-04-09 17:53:25 -0700510 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
Alan Cox36c621d2009-01-02 13:46:10 +0000511 if (port->flags & ASYNC_HUP_NOTIFY)
512 retval = -EAGAIN;
513 else
514 retval = -ERESTARTSYS;
515 break;
516 }
Jiri Slaby0eee50a2012-01-12 22:55:15 +0100517 /*
518 * Probe the carrier. For devices with no carrier detect
519 * tty_port_carrier_raised will always return true.
520 * Never ask drivers if CLOCAL is set, this causes troubles
521 * on some hardware.
522 */
Peter Hurleyfef062c2015-10-10 16:00:52 -0400523 if (do_clocal || tty_port_carrier_raised(port))
Alan Cox36c621d2009-01-02 13:46:10 +0000524 break;
525 if (signal_pending(current)) {
526 retval = -ERESTARTSYS;
527 break;
528 }
Alan Cox89c8d912012-08-08 16:30:13 +0100529 tty_unlock(tty);
Alan Cox36c621d2009-01-02 13:46:10 +0000530 schedule();
Alan Cox89c8d912012-08-08 16:30:13 +0100531 tty_lock(tty);
Alan Cox36c621d2009-01-02 13:46:10 +0000532 }
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100533 finish_wait(&port->open_wait, &wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000534
535 /* Update counts. A parallel hangup will have set count to zero and
Xiaofei Tan1df92642021-05-12 17:26:25 +0800536 * we must not mess that up further.
537 */
Alan Cox36c621d2009-01-02 13:46:10 +0000538 spin_lock_irqsave(&port->lock, flags);
539 if (!tty_hung_up_p(filp))
540 port->count++;
541 port->blocked_open--;
Alan Cox36c621d2009-01-02 13:46:10 +0000542 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley807c8d812016-04-09 17:53:22 -0700543 if (retval == 0)
544 tty_port_set_active(port, 1);
Alan Coxecc2e052009-07-17 16:17:26 +0100545 return retval;
Alan Cox36c621d2009-01-02 13:46:10 +0000546}
547EXPORT_SYMBOL(tty_port_block_til_ready);
548
Johan Hovoldb74414f2013-03-07 15:55:52 +0100549static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
550{
551 unsigned int bps = tty_get_baud_rate(tty);
552 long timeout;
553
554 if (bps > 1200) {
555 timeout = (HZ * 10 * port->drain_delay) / bps;
556 timeout = max_t(long, timeout, HZ / 10);
557 } else {
558 timeout = 2 * HZ;
559 }
560 schedule_timeout_interruptible(timeout);
561}
562
Peter Hurley79c1faa2015-10-10 16:00:51 -0400563/* Caller holds tty lock. */
Alan Coxd774a562009-10-06 16:06:21 +0100564int tty_port_close_start(struct tty_port *port,
565 struct tty_struct *tty, struct file *filp)
Alan Coxa6614992009-01-02 13:46:50 +0000566{
567 unsigned long flags;
568
Peter Hurley633caba82014-11-05 12:40:03 -0500569 if (tty_hung_up_p(filp))
Alan Coxa6614992009-01-02 13:46:50 +0000570 return 0;
Alan Coxa6614992009-01-02 13:46:50 +0000571
Peter Hurley633caba82014-11-05 12:40:03 -0500572 spin_lock_irqsave(&port->lock, flags);
Alan Coxd774a562009-10-06 16:06:21 +0100573 if (tty->count == 1 && port->count != 1) {
Peter Hurley339f36b2015-11-08 13:01:13 -0500574 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
575 port->count);
Alan Coxa6614992009-01-02 13:46:50 +0000576 port->count = 1;
577 }
578 if (--port->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -0500579 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
580 port->count);
Alan Coxa6614992009-01-02 13:46:50 +0000581 port->count = 0;
582 }
583
584 if (port->count) {
585 spin_unlock_irqrestore(&port->lock, flags);
586 return 0;
587 }
Alan Coxa6614992009-01-02 13:46:50 +0000588 spin_unlock_irqrestore(&port->lock, flags);
Johan Hovold0b2588c2013-03-07 15:55:53 +0100589
Peter Hurleyddc7b752014-06-16 09:17:03 -0400590 tty->closing = 1;
591
Peter Hurleyd41861c2016-04-09 17:53:25 -0700592 if (tty_port_initialized(port)) {
Johan Hovold0b2588c2013-03-07 15:55:53 +0100593 /* Don't block on a stalled port, just pull the chain */
Jiri Slaby6e94dbc2021-05-05 11:19:05 +0200594 if (tty->flow.tco_stopped)
Johan Hovold0b2588c2013-03-07 15:55:53 +0100595 tty_driver_flush_buffer(tty);
596 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
Peter Hurley79c1faa2015-10-10 16:00:51 -0400597 tty_wait_until_sent(tty, port->closing_wait);
Johan Hovold0b2588c2013-03-07 15:55:53 +0100598 if (port->drain_delay)
599 tty_port_drain_delay(port, tty);
600 }
Alan Coxe707c352009-11-05 13:27:57 +0000601 /* Flush the ldisc buffering */
602 tty_ldisc_flush(tty);
603
Peter Hurley469d6d02013-09-18 20:47:06 -0400604 /* Report to caller this is the last port reference */
Alan Coxa6614992009-01-02 13:46:50 +0000605 return 1;
606}
607EXPORT_SYMBOL(tty_port_close_start);
608
Peter Hurley0733db912014-06-16 09:16:59 -0400609/* Caller holds tty lock */
Alan Coxa6614992009-01-02 13:46:50 +0000610void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
611{
612 unsigned long flags;
613
Peter Hurley3f40f5b2014-11-05 12:40:05 -0500614 tty_ldisc_flush(tty);
Alan Coxa6614992009-01-02 13:46:50 +0000615 tty->closing = 0;
616
Peter Hurleyddc7b752014-06-16 09:17:03 -0400617 spin_lock_irqsave(&port->lock, flags);
618
Alan Coxa6614992009-01-02 13:46:50 +0000619 if (port->blocked_open) {
620 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley5823323e2016-01-10 20:36:14 -0800621 if (port->close_delay)
622 msleep_interruptible(jiffies_to_msecs(port->close_delay));
Alan Coxa6614992009-01-02 13:46:50 +0000623 spin_lock_irqsave(&port->lock, flags);
624 wake_up_interruptible(&port->open_wait);
625 }
Alan Coxa6614992009-01-02 13:46:50 +0000626 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley807c8d812016-04-09 17:53:22 -0700627 tty_port_set_active(port, 0);
Alan Coxa6614992009-01-02 13:46:50 +0000628}
629EXPORT_SYMBOL(tty_port_close_end);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700630
Lee Jones1b1deb42020-11-04 19:35:19 +0000631/*
Peter Hurley0733db912014-06-16 09:16:59 -0400632 * tty_port_close
633 *
634 * Caller holds tty lock
Peter Hurley0733db912014-06-16 09:16:59 -0400635 */
Alan Cox7ca0ff92009-09-19 13:13:20 -0700636void tty_port_close(struct tty_port *port, struct tty_struct *tty,
637 struct file *filp)
638{
639 if (tty_port_close_start(port, tty, filp) == 0)
640 return;
Johan Hovold957daca2013-03-07 15:55:51 +0100641 tty_port_shutdown(port, tty);
Chanho Park2a486022018-11-22 18:23:47 +0900642 if (!port->console)
643 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700644 tty_port_close_end(port, tty);
645 tty_port_tty_set(port, NULL);
646}
647EXPORT_SYMBOL(tty_port_close);
Alan Cox64bc3972009-10-06 16:06:11 +0100648
Jiri Slaby72a33bf2012-08-07 21:47:49 +0200649/**
650 * tty_port_install - generic tty->ops->install handler
651 * @port: tty_port of the device
652 * @driver: tty_driver for this device
653 * @tty: tty to be installed
654 *
655 * It is the same as tty_standard_install except the provided @port is linked
656 * to a concrete tty specified by @tty. Use this or tty_port_register_device
657 * (or both). Call tty_port_link_device as a last resort.
658 */
Jiri Slaby695586c2012-06-04 13:35:32 +0200659int tty_port_install(struct tty_port *port, struct tty_driver *driver,
660 struct tty_struct *tty)
661{
662 tty->port = port;
663 return tty_standard_install(driver, tty);
664}
665EXPORT_SYMBOL_GPL(tty_port_install);
666
Lee Jones1b1deb42020-11-04 19:35:19 +0000667/*
Peter Hurleyaddd4672014-06-16 09:17:00 -0400668 * tty_port_open
669 *
670 * Caller holds tty lock.
671 *
672 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
673 * tty and tty_port may have changed state (eg., may be hung up now)
674 */
Alan Cox64bc3972009-10-06 16:06:11 +0100675int tty_port_open(struct tty_port *port, struct tty_struct *tty,
Alan Coxd774a562009-10-06 16:06:21 +0100676 struct file *filp)
Alan Cox64bc3972009-10-06 16:06:11 +0100677{
678 spin_lock_irq(&port->lock);
Peter Hurleye359a4e2014-06-16 09:17:06 -0400679 ++port->count;
Alan Cox64bc3972009-10-06 16:06:11 +0100680 spin_unlock_irq(&port->lock);
681 tty_port_tty_set(port, tty);
682
683 /*
684 * Do the device-specific open only if the hardware isn't
685 * already initialized. Serialize open and shutdown using the
686 * port mutex.
687 */
688
689 mutex_lock(&port->mutex);
690
Peter Hurleyd41861c2016-04-09 17:53:25 -0700691 if (!tty_port_initialized(port)) {
Alan Coxa9a37ec2009-11-30 13:16:57 +0000692 clear_bit(TTY_IO_ERROR, &tty->flags);
Johan Hovold0d3cb6f2019-04-03 09:40:53 +0200693 if (port->ops->activate) {
Alan Cox64bc3972009-10-06 16:06:11 +0100694 int retval = port->ops->activate(port, tty);
Xiaofei Tan54ad59a2021-05-12 17:26:24 +0800695
Alan Cox64bc3972009-10-06 16:06:11 +0100696 if (retval) {
Alan Coxd774a562009-10-06 16:06:21 +0100697 mutex_unlock(&port->mutex);
698 return retval;
699 }
700 }
Peter Hurleyd41861c2016-04-09 17:53:25 -0700701 tty_port_set_initialized(port, 1);
Alan Cox64bc3972009-10-06 16:06:11 +0100702 }
703 mutex_unlock(&port->mutex);
704 return tty_port_block_til_ready(port, tty, filp);
705}
Alan Cox64bc3972009-10-06 16:06:11 +0100706EXPORT_SYMBOL(tty_port_open);