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         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 &&
 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         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) {
 234                 wait_event_interruptible(port->close_wait,
 235                                 !(port->flags & ASYNC_CLOSING));
 236                 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 */
 244         if (tty->flags & (1 << TTY_IO_ERROR)) {
 245                 port->flags |= ASYNC_NORMAL_ACTIVE;
 246                 return 0;
 247         }
 248         if (filp->f_flags & O_NONBLOCK) {
 249                 /* Indicate we are open */
 250                 if (tty->termios->c_cflag & CBAUD)
 251                         tty_port_raise_dtr_rts(port);
 252                 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;
 264
 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 */
 274                 if (tty->termios->c_cflag & CBAUD)
 275                         tty_port_raise_dtr_rts(port);
 276
 277                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 278                 /* Check for a hangup or uninitialised port.
 279                                                         Return accordingly */
 280                 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         }
 299         finish_wait(&port->open_wait, &wait);
 300
 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);
 310         return retval;
 311 }
 312 EXPORT_SYMBOL(tty_port_block_til_ready);
 313
 314 int tty_port_close_start(struct tty_port *port,
 315                                 struct tty_struct *tty, struct file *filp)
 316 {
 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
 325         if (tty->count == 1 && port->count != 1) {
 326                 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);
 339                 if (port->ops->drop)
 340                         port->ops->drop(port);
 341                 return 0;
 342         }
 343         set_bit(ASYNCB_CLOSING, &port->flags);
 344         tty->closing = 1;
 345         spin_unlock_irqrestore(&port->lock, flags);
 346         /* Don't block on a stalled port, just pull the chain */
 347         if (tty->flow_stopped)
 348                 tty_driver_flush_buffer(tty);
 349         if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
 350                         port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 351                 tty_wait_until_sent(tty, port->closing_wait);
 352         if (port->drain_delay) {
 353                 unsigned int bps = tty_get_baud_rate(tty);
 354                 long timeout;
 355
 356                 if (bps > 1200)
 357                         timeout = max_t(long,
 358                                 (HZ * 10 * port->drain_delay) / bps, HZ / 10);
 359                 else
 360                         timeout = 2 * HZ;
 361                 schedule_timeout_interruptible(timeout);
 362         }
 363         /* 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
 371         /* 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 */
 374         return 1;
 375 }
 376 EXPORT_SYMBOL(tty_port_close_start);
 377
 378 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 379 {
 380         unsigned long flags;
 381
 382         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 }
 398 EXPORT_SYMBOL(tty_port_close_end);
 399
 400 void 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);
 406         set_bit(TTY_IO_ERROR, &tty->flags);
 407         tty_port_close_end(port, tty);
 408         tty_port_tty_set(port, NULL);
 409 }
 410 EXPORT_SYMBOL(tty_port_close);
 411
 412 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 413                                                         struct file *filp)
 414 {
 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)) {
 430                 clear_bit(TTY_IO_ERROR, &tty->flags);
 431                 if (port->ops->activate) {
 432                         int retval = port->ops->activate(port, tty);
 433                         if (retval) {
 434                                 mutex_unlock(&port->mutex);
 435                                 return retval;
 436                         }
 437                 }
 438                 set_bit(ASYNCB_INITIALIZED, &port->flags);
 439         }
 440         mutex_unlock(&port->mutex);
 441         return tty_port_block_til_ready(port, tty, filp);
 442 }
 443
 444 EXPORT_SYMBOL(tty_port_open);