tty_port: Fix return on interrupted use
[linux-2.6.git] / drivers / char / tty_port.c
1 /*
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>
10 #include <linux/serial.h>
11 #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
21 void 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);
26         mutex_init(&port->mutex);
27         spin_lock_init(&port->lock);
28         port->close_delay = (50 * HZ) / 100;
29         port->closing_wait = (3000 * HZ) / 100;
30 }
31 EXPORT_SYMBOL(tty_port_init);
32
33 int tty_port_alloc_xmit_buf(struct tty_port *port)
34 {
35         /* We may sleep in get_zeroed_page() */
36         mutex_lock(&port->mutex);
37         if (port->xmit_buf == NULL)
38                 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
39         mutex_unlock(&port->mutex);
40         if (port->xmit_buf == NULL)
41                 return -ENOMEM;
42         return 0;
43 }
44 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
45
46 void tty_port_free_xmit_buf(struct tty_port *port)
47 {
48         mutex_lock(&port->mutex);
49         if (port->xmit_buf != NULL) {
50                 free_page((unsigned long)port->xmit_buf);
51                 port->xmit_buf = NULL;
52         }
53         mutex_unlock(&port->mutex);
54 }
55 EXPORT_SYMBOL(tty_port_free_xmit_buf);
56
57
58 /**
59  *      tty_port_tty_get        -       get a tty reference
60  *      @port: tty port
61  *
62  *      Return a refcount protected tty instance or NULL if the port is not
63  *      associated with a tty (eg due to close or hangup)
64  */
65
66 struct tty_struct *tty_port_tty_get(struct tty_port *port)
67 {
68         unsigned long flags;
69         struct tty_struct *tty;
70
71         spin_lock_irqsave(&port->lock, flags);
72         tty = tty_kref_get(port->tty);
73         spin_unlock_irqrestore(&port->lock, flags);
74         return tty;
75 }
76 EXPORT_SYMBOL(tty_port_tty_get);
77
78 /**
79  *      tty_port_tty_set        -       set the tty of a port
80  *      @port: tty port
81  *      @tty: the tty
82  *
83  *      Associate the port and tty pair. Manages any internal refcounts.
84  *      Pass NULL to deassociate a port
85  */
86
87 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
88 {
89         unsigned long flags;
90
91         spin_lock_irqsave(&port->lock, flags);
92         if (port->tty)
93                 tty_kref_put(port->tty);
94         port->tty = tty_kref_get(tty);
95         spin_unlock_irqrestore(&port->lock, flags);
96 }
97 EXPORT_SYMBOL(tty_port_tty_set);
98
99 /**
100  *      tty_port_hangup         -       hangup helper
101  *      @port: tty port
102  *
103  *      Perform port level tty hangup flag and count changes. Drop the tty
104  *      reference.
105  */
106
107 void tty_port_hangup(struct tty_port *port)
108 {
109         unsigned long flags;
110
111         spin_lock_irqsave(&port->lock, flags);
112         port->count = 0;
113         port->flags &= ~ASYNC_NORMAL_ACTIVE;
114         if (port->tty)
115                 tty_kref_put(port->tty);
116         port->tty = NULL;
117         spin_unlock_irqrestore(&port->lock, flags);
118         wake_up_interruptible(&port->open_wait);
119 }
120 EXPORT_SYMBOL(tty_port_hangup);
121
122 /**
123  *      tty_port_carrier_raised -       carrier raised check
124  *      @port: tty port
125  *
126  *      Wrapper for the carrier detect logic. For the moment this is used
127  *      to hide some internal details. This will eventually become entirely
128  *      internal to the tty port.
129  */
130
131 int tty_port_carrier_raised(struct tty_port *port)
132 {
133         if (port->ops->carrier_raised == NULL)
134                 return 1;
135         return port->ops->carrier_raised(port);
136 }
137 EXPORT_SYMBOL(tty_port_carrier_raised);
138
139 /**
140  *      tty_port_raise_dtr_rts  -       Raise DTR/RTS
141  *      @port: tty port
142  *
143  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
144  *      to hide some internal details. This will eventually become entirely
145  *      internal to the tty port.
146  */
147
148 void tty_port_raise_dtr_rts(struct tty_port *port)
149 {
150         if (port->ops->dtr_rts)
151                 port->ops->dtr_rts(port, 1);
152 }
153 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
154
155 /**
156  *      tty_port_lower_dtr_rts  -       Lower DTR/RTS
157  *      @port: tty port
158  *
159  *      Wrapper for the DTR/RTS raise 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
164 void tty_port_lower_dtr_rts(struct tty_port *port)
165 {
166         if (port->ops->dtr_rts)
167                 port->ops->dtr_rts(port, 0);
168 }
169 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
170
171 /**
172  *      tty_port_block_til_ready        -       Waiting logic for tty open
173  *      @port: the tty port being opened
174  *      @tty: the tty device being bound
175  *      @filp: the file pointer of the opener
176  *
177  *      Implement the core POSIX/SuS tty behaviour when opening a tty device.
178  *      Handles:
179  *              - hangup (both before and during)
180  *              - non blocking open
181  *              - rts/dtr/dcd
182  *              - signals
183  *              - port flags and counts
184  *
185  *      The passed tty_port must implement the carrier_raised method if it can
186  *      do carrier detect and the dtr_rts method if it supports software
187  *      management of these lines. Note that the dtr/rts raise is done each
188  *      iteration as a hangup may have previously dropped them while we wait.
189  */
190  
191 int tty_port_block_til_ready(struct tty_port *port,
192                                 struct tty_struct *tty, struct file *filp)
193 {
194         int do_clocal = 0, retval;
195         unsigned long flags;
196         DEFINE_WAIT(wait);
197         int cd;
198
199         /* block if port is in the process of being closed */
200         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
201                 wait_event_interruptible(port->close_wait,
202                                 !(port->flags & ASYNC_CLOSING));
203                 if (port->flags & ASYNC_HUP_NOTIFY)
204                         return -EAGAIN;
205                 else
206                         return -ERESTARTSYS;
207         }
208
209         /* if non-blocking mode is set we can pass directly to open unless
210            the port has just hung up or is in another error state */
211         if ((filp->f_flags & O_NONBLOCK) ||
212                         (tty->flags & (1 << TTY_IO_ERROR))) {
213                 port->flags |= ASYNC_NORMAL_ACTIVE;
214                 return 0;
215         }
216
217         if (C_CLOCAL(tty))
218                 do_clocal = 1;
219
220         /* Block waiting until we can proceed. We may need to wait for the
221            carrier, but we must also wait for any close that is in progress
222            before the next open may complete */
223
224         retval = 0;
225
226         /* The port lock protects the port counts */
227         spin_lock_irqsave(&port->lock, flags);
228         if (!tty_hung_up_p(filp))
229                 port->count--;
230         port->blocked_open++;
231         spin_unlock_irqrestore(&port->lock, flags);
232
233         while (1) {
234                 /* Indicate we are open */
235                 if (tty->termios->c_cflag & CBAUD)
236                         tty_port_raise_dtr_rts(port);
237
238                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
239                 /* Check for a hangup or uninitialised port. Return accordingly */
240                 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
241                         if (port->flags & ASYNC_HUP_NOTIFY)
242                                 retval = -EAGAIN;
243                         else
244                                 retval = -ERESTARTSYS;
245                         break;
246                 }
247                 /* Probe the carrier. For devices with no carrier detect this
248                    will always return true */
249                 cd = tty_port_carrier_raised(port);
250                 if (!(port->flags & ASYNC_CLOSING) &&
251                                 (do_clocal || cd))
252                         break;
253                 if (signal_pending(current)) {
254                         retval = -ERESTARTSYS;
255                         break;
256                 }
257                 schedule();
258         }
259         finish_wait(&port->open_wait, &wait);
260
261         /* Update counts. A parallel hangup will have set count to zero and
262            we must not mess that up further */
263         spin_lock_irqsave(&port->lock, flags);
264         if (!tty_hung_up_p(filp))
265                 port->count++;
266         port->blocked_open--;
267         if (retval == 0)
268                 port->flags |= ASYNC_NORMAL_ACTIVE;
269         spin_unlock_irqrestore(&port->lock, flags);
270         return retval;
271         
272 }
273 EXPORT_SYMBOL(tty_port_block_til_ready);
274
275 int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct file *filp)
276 {
277         unsigned long flags;
278
279         spin_lock_irqsave(&port->lock, flags);
280         if (tty_hung_up_p(filp)) {
281                 spin_unlock_irqrestore(&port->lock, flags);
282                 return 0;
283         }
284
285         if( tty->count == 1 && port->count != 1) {
286                 printk(KERN_WARNING
287                     "tty_port_close_start: tty->count = 1 port count = %d.\n",
288                                                                 port->count);
289                 port->count = 1;
290         }
291         if (--port->count < 0) {
292                 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
293                                                                 port->count);
294                 port->count = 0;
295         }
296
297         if (port->count) {
298                 spin_unlock_irqrestore(&port->lock, flags);
299                 return 0;
300         }
301         port->flags |= ASYNC_CLOSING;
302         tty->closing = 1;
303         spin_unlock_irqrestore(&port->lock, flags);
304         /* Don't block on a stalled port, just pull the chain */
305         if (tty->flow_stopped)
306                 tty_driver_flush_buffer(tty);
307         if (port->flags & ASYNC_INITIALIZED &&
308                         port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
309                 tty_wait_until_sent(tty, port->closing_wait);
310         if (port->drain_delay) {
311                 unsigned int bps = tty_get_baud_rate(tty);
312                 long timeout;
313
314                 if (bps > 1200)
315                         timeout = max_t(long, (HZ * 10 * port->drain_delay) / bps,
316                                                                 HZ / 10);
317                 else
318                         timeout = 2 * HZ;
319                 schedule_timeout_interruptible(timeout);
320         }
321         return 1;
322 }
323 EXPORT_SYMBOL(tty_port_close_start);
324
325 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
326 {
327         unsigned long flags;
328
329         tty_ldisc_flush(tty);
330
331         if (tty->termios->c_cflag & HUPCL)
332                 tty_port_lower_dtr_rts(port);
333
334         spin_lock_irqsave(&port->lock, flags);
335         tty->closing = 0;
336
337         if (port->blocked_open) {
338                 spin_unlock_irqrestore(&port->lock, flags);
339                 if (port->close_delay) {
340                         msleep_interruptible(
341                                 jiffies_to_msecs(port->close_delay));
342                 }
343                 spin_lock_irqsave(&port->lock, flags);
344                 wake_up_interruptible(&port->open_wait);
345         }
346         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
347         wake_up_interruptible(&port->close_wait);
348         spin_unlock_irqrestore(&port->lock, flags);
349 }
350 EXPORT_SYMBOL(tty_port_close_end);