blob: a3bd1d0b66cfe3fbba3bf9592c0bfbab26bb88a3 [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 int cd;
231
232 /* block if port is in the process of being closed */
233 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
Jiri Slaby5fc5b422009-06-11 14:32:42 +0100234 wait_event_interruptible(port->close_wait,
235 !(port->flags & ASYNC_CLOSING));
Alan Cox36c621d2009-01-02 13:46:10 +0000236 if (port->flags & ASYNC_HUP_NOTIFY)
237 return -EAGAIN;
238 else
239 return -ERESTARTSYS;
240 }
241
242 /* if non-blocking mode is set we can pass directly to open unless
243 the port has just hung up or is in another error state */
Alan Cox8627b962009-11-18 14:12:58 +0000244 if (tty->flags & (1 << TTY_IO_ERROR)) {
245 port->flags |= ASYNC_NORMAL_ACTIVE;
246 return 0;
247 }
248 if (filp->f_flags & O_NONBLOCK) {
Alan Cox4175f3e2009-10-28 21:12:32 +0100249 /* Indicate we are open */
250 if (tty->termios->c_cflag & CBAUD)
251 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000252 port->flags |= ASYNC_NORMAL_ACTIVE;
253 return 0;
254 }
255
256 if (C_CLOCAL(tty))
257 do_clocal = 1;
258
259 /* Block waiting until we can proceed. We may need to wait for the
260 carrier, but we must also wait for any close that is in progress
261 before the next open may complete */
262
263 retval = 0;
Alan Cox36c621d2009-01-02 13:46:10 +0000264
265 /* The port lock protects the port counts */
266 spin_lock_irqsave(&port->lock, flags);
267 if (!tty_hung_up_p(filp))
268 port->count--;
269 port->blocked_open++;
270 spin_unlock_irqrestore(&port->lock, flags);
271
272 while (1) {
273 /* Indicate we are open */
Alan Cox78349092009-01-02 13:46:43 +0000274 if (tty->termios->c_cflag & CBAUD)
275 tty_port_raise_dtr_rts(port);
Alan Cox36c621d2009-01-02 13:46:10 +0000276
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100277 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
Alan Coxd774a562009-10-06 16:06:21 +0100278 /* Check for a hangup or uninitialised port.
279 Return accordingly */
Alan Cox36c621d2009-01-02 13:46:10 +0000280 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
281 if (port->flags & ASYNC_HUP_NOTIFY)
282 retval = -EAGAIN;
283 else
284 retval = -ERESTARTSYS;
285 break;
286 }
287 /* Probe the carrier. For devices with no carrier detect this
288 will always return true */
289 cd = tty_port_carrier_raised(port);
290 if (!(port->flags & ASYNC_CLOSING) &&
291 (do_clocal || cd))
292 break;
293 if (signal_pending(current)) {
294 retval = -ERESTARTSYS;
295 break;
296 }
297 schedule();
298 }
Jiri Slaby3e3b5c02009-06-11 14:33:37 +0100299 finish_wait(&port->open_wait, &wait);
Alan Cox36c621d2009-01-02 13:46:10 +0000300
301 /* Update counts. A parallel hangup will have set count to zero and
302 we must not mess that up further */
303 spin_lock_irqsave(&port->lock, flags);
304 if (!tty_hung_up_p(filp))
305 port->count++;
306 port->blocked_open--;
307 if (retval == 0)
308 port->flags |= ASYNC_NORMAL_ACTIVE;
309 spin_unlock_irqrestore(&port->lock, flags);
Alan Coxecc2e052009-07-17 16:17:26 +0100310 return retval;
Alan Cox36c621d2009-01-02 13:46:10 +0000311}
312EXPORT_SYMBOL(tty_port_block_til_ready);
313
Alan Coxd774a562009-10-06 16:06:21 +0100314int tty_port_close_start(struct tty_port *port,
315 struct tty_struct *tty, struct file *filp)
Alan Coxa6614992009-01-02 13:46:50 +0000316{
317 unsigned long flags;
318
319 spin_lock_irqsave(&port->lock, flags);
320 if (tty_hung_up_p(filp)) {
321 spin_unlock_irqrestore(&port->lock, flags);
322 return 0;
323 }
324
Alan Coxd774a562009-10-06 16:06:21 +0100325 if (tty->count == 1 && port->count != 1) {
Alan Coxa6614992009-01-02 13:46:50 +0000326 printk(KERN_WARNING
327 "tty_port_close_start: tty->count = 1 port count = %d.\n",
328 port->count);
329 port->count = 1;
330 }
331 if (--port->count < 0) {
332 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
333 port->count);
334 port->count = 0;
335 }
336
337 if (port->count) {
338 spin_unlock_irqrestore(&port->lock, flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700339 if (port->ops->drop)
340 port->ops->drop(port);
Alan Coxa6614992009-01-02 13:46:50 +0000341 return 0;
342 }
Alan Stern1f5c13f2009-08-20 15:23:47 -0400343 set_bit(ASYNCB_CLOSING, &port->flags);
Alan Coxa6614992009-01-02 13:46:50 +0000344 tty->closing = 1;
345 spin_unlock_irqrestore(&port->lock, flags);
Alan Coxfba85e02009-01-02 13:48:39 +0000346 /* Don't block on a stalled port, just pull the chain */
347 if (tty->flow_stopped)
348 tty_driver_flush_buffer(tty);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700349 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
Alan Cox6ed1dba2009-01-02 13:48:11 +0000350 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
Alan Coxa6614992009-01-02 13:46:50 +0000351 tty_wait_until_sent(tty, port->closing_wait);
Alan Cox1ec739b2009-06-11 12:25:25 +0100352 if (port->drain_delay) {
353 unsigned int bps = tty_get_baud_rate(tty);
354 long timeout;
355
356 if (bps > 1200)
Alan Coxd774a562009-10-06 16:06:21 +0100357 timeout = max_t(long,
358 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
Alan Cox1ec739b2009-06-11 12:25:25 +0100359 else
360 timeout = 2 * HZ;
361 schedule_timeout_interruptible(timeout);
362 }
Alan Coxe707c352009-11-05 13:27:57 +0000363 /* Flush the ldisc buffering */
364 tty_ldisc_flush(tty);
365
366 /* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
367 hang up the line */
368 if (tty->termios->c_cflag & HUPCL)
369 tty_port_lower_dtr_rts(port);
370
Alan Cox7ca0ff92009-09-19 13:13:20 -0700371 /* Don't call port->drop for the last reference. Callers will want
372 to drop the last active reference in ->shutdown() or the tty
373 shutdown path */
Alan Coxa6614992009-01-02 13:46:50 +0000374 return 1;
375}
376EXPORT_SYMBOL(tty_port_close_start);
377
378void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
379{
380 unsigned long flags;
381
Alan Coxa6614992009-01-02 13:46:50 +0000382 spin_lock_irqsave(&port->lock, flags);
383 tty->closing = 0;
384
385 if (port->blocked_open) {
386 spin_unlock_irqrestore(&port->lock, flags);
387 if (port->close_delay) {
388 msleep_interruptible(
389 jiffies_to_msecs(port->close_delay));
390 }
391 spin_lock_irqsave(&port->lock, flags);
392 wake_up_interruptible(&port->open_wait);
393 }
394 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
395 wake_up_interruptible(&port->close_wait);
396 spin_unlock_irqrestore(&port->lock, flags);
397}
398EXPORT_SYMBOL(tty_port_close_end);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700399
400void tty_port_close(struct tty_port *port, struct tty_struct *tty,
401 struct file *filp)
402{
403 if (tty_port_close_start(port, tty, filp) == 0)
404 return;
405 tty_port_shutdown(port);
Alan Coxd74e8282009-11-30 13:16:52 +0000406 set_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox7ca0ff92009-09-19 13:13:20 -0700407 tty_port_close_end(port, tty);
408 tty_port_tty_set(port, NULL);
409}
410EXPORT_SYMBOL(tty_port_close);
Alan Cox64bc3972009-10-06 16:06:11 +0100411
412int tty_port_open(struct tty_port *port, struct tty_struct *tty,
Alan Coxd774a562009-10-06 16:06:21 +0100413 struct file *filp)
Alan Cox64bc3972009-10-06 16:06:11 +0100414{
415 spin_lock_irq(&port->lock);
416 if (!tty_hung_up_p(filp))
417 ++port->count;
418 spin_unlock_irq(&port->lock);
419 tty_port_tty_set(port, tty);
420
421 /*
422 * Do the device-specific open only if the hardware isn't
423 * already initialized. Serialize open and shutdown using the
424 * port mutex.
425 */
426
427 mutex_lock(&port->mutex);
428
429 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
Alan Coxa9a37ec2009-11-30 13:16:57 +0000430 clear_bit(TTY_IO_ERROR, &tty->flags);
Alan Cox64bc3972009-10-06 16:06:11 +0100431 if (port->ops->activate) {
432 int retval = port->ops->activate(port, tty);
433 if (retval) {
Alan Coxd774a562009-10-06 16:06:21 +0100434 mutex_unlock(&port->mutex);
435 return retval;
436 }
437 }
Alan Cox64bc3972009-10-06 16:06:11 +0100438 set_bit(ASYNCB_INITIALIZED, &port->flags);
439 }
440 mutex_unlock(&port->mutex);
441 return tty_port_block_til_ready(port, tty, filp);
442}
443
444EXPORT_SYMBOL(tty_port_open);