Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tty_port.c
Go to the documentation of this file.
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 
22 {
23  memset(port, 0, sizeof(*port));
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 }
35 
48  struct tty_driver *driver, unsigned index)
49 {
50  if (WARN_ON(index >= driver->num))
51  return;
52  driver->ports[index] = port;
53 }
55 
68  struct tty_driver *driver, unsigned index,
69  struct device *device)
70 {
71  tty_port_link_device(port, driver, index);
72  return tty_register_device(driver, index, device);
73 }
75 
90  struct tty_driver *driver, unsigned index,
91  struct device *device, void *drvdata,
92  const struct attribute_group **attr_grp)
93 {
94  tty_port_link_device(port, driver, index);
95  return tty_register_device_attr(driver, index, device, drvdata,
96  attr_grp);
97 }
99 
101 {
102  /* We may sleep in get_zeroed_page() */
103  mutex_lock(&port->buf_mutex);
104  if (port->xmit_buf == NULL)
105  port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
106  mutex_unlock(&port->buf_mutex);
107  if (port->xmit_buf == NULL)
108  return -ENOMEM;
109  return 0;
110 }
112 
114 {
115  mutex_lock(&port->buf_mutex);
116  if (port->xmit_buf != NULL) {
117  free_page((unsigned long)port->xmit_buf);
118  port->xmit_buf = NULL;
119  }
120  mutex_unlock(&port->buf_mutex);
121 }
123 
124 static void tty_port_destructor(struct kref *kref)
125 {
126  struct tty_port *port = container_of(kref, struct tty_port, kref);
127  if (port->xmit_buf)
128  free_page((unsigned long)port->xmit_buf);
129  if (port->ops->destruct)
130  port->ops->destruct(port);
131  else
132  kfree(port);
133 }
134 
135 void tty_port_put(struct tty_port *port)
136 {
137  if (port)
138  kref_put(&port->kref, tty_port_destructor);
139 }
141 
150 struct tty_struct *tty_port_tty_get(struct tty_port *port)
151 {
152  unsigned long flags;
153  struct tty_struct *tty;
154 
155  spin_lock_irqsave(&port->lock, flags);
156  tty = tty_kref_get(port->tty);
157  spin_unlock_irqrestore(&port->lock, flags);
158  return tty;
159 }
161 
171 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
172 {
173  unsigned long flags;
174 
175  spin_lock_irqsave(&port->lock, flags);
176  if (port->tty)
177  tty_kref_put(port->tty);
178  port->tty = tty_kref_get(tty);
179  spin_unlock_irqrestore(&port->lock, flags);
180 }
182 
183 static void tty_port_shutdown(struct tty_port *port)
184 {
185  mutex_lock(&port->mutex);
186  if (port->ops->shutdown && !port->console &&
188  port->ops->shutdown(port);
189  mutex_unlock(&port->mutex);
190 }
191 
200 void tty_port_hangup(struct tty_port *port)
201 {
202  unsigned long flags;
203 
204  spin_lock_irqsave(&port->lock, flags);
205  port->count = 0;
206  port->flags &= ~ASYNC_NORMAL_ACTIVE;
207  if (port->tty) {
208  set_bit(TTY_IO_ERROR, &port->tty->flags);
209  tty_kref_put(port->tty);
210  }
211  port->tty = NULL;
212  spin_unlock_irqrestore(&port->lock, flags);
215  tty_port_shutdown(port);
216 }
218 
229 {
230  if (port->ops->carrier_raised == NULL)
231  return 1;
232  return port->ops->carrier_raised(port);
233 }
235 
246 {
247  if (port->ops->dtr_rts)
248  port->ops->dtr_rts(port, 1);
249 }
251 
262 {
263  if (port->ops->dtr_rts)
264  port->ops->dtr_rts(port, 0);
265 }
267 
289  struct tty_struct *tty, struct file *filp)
290 {
291  int do_clocal = 0, retval;
292  unsigned long flags;
293  DEFINE_WAIT(wait);
294 
295  /* block if port is in the process of being closed */
296  if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
298  !(port->flags & ASYNC_CLOSING));
299  if (port->flags & ASYNC_HUP_NOTIFY)
300  return -EAGAIN;
301  else
302  return -ERESTARTSYS;
303  }
304 
305  /* if non-blocking mode is set we can pass directly to open unless
306  the port has just hung up or is in another error state */
307  if (tty->flags & (1 << TTY_IO_ERROR)) {
308  port->flags |= ASYNC_NORMAL_ACTIVE;
309  return 0;
310  }
311  if (filp->f_flags & O_NONBLOCK) {
312  /* Indicate we are open */
313  if (tty->termios.c_cflag & CBAUD)
315  port->flags |= ASYNC_NORMAL_ACTIVE;
316  return 0;
317  }
318 
319  if (C_CLOCAL(tty))
320  do_clocal = 1;
321 
322  /* Block waiting until we can proceed. We may need to wait for the
323  carrier, but we must also wait for any close that is in progress
324  before the next open may complete */
325 
326  retval = 0;
327 
328  /* The port lock protects the port counts */
329  spin_lock_irqsave(&port->lock, flags);
330  if (!tty_hung_up_p(filp))
331  port->count--;
332  port->blocked_open++;
333  spin_unlock_irqrestore(&port->lock, flags);
334 
335  while (1) {
336  /* Indicate we are open */
337  if (tty->termios.c_cflag & CBAUD)
339 
341  /* Check for a hangup or uninitialised port.
342  Return accordingly */
343  if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
344  if (port->flags & ASYNC_HUP_NOTIFY)
345  retval = -EAGAIN;
346  else
347  retval = -ERESTARTSYS;
348  break;
349  }
350  /*
351  * Probe the carrier. For devices with no carrier detect
352  * tty_port_carrier_raised will always return true.
353  * Never ask drivers if CLOCAL is set, this causes troubles
354  * on some hardware.
355  */
356  if (!(port->flags & ASYNC_CLOSING) &&
357  (do_clocal || tty_port_carrier_raised(port)))
358  break;
359  if (signal_pending(current)) {
360  retval = -ERESTARTSYS;
361  break;
362  }
363  tty_unlock(tty);
364  schedule();
365  tty_lock(tty);
366  }
367  finish_wait(&port->open_wait, &wait);
368 
369  /* Update counts. A parallel hangup will have set count to zero and
370  we must not mess that up further */
371  spin_lock_irqsave(&port->lock, flags);
372  if (!tty_hung_up_p(filp))
373  port->count++;
374  port->blocked_open--;
375  if (retval == 0)
376  port->flags |= ASYNC_NORMAL_ACTIVE;
377  spin_unlock_irqrestore(&port->lock, flags);
378  return retval;
379 }
381 
383  struct tty_struct *tty, struct file *filp)
384 {
385  unsigned long flags;
386 
387  spin_lock_irqsave(&port->lock, flags);
388  if (tty_hung_up_p(filp)) {
389  spin_unlock_irqrestore(&port->lock, flags);
390  return 0;
391  }
392 
393  if (tty->count == 1 && port->count != 1) {
395  "tty_port_close_start: tty->count = 1 port count = %d.\n",
396  port->count);
397  port->count = 1;
398  }
399  if (--port->count < 0) {
400  printk(KERN_WARNING "tty_port_close_start: count = %d\n",
401  port->count);
402  port->count = 0;
403  }
404 
405  if (port->count) {
406  spin_unlock_irqrestore(&port->lock, flags);
407  if (port->ops->drop)
408  port->ops->drop(port);
409  return 0;
410  }
411  set_bit(ASYNCB_CLOSING, &port->flags);
412  tty->closing = 1;
413  spin_unlock_irqrestore(&port->lock, flags);
414  /* Don't block on a stalled port, just pull the chain */
415  if (tty->flow_stopped)
417  if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
419  tty_wait_until_sent_from_close(tty, port->closing_wait);
420  if (port->drain_delay) {
421  unsigned int bps = tty_get_baud_rate(tty);
422  long timeout;
423 
424  if (bps > 1200)
425  timeout = max_t(long,
426  (HZ * 10 * port->drain_delay) / bps, HZ / 10);
427  else
428  timeout = 2 * HZ;
430  }
431  /* Flush the ldisc buffering */
432  tty_ldisc_flush(tty);
433 
434  /* Drop DTR/RTS if HUPCL is set. This causes any attached modem to
435  hang up the line */
436  if (tty->termios.c_cflag & HUPCL)
438 
439  /* Don't call port->drop for the last reference. Callers will want
440  to drop the last active reference in ->shutdown() or the tty
441  shutdown path */
442  return 1;
443 }
445 
446 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
447 {
448  unsigned long flags;
449 
450  spin_lock_irqsave(&port->lock, flags);
451  tty->closing = 0;
452 
453  if (port->blocked_open) {
454  spin_unlock_irqrestore(&port->lock, flags);
455  if (port->close_delay) {
458  }
459  spin_lock_irqsave(&port->lock, flags);
461  }
464  spin_unlock_irqrestore(&port->lock, flags);
465 }
467 
468 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
469  struct file *filp)
470 {
471  if (tty_port_close_start(port, tty, filp) == 0)
472  return;
473  tty_port_shutdown(port);
474  set_bit(TTY_IO_ERROR, &tty->flags);
475  tty_port_close_end(port, tty);
476  tty_port_tty_set(port, NULL);
477 }
479 
490 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
491  struct tty_struct *tty)
492 {
493  tty->port = port;
494  return tty_standard_install(driver, tty);
495 }
497 
498 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
499  struct file *filp)
500 {
501  spin_lock_irq(&port->lock);
502  if (!tty_hung_up_p(filp))
503  ++port->count;
504  spin_unlock_irq(&port->lock);
505  tty_port_tty_set(port, tty);
506 
507  /*
508  * Do the device-specific open only if the hardware isn't
509  * already initialized. Serialize open and shutdown using the
510  * port mutex.
511  */
512 
513  mutex_lock(&port->mutex);
514 
515  if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
516  clear_bit(TTY_IO_ERROR, &tty->flags);
517  if (port->ops->activate) {
518  int retval = port->ops->activate(port, tty);
519  if (retval) {
520  mutex_unlock(&port->mutex);
521  return retval;
522  }
523  }
525  }
526  mutex_unlock(&port->mutex);
527  return tty_port_block_til_ready(port, tty, filp);
528 }
529