blob: 1b9335796da42b2c9399dd7675200fc5f1d3cae3 [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);
25 init_waitqueue_head(&port->close_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -070026 init_waitqueue_head(&port->delta_msr_wait);
Alan Cox9e485652008-10-13 10:37:07 +010027 mutex_init(&port->mutex);
Alan Cox44e49092009-11-30 13:16:41 +000028 mutex_init(&port->buf_mutex);
Alan Cox4a90f092008-10-13 10:39:46 +010029 spin_lock_init(&port->lock);
Alan Cox9e485652008-10-13 10:37:07 +010030 port->close_delay = (50 * HZ) / 100;
31 port->closing_wait = (3000 * HZ) / 100;
Alan Cox568aafc2009-11-30 13:17:14 +000032 kref_init(&port->kref);
Alan Cox9e485652008-10-13 10:37:07 +010033}
34EXPORT_SYMBOL(tty_port_init);
35
Jiri Slaby72a33bf2012-08-07 21:47:49 +020036/**
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020037 * 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/**
Jiri Slaby72a33bf2012-08-07 21:47:49 +020057 * 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 */
Jiri Slaby057eb852012-06-04 13:35:37 +020067struct device *tty_port_register_device(struct tty_port *port,
68 struct tty_driver *driver, unsigned index,
69 struct device *device)
70{
Jiri Slaby2cb4ca02012-08-07 21:47:50 +020071 tty_port_link_device(port, driver, index);
Jiri Slaby057eb852012-06-04 13:35:37 +020072 return tty_register_device(driver, index, device);
73}
74EXPORT_SYMBOL_GPL(tty_port_register_device);
75
Tomas Hlavacekb1b79912012-09-06 23:17:47 +020076/**
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
Alan Cox9e485652008-10-13 10:37:07 +0100100int tty_port_alloc_xmit_buf(struct tty_port *port)
101{
102 /* We may sleep in get_zeroed_page() */
Alan Cox44e49092009-11-30 13:16:41 +0000103 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100104 if (port->xmit_buf == NULL)
105 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
Alan Cox44e49092009-11-30 13:16:41 +0000106 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100107 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{
Alan Cox44e49092009-11-30 13:16:41 +0000115 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100116 if (port->xmit_buf != NULL) {
117 free_page((unsigned long)port->xmit_buf);
118 port->xmit_buf = NULL;
119 }
Alan Cox44e49092009-11-30 13:16:41 +0000120 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +0100121}
122EXPORT_SYMBOL(tty_port_free_xmit_buf);
123
Jiri Slabyde274bf2012-11-15 09:49:54 +0100124/**
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{
Peter Hurley4f98d462013-03-11 16:44:34 -0400134 cancel_work_sync(&port->buf.work);
Jiri Slabyde274bf2012-11-15 09:49:54 +0100135 tty_buffer_free_all(port);
136}
137EXPORT_SYMBOL(tty_port_destroy);
138
Alan Cox568aafc2009-11-30 13:17:14 +0000139static void tty_port_destructor(struct kref *kref)
140{
141 struct tty_port *port = container_of(kref, struct tty_port, kref);
Peter Hurleye3bfea22013-09-18 20:42:39 -0400142
143 /* check if last port ref was dropped before tty release */
144 if (WARN_ON(port->itty))
145 return;
Alan Cox568aafc2009-11-30 13:17:14 +0000146 if (port->xmit_buf)
147 free_page((unsigned long)port->xmit_buf);
Jiri Slabyde274bf2012-11-15 09:49:54 +0100148 tty_port_destroy(port);
Jiri Slaby81c79832012-11-15 09:49:49 +0100149 if (port->ops && port->ops->destruct)
Alan Cox568aafc2009-11-30 13:17:14 +0000150 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);
Alan Cox9e485652008-10-13 10:37:07 +0100161
Alan Cox4a90f092008-10-13 10:39:46 +0100162/**
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);
Alan Coxcb4bca32008-10-21 13:47:44 +0100198 port->tty = tty_kref_get(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100199 spin_unlock_irqrestore(&port->lock, flags);
200}
201EXPORT_SYMBOL(tty_port_tty_set);
Alan Cox31f35932009-01-02 13:45:05 +0000202
Johan Hovold957daca2013-03-07 15:55:51 +0100203static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
Alan Cox7ca0ff92009-09-19 13:13:20 -0700204{
Alan Cox64bc3972009-10-06 16:06:11 +0100205 mutex_lock(&port->mutex);
Johan Hovold8bde9652013-03-07 15:55:48 +0100206 if (port->console)
207 goto out;
208
209 if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
Johan Hovold957daca2013-03-07 15:55:51 +0100210 /*
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
Johan Hovold8bde9652013-03-07 15:55:48 +0100217 if (port->ops->shutdown)
Alan Cox7ca0ff92009-09-19 13:13:20 -0700218 port->ops->shutdown(port);
Johan Hovold8bde9652013-03-07 15:55:48 +0100219 }
220out:
Alan Cox64bc3972009-10-06 16:06:11 +0100221 mutex_unlock(&port->mutex);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700222}
223
Alan Cox31f35932009-01-02 13:45:05 +0000224/**
Alan Cox3e616962009-01-02 13:45:26 +0000225 * 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.
Peter Hurley9c9928b2014-06-16 09:17:02 -0400230 *
231 * Caller holds tty lock.
Alan Cox3e616962009-01-02 13:45:26 +0000232 */
233
234void tty_port_hangup(struct tty_port *port)
235{
Johan Hovold957daca2013-03-07 15:55:51 +0100236 struct tty_struct *tty;
Alan Cox3e616962009-01-02 13:45:26 +0000237 unsigned long flags;
238
239 spin_lock_irqsave(&port->lock, flags);
240 port->count = 0;
241 port->flags &= ~ASYNC_NORMAL_ACTIVE;
Johan Hovold957daca2013-03-07 15:55:51 +0100242 tty = port->tty;
243 if (tty)
244 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox3e616962009-01-02 13:45:26 +0000245 port->tty = NULL;
246 spin_unlock_irqrestore(&port->lock, flags);
Johan Hovold957daca2013-03-07 15:55:51 +0100247 tty_port_shutdown(port, tty);
248 tty_kref_put(tty);
Alan Cox3e616962009-01-02 13:45:26 +0000249 wake_up_interruptible(&port->open_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -0700250 wake_up_interruptible(&port->delta_msr_wait);
Alan Cox3e616962009-01-02 13:45:26 +0000251}
252EXPORT_SYMBOL(tty_port_hangup);
253
254/**
Jiri Slabyaa27a092013-03-07 13:12:30 +0100255 * tty_port_tty_hangup - helper to hang up a tty
256 *
257 * @port: tty port
258 * @check_clocal: hang only ttys with CLOCAL unset?
259 */
260void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
261{
262 struct tty_struct *tty = tty_port_tty_get(port);
263
Gianluca Anzolin1d9e6892013-07-25 07:26:16 +0200264 if (tty && (!check_clocal || !C_CLOCAL(tty)))
Jiri Slabyaa27a092013-03-07 13:12:30 +0100265 tty_hangup(tty);
Gianluca Anzolin1d9e6892013-07-25 07:26:16 +0200266 tty_kref_put(tty);
Jiri Slabyaa27a092013-03-07 13:12:30 +0100267}
268EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
269
270/**
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100271 * tty_port_tty_wakeup - helper to wake up a tty
272 *
273 * @port: tty port
274 */
275void tty_port_tty_wakeup(struct tty_port *port)
276{
277 struct tty_struct *tty = tty_port_tty_get(port);
278
279 if (tty) {
280 tty_wakeup(tty);
281 tty_kref_put(tty);
282 }
283}
284EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
285
286/**
Alan Cox31f35932009-01-02 13:45:05 +0000287 * tty_port_carrier_raised - carrier raised check
288 * @port: tty port
289 *
290 * Wrapper for the carrier detect logic. For the moment this is used
291 * to hide some internal details. This will eventually become entirely
292 * internal to the tty port.
293 */
294
295int tty_port_carrier_raised(struct tty_port *port)
296{
297 if (port->ops->carrier_raised == NULL)
298 return 1;
299 return port->ops->carrier_raised(port);
300}
301EXPORT_SYMBOL(tty_port_carrier_raised);
Alan Cox5d951fb2009-01-02 13:45:19 +0000302
303/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100304 * tty_port_raise_dtr_rts - Raise DTR/RTS
Alan Cox5d951fb2009-01-02 13:45:19 +0000305 * @port: tty port
306 *
307 * Wrapper for the DTR/RTS raise logic. For the moment this is used
308 * to hide some internal details. This will eventually become entirely
309 * internal to the tty port.
310 */
311
312void tty_port_raise_dtr_rts(struct tty_port *port)
313{
Alan Coxfcc8ac12009-06-11 12:24:17 +0100314 if (port->ops->dtr_rts)
315 port->ops->dtr_rts(port, 1);
Alan Cox5d951fb2009-01-02 13:45:19 +0000316}
317EXPORT_SYMBOL(tty_port_raise_dtr_rts);
Alan Cox36c621d2009-01-02 13:46:10 +0000318
319/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100320 * tty_port_lower_dtr_rts - Lower DTR/RTS
321 * @port: tty port
322 *
323 * Wrapper for the DTR/RTS raise logic. For the moment this is used
324 * to hide some internal details. This will eventually become entirely
325 * internal to the tty port.
326 */
327
328void tty_port_lower_dtr_rts(struct tty_port *port)
329{
330 if (port->ops->dtr_rts)
331 port->ops->dtr_rts(port, 0);
332}
333EXPORT_SYMBOL(tty_port_lower_dtr_rts);
334
335/**
Alan Cox36c621d2009-01-02 13:46:10 +0000336 * tty_port_block_til_ready - Waiting logic for tty open
337 * @port: the tty port being opened
338 * @tty: the tty device being bound
339 * @filp: the file pointer of the opener
340 *
341 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
342 * Handles:
343 * - hangup (both before and during)
344 * - non blocking open
345 * - rts/dtr/dcd
346 * - signals
347 * - port flags and counts
348 *
349 * The passed tty_port must implement the carrier_raised method if it can
Alan Coxfcc8ac12009-06-11 12:24:17 +0100350 * do carrier detect and the dtr_rts method if it supports software
Alan Cox36c621d2009-01-02 13:46:10 +0000351 * management of these lines. Note that the dtr/rts raise is done each
352 * iteration as a hangup may have previously dropped them while we wait.
Peter Hurleyc590f6b2014-06-16 09:17:01 -0400353 *
354 * Caller holds tty lock.
355 *
356 * NB: May drop and reacquire tty lock when blocking, so tty and tty_port
357 * may have changed state (eg., may have been hung up).
Alan Cox36c621d2009-01-02 13:46:10 +0000358 */
Alan Coxd774a562009-10-06 16:06:21 +0100359
Alan Cox36c621d2009-01-02 13:46:10 +0000360int tty_port_block_til_ready(struct tty_port *port,
361 struct tty_struct *tty, struct file *filp)
362{
363 int do_clocal = 0, retval;
364 unsigned long flags;
Jiri Slaby6af9a432009-06-24 18:35:05 +0100365 DEFINE_WAIT(wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000366
367 /* block if port is in the process of being closed */
Peter Hurleye359a4e2014-06-16 09:17:06 -0400368 if (port->flags & ASYNC_CLOSING) {
Alan Cox89c8d912012-08-08 16:30:13 +0100369 wait_event_interruptible_tty(tty, port->close_wait,
Jiri Slaby5fc5b422009-06-11 14:32:42 +0100370 !(port->flags & ASYNC_CLOSING));
Alan Cox36c621d2009-01-02 13:46:10 +0000371 if (port->flags & ASYNC_HUP_NOTIFY)
372 return -EAGAIN;
373 else
374 return -ERESTARTSYS;
375 }
376
377 /* if non-blocking mode is set we can pass directly to open unless
378 the port has just hung up or is in another error state */
Alan Cox8627b962009-11-18 14:12:58 +0000379 if (tty->flags & (1 << TTY_IO_ERROR)) {
380 port->flags |= ASYNC_NORMAL_ACTIVE;
381 return 0;
382 }
383 if (filp->f_flags & O_NONBLOCK) {
Alan Cox4175f3e2009-10-28 21:12:32 +0100384 /* Indicate we are open */
Alan Coxadc8d742012-07-14 15:31:47 +0100385 if (tty->termios.c_cflag & CBAUD)
Alan Cox4175f3e2009-10-28 21:12:32 +0100386 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000387 port->flags |= ASYNC_NORMAL_ACTIVE;
388 return 0;
389 }
390
391 if (C_CLOCAL(tty))
392 do_clocal = 1;
393
394 /* Block waiting until we can proceed. We may need to wait for the
395 carrier, but we must also wait for any close that is in progress
396 before the next open may complete */
397
398 retval = 0;
Alan Cox36c621d2009-01-02 13:46:10 +0000399
400 /* The port lock protects the port counts */
401 spin_lock_irqsave(&port->lock, flags);
Peter Hurleye359a4e2014-06-16 09:17:06 -0400402 port->count--;
Alan Cox36c621d2009-01-02 13:46:10 +0000403 port->blocked_open++;
404 spin_unlock_irqrestore(&port->lock, flags);
405
406 while (1) {
407 /* Indicate we are open */
Johan Hovolde584a022013-03-07 15:55:50 +0100408 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
Alan Cox78349092009-01-02 13:46:43 +0000409 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000410
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100411 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
Alan Coxd774a562009-10-06 16:06:21 +0100412 /* Check for a hangup or uninitialised port.
413 Return accordingly */
Alan Cox36c621d2009-01-02 13:46:10 +0000414 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
415 if (port->flags & ASYNC_HUP_NOTIFY)
416 retval = -EAGAIN;
417 else
418 retval = -ERESTARTSYS;
419 break;
420 }
Jiri Slaby0eee50a2012-01-12 22:55:15 +0100421 /*
422 * Probe the carrier. For devices with no carrier detect
423 * tty_port_carrier_raised will always return true.
424 * Never ask drivers if CLOCAL is set, this causes troubles
425 * on some hardware.
426 */
Alan Cox36c621d2009-01-02 13:46:10 +0000427 if (!(port->flags & ASYNC_CLOSING) &&
Jiri Slaby0eee50a2012-01-12 22:55:15 +0100428 (do_clocal || tty_port_carrier_raised(port)))
Alan Cox36c621d2009-01-02 13:46:10 +0000429 break;
430 if (signal_pending(current)) {
431 retval = -ERESTARTSYS;
432 break;
433 }
Alan Cox89c8d912012-08-08 16:30:13 +0100434 tty_unlock(tty);
Alan Cox36c621d2009-01-02 13:46:10 +0000435 schedule();
Alan Cox89c8d912012-08-08 16:30:13 +0100436 tty_lock(tty);
Alan Cox36c621d2009-01-02 13:46:10 +0000437 }
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100438 finish_wait(&port->open_wait, &wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000439
440 /* Update counts. A parallel hangup will have set count to zero and
441 we must not mess that up further */
442 spin_lock_irqsave(&port->lock, flags);
443 if (!tty_hung_up_p(filp))
444 port->count++;
445 port->blocked_open--;
446 if (retval == 0)
447 port->flags |= ASYNC_NORMAL_ACTIVE;
448 spin_unlock_irqrestore(&port->lock, flags);
Alan Coxecc2e052009-07-17 16:17:26 +0100449 return retval;
Alan Cox36c621d2009-01-02 13:46:10 +0000450}
451EXPORT_SYMBOL(tty_port_block_til_ready);
452
Johan Hovoldb74414f2013-03-07 15:55:52 +0100453static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
454{
455 unsigned int bps = tty_get_baud_rate(tty);
456 long timeout;
457
458 if (bps > 1200) {
459 timeout = (HZ * 10 * port->drain_delay) / bps;
460 timeout = max_t(long, timeout, HZ / 10);
461 } else {
462 timeout = 2 * HZ;
463 }
464 schedule_timeout_interruptible(timeout);
465}
466
Peter Hurley0733db92014-06-16 09:16:59 -0400467/* Caller holds tty lock.
468 * NB: may drop and reacquire tty lock (in tty_wait_until_sent_from_close())
469 * so tty and tty port may have changed state (but not hung up or reopened).
470 */
Alan Coxd774a562009-10-06 16:06:21 +0100471int tty_port_close_start(struct tty_port *port,
472 struct tty_struct *tty, struct file *filp)
Alan Coxa6614992009-01-02 13:46:50 +0000473{
474 unsigned long flags;
475
476 spin_lock_irqsave(&port->lock, flags);
477 if (tty_hung_up_p(filp)) {
478 spin_unlock_irqrestore(&port->lock, flags);
479 return 0;
480 }
481
Alan Coxd774a562009-10-06 16:06:21 +0100482 if (tty->count == 1 && port->count != 1) {
Alan Coxa6614992009-01-02 13:46:50 +0000483 printk(KERN_WARNING
484 "tty_port_close_start: tty->count = 1 port count = %d.\n",
485 port->count);
486 port->count = 1;
487 }
488 if (--port->count < 0) {
489 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
490 port->count);
491 port->count = 0;
492 }
493
494 if (port->count) {
495 spin_unlock_irqrestore(&port->lock, flags);
496 return 0;
497 }
Alan Stern1f5c13f2009-08-20 15:23:47 -0400498 set_bit(ASYNCB_CLOSING, &port->flags);
Alan Coxa6614992009-01-02 13:46:50 +0000499 spin_unlock_irqrestore(&port->lock, flags);
Johan Hovold0b2588c2013-03-07 15:55:53 +0100500
Peter Hurleyddc7b752014-06-16 09:17:03 -0400501 tty->closing = 1;
502
Johan Hovold0b2588c2013-03-07 15:55:53 +0100503 if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
504 /* Don't block on a stalled port, just pull the chain */
505 if (tty->flow_stopped)
506 tty_driver_flush_buffer(tty);
507 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
508 tty_wait_until_sent_from_close(tty, port->closing_wait);
509 if (port->drain_delay)
510 tty_port_drain_delay(port, tty);
511 }
Alan Coxe707c352009-11-05 13:27:57 +0000512 /* Flush the ldisc buffering */
513 tty_ldisc_flush(tty);
514
Peter Hurley469d6d02013-09-18 20:47:06 -0400515 /* Report to caller this is the last port reference */
Alan Coxa6614992009-01-02 13:46:50 +0000516 return 1;
517}
518EXPORT_SYMBOL(tty_port_close_start);
519
Peter Hurley0733db92014-06-16 09:16:59 -0400520/* Caller holds tty lock */
Alan Coxa6614992009-01-02 13:46:50 +0000521void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
522{
523 unsigned long flags;
524
Alan Coxa6614992009-01-02 13:46:50 +0000525 tty->closing = 0;
526
Peter Hurleyddc7b752014-06-16 09:17:03 -0400527 spin_lock_irqsave(&port->lock, flags);
528
Alan Coxa6614992009-01-02 13:46:50 +0000529 if (port->blocked_open) {
530 spin_unlock_irqrestore(&port->lock, flags);
531 if (port->close_delay) {
532 msleep_interruptible(
533 jiffies_to_msecs(port->close_delay));
534 }
535 spin_lock_irqsave(&port->lock, flags);
536 wake_up_interruptible(&port->open_wait);
537 }
538 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
539 wake_up_interruptible(&port->close_wait);
540 spin_unlock_irqrestore(&port->lock, flags);
541}
542EXPORT_SYMBOL(tty_port_close_end);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700543
Peter Hurley0733db92014-06-16 09:16:59 -0400544/**
545 * tty_port_close
546 *
547 * Caller holds tty lock
548 *
549 * NB: may drop and reacquire tty lock (in tty_port_close_start()->
550 * tty_wait_until_sent_from_close()) so tty and tty_port may have changed
551 * state (but not hung up or reopened).
552 */
Alan Cox7ca0ff92009-09-19 13:13:20 -0700553void tty_port_close(struct tty_port *port, struct tty_struct *tty,
554 struct file *filp)
555{
556 if (tty_port_close_start(port, tty, filp) == 0)
557 return;
Johan Hovold957daca2013-03-07 15:55:51 +0100558 tty_port_shutdown(port, tty);
Alan Coxd74e8282009-11-30 13:16:52 +0000559 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700560 tty_port_close_end(port, tty);
561 tty_port_tty_set(port, NULL);
562}
563EXPORT_SYMBOL(tty_port_close);
Alan Cox64bc3972009-10-06 16:06:11 +0100564
Jiri Slaby72a33bf2012-08-07 21:47:49 +0200565/**
566 * tty_port_install - generic tty->ops->install handler
567 * @port: tty_port of the device
568 * @driver: tty_driver for this device
569 * @tty: tty to be installed
570 *
571 * It is the same as tty_standard_install except the provided @port is linked
572 * to a concrete tty specified by @tty. Use this or tty_port_register_device
573 * (or both). Call tty_port_link_device as a last resort.
574 */
Jiri Slaby695586c2012-06-04 13:35:32 +0200575int tty_port_install(struct tty_port *port, struct tty_driver *driver,
576 struct tty_struct *tty)
577{
578 tty->port = port;
579 return tty_standard_install(driver, tty);
580}
581EXPORT_SYMBOL_GPL(tty_port_install);
582
Peter Hurleyaddd4672014-06-16 09:17:00 -0400583/**
584 * tty_port_open
585 *
586 * Caller holds tty lock.
587 *
588 * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
589 * tty and tty_port may have changed state (eg., may be hung up now)
590 */
Alan Cox64bc3972009-10-06 16:06:11 +0100591int tty_port_open(struct tty_port *port, struct tty_struct *tty,
Alan Coxd774a562009-10-06 16:06:21 +0100592 struct file *filp)
Alan Cox64bc3972009-10-06 16:06:11 +0100593{
594 spin_lock_irq(&port->lock);
Peter Hurleye359a4e2014-06-16 09:17:06 -0400595 ++port->count;
Alan Cox64bc3972009-10-06 16:06:11 +0100596 spin_unlock_irq(&port->lock);
597 tty_port_tty_set(port, tty);
598
599 /*
600 * Do the device-specific open only if the hardware isn't
601 * already initialized. Serialize open and shutdown using the
602 * port mutex.
603 */
604
605 mutex_lock(&port->mutex);
606
607 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
Alan Coxa9a37ec2009-11-30 13:16:57 +0000608 clear_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox64bc3972009-10-06 16:06:11 +0100609 if (port->ops->activate) {
610 int retval = port->ops->activate(port, tty);
611 if (retval) {
Alan Coxd774a562009-10-06 16:06:21 +0100612 mutex_unlock(&port->mutex);
613 return retval;
614 }
615 }
Alan Cox64bc3972009-10-06 16:06:11 +0100616 set_bit(ASYNCB_INITIALIZED, &port->flags);
617 }
618 mutex_unlock(&port->mutex);
619 return tty_port_block_til_ready(port, tty, filp);
620}
621
622EXPORT_SYMBOL(tty_port_open);