blob: c3f9d93ba2277239c86db36c63d028cd3095ea68 [file] [log] [blame]
Alan Cox9e485652008-10-13 10:37:07 +01001/*
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>
Alan Cox3e616962009-01-02 13:45:26 +000010#include <linux/serial.h>
Alan Cox9e485652008-10-13 10:37:07 +010011#include <linux/timer.h>
12#include <linux/string.h>
13#include <linux/slab.h>
14#include <linux/sched.h>
Alan Cox9e485652008-10-13 10:37:07 +010015#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));
Jiri Slabyecbbfd42012-10-18 22:26:47 +020023 tty_buffer_init(port);
Alan Cox9e485652008-10-13 10:37:07 +010024 init_waitqueue_head(&port->open_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -070025 init_waitqueue_head(&port->delta_msr_wait);
Alan Cox9e485652008-10-13 10:37:07 +010026 mutex_init(&port->mutex);
Alan Cox44e49092009-11-30 13:16:41 +000027 mutex_init(&port->buf_mutex);
Alan Cox4a90f092008-10-13 10:39:46 +010028 spin_lock_init(&port->lock);
Alan Cox9e485652008-10-13 10:37:07 +010029 port->close_delay = (50 * HZ) / 100;
30 port->closing_wait = (3000 * HZ) / 100;
Alan Cox568aafc2009-11-30 13:17:14 +000031 kref_init(&port->kref);
Alan Cox9e485652008-10-13 10:37:07 +010032}
33EXPORT_SYMBOL(tty_port_init);
34
Jiri Slaby72a33bf2012-08-07 21:47:49 +020035/**
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020036 * tty_port_link_device - link tty and tty_port
37 * @port: tty_port of the device
38 * @driver: tty_driver for this device
39 * @index: index of the tty
40 *
41 * Provide the tty layer wit ha link from a tty (specified by @index) to a
42 * tty_port (@port). Use this only if neither tty_port_register_device nor
43 * tty_port_install is used in the driver. If used, this has to be called before
44 * tty_register_driver.
45 */
46void tty_port_link_device(struct tty_port *port,
47 struct tty_driver *driver, unsigned index)
48{
49 if (WARN_ON(index >= driver->num))
50 return;
51 driver->ports[index] = port;
52}
53EXPORT_SYMBOL_GPL(tty_port_link_device);
54
55/**
Jiri Slaby72a33bf2012-08-07 21:47:49 +020056 * tty_port_register_device - register tty device
57 * @port: tty_port of the device
58 * @driver: tty_driver for this device
59 * @index: index of the tty
60 * @device: parent if exists, otherwise NULL
61 *
62 * It is the same as tty_register_device except the provided @port is linked to
63 * a concrete tty specified by @index. Use this or tty_port_install (or both).
64 * Call tty_port_link_device as a last resort.
65 */
Jiri Slaby057eb852012-06-04 13:35:37 +020066struct device *tty_port_register_device(struct tty_port *port,
67 struct tty_driver *driver, unsigned index,
68 struct device *device)
69{
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020070 tty_port_link_device(port, driver, index);
Jiri Slaby057eb852012-06-04 13:35:37 +020071 return tty_register_device(driver, index, device);
72}
73EXPORT_SYMBOL_GPL(tty_port_register_device);
74
Tomas Hlavacekb1b79912012-09-06 23:17:47 +020075/**
76 * tty_port_register_device_attr - register tty device
77 * @port: tty_port of the device
78 * @driver: tty_driver for this device
79 * @index: index of the tty
80 * @device: parent if exists, otherwise NULL
81 * @drvdata: Driver data to be set to device.
82 * @attr_grp: Attribute group to be set on device.
83 *
84 * It is the same as tty_register_device_attr except the provided @port is
85 * linked to a concrete tty specified by @index. Use this or tty_port_install
86 * (or both). Call tty_port_link_device as a last resort.
87 */
88struct device *tty_port_register_device_attr(struct tty_port *port,
89 struct tty_driver *driver, unsigned index,
90 struct device *device, void *drvdata,
91 const struct attribute_group **attr_grp)
92{
93 tty_port_link_device(port, driver, index);
94 return tty_register_device_attr(driver, index, device, drvdata,
95 attr_grp);
96}
97EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
98
Alan Cox9e485652008-10-13 10:37:07 +010099int tty_port_alloc_xmit_buf(struct tty_port *port)
100{
101 /* We may sleep in get_zeroed_page() */
Alan Cox44e49092009-11-30 13:16:41 +0000102 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100103 if (port->xmit_buf == NULL)
104 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
Alan Cox44e49092009-11-30 13:16:41 +0000105 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100106 if (port->xmit_buf == NULL)
107 return -ENOMEM;
108 return 0;
109}
110EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
111
112void tty_port_free_xmit_buf(struct tty_port *port)
113{
Alan Cox44e49092009-11-30 13:16:41 +0000114 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100115 if (port->xmit_buf != NULL) {
116 free_page((unsigned long)port->xmit_buf);
117 port->xmit_buf = NULL;
118 }
Alan Cox44e49092009-11-30 13:16:41 +0000119 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100120}
121EXPORT_SYMBOL(tty_port_free_xmit_buf);
122
Jiri Slabyde274bf2012-11-15 09:49:54 +0100123/**
124 * tty_port_destroy -- destroy inited port
125 * @port: tty port to be doestroyed
126 *
127 * When a port was initialized using tty_port_init, one has to destroy the
128 * port by this function. Either indirectly by using tty_port refcounting
129 * (tty_port_put) or directly if refcounting is not used.
130 */
131void tty_port_destroy(struct tty_port *port)
132{
Peter Hurleye1760582015-10-17 16:36:23 -0400133 tty_buffer_cancel_work(port);
Jiri Slabyde274bf2012-11-15 09:49:54 +0100134 tty_buffer_free_all(port);
135}
136EXPORT_SYMBOL(tty_port_destroy);
137
Alan Cox568aafc2009-11-30 13:17:14 +0000138static void tty_port_destructor(struct kref *kref)
139{
140 struct tty_port *port = container_of(kref, struct tty_port, kref);
Peter Hurleye3bfea22013-09-18 20:42:39 -0400141
142 /* check if last port ref was dropped before tty release */
143 if (WARN_ON(port->itty))
144 return;
Alan Cox568aafc2009-11-30 13:17:14 +0000145 if (port->xmit_buf)
146 free_page((unsigned long)port->xmit_buf);
Jiri Slabyde274bf2012-11-15 09:49:54 +0100147 tty_port_destroy(port);
Jiri Slaby81c79832012-11-15 09:49:49 +0100148 if (port->ops && port->ops->destruct)
Alan Cox568aafc2009-11-30 13:17:14 +0000149 port->ops->destruct(port);
150 else
151 kfree(port);
152}
153
154void tty_port_put(struct tty_port *port)
155{
156 if (port)
157 kref_put(&port->kref, tty_port_destructor);
158}
159EXPORT_SYMBOL(tty_port_put);
Alan Cox9e485652008-10-13 10:37:07 +0100160
Alan Cox4a90f092008-10-13 10:39:46 +0100161/**
162 * tty_port_tty_get - get a tty reference
163 * @port: tty port
164 *
165 * Return a refcount protected tty instance or NULL if the port is not
166 * associated with a tty (eg due to close or hangup)
167 */
168
169struct tty_struct *tty_port_tty_get(struct tty_port *port)
170{
171 unsigned long flags;
172 struct tty_struct *tty;
173
174 spin_lock_irqsave(&port->lock, flags);
175 tty = tty_kref_get(port->tty);
176 spin_unlock_irqrestore(&port->lock, flags);
177 return tty;
178}
179EXPORT_SYMBOL(tty_port_tty_get);
180
181/**
182 * tty_port_tty_set - set the tty of a port
183 * @port: tty port
184 * @tty: the tty
185 *
186 * Associate the port and tty pair. Manages any internal refcounts.
187 * Pass NULL to deassociate a port
188 */
189
190void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
191{
192 unsigned long flags;
193
194 spin_lock_irqsave(&port->lock, flags);
Markus Elfringa211b1a2014-11-21 13:42:29 +0100195 tty_kref_put(port->tty);
Alan Coxcb4bca32008-10-21 13:47:44 +0100196 port->tty = tty_kref_get(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100197 spin_unlock_irqrestore(&port->lock, flags);
198}
199EXPORT_SYMBOL(tty_port_tty_set);
Alan Cox31f35932009-01-02 13:45:05 +0000200
Johan Hovold957daca2013-03-07 15:55:51 +0100201static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
Alan Cox7ca0ff92009-09-19 13:13:20 -0700202{
Alan Cox64bc3972009-10-06 16:06:11 +0100203 mutex_lock(&port->mutex);
Johan Hovold8bde9652013-03-07 15:55:48 +0100204 if (port->console)
205 goto out;
206
Peter Hurleyd41861c2016-04-09 17:53:25 -0700207 if (tty_port_initialized(port)) {
208 tty_port_set_initialized(port, 0);
Johan Hovold957daca2013-03-07 15:55:51 +0100209 /*
210 * Drop DTR/RTS if HUPCL is set. This causes any attached
211 * modem to hang up the line.
212 */
213 if (tty && C_HUPCL(tty))
214 tty_port_lower_dtr_rts(port);
215
Johan Hovold8bde9652013-03-07 15:55:48 +0100216 if (port->ops->shutdown)
Alan Cox7ca0ff92009-09-19 13:13:20 -0700217 port->ops->shutdown(port);
Johan Hovold8bde9652013-03-07 15:55:48 +0100218 }
219out:
Alan Cox64bc3972009-10-06 16:06:11 +0100220 mutex_unlock(&port->mutex);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700221}
222
Alan Cox31f35932009-01-02 13:45:05 +0000223/**
Alan Cox3e616962009-01-02 13:45:26 +0000224 * tty_port_hangup - hangup helper
225 * @port: tty port
226 *
227 * Perform port level tty hangup flag and count changes. Drop the tty
228 * reference.
Peter Hurley9c9928b2014-06-16 09:17:02 -0400229 *
230 * Caller holds tty lock.
Alan Cox3e616962009-01-02 13:45:26 +0000231 */
232
233void tty_port_hangup(struct tty_port *port)
234{
Johan Hovold957daca2013-03-07 15:55:51 +0100235 struct tty_struct *tty;
Alan Cox3e616962009-01-02 13:45:26 +0000236 unsigned long flags;
237
238 spin_lock_irqsave(&port->lock, flags);
239 port->count = 0;
Johan Hovold957daca2013-03-07 15:55:51 +0100240 tty = port->tty;
241 if (tty)
242 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox3e616962009-01-02 13:45:26 +0000243 port->tty = NULL;
244 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley807c8d812016-04-09 17:53:22 -0700245 tty_port_set_active(port, 0);
Johan Hovold957daca2013-03-07 15:55:51 +0100246 tty_port_shutdown(port, tty);
247 tty_kref_put(tty);
Alan Cox3e616962009-01-02 13:45:26 +0000248 wake_up_interruptible(&port->open_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -0700249 wake_up_interruptible(&port->delta_msr_wait);
Alan Cox3e616962009-01-02 13:45:26 +0000250}
251EXPORT_SYMBOL(tty_port_hangup);
252
253/**
Jiri Slabyaa27a092013-03-07 13:12:30 +0100254 * tty_port_tty_hangup - helper to hang up a tty
255 *
256 * @port: tty port
257 * @check_clocal: hang only ttys with CLOCAL unset?
258 */
259void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
260{
261 struct tty_struct *tty = tty_port_tty_get(port);
262
Gianluca Anzolin1d9e6892013-07-25 07:26:16 +0200263 if (tty && (!check_clocal || !C_CLOCAL(tty)))
Jiri Slabyaa27a092013-03-07 13:12:30 +0100264 tty_hangup(tty);
Gianluca Anzolin1d9e6892013-07-25 07:26:16 +0200265 tty_kref_put(tty);
Jiri Slabyaa27a092013-03-07 13:12:30 +0100266}
267EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
268
269/**
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100270 * tty_port_tty_wakeup - helper to wake up a tty
271 *
272 * @port: tty port
273 */
274void tty_port_tty_wakeup(struct tty_port *port)
275{
276 struct tty_struct *tty = tty_port_tty_get(port);
277
278 if (tty) {
279 tty_wakeup(tty);
280 tty_kref_put(tty);
281 }
282}
283EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
284
285/**
Alan Cox31f35932009-01-02 13:45:05 +0000286 * tty_port_carrier_raised - carrier raised check
287 * @port: tty port
288 *
289 * Wrapper for the carrier detect logic. For the moment this is used
290 * to hide some internal details. This will eventually become entirely
291 * internal to the tty port.
292 */
293
294int tty_port_carrier_raised(struct tty_port *port)
295{
296 if (port->ops->carrier_raised == NULL)
297 return 1;
298 return port->ops->carrier_raised(port);
299}
300EXPORT_SYMBOL(tty_port_carrier_raised);
Alan Cox5d951fb2009-01-02 13:45:19 +0000301
302/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100303 * tty_port_raise_dtr_rts - Raise DTR/RTS
Alan Cox5d951fb2009-01-02 13:45:19 +0000304 * @port: tty port
305 *
306 * Wrapper for the DTR/RTS raise logic. For the moment this is used
307 * to hide some internal details. This will eventually become entirely
308 * internal to the tty port.
309 */
310
311void tty_port_raise_dtr_rts(struct tty_port *port)
312{
Alan Coxfcc8ac12009-06-11 12:24:17 +0100313 if (port->ops->dtr_rts)
314 port->ops->dtr_rts(port, 1);
Alan Cox5d951fb2009-01-02 13:45:19 +0000315}
316EXPORT_SYMBOL(tty_port_raise_dtr_rts);
Alan Cox36c621d2009-01-02 13:46:10 +0000317
318/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100319 * tty_port_lower_dtr_rts - Lower DTR/RTS
320 * @port: tty port
321 *
322 * Wrapper for the DTR/RTS raise logic. For the moment this is used
323 * to hide some internal details. This will eventually become entirely
324 * internal to the tty port.
325 */
326
327void tty_port_lower_dtr_rts(struct tty_port *port)
328{
329 if (port->ops->dtr_rts)
330 port->ops->dtr_rts(port, 0);
331}
332EXPORT_SYMBOL(tty_port_lower_dtr_rts);
333
334/**
Alan Cox36c621d2009-01-02 13:46:10 +0000335 * tty_port_block_til_ready - Waiting logic for tty open
336 * @port: the tty port being opened
337 * @tty: the tty device being bound
338 * @filp: the file pointer of the opener
339 *
340 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
341 * Handles:
342 * - hangup (both before and during)
343 * - non blocking open
344 * - rts/dtr/dcd
345 * - signals
346 * - port flags and counts
347 *
348 * The passed tty_port must implement the carrier_raised method if it can
Alan Coxfcc8ac12009-06-11 12:24:17 +0100349 * do carrier detect and the dtr_rts method if it supports software
Alan Cox36c621d2009-01-02 13:46:10 +0000350 * management of these lines. Note that the dtr/rts raise is done each
351 * iteration as a hangup may have previously dropped them while we wait.
Peter Hurleyc590f6b2014-06-16 09:17:01 -0400352 *
353 * Caller holds tty lock.
354 *
355 * NB: May drop and reacquire tty lock when blocking, so tty and tty_port
356 * may have changed state (eg., may have been hung up).
Alan Cox36c621d2009-01-02 13:46:10 +0000357 */
Alan Coxd774a562009-10-06 16:06:21 +0100358
Alan Cox36c621d2009-01-02 13:46:10 +0000359int tty_port_block_til_ready(struct tty_port *port,
360 struct tty_struct *tty, struct file *filp)
361{
362 int do_clocal = 0, retval;
363 unsigned long flags;
Jiri Slaby6af9a432009-06-24 18:35:05 +0100364 DEFINE_WAIT(wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000365
Alan Cox36c621d2009-01-02 13:46:10 +0000366 /* if non-blocking mode is set we can pass directly to open unless
367 the port has just hung up or is in another error state */
Peter Hurley18900ca2016-04-09 17:06:48 -0700368 if (tty_io_error(tty)) {
Peter Hurley807c8d812016-04-09 17:53:22 -0700369 tty_port_set_active(port, 1);
Alan Cox8627b962009-11-18 14:12:58 +0000370 return 0;
371 }
372 if (filp->f_flags & O_NONBLOCK) {
Alan Cox4175f3e2009-10-28 21:12:32 +0100373 /* Indicate we are open */
Peter Hurley9db276f2016-01-10 20:36:15 -0800374 if (C_BAUD(tty))
Alan Cox4175f3e2009-10-28 21:12:32 +0100375 tty_port_raise_dtr_rts(port);
Peter Hurley807c8d812016-04-09 17:53:22 -0700376 tty_port_set_active(port, 1);
Alan Cox36c621d2009-01-02 13:46:10 +0000377 return 0;
378 }
379
380 if (C_CLOCAL(tty))
381 do_clocal = 1;
382
383 /* Block waiting until we can proceed. We may need to wait for the
384 carrier, but we must also wait for any close that is in progress
385 before the next open may complete */
386
387 retval = 0;
Alan Cox36c621d2009-01-02 13:46:10 +0000388
389 /* The port lock protects the port counts */
390 spin_lock_irqsave(&port->lock, flags);
Peter Hurleye359a4e2014-06-16 09:17:06 -0400391 port->count--;
Alan Cox36c621d2009-01-02 13:46:10 +0000392 port->blocked_open++;
393 spin_unlock_irqrestore(&port->lock, flags);
394
395 while (1) {
396 /* Indicate we are open */
Peter Hurleyd41861c2016-04-09 17:53:25 -0700397 if (C_BAUD(tty) && tty_port_initialized(port))
Alan Cox78349092009-01-02 13:46:43 +0000398 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000399
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100400 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
Alan Coxd774a562009-10-06 16:06:21 +0100401 /* Check for a hangup or uninitialised port.
402 Return accordingly */
Peter Hurleyd41861c2016-04-09 17:53:25 -0700403 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
Alan Cox36c621d2009-01-02 13:46:10 +0000404 if (port->flags & ASYNC_HUP_NOTIFY)
405 retval = -EAGAIN;
406 else
407 retval = -ERESTARTSYS;
408 break;
409 }
Jiri Slaby0eee50a2012-01-12 22:55:15 +0100410 /*
411 * Probe the carrier. For devices with no carrier detect
412 * tty_port_carrier_raised will always return true.
413 * Never ask drivers if CLOCAL is set, this causes troubles
414 * on some hardware.
415 */
Peter Hurleyfef062c2015-10-10 16:00:52 -0400416 if (do_clocal || tty_port_carrier_raised(port))
Alan Cox36c621d2009-01-02 13:46:10 +0000417 break;
418 if (signal_pending(current)) {
419 retval = -ERESTARTSYS;
420 break;
421 }
Alan Cox89c8d912012-08-08 16:30:13 +0100422 tty_unlock(tty);
Alan Cox36c621d2009-01-02 13:46:10 +0000423 schedule();
Alan Cox89c8d912012-08-08 16:30:13 +0100424 tty_lock(tty);
Alan Cox36c621d2009-01-02 13:46:10 +0000425 }
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100426 finish_wait(&port->open_wait, &wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000427
428 /* Update counts. A parallel hangup will have set count to zero and
429 we must not mess that up further */
430 spin_lock_irqsave(&port->lock, flags);
431 if (!tty_hung_up_p(filp))
432 port->count++;
433 port->blocked_open--;
Alan Cox36c621d2009-01-02 13:46:10 +0000434 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley807c8d812016-04-09 17:53:22 -0700435 if (retval == 0)
436 tty_port_set_active(port, 1);
Alan Coxecc2e052009-07-17 16:17:26 +0100437 return retval;
Alan Cox36c621d2009-01-02 13:46:10 +0000438}
439EXPORT_SYMBOL(tty_port_block_til_ready);
440
Johan Hovoldb74414f2013-03-07 15:55:52 +0100441static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
442{
443 unsigned int bps = tty_get_baud_rate(tty);
444 long timeout;
445
446 if (bps > 1200) {
447 timeout = (HZ * 10 * port->drain_delay) / bps;
448 timeout = max_t(long, timeout, HZ / 10);
449 } else {
450 timeout = 2 * HZ;
451 }
452 schedule_timeout_interruptible(timeout);
453}
454
Peter Hurley79c1faa2015-10-10 16:00:51 -0400455/* Caller holds tty lock. */
Alan Coxd774a562009-10-06 16:06:21 +0100456int tty_port_close_start(struct tty_port *port,
457 struct tty_struct *tty, struct file *filp)
Alan Coxa6614992009-01-02 13:46:50 +0000458{
459 unsigned long flags;
460
Peter Hurley633caba2014-11-05 12:40:03 -0500461 if (tty_hung_up_p(filp))
Alan Coxa6614992009-01-02 13:46:50 +0000462 return 0;
Alan Coxa6614992009-01-02 13:46:50 +0000463
Peter Hurley633caba2014-11-05 12:40:03 -0500464 spin_lock_irqsave(&port->lock, flags);
Alan Coxd774a562009-10-06 16:06:21 +0100465 if (tty->count == 1 && port->count != 1) {
Peter Hurley339f36b2015-11-08 13:01:13 -0500466 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
467 port->count);
Alan Coxa6614992009-01-02 13:46:50 +0000468 port->count = 1;
469 }
470 if (--port->count < 0) {
Peter Hurley339f36b2015-11-08 13:01:13 -0500471 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
472 port->count);
Alan Coxa6614992009-01-02 13:46:50 +0000473 port->count = 0;
474 }
475
476 if (port->count) {
477 spin_unlock_irqrestore(&port->lock, flags);
478 return 0;
479 }
Alan Coxa6614992009-01-02 13:46:50 +0000480 spin_unlock_irqrestore(&port->lock, flags);
Johan Hovold0b2588c2013-03-07 15:55:53 +0100481
Peter Hurleyddc7b752014-06-16 09:17:03 -0400482 tty->closing = 1;
483
Peter Hurleyd41861c2016-04-09 17:53:25 -0700484 if (tty_port_initialized(port)) {
Johan Hovold0b2588c2013-03-07 15:55:53 +0100485 /* Don't block on a stalled port, just pull the chain */
486 if (tty->flow_stopped)
487 tty_driver_flush_buffer(tty);
488 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
Peter Hurley79c1faa2015-10-10 16:00:51 -0400489 tty_wait_until_sent(tty, port->closing_wait);
Johan Hovold0b2588c2013-03-07 15:55:53 +0100490 if (port->drain_delay)
491 tty_port_drain_delay(port, tty);
492 }
Alan Coxe707c352009-11-05 13:27:57 +0000493 /* Flush the ldisc buffering */
494 tty_ldisc_flush(tty);
495
Peter Hurley469d6d02013-09-18 20:47:06 -0400496 /* Report to caller this is the last port reference */
Alan Coxa6614992009-01-02 13:46:50 +0000497 return 1;
498}
499EXPORT_SYMBOL(tty_port_close_start);
500
Peter Hurley0733db92014-06-16 09:16:59 -0400501/* Caller holds tty lock */
Alan Coxa6614992009-01-02 13:46:50 +0000502void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
503{
504 unsigned long flags;
505
Peter Hurley3f40f5b2014-11-05 12:40:05 -0500506 tty_ldisc_flush(tty);
Alan Coxa6614992009-01-02 13:46:50 +0000507 tty->closing = 0;
508
Peter Hurleyddc7b752014-06-16 09:17:03 -0400509 spin_lock_irqsave(&port->lock, flags);
510
Alan Coxa6614992009-01-02 13:46:50 +0000511 if (port->blocked_open) {
512 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley5823323e2016-01-10 20:36:14 -0800513 if (port->close_delay)
514 msleep_interruptible(jiffies_to_msecs(port->close_delay));
Alan Coxa6614992009-01-02 13:46:50 +0000515 spin_lock_irqsave(&port->lock, flags);
516 wake_up_interruptible(&port->open_wait);
517 }
Alan Coxa6614992009-01-02 13:46:50 +0000518 spin_unlock_irqrestore(&port->lock, flags);
Peter Hurley807c8d812016-04-09 17:53:22 -0700519 tty_port_set_active(port, 0);
Alan Coxa6614992009-01-02 13:46:50 +0000520}
521EXPORT_SYMBOL(tty_port_close_end);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700522
Peter Hurley0733db92014-06-16 09:16:59 -0400523/**
524 * tty_port_close
525 *
526 * Caller holds tty lock
Peter Hurley0733db92014-06-16 09:16:59 -0400527 */
Alan Cox7ca0ff92009-09-19 13:13:20 -0700528void tty_port_close(struct tty_port *port, struct tty_struct *tty,
529 struct file *filp)
530{
531 if (tty_port_close_start(port, tty, filp) == 0)
532 return;
Johan Hovold957daca2013-03-07 15:55:51 +0100533 tty_port_shutdown(port, tty);
Alan Coxd74e8282009-11-30 13:16:52 +0000534 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700535 tty_port_close_end(port, tty);
536 tty_port_tty_set(port, NULL);
537}
538EXPORT_SYMBOL(tty_port_close);
Alan Cox64bc3972009-10-06 16:06:11 +0100539
Jiri Slaby72a33bf2012-08-07 21:47:49 +0200540/**
541 * tty_port_install - generic tty->ops->install handler
542 * @port: tty_port of the device
543 * @driver: tty_driver for this device
544 * @tty: tty to be installed
545 *
546 * It is the same as tty_standard_install except the provided @port is linked
547 * to a concrete tty specified by @tty. Use this or tty_port_register_device
548 * (or both). Call tty_port_link_device as a last resort.
549 */
Jiri Slaby695586c2012-06-04 13:35:32 +0200550int tty_port_install(struct tty_port *port, struct tty_driver *driver,
551 struct tty_struct *tty)
552{
553 tty->port = port;
554 return tty_standard_install(driver, tty);
555}
556EXPORT_SYMBOL_GPL(tty_port_install);
557
Peter Hurleyaddd4672014-06-16 09:17:00 -0400558/**
559 * tty_port_open
560 *
561 * Caller holds tty lock.
562 *
563 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
564 * tty and tty_port may have changed state (eg., may be hung up now)
565 */
Alan Cox64bc3972009-10-06 16:06:11 +0100566int tty_port_open(struct tty_port *port, struct tty_struct *tty,
Alan Coxd774a562009-10-06 16:06:21 +0100567 struct file *filp)
Alan Cox64bc3972009-10-06 16:06:11 +0100568{
569 spin_lock_irq(&port->lock);
Peter Hurleye359a4e2014-06-16 09:17:06 -0400570 ++port->count;
Alan Cox64bc3972009-10-06 16:06:11 +0100571 spin_unlock_irq(&port->lock);
572 tty_port_tty_set(port, tty);
573
574 /*
575 * Do the device-specific open only if the hardware isn't
576 * already initialized. Serialize open and shutdown using the
577 * port mutex.
578 */
579
580 mutex_lock(&port->mutex);
581
Peter Hurleyd41861c2016-04-09 17:53:25 -0700582 if (!tty_port_initialized(port)) {
Alan Coxa9a37ec2009-11-30 13:16:57 +0000583 clear_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox64bc3972009-10-06 16:06:11 +0100584 if (port->ops->activate) {
585 int retval = port->ops->activate(port, tty);
586 if (retval) {
Alan Coxd774a562009-10-06 16:06:21 +0100587 mutex_unlock(&port->mutex);
588 return retval;
589 }
590 }
Peter Hurleyd41861c2016-04-09 17:53:25 -0700591 tty_port_set_initialized(port, 1);
Alan Cox64bc3972009-10-06 16:06:11 +0100592 }
593 mutex_unlock(&port->mutex);
594 return tty_port_block_til_ready(port, tty, filp);
595}
596
597EXPORT_SYMBOL(tty_port_open);