5 #include <linux/types.h>
6 #include <linux/errno.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>
21 void tty_port_init(struct tty_port *port)
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 spin_lock_init(&port->lock);
29 port->close_delay = (50 * HZ) / 100;
30 port->closing_wait = (3000 * HZ) / 100;
32 EXPORT_SYMBOL(tty_port_init);
34 int tty_port_alloc_xmit_buf(struct tty_port *port)
36 /* We may sleep in get_zeroed_page() */
37 mutex_lock(&port->mutex);
38 if (port->xmit_buf == NULL)
39 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
40 mutex_unlock(&port->mutex);
41 if (port->xmit_buf == NULL)
45 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
47 void tty_port_free_xmit_buf(struct tty_port *port)
49 mutex_lock(&port->mutex);
50 if (port->xmit_buf != NULL) {
51 free_page((unsigned long)port->xmit_buf);
52 port->xmit_buf = NULL;
54 mutex_unlock(&port->mutex);
56 EXPORT_SYMBOL(tty_port_free_xmit_buf);
60 * tty_port_tty_get - get a tty reference
63 * Return a refcount protected tty instance or NULL if the port is not
64 * associated with a tty (eg due to close or hangup)
67 struct tty_struct *tty_port_tty_get(struct tty_port *port)
70 struct tty_struct *tty;
72 spin_lock_irqsave(&port->lock, flags);
73 tty = tty_kref_get(port->tty);
74 spin_unlock_irqrestore(&port->lock, flags);
77 EXPORT_SYMBOL(tty_port_tty_get);
80 * tty_port_tty_set - set the tty of a port
84 * Associate the port and tty pair. Manages any internal refcounts.
85 * Pass NULL to deassociate a port
88 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
92 spin_lock_irqsave(&port->lock, flags);
94 tty_kref_put(port->tty);
95 port->tty = tty_kref_get(tty);
96 spin_unlock_irqrestore(&port->lock, flags);
98 EXPORT_SYMBOL(tty_port_tty_set);
100 static void tty_port_shutdown(struct tty_port *port)
102 if (port->ops->shutdown &&
103 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
104 port->ops->shutdown(port);
109 * tty_port_hangup - hangup helper
112 * Perform port level tty hangup flag and count changes. Drop the tty
116 void tty_port_hangup(struct tty_port *port)
120 spin_lock_irqsave(&port->lock, flags);
122 port->flags &= ~ASYNC_NORMAL_ACTIVE;
124 tty_kref_put(port->tty);
126 spin_unlock_irqrestore(&port->lock, flags);
127 wake_up_interruptible(&port->open_wait);
128 wake_up_interruptible(&port->delta_msr_wait);
129 tty_port_shutdown(port);
131 EXPORT_SYMBOL(tty_port_hangup);
134 * tty_port_carrier_raised - carrier raised check
137 * Wrapper for the carrier detect logic. For the moment this is used
138 * to hide some internal details. This will eventually become entirely
139 * internal to the tty port.
142 int tty_port_carrier_raised(struct tty_port *port)
144 if (port->ops->carrier_raised == NULL)
146 return port->ops->carrier_raised(port);
148 EXPORT_SYMBOL(tty_port_carrier_raised);
151 * tty_port_raise_dtr_rts - Raise DTR/RTS
154 * Wrapper for the DTR/RTS raise logic. For the moment this is used
155 * to hide some internal details. This will eventually become entirely
156 * internal to the tty port.
159 void tty_port_raise_dtr_rts(struct tty_port *port)
161 if (port->ops->dtr_rts)
162 port->ops->dtr_rts(port, 1);
164 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
167 * tty_port_lower_dtr_rts - Lower DTR/RTS
170 * Wrapper for the DTR/RTS raise logic. For the moment this is used
171 * to hide some internal details. This will eventually become entirely
172 * internal to the tty port.
175 void tty_port_lower_dtr_rts(struct tty_port *port)
177 if (port->ops->dtr_rts)
178 port->ops->dtr_rts(port, 0);
180 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
183 * tty_port_block_til_ready - Waiting logic for tty open
184 * @port: the tty port being opened
185 * @tty: the tty device being bound
186 * @filp: the file pointer of the opener
188 * Implement the core POSIX/SuS tty behaviour when opening a tty device.
190 * - hangup (both before and during)
191 * - non blocking open
194 * - port flags and counts
196 * The passed tty_port must implement the carrier_raised method if it can
197 * do carrier detect and the dtr_rts method if it supports software
198 * management of these lines. Note that the dtr/rts raise is done each
199 * iteration as a hangup may have previously dropped them while we wait.
202 int tty_port_block_til_ready(struct tty_port *port,
203 struct tty_struct *tty, struct file *filp)
205 int do_clocal = 0, retval;
210 /* block if port is in the process of being closed */
211 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
212 wait_event_interruptible(port->close_wait,
213 !(port->flags & ASYNC_CLOSING));
214 if (port->flags & ASYNC_HUP_NOTIFY)
220 /* if non-blocking mode is set we can pass directly to open unless
221 the port has just hung up or is in another error state */
222 if ((filp->f_flags & O_NONBLOCK) ||
223 (tty->flags & (1 << TTY_IO_ERROR))) {
224 /* Indicate we are open */
225 if (tty->termios->c_cflag & CBAUD)
226 tty_port_raise_dtr_rts(port);
227 port->flags |= ASYNC_NORMAL_ACTIVE;
234 /* Block waiting until we can proceed. We may need to wait for the
235 carrier, but we must also wait for any close that is in progress
236 before the next open may complete */
240 /* The port lock protects the port counts */
241 spin_lock_irqsave(&port->lock, flags);
242 if (!tty_hung_up_p(filp))
244 port->blocked_open++;
245 spin_unlock_irqrestore(&port->lock, flags);
248 /* Indicate we are open */
249 if (tty->termios->c_cflag & CBAUD)
250 tty_port_raise_dtr_rts(port);
252 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
253 /* Check for a hangup or uninitialised port. Return accordingly */
254 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
255 if (port->flags & ASYNC_HUP_NOTIFY)
258 retval = -ERESTARTSYS;
261 /* Probe the carrier. For devices with no carrier detect this
262 will always return true */
263 cd = tty_port_carrier_raised(port);
264 if (!(port->flags & ASYNC_CLOSING) &&
267 if (signal_pending(current)) {
268 retval = -ERESTARTSYS;
273 finish_wait(&port->open_wait, &wait);
275 /* Update counts. A parallel hangup will have set count to zero and
276 we must not mess that up further */
277 spin_lock_irqsave(&port->lock, flags);
278 if (!tty_hung_up_p(filp))
280 port->blocked_open--;
282 port->flags |= ASYNC_NORMAL_ACTIVE;
283 spin_unlock_irqrestore(&port->lock, flags);
287 EXPORT_SYMBOL(tty_port_block_til_ready);
289 int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct file *filp)
293 spin_lock_irqsave(&port->lock, flags);
294 if (tty_hung_up_p(filp)) {
295 spin_unlock_irqrestore(&port->lock, flags);
299 if( tty->count == 1 && port->count != 1) {
301 "tty_port_close_start: tty->count = 1 port count = %d.\n",
305 if (--port->count < 0) {
306 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
312 spin_unlock_irqrestore(&port->lock, flags);
314 port->ops->drop(port);
317 set_bit(ASYNCB_CLOSING, &port->flags);
319 spin_unlock_irqrestore(&port->lock, flags);
320 /* Don't block on a stalled port, just pull the chain */
321 if (tty->flow_stopped)
322 tty_driver_flush_buffer(tty);
323 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
324 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
325 tty_wait_until_sent(tty, port->closing_wait);
326 if (port->drain_delay) {
327 unsigned int bps = tty_get_baud_rate(tty);
331 timeout = max_t(long, (HZ * 10 * port->drain_delay) / bps,
335 schedule_timeout_interruptible(timeout);
337 /* Don't call port->drop for the last reference. Callers will want
338 to drop the last active reference in ->shutdown() or the tty
342 EXPORT_SYMBOL(tty_port_close_start);
344 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
348 tty_ldisc_flush(tty);
350 if (tty->termios->c_cflag & HUPCL)
351 tty_port_lower_dtr_rts(port);
353 spin_lock_irqsave(&port->lock, flags);
356 if (port->blocked_open) {
357 spin_unlock_irqrestore(&port->lock, flags);
358 if (port->close_delay) {
359 msleep_interruptible(
360 jiffies_to_msecs(port->close_delay));
362 spin_lock_irqsave(&port->lock, flags);
363 wake_up_interruptible(&port->open_wait);
365 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
366 wake_up_interruptible(&port->close_wait);
367 spin_unlock_irqrestore(&port->lock, flags);
369 EXPORT_SYMBOL(tty_port_close_end);
371 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
374 if (tty_port_close_start(port, tty, filp) == 0)
376 tty_port_shutdown(port);
377 tty_port_close_end(port, tty);
378 tty_port_tty_set(port, NULL);
380 EXPORT_SYMBOL(tty_port_close);