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/wait.h>
  16 #include <linux/bitops.h>
  17 #include <linux/delay.h>
  18 #include <linux/module.h>
  19
  20 void tty_port_init(struct tty_port *port)
  21 {
  22         memset(port, 0, sizeof(*port));
  23         tty_buffer_init(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 /**
  37  * tty_port_link_device - link tty and tty_port
  38  * @port: tty_port of the device
  39  * @driver: tty_driver for this device
  40  * @index: index of the tty
  41  *
  42  * Provide the tty layer wit ha link from a tty (specified by @index) to a
  43  * tty_port (@port). Use this only if neither tty_port_register_device nor
  44  * tty_port_install is used in the driver. If used, this has to be called before
  45  * tty_register_driver.
  46  */
  47 void tty_port_link_device(struct tty_port *port,
  48                 struct tty_driver *driver, unsigned index)
  49 {
  50         if (WARN_ON(index >= driver->num))
  51                 return;
  52         driver->ports[index] = port;
  53 }
  54 EXPORT_SYMBOL_GPL(tty_port_link_device);
  55
  56 /**
  57  * tty_port_register_device - register tty device
  58  * @port: tty_port of the device
  59  * @driver: tty_driver for this device
  60  * @index: index of the tty
  61  * @device: parent if exists, otherwise NULL
  62  *
  63  * It is the same as tty_register_device except the provided @port is linked to
  64  * a concrete tty specified by @index. Use this or tty_port_install (or both).
  65  * Call tty_port_link_device as a last resort.
  66  */
  67 struct device *tty_port_register_device(struct tty_port *port,
  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 }
  74 EXPORT_SYMBOL_GPL(tty_port_register_device);
  75
  76 /**
  77  * tty_port_register_device_attr - register tty device
  78  * @port: tty_port of the device
  79  * @driver: tty_driver for this device
  80  * @index: index of the tty
  81  * @device: parent if exists, otherwise NULL
  82  * @drvdata: Driver data to be set to device.
  83  * @attr_grp: Attribute group to be set on device.
  84  *
  85  * It is the same as tty_register_device_attr except the provided @port is
  86  * linked to a concrete tty specified by @index. Use this or tty_port_install
  87  * (or both). Call tty_port_link_device as a last resort.
  88  */
  89 struct device *tty_port_register_device_attr(struct tty_port *port,
  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 }
  98 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
  99
 100 int tty_port_alloc_xmit_buf(struct tty_port *port)
 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 }
 111 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
 112
 113 void tty_port_free_xmit_buf(struct tty_port *port)
 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 }
 122 EXPORT_SYMBOL(tty_port_free_xmit_buf);
 123
 124 /**
 125  * tty_port_destroy -- destroy inited port
 126  * @port: tty port to be doestroyed
 127  *
 128  * When a port was initialized using tty_port_init, one has to destroy the
 129  * port by this function. Either indirectly by using tty_port refcounting
 130  * (tty_port_put) or directly if refcounting is not used.
 131  */
 132 void tty_port_destroy(struct tty_port *port)
 133 {
 134         cancel_work_sync(&port->buf.work);
 135         tty_buffer_free_all(port);
 136 }
 137 EXPORT_SYMBOL(tty_port_destroy);
 138
 139 static void tty_port_destructor(struct kref *kref)
 140 {
 141         struct tty_port *port = container_of(kref, struct tty_port, kref);
 142
 143         /* check if last port ref was dropped before tty release */
 144         if (WARN_ON(port->itty))
 145                 return;
 146         if (port->xmit_buf)
 147                 free_page((unsigned long)port->xmit_buf);
 148         tty_port_destroy(port);
 149         if (port->ops && port->ops->destruct)
 150                 port->ops->destruct(port);
 151         else
 152                 kfree(port);
 153 }
 154
 155 void tty_port_put(struct tty_port *port)
 156 {
 157         if (port)
 158                 kref_put(&port->kref, tty_port_destructor);
 159 }
 160 EXPORT_SYMBOL(tty_port_put);
 161
 162 /**
 163  *      tty_port_tty_get        -       get a tty reference
 164  *      @port: tty port
 165  *
 166  *      Return a refcount protected tty instance or NULL if the port is not
 167  *      associated with a tty (eg due to close or hangup)
 168  */
 169
 170 struct tty_struct *tty_port_tty_get(struct tty_port *port)
 171 {
 172         unsigned long flags;
 173         struct tty_struct *tty;
 174
 175         spin_lock_irqsave(&port->lock, flags);
 176         tty = tty_kref_get(port->tty);
 177         spin_unlock_irqrestore(&port->lock, flags);
 178         return tty;
 179 }
 180 EXPORT_SYMBOL(tty_port_tty_get);
 181
 182 /**
 183  *      tty_port_tty_set        -       set the tty of a port
 184  *      @port: tty port
 185  *      @tty: the tty
 186  *
 187  *      Associate the port and tty pair. Manages any internal refcounts.
 188  *      Pass NULL to deassociate a port
 189  */
 190
 191 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
 192 {
 193         unsigned long flags;
 194
 195         spin_lock_irqsave(&port->lock, flags);
 196         if (port->tty)
 197                 tty_kref_put(port->tty);
 198         port->tty = tty_kref_get(tty);
 199         spin_unlock_irqrestore(&port->lock, flags);
 200 }
 201 EXPORT_SYMBOL(tty_port_tty_set);
 202
 203 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
 204 {
 205         mutex_lock(&port->mutex);
 206         if (port->console)
 207                 goto out;
 208
 209         if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
 210                 /*
 211                  * Drop DTR/RTS if HUPCL is set. This causes any attached
 212                  * modem to hang up the line.
 213                  */
 214                 if (tty && C_HUPCL(tty))
 215                         tty_port_lower_dtr_rts(port);
 216
 217                 if (port->ops->shutdown)
 218                         port->ops->shutdown(port);
 219         }
 220 out:
 221         mutex_unlock(&port->mutex);
 222 }
 223
 224 /**
 225  *      tty_port_hangup         -       hangup helper
 226  *      @port: tty port
 227  *
 228  *      Perform port level tty hangup flag and count changes. Drop the tty
 229  *      reference.
 230  *
 231  *      Caller holds tty lock.
 232  */
 233
 234 void tty_port_hangup(struct tty_port *port)
 235 {
 236         struct tty_struct *tty;
 237         unsigned long flags;
 238
 239         spin_lock_irqsave(&port->lock, flags);
 240         port->count = 0;
 241         port->flags &= ~ASYNC_NORMAL_ACTIVE;
 242         tty = port->tty;
 243         if (tty)
 244                 set_bit(TTY_IO_ERROR, &tty->flags);
 245         port->tty = NULL;
 246         spin_unlock_irqrestore(&port->lock, flags);
 247         tty_port_shutdown(port, tty);
 248         tty_kref_put(tty);
 249         wake_up_interruptible(&port->open_wait);
 250         wake_up_interruptible(&port->delta_msr_wait);
 251 }
 252 EXPORT_SYMBOL(tty_port_hangup);
 253
 254 /**
 255  * tty_port_tty_hangup - helper to hang up a tty
 256  *
 257  * @port: tty port
 258  * @check_clocal: hang only ttys with CLOCAL unset?
 259  */
 260 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
 261 {
 262         struct tty_struct *tty = tty_port_tty_get(port);
 263
 264         if (tty && (!check_clocal || !C_CLOCAL(tty)))
 265                 tty_hangup(tty);
 266         tty_kref_put(tty);
 267 }
 268 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
 269
 270 /**
 271  * tty_port_tty_wakeup - helper to wake up a tty
 272  *
 273  * @port: tty port
 274  */
 275 void tty_port_tty_wakeup(struct tty_port *port)
 276 {
 277         struct tty_struct *tty = tty_port_tty_get(port);
 278
 279         if (tty) {
 280                 tty_wakeup(tty);
 281                 tty_kref_put(tty);
 282         }
 283 }
 284 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
 285
 286 /**
 287  *      tty_port_carrier_raised -       carrier raised check
 288  *      @port: tty port
 289  *
 290  *      Wrapper for the carrier detect logic. For the moment this is used
 291  *      to hide some internal details. This will eventually become entirely
 292  *      internal to the tty port.
 293  */
 294
 295 int tty_port_carrier_raised(struct tty_port *port)
 296 {
 297         if (port->ops->carrier_raised == NULL)
 298                 return 1;
 299         return port->ops->carrier_raised(port);
 300 }
 301 EXPORT_SYMBOL(tty_port_carrier_raised);
 302
 303 /**
 304  *      tty_port_raise_dtr_rts  -       Raise DTR/RTS
 305  *      @port: tty port
 306  *
 307  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
 308  *      to hide some internal details. This will eventually become entirely
 309  *      internal to the tty port.
 310  */
 311
 312 void tty_port_raise_dtr_rts(struct tty_port *port)
 313 {
 314         if (port->ops->dtr_rts)
 315                 port->ops->dtr_rts(port, 1);
 316 }
 317 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
 318
 319 /**
 320  *      tty_port_lower_dtr_rts  -       Lower DTR/RTS
 321  *      @port: tty port
 322  *
 323  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
 324  *      to hide some internal details. This will eventually become entirely
 325  *      internal to the tty port.
 326  */
 327
 328 void tty_port_lower_dtr_rts(struct tty_port *port)
 329 {
 330         if (port->ops->dtr_rts)
 331                 port->ops->dtr_rts(port, 0);
 332 }
 333 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
 334
 335 /**
 336  *      tty_port_block_til_ready        -       Waiting logic for tty open
 337  *      @port: the tty port being opened
 338  *      @tty: the tty device being bound
 339  *      @filp: the file pointer of the opener
 340  *
 341  *      Implement the core POSIX/SuS tty behaviour when opening a tty device.
 342  *      Handles:
 343  *              - hangup (both before and during)
 344  *              - non blocking open
 345  *              - rts/dtr/dcd
 346  *              - signals
 347  *              - port flags and counts
 348  *
 349  *      The passed tty_port must implement the carrier_raised method if it can
 350  *      do carrier detect and the dtr_rts method if it supports software
 351  *      management of these lines. Note that the dtr/rts raise is done each
 352  *      iteration as a hangup may have previously dropped them while we wait.
 353  *
 354  *      Caller holds tty lock.
 355  *
 356  *      NB: May drop and reacquire tty lock when blocking, so tty and tty_port
 357  *      may have changed state (eg., may have been hung up).
 358  */
 359
 360 int tty_port_block_til_ready(struct tty_port *port,
 361                                 struct tty_struct *tty, struct file *filp)
 362 {
 363         int do_clocal = 0, retval;
 364         unsigned long flags;
 365         DEFINE_WAIT(wait);
 366
 367         /* block if port is in the process of being closed */
 368         if (port->flags & ASYNC_CLOSING) {
 369                 wait_event_interruptible_tty(tty, port->close_wait,
 370                                 !(port->flags & ASYNC_CLOSING));
 371                 if (port->flags & ASYNC_HUP_NOTIFY)
 372                         return -EAGAIN;
 373                 else
 374                         return -ERESTARTSYS;
 375         }
 376
 377         /* if non-blocking mode is set we can pass directly to open unless
 378            the port has just hung up or is in another error state */
 379         if (tty->flags & (1 << TTY_IO_ERROR)) {
 380                 port->flags |= ASYNC_NORMAL_ACTIVE;
 381                 return 0;
 382         }
 383         if (filp->f_flags & O_NONBLOCK) {
 384                 /* Indicate we are open */
 385                 if (tty->termios.c_cflag & CBAUD)
 386                         tty_port_raise_dtr_rts(port);
 387                 port->flags |= ASYNC_NORMAL_ACTIVE;
 388                 return 0;
 389         }
 390
 391         if (C_CLOCAL(tty))
 392                 do_clocal = 1;
 393
 394         /* Block waiting until we can proceed. We may need to wait for the
 395            carrier, but we must also wait for any close that is in progress
 396            before the next open may complete */
 397
 398         retval = 0;
 399
 400         /* The port lock protects the port counts */
 401         spin_lock_irqsave(&port->lock, flags);
 402         port->count--;
 403         port->blocked_open++;
 404         spin_unlock_irqrestore(&port->lock, flags);
 405
 406         while (1) {
 407                 /* Indicate we are open */
 408                 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
 409                         tty_port_raise_dtr_rts(port);
 410
 411                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 412                 /* Check for a hangup or uninitialised port.
 413                                                         Return accordingly */
 414                 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
 415                         if (port->flags & ASYNC_HUP_NOTIFY)
 416                                 retval = -EAGAIN;
 417                         else
 418                                 retval = -ERESTARTSYS;
 419                         break;
 420                 }
 421                 /*
 422                  * Probe the carrier. For devices with no carrier detect
 423                  * tty_port_carrier_raised will always return true.
 424                  * Never ask drivers if CLOCAL is set, this causes troubles
 425                  * on some hardware.
 426                  */
 427                 if (!(port->flags & ASYNC_CLOSING) &&
 428                                 (do_clocal || tty_port_carrier_raised(port)))
 429                         break;
 430                 if (signal_pending(current)) {
 431                         retval = -ERESTARTSYS;
 432                         break;
 433                 }
 434                 tty_unlock(tty);
 435                 schedule();
 436                 tty_lock(tty);
 437         }
 438         finish_wait(&port->open_wait, &wait);
 439
 440         /* Update counts. A parallel hangup will have set count to zero and
 441            we must not mess that up further */
 442         spin_lock_irqsave(&port->lock, flags);
 443         if (!tty_hung_up_p(filp))
 444                 port->count++;
 445         port->blocked_open--;
 446         if (retval == 0)
 447                 port->flags |= ASYNC_NORMAL_ACTIVE;
 448         spin_unlock_irqrestore(&port->lock, flags);
 449         return retval;
 450 }
 451 EXPORT_SYMBOL(tty_port_block_til_ready);
 452
 453 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
 454 {
 455         unsigned int bps = tty_get_baud_rate(tty);
 456         long timeout;
 457
 458         if (bps > 1200) {
 459                 timeout = (HZ * 10 * port->drain_delay) / bps;
 460                 timeout = max_t(long, timeout, HZ / 10);
 461         } else {
 462                 timeout = 2 * HZ;
 463         }
 464         schedule_timeout_interruptible(timeout);
 465 }
 466
 467 /* Caller holds tty lock.
 468  * NB: may drop and reacquire tty lock (in tty_wait_until_sent_from_close())
 469  * so tty and tty port may have changed state (but not hung up or reopened).
 470  */
 471 int tty_port_close_start(struct tty_port *port,
 472                                 struct tty_struct *tty, struct file *filp)
 473 {
 474         unsigned long flags;
 475
 476         spin_lock_irqsave(&port->lock, flags);
 477         if (tty_hung_up_p(filp)) {
 478                 spin_unlock_irqrestore(&port->lock, flags);
 479                 return 0;
 480         }
 481
 482         if (tty->count == 1 && port->count != 1) {
 483                 printk(KERN_WARNING
 484                     "tty_port_close_start: tty->count = 1 port count = %d.\n",
 485                                                                 port->count);
 486                 port->count = 1;
 487         }
 488         if (--port->count < 0) {
 489                 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
 490                                                                 port->count);
 491                 port->count = 0;
 492         }
 493
 494         if (port->count) {
 495                 spin_unlock_irqrestore(&port->lock, flags);
 496                 return 0;
 497         }
 498         set_bit(ASYNCB_CLOSING, &port->flags);
 499         spin_unlock_irqrestore(&port->lock, flags);
 500
 501         tty->closing = 1;
 502
 503         if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 504                 /* Don't block on a stalled port, just pull the chain */
 505                 if (tty->flow_stopped)
 506                         tty_driver_flush_buffer(tty);
 507                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 508                         tty_wait_until_sent_from_close(tty, port->closing_wait);
 509                 if (port->drain_delay)
 510                         tty_port_drain_delay(port, tty);
 511         }
 512         /* Flush the ldisc buffering */
 513         tty_ldisc_flush(tty);
 514
 515         /* Report to caller this is the last port reference */
 516         return 1;
 517 }
 518 EXPORT_SYMBOL(tty_port_close_start);
 519
 520 /* Caller holds tty lock */
 521 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 522 {
 523         unsigned long flags;
 524
 525         tty->closing = 0;
 526
 527         spin_lock_irqsave(&port->lock, flags);
 528
 529         if (port->blocked_open) {
 530                 spin_unlock_irqrestore(&port->lock, flags);
 531                 if (port->close_delay) {
 532                         msleep_interruptible(
 533                                 jiffies_to_msecs(port->close_delay));
 534                 }
 535                 spin_lock_irqsave(&port->lock, flags);
 536                 wake_up_interruptible(&port->open_wait);
 537         }
 538         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
 539         wake_up_interruptible(&port->close_wait);
 540         spin_unlock_irqrestore(&port->lock, flags);
 541 }
 542 EXPORT_SYMBOL(tty_port_close_end);
 543
 544 /**
 545  * tty_port_close
 546  *
 547  * Caller holds tty lock
 548  *
 549  * NB: may drop and reacquire tty lock (in tty_port_close_start()->
 550  * tty_wait_until_sent_from_close()) so tty and tty_port may have changed
 551  * state (but not hung up or reopened).
 552  */
 553 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 554                                                         struct file *filp)
 555 {
 556         if (tty_port_close_start(port, tty, filp) == 0)
 557                 return;
 558         tty_port_shutdown(port, tty);
 559         set_bit(TTY_IO_ERROR, &tty->flags);
 560         tty_port_close_end(port, tty);
 561         tty_port_tty_set(port, NULL);
 562 }
 563 EXPORT_SYMBOL(tty_port_close);
 564
 565 /**
 566  * tty_port_install - generic tty->ops->install handler
 567  * @port: tty_port of the device
 568  * @driver: tty_driver for this device
 569  * @tty: tty to be installed
 570  *
 571  * It is the same as tty_standard_install except the provided @port is linked
 572  * to a concrete tty specified by @tty. Use this or tty_port_register_device
 573  * (or both). Call tty_port_link_device as a last resort.
 574  */
 575 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 576                 struct tty_struct *tty)
 577 {
 578         tty->port = port;
 579         return tty_standard_install(driver, tty);
 580 }
 581 EXPORT_SYMBOL_GPL(tty_port_install);
 582
 583 /**
 584  * tty_port_open
 585  *
 586  * Caller holds tty lock.
 587  *
 588  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 589  * tty and tty_port may have changed state (eg., may be hung up now)
 590  */
 591 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 592                                                         struct file *filp)
 593 {
 594         spin_lock_irq(&port->lock);
 595         ++port->count;
 596         spin_unlock_irq(&port->lock);
 597         tty_port_tty_set(port, tty);
 598
 599         /*
 600          * Do the device-specific open only if the hardware isn't
 601          * already initialized. Serialize open and shutdown using the
 602          * port mutex.
 603          */
 604
 605         mutex_lock(&port->mutex);
 606
 607         if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 608                 clear_bit(TTY_IO_ERROR, &tty->flags);
 609                 if (port->ops->activate) {
 610                         int retval = port->ops->activate(port, tty);
 611                         if (retval) {
 612                                 mutex_unlock(&port->mutex);
 613                                 return retval;
 614                         }
 615                 }
 616                 set_bit(ASYNCB_INITIALIZED, &port->flags);
 617         }
 618         mutex_unlock(&port->mutex);
 619         return tty_port_block_til_ready(port, tty, filp);
 620 }
 621
 622 EXPORT_SYMBOL(tty_port_open);