blob: bf6e238146ae40acd4ac8ea2f517574870366590 [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>
15#include <linux/init.h>
16#include <linux/wait.h>
17#include <linux/bitops.h>
18#include <linux/delay.h>
19#include <linux/module.h>
20
21void tty_port_init(struct tty_port *port)
22{
23 memset(port, 0, sizeof(*port));
24 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
36int tty_port_alloc_xmit_buf(struct tty_port *port)
37{
38 /* We may sleep in get_zeroed_page() */
Alan Cox44e49092009-11-30 13:16:41 +000039 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +010040 if (port->xmit_buf == NULL)
41 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
Alan Cox44e49092009-11-30 13:16:41 +000042 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +010043 if (port->xmit_buf == NULL)
44 return -ENOMEM;
45 return 0;
46}
47EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
48
49void tty_port_free_xmit_buf(struct tty_port *port)
50{
Alan Cox44e49092009-11-30 13:16:41 +000051 mutex_lock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +010052 if (port->xmit_buf != NULL) {
53 free_page((unsigned long)port->xmit_buf);
54 port->xmit_buf = NULL;
55 }
Alan Cox44e49092009-11-30 13:16:41 +000056 mutex_unlock(&port->buf_mutex);
Alan Cox9e485652008-10-13 10:37:07 +010057}
58EXPORT_SYMBOL(tty_port_free_xmit_buf);
59
Alan Cox568aafc2009-11-30 13:17:14 +000060static void tty_port_destructor(struct kref *kref)
61{
62 struct tty_port *port = container_of(kref, struct tty_port, kref);
63 if (port->xmit_buf)
64 free_page((unsigned long)port->xmit_buf);
65 if (port->ops->destruct)
66 port->ops->destruct(port);
67 else
68 kfree(port);
69}
70
71void tty_port_put(struct tty_port *port)
72{
73 if (port)
74 kref_put(&port->kref, tty_port_destructor);
75}
76EXPORT_SYMBOL(tty_port_put);
Alan Cox9e485652008-10-13 10:37:07 +010077
Alan Cox4a90f092008-10-13 10:39:46 +010078/**
79 * tty_port_tty_get - get a tty reference
80 * @port: tty port
81 *
82 * Return a refcount protected tty instance or NULL if the port is not
83 * associated with a tty (eg due to close or hangup)
84 */
85
86struct tty_struct *tty_port_tty_get(struct tty_port *port)
87{
88 unsigned long flags;
89 struct tty_struct *tty;
90
91 spin_lock_irqsave(&port->lock, flags);
92 tty = tty_kref_get(port->tty);
93 spin_unlock_irqrestore(&port->lock, flags);
94 return tty;
95}
96EXPORT_SYMBOL(tty_port_tty_get);
97
98/**
99 * tty_port_tty_set - set the tty of a port
100 * @port: tty port
101 * @tty: the tty
102 *
103 * Associate the port and tty pair. Manages any internal refcounts.
104 * Pass NULL to deassociate a port
105 */
106
107void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
108{
109 unsigned long flags;
110
111 spin_lock_irqsave(&port->lock, flags);
112 if (port->tty)
113 tty_kref_put(port->tty);
Alan Coxcb4bca32008-10-21 13:47:44 +0100114 port->tty = tty_kref_get(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100115 spin_unlock_irqrestore(&port->lock, flags);
116}
117EXPORT_SYMBOL(tty_port_tty_set);
Alan Cox31f35932009-01-02 13:45:05 +0000118
Alan Cox7ca0ff92009-09-19 13:13:20 -0700119static void tty_port_shutdown(struct tty_port *port)
120{
Alan Cox64bc3972009-10-06 16:06:11 +0100121 mutex_lock(&port->mutex);
Jason Wessel336cee42010-03-08 21:50:11 -0600122 if (port->ops->shutdown && !port->console &&
Alan Stern1f5c13f2009-08-20 15:23:47 -0400123 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
Alan Cox7ca0ff92009-09-19 13:13:20 -0700124 port->ops->shutdown(port);
Alan Cox64bc3972009-10-06 16:06:11 +0100125 mutex_unlock(&port->mutex);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700126}
127
Alan Cox31f35932009-01-02 13:45:05 +0000128/**
Alan Cox3e616962009-01-02 13:45:26 +0000129 * tty_port_hangup - hangup helper
130 * @port: tty port
131 *
132 * Perform port level tty hangup flag and count changes. Drop the tty
133 * reference.
134 */
135
136void tty_port_hangup(struct tty_port *port)
137{
138 unsigned long flags;
139
140 spin_lock_irqsave(&port->lock, flags);
141 port->count = 0;
142 port->flags &= ~ASYNC_NORMAL_ACTIVE;
Alan Coxd74e8282009-11-30 13:16:52 +0000143 if (port->tty) {
144 set_bit(TTY_IO_ERROR, &port->tty->flags);
Alan Cox3e616962009-01-02 13:45:26 +0000145 tty_kref_put(port->tty);
Alan Coxd74e8282009-11-30 13:16:52 +0000146 }
Alan Cox3e616962009-01-02 13:45:26 +0000147 port->tty = NULL;
148 spin_unlock_irqrestore(&port->lock, flags);
149 wake_up_interruptible(&port->open_wait);
Alan Coxbdc04e32009-09-19 13:13:31 -0700150 wake_up_interruptible(&port->delta_msr_wait);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700151 tty_port_shutdown(port);
Alan Cox3e616962009-01-02 13:45:26 +0000152}
153EXPORT_SYMBOL(tty_port_hangup);
154
155/**
Alan Cox31f35932009-01-02 13:45:05 +0000156 * tty_port_carrier_raised - carrier raised check
157 * @port: tty port
158 *
159 * Wrapper for the carrier detect logic. For the moment this is used
160 * to hide some internal details. This will eventually become entirely
161 * internal to the tty port.
162 */
163
164int tty_port_carrier_raised(struct tty_port *port)
165{
166 if (port->ops->carrier_raised == NULL)
167 return 1;
168 return port->ops->carrier_raised(port);
169}
170EXPORT_SYMBOL(tty_port_carrier_raised);
Alan Cox5d951fb2009-01-02 13:45:19 +0000171
172/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100173 * tty_port_raise_dtr_rts - Raise DTR/RTS
Alan Cox5d951fb2009-01-02 13:45:19 +0000174 * @port: tty port
175 *
176 * Wrapper for the DTR/RTS raise logic. For the moment this is used
177 * to hide some internal details. This will eventually become entirely
178 * internal to the tty port.
179 */
180
181void tty_port_raise_dtr_rts(struct tty_port *port)
182{
Alan Coxfcc8ac12009-06-11 12:24:17 +0100183 if (port->ops->dtr_rts)
184 port->ops->dtr_rts(port, 1);
Alan Cox5d951fb2009-01-02 13:45:19 +0000185}
186EXPORT_SYMBOL(tty_port_raise_dtr_rts);
Alan Cox36c621d2009-01-02 13:46:10 +0000187
188/**
Alan Coxfcc8ac12009-06-11 12:24:17 +0100189 * tty_port_lower_dtr_rts - Lower DTR/RTS
190 * @port: tty port
191 *
192 * Wrapper for the DTR/RTS raise logic. For the moment this is used
193 * to hide some internal details. This will eventually become entirely
194 * internal to the tty port.
195 */
196
197void tty_port_lower_dtr_rts(struct tty_port *port)
198{
199 if (port->ops->dtr_rts)
200 port->ops->dtr_rts(port, 0);
201}
202EXPORT_SYMBOL(tty_port_lower_dtr_rts);
203
204/**
Alan Cox36c621d2009-01-02 13:46:10 +0000205 * tty_port_block_til_ready - Waiting logic for tty open
206 * @port: the tty port being opened
207 * @tty: the tty device being bound
208 * @filp: the file pointer of the opener
209 *
210 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
211 * Handles:
212 * - hangup (both before and during)
213 * - non blocking open
214 * - rts/dtr/dcd
215 * - signals
216 * - port flags and counts
217 *
218 * The passed tty_port must implement the carrier_raised method if it can
Alan Coxfcc8ac12009-06-11 12:24:17 +0100219 * do carrier detect and the dtr_rts method if it supports software
Alan Cox36c621d2009-01-02 13:46:10 +0000220 * management of these lines. Note that the dtr/rts raise is done each
221 * iteration as a hangup may have previously dropped them while we wait.
222 */
Alan Coxd774a562009-10-06 16:06:21 +0100223
Alan Cox36c621d2009-01-02 13:46:10 +0000224int tty_port_block_til_ready(struct tty_port *port,
225 struct tty_struct *tty, struct file *filp)
226{
227 int do_clocal = 0, retval;
228 unsigned long flags;
Jiri Slaby6af9a432009-06-24 18:35:05 +0100229 DEFINE_WAIT(wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000230
231 /* block if port is in the process of being closed */
232 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
Linus Torvaldsf3095322012-06-02 15:21:43 -0700233 wait_event_interruptible_tty(port->close_wait,
Jiri Slaby5fc5b422009-06-11 14:32:42 +0100234 !(port->flags & ASYNC_CLOSING));
Alan Cox36c621d2009-01-02 13:46:10 +0000235 if (port->flags & ASYNC_HUP_NOTIFY)
236 return -EAGAIN;
237 else
238 return -ERESTARTSYS;
239 }
240
241 /* if non-blocking mode is set we can pass directly to open unless
242 the port has just hung up or is in another error state */
Alan Cox8627b962009-11-18 14:12:58 +0000243 if (tty->flags & (1 << TTY_IO_ERROR)) {
244 port->flags |= ASYNC_NORMAL_ACTIVE;
245 return 0;
246 }
247 if (filp->f_flags & O_NONBLOCK) {
Alan Cox4175f3e2009-10-28 21:12:32 +0100248 /* Indicate we are open */
249 if (tty->termios->c_cflag & CBAUD)
250 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000251 port->flags |= ASYNC_NORMAL_ACTIVE;
252 return 0;
253 }
254
255 if (C_CLOCAL(tty))
256 do_clocal = 1;
257
258 /* Block waiting until we can proceed. We may need to wait for the
259 carrier, but we must also wait for any close that is in progress
260 before the next open may complete */
261
262 retval = 0;
Alan Cox36c621d2009-01-02 13:46:10 +0000263
264 /* The port lock protects the port counts */
265 spin_lock_irqsave(&port->lock, flags);
266 if (!tty_hung_up_p(filp))
267 port->count--;
268 port->blocked_open++;
269 spin_unlock_irqrestore(&port->lock, flags);
270
271 while (1) {
272 /* Indicate we are open */
Alan Cox78349092009-01-02 13:46:43 +0000273 if (tty->termios->c_cflag & CBAUD)
274 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000275
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100276 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
Alan Coxd774a562009-10-06 16:06:21 +0100277 /* Check for a hangup or uninitialised port.
278 Return accordingly */
Alan Cox36c621d2009-01-02 13:46:10 +0000279 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
280 if (port->flags & ASYNC_HUP_NOTIFY)
281 retval = -EAGAIN;
282 else
283 retval = -ERESTARTSYS;
284 break;
285 }
Jiri Slaby0eee50a2012-01-12 22:55:15 +0100286 /*
287 * Probe the carrier. For devices with no carrier detect
288 * tty_port_carrier_raised will always return true.
289 * Never ask drivers if CLOCAL is set, this causes troubles
290 * on some hardware.
291 */
Alan Cox36c621d2009-01-02 13:46:10 +0000292 if (!(port->flags & ASYNC_CLOSING) &&
Jiri Slaby0eee50a2012-01-12 22:55:15 +0100293 (do_clocal || tty_port_carrier_raised(port)))
Alan Cox36c621d2009-01-02 13:46:10 +0000294 break;
295 if (signal_pending(current)) {
296 retval = -ERESTARTSYS;
297 break;
298 }
Linus Torvaldsf3095322012-06-02 15:21:43 -0700299 tty_unlock();
Alan Cox36c621d2009-01-02 13:46:10 +0000300 schedule();
Linus Torvaldsf3095322012-06-02 15:21:43 -0700301 tty_lock();
Alan Cox36c621d2009-01-02 13:46:10 +0000302 }
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100303 finish_wait(&port->open_wait, &wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000304
305 /* Update counts. A parallel hangup will have set count to zero and
306 we must not mess that up further */
307 spin_lock_irqsave(&port->lock, flags);
308 if (!tty_hung_up_p(filp))
309 port->count++;
310 port->blocked_open--;
311 if (retval == 0)
312 port->flags |= ASYNC_NORMAL_ACTIVE;
313 spin_unlock_irqrestore(&port->lock, flags);
Alan Coxecc2e052009-07-17 16:17:26 +0100314 return retval;
Alan Cox36c621d2009-01-02 13:46:10 +0000315}
316EXPORT_SYMBOL(tty_port_block_til_ready);
317
Alan Coxd774a562009-10-06 16:06:21 +0100318int tty_port_close_start(struct tty_port *port,
319 struct tty_struct *tty, struct file *filp)
Alan Coxa6614992009-01-02 13:46:50 +0000320{
321 unsigned long flags;
322
323 spin_lock_irqsave(&port->lock, flags);
324 if (tty_hung_up_p(filp)) {
325 spin_unlock_irqrestore(&port->lock, flags);
326 return 0;
327 }
328
Alan Coxd774a562009-10-06 16:06:21 +0100329 if (tty->count == 1 && port->count != 1) {
Alan Coxa6614992009-01-02 13:46:50 +0000330 printk(KERN_WARNING
331 "tty_port_close_start: tty->count = 1 port count = %d.\n",
332 port->count);
333 port->count = 1;
334 }
335 if (--port->count < 0) {
336 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
337 port->count);
338 port->count = 0;
339 }
340
341 if (port->count) {
342 spin_unlock_irqrestore(&port->lock, flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700343 if (port->ops->drop)
344 port->ops->drop(port);
Alan Coxa6614992009-01-02 13:46:50 +0000345 return 0;
346 }
Alan Stern1f5c13f2009-08-20 15:23:47 -0400347 set_bit(ASYNCB_CLOSING, &port->flags);
Alan Coxa6614992009-01-02 13:46:50 +0000348 tty->closing = 1;
349 spin_unlock_irqrestore(&port->lock, flags);
Alan Coxfba85e02009-01-02 13:48:39 +0000350 /* Don't block on a stalled port, just pull the chain */
351 if (tty->flow_stopped)
352 tty_driver_flush_buffer(tty);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700353 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
Alan Cox6ed1dba2009-01-02 13:48:11 +0000354 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
Jiri Slaby424cc032011-08-25 15:12:07 +0200355 tty_wait_until_sent_from_close(tty, port->closing_wait);
Alan Cox1ec739b2009-06-11 12:25:25 +0100356 if (port->drain_delay) {
357 unsigned int bps = tty_get_baud_rate(tty);
358 long timeout;
359
360 if (bps > 1200)
Alan Coxd774a562009-10-06 16:06:21 +0100361 timeout = max_t(long,
362 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
Alan Cox1ec739b2009-06-11 12:25:25 +0100363 else
364 timeout = 2 * HZ;
365 schedule_timeout_interruptible(timeout);
366 }
Alan Coxe707c352009-11-05 13:27:57 +0000367 /* Flush the ldisc buffering */
368 tty_ldisc_flush(tty);
369
370 /* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
371 hang up the line */
372 if (tty->termios->c_cflag & HUPCL)
373 tty_port_lower_dtr_rts(port);
374
Alan Cox7ca0ff92009-09-19 13:13:20 -0700375 /* Don't call port->drop for the last reference. Callers will want
376 to drop the last active reference in ->shutdown() or the tty
377 shutdown path */
Alan Coxa6614992009-01-02 13:46:50 +0000378 return 1;
379}
380EXPORT_SYMBOL(tty_port_close_start);
381
382void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
383{
384 unsigned long flags;
385
Alan Coxa6614992009-01-02 13:46:50 +0000386 spin_lock_irqsave(&port->lock, flags);
387 tty->closing = 0;
388
389 if (port->blocked_open) {
390 spin_unlock_irqrestore(&port->lock, flags);
391 if (port->close_delay) {
392 msleep_interruptible(
393 jiffies_to_msecs(port->close_delay));
394 }
395 spin_lock_irqsave(&port->lock, flags);
396 wake_up_interruptible(&port->open_wait);
397 }
398 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
399 wake_up_interruptible(&port->close_wait);
400 spin_unlock_irqrestore(&port->lock, flags);
401}
402EXPORT_SYMBOL(tty_port_close_end);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700403
404void tty_port_close(struct tty_port *port, struct tty_struct *tty,
405 struct file *filp)
406{
407 if (tty_port_close_start(port, tty, filp) == 0)
408 return;
409 tty_port_shutdown(port);
Alan Coxd74e8282009-11-30 13:16:52 +0000410 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700411 tty_port_close_end(port, tty);
412 tty_port_tty_set(port, NULL);
413}
414EXPORT_SYMBOL(tty_port_close);
Alan Cox64bc3972009-10-06 16:06:11 +0100415
416int tty_port_open(struct tty_port *port, struct tty_struct *tty,
Alan Coxd774a562009-10-06 16:06:21 +0100417 struct file *filp)
Alan Cox64bc3972009-10-06 16:06:11 +0100418{
419 spin_lock_irq(&port->lock);
420 if (!tty_hung_up_p(filp))
421 ++port->count;
422 spin_unlock_irq(&port->lock);
423 tty_port_tty_set(port, tty);
424
425 /*
426 * Do the device-specific open only if the hardware isn't
427 * already initialized. Serialize open and shutdown using the
428 * port mutex.
429 */
430
431 mutex_lock(&port->mutex);
432
433 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
Alan Coxa9a37ec2009-11-30 13:16:57 +0000434 clear_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox64bc3972009-10-06 16:06:11 +0100435 if (port->ops->activate) {
436 int retval = port->ops->activate(port, tty);
437 if (retval) {
Alan Coxd774a562009-10-06 16:06:21 +0100438 mutex_unlock(&port->mutex);
439 return retval;
440 }
441 }
Alan Cox64bc3972009-10-06 16:06:11 +0100442 set_bit(ASYNCB_INITIALIZED, &port->flags);
443 }
444 mutex_unlock(&port->mutex);
445 return tty_port_block_til_ready(port, tty, filp);
446}
447
448EXPORT_SYMBOL(tty_port_open);