Revert "ARM: tegra: tegratab: dummy change"
[linux-2.6.git] / drivers / tty / 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         init_waitqueue_head(&port->delta_msr_wait);
27         mutex_init(&port->mutex);
28         mutex_init(&port->buf_mutex);
29         spin_lock_init(&port->lock);
30         port->close_delay = (50 * HZ) / 100;
31         port->closing_wait = (3000 * HZ) / 100;
32         kref_init(&port->kref);
33 }
34 EXPORT_SYMBOL(tty_port_init);
35
36 int tty_port_alloc_xmit_buf(struct tty_port *port)
37 {
38         /* We may sleep in get_zeroed_page() */
39         mutex_lock(&port->buf_mutex);
40         if (port->xmit_buf == NULL)
41                 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
42         mutex_unlock(&port->buf_mutex);
43         if (port->xmit_buf == NULL)
44                 return -ENOMEM;
45         return 0;
46 }
47 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
48
49 void tty_port_free_xmit_buf(struct tty_port *port)
50 {
51         mutex_lock(&port->buf_mutex);
52         if (port->xmit_buf != NULL) {
53                 free_page((unsigned long)port->xmit_buf);
54                 port->xmit_buf = NULL;
55         }
56         mutex_unlock(&port->buf_mutex);
57 }
58 EXPORT_SYMBOL(tty_port_free_xmit_buf);
59
60 static 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
71 void tty_port_put(struct tty_port *port)
72 {
73         if (port)
74                 kref_put(&port->kref, tty_port_destructor);
75 }
76 EXPORT_SYMBOL(tty_port_put);
77
78 /**
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
86 struct 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 }
96 EXPORT_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
107 void 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);
114         port->tty = tty_kref_get(tty);
115         spin_unlock_irqrestore(&port->lock, flags);
116 }
117 EXPORT_SYMBOL(tty_port_tty_set);
118
119 static void tty_port_shutdown(struct tty_port *port)
120 {
121         mutex_lock(&port->mutex);
122         if (port->ops->shutdown && !port->console &&
123                 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
124                         port->ops->shutdown(port);
125         mutex_unlock(&port->mutex);
126 }
127
128 /**
129  *      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
136 void 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;
143         if (port->tty) {
144                 set_bit(TTY_IO_ERROR, &port->tty->flags);
145                 tty_kref_put(port->tty);
146         }
147         port->tty = NULL;
148         spin_unlock_irqrestore(&port->lock, flags);
149         wake_up_interruptible(&port->open_wait);
150         wake_up_interruptible(&port->delta_msr_wait);
151         tty_port_shutdown(port);
152 }
153 EXPORT_SYMBOL(tty_port_hangup);
154
155 /**
156  *      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
164 int 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 }
170 EXPORT_SYMBOL(tty_port_carrier_raised);
171
172 /**
173  *      tty_port_raise_dtr_rts  -       Raise DTR/RTS
174  *      @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
181 void tty_port_raise_dtr_rts(struct tty_port *port)
182 {
183         if (port->ops->dtr_rts)
184                 port->ops->dtr_rts(port, 1);
185 }
186 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
187
188 /**
189  *      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
197 void tty_port_lower_dtr_rts(struct tty_port *port)
198 {
199         if (port->ops->dtr_rts)
200                 port->ops->dtr_rts(port, 0);
201 }
202 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
203
204 /**
205  *      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
219  *      do carrier detect and the dtr_rts method if it supports software
220  *      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  */
223
224 int 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;
229         DEFINE_WAIT(wait);
230
231         /* block if port is in the process of being closed */
232         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
233                 wait_event_interruptible_tty(port->close_wait,
234                                 !(port->flags & ASYNC_CLOSING));
235                 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 */
243         if (tty->flags & (1 << TTY_IO_ERROR)) {
244                 port->flags |= ASYNC_NORMAL_ACTIVE;
245                 return 0;
246         }
247         if (filp->f_flags & O_NONBLOCK) {
248                 /* Indicate we are open */
249                 if (tty->termios->c_cflag & CBAUD)
250                         tty_port_raise_dtr_rts(port);
251                 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;
263
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 */
273                 if (tty->termios->c_cflag & CBAUD)
274                         tty_port_raise_dtr_rts(port);
275
276                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
277                 /* Check for a hangup or uninitialised port.
278                                                         Return accordingly */
279                 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                 }
286                 /*
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                  */
292                 if (!(port->flags & ASYNC_CLOSING) &&
293                                 (do_clocal || tty_port_carrier_raised(port)))
294                         break;
295                 if (signal_pending(current)) {
296                         retval = -ERESTARTSYS;
297                         break;
298                 }
299                 tty_unlock();
300                 schedule();
301                 tty_lock();
302         }
303         finish_wait(&port->open_wait, &wait);
304
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);
314         return retval;
315 }
316 EXPORT_SYMBOL(tty_port_block_til_ready);
317
318 int tty_port_close_start(struct tty_port *port,
319                                 struct tty_struct *tty, struct file *filp)
320 {
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
329         if (tty->count == 1 && port->count != 1) {
330                 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);
343                 if (port->ops->drop)
344                         port->ops->drop(port);
345                 return 0;
346         }
347         set_bit(ASYNCB_CLOSING, &port->flags);
348         tty->closing = 1;
349         spin_unlock_irqrestore(&port->lock, flags);
350         /* Don't block on a stalled port, just pull the chain */
351         if (tty->flow_stopped)
352                 tty_driver_flush_buffer(tty);
353         if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
354                         port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
355                 tty_wait_until_sent_from_close(tty, port->closing_wait);
356         if (port->drain_delay) {
357                 unsigned int bps = tty_get_baud_rate(tty);
358                 long timeout;
359
360                 if (bps > 1200)
361                         timeout = max_t(long,
362                                 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
363                 else
364                         timeout = 2 * HZ;
365                 schedule_timeout_interruptible(timeout);
366         }
367         /* 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
375         /* 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 */
378         return 1;
379 }
380 EXPORT_SYMBOL(tty_port_close_start);
381
382 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
383 {
384         unsigned long flags;
385
386         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 }
402 EXPORT_SYMBOL(tty_port_close_end);
403
404 void 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);
410         set_bit(TTY_IO_ERROR, &tty->flags);
411         tty_port_close_end(port, tty);
412         tty_port_tty_set(port, NULL);
413 }
414 EXPORT_SYMBOL(tty_port_close);
415
416 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
417                                                         struct file *filp)
418 {
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)) {
434                 clear_bit(TTY_IO_ERROR, &tty->flags);
435                 if (port->ops->activate) {
436                         int retval = port->ops->activate(port, tty);
437                         if (retval) {
438                                 mutex_unlock(&port->mutex);
439                                 return retval;
440                         }
441                 }
442                 set_bit(ASYNCB_INITIALIZED, &port->flags);
443         }
444         mutex_unlock(&port->mutex);
445         return tty_port_block_til_ready(port, tty, filp);
446 }
447
448 EXPORT_SYMBOL(tty_port_open);