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
 232 void tty_port_hangup(struct tty_port *port)
 233 {
 234         struct tty_struct *tty;
 235         unsigned long flags;
 236
 237         spin_lock_irqsave(&port->lock, flags);
 238         port->count = 0;
 239         port->flags &= ~ASYNC_NORMAL_ACTIVE;
 240         tty = port->tty;
 241         if (tty)
 242                 set_bit(TTY_IO_ERROR, &tty->flags);
 243         port->tty = NULL;
 244         spin_unlock_irqrestore(&port->lock, flags);
 245         tty_port_shutdown(port, tty);
 246         tty_kref_put(tty);
 247         wake_up_interruptible(&port->open_wait);
 248         wake_up_interruptible(&port->delta_msr_wait);
 249 }
 250 EXPORT_SYMBOL(tty_port_hangup);
 251
 252 /**
 253  * tty_port_tty_hangup - helper to hang up a tty
 254  *
 255  * @port: tty port
 256  * @check_clocal: hang only ttys with CLOCAL unset?
 257  */
 258 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
 259 {
 260         struct tty_struct *tty = tty_port_tty_get(port);
 261
 262         if (tty && (!check_clocal || !C_CLOCAL(tty)))
 263                 tty_hangup(tty);
 264         tty_kref_put(tty);
 265 }
 266 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
 267
 268 /**
 269  * tty_port_tty_wakeup - helper to wake up a tty
 270  *
 271  * @port: tty port
 272  */
 273 void tty_port_tty_wakeup(struct tty_port *port)
 274 {
 275         struct tty_struct *tty = tty_port_tty_get(port);
 276
 277         if (tty) {
 278                 tty_wakeup(tty);
 279                 tty_kref_put(tty);
 280         }
 281 }
 282 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
 283
 284 /**
 285  *      tty_port_carrier_raised -       carrier raised check
 286  *      @port: tty port
 287  *
 288  *      Wrapper for the carrier detect logic. For the moment this is used
 289  *      to hide some internal details. This will eventually become entirely
 290  *      internal to the tty port.
 291  */
 292
 293 int tty_port_carrier_raised(struct tty_port *port)
 294 {
 295         if (port->ops->carrier_raised == NULL)
 296                 return 1;
 297         return port->ops->carrier_raised(port);
 298 }
 299 EXPORT_SYMBOL(tty_port_carrier_raised);
 300
 301 /**
 302  *      tty_port_raise_dtr_rts  -       Raise DTR/RTS
 303  *      @port: tty port
 304  *
 305  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
 306  *      to hide some internal details. This will eventually become entirely
 307  *      internal to the tty port.
 308  */
 309
 310 void tty_port_raise_dtr_rts(struct tty_port *port)
 311 {
 312         if (port->ops->dtr_rts)
 313                 port->ops->dtr_rts(port, 1);
 314 }
 315 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
 316
 317 /**
 318  *      tty_port_lower_dtr_rts  -       Lower DTR/RTS
 319  *      @port: tty port
 320  *
 321  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
 322  *      to hide some internal details. This will eventually become entirely
 323  *      internal to the tty port.
 324  */
 325
 326 void tty_port_lower_dtr_rts(struct tty_port *port)
 327 {
 328         if (port->ops->dtr_rts)
 329                 port->ops->dtr_rts(port, 0);
 330 }
 331 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
 332
 333 /**
 334  *      tty_port_block_til_ready        -       Waiting logic for tty open
 335  *      @port: the tty port being opened
 336  *      @tty: the tty device being bound
 337  *      @filp: the file pointer of the opener
 338  *
 339  *      Implement the core POSIX/SuS tty behaviour when opening a tty device.
 340  *      Handles:
 341  *              - hangup (both before and during)
 342  *              - non blocking open
 343  *              - rts/dtr/dcd
 344  *              - signals
 345  *              - port flags and counts
 346  *
 347  *      The passed tty_port must implement the carrier_raised method if it can
 348  *      do carrier detect and the dtr_rts method if it supports software
 349  *      management of these lines. Note that the dtr/rts raise is done each
 350  *      iteration as a hangup may have previously dropped them while we wait.
 351  *
 352  *      Caller holds tty lock.
 353  *
 354  *      NB: May drop and reacquire tty lock when blocking, so tty and tty_port
 355  *      may have changed state (eg., may have been hung up).
 356  */
 357
 358 int tty_port_block_til_ready(struct tty_port *port,
 359                                 struct tty_struct *tty, struct file *filp)
 360 {
 361         int do_clocal = 0, retval;
 362         unsigned long flags;
 363         DEFINE_WAIT(wait);
 364
 365         /* block if port is in the process of being closed */
 366         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
 367                 wait_event_interruptible_tty(tty, port->close_wait,
 368                                 !(port->flags & ASYNC_CLOSING));
 369                 if (port->flags & ASYNC_HUP_NOTIFY)
 370                         return -EAGAIN;
 371                 else
 372                         return -ERESTARTSYS;
 373         }
 374
 375         /* if non-blocking mode is set we can pass directly to open unless
 376            the port has just hung up or is in another error state */
 377         if (tty->flags & (1 << TTY_IO_ERROR)) {
 378                 port->flags |= ASYNC_NORMAL_ACTIVE;
 379                 return 0;
 380         }
 381         if (filp->f_flags & O_NONBLOCK) {
 382                 /* Indicate we are open */
 383                 if (tty->termios.c_cflag & CBAUD)
 384                         tty_port_raise_dtr_rts(port);
 385                 port->flags |= ASYNC_NORMAL_ACTIVE;
 386                 return 0;
 387         }
 388
 389         if (C_CLOCAL(tty))
 390                 do_clocal = 1;
 391
 392         /* Block waiting until we can proceed. We may need to wait for the
 393            carrier, but we must also wait for any close that is in progress
 394            before the next open may complete */
 395
 396         retval = 0;
 397
 398         /* The port lock protects the port counts */
 399         spin_lock_irqsave(&port->lock, flags);
 400         if (!tty_hung_up_p(filp))
 401                 port->count--;
 402         port->blocked_open++;
 403         spin_unlock_irqrestore(&port->lock, flags);
 404
 405         while (1) {
 406                 /* Indicate we are open */
 407                 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
 408                         tty_port_raise_dtr_rts(port);
 409
 410                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 411                 /* Check for a hangup or uninitialised port.
 412                                                         Return accordingly */
 413                 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
 414                         if (port->flags & ASYNC_HUP_NOTIFY)
 415                                 retval = -EAGAIN;
 416                         else
 417                                 retval = -ERESTARTSYS;
 418                         break;
 419                 }
 420                 /*
 421                  * Probe the carrier. For devices with no carrier detect
 422                  * tty_port_carrier_raised will always return true.
 423                  * Never ask drivers if CLOCAL is set, this causes troubles
 424                  * on some hardware.
 425                  */
 426                 if (!(port->flags & ASYNC_CLOSING) &&
 427                                 (do_clocal || tty_port_carrier_raised(port)))
 428                         break;
 429                 if (signal_pending(current)) {
 430                         retval = -ERESTARTSYS;
 431                         break;
 432                 }
 433                 tty_unlock(tty);
 434                 schedule();
 435                 tty_lock(tty);
 436         }
 437         finish_wait(&port->open_wait, &wait);
 438
 439         /* Update counts. A parallel hangup will have set count to zero and
 440            we must not mess that up further */
 441         spin_lock_irqsave(&port->lock, flags);
 442         if (!tty_hung_up_p(filp))
 443                 port->count++;
 444         port->blocked_open--;
 445         if (retval == 0)
 446                 port->flags |= ASYNC_NORMAL_ACTIVE;
 447         spin_unlock_irqrestore(&port->lock, flags);
 448         return retval;
 449 }
 450 EXPORT_SYMBOL(tty_port_block_til_ready);
 451
 452 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
 453 {
 454         unsigned int bps = tty_get_baud_rate(tty);
 455         long timeout;
 456
 457         if (bps > 1200) {
 458                 timeout = (HZ * 10 * port->drain_delay) / bps;
 459                 timeout = max_t(long, timeout, HZ / 10);
 460         } else {
 461                 timeout = 2 * HZ;
 462         }
 463         schedule_timeout_interruptible(timeout);
 464 }
 465
 466 /* Caller holds tty lock.
 467  * NB: may drop and reacquire tty lock (in tty_wait_until_sent_from_close())
 468  * so tty and tty port may have changed state (but not hung up or reopened).
 469  */
 470 int tty_port_close_start(struct tty_port *port,
 471                                 struct tty_struct *tty, struct file *filp)
 472 {
 473         unsigned long flags;
 474
 475         spin_lock_irqsave(&port->lock, flags);
 476         if (tty_hung_up_p(filp)) {
 477                 spin_unlock_irqrestore(&port->lock, flags);
 478                 return 0;
 479         }
 480
 481         if (tty->count == 1 && port->count != 1) {
 482                 printk(KERN_WARNING
 483                     "tty_port_close_start: tty->count = 1 port count = %d.\n",
 484                                                                 port->count);
 485                 port->count = 1;
 486         }
 487         if (--port->count < 0) {
 488                 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
 489                                                                 port->count);
 490                 port->count = 0;
 491         }
 492
 493         if (port->count) {
 494                 spin_unlock_irqrestore(&port->lock, flags);
 495                 return 0;
 496         }
 497         set_bit(ASYNCB_CLOSING, &port->flags);
 498         tty->closing = 1;
 499         spin_unlock_irqrestore(&port->lock, flags);
 500
 501         if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 502                 /* Don't block on a stalled port, just pull the chain */
 503                 if (tty->flow_stopped)
 504                         tty_driver_flush_buffer(tty);
 505                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 506                         tty_wait_until_sent_from_close(tty, port->closing_wait);
 507                 if (port->drain_delay)
 508                         tty_port_drain_delay(port, tty);
 509         }
 510         /* Flush the ldisc buffering */
 511         tty_ldisc_flush(tty);
 512
 513         /* Report to caller this is the last port reference */
 514         return 1;
 515 }
 516 EXPORT_SYMBOL(tty_port_close_start);
 517
 518 /* Caller holds tty lock */
 519 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 520 {
 521         unsigned long flags;
 522
 523         spin_lock_irqsave(&port->lock, flags);
 524         tty->closing = 0;
 525
 526         if (port->blocked_open) {
 527                 spin_unlock_irqrestore(&port->lock, flags);
 528                 if (port->close_delay) {
 529                         msleep_interruptible(
 530                                 jiffies_to_msecs(port->close_delay));
 531                 }
 532                 spin_lock_irqsave(&port->lock, flags);
 533                 wake_up_interruptible(&port->open_wait);
 534         }
 535         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
 536         wake_up_interruptible(&port->close_wait);
 537         spin_unlock_irqrestore(&port->lock, flags);
 538 }
 539 EXPORT_SYMBOL(tty_port_close_end);
 540
 541 /**
 542  * tty_port_close
 543  *
 544  * Caller holds tty lock
 545  *
 546  * NB: may drop and reacquire tty lock (in tty_port_close_start()->
 547  * tty_wait_until_sent_from_close()) so tty and tty_port may have changed
 548  * state (but not hung up or reopened).
 549  */
 550 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 551                                                         struct file *filp)
 552 {
 553         if (tty_port_close_start(port, tty, filp) == 0)
 554                 return;
 555         tty_port_shutdown(port, tty);
 556         set_bit(TTY_IO_ERROR, &tty->flags);
 557         tty_port_close_end(port, tty);
 558         tty_port_tty_set(port, NULL);
 559 }
 560 EXPORT_SYMBOL(tty_port_close);
 561
 562 /**
 563  * tty_port_install - generic tty->ops->install handler
 564  * @port: tty_port of the device
 565  * @driver: tty_driver for this device
 566  * @tty: tty to be installed
 567  *
 568  * It is the same as tty_standard_install except the provided @port is linked
 569  * to a concrete tty specified by @tty. Use this or tty_port_register_device
 570  * (or both). Call tty_port_link_device as a last resort.
 571  */
 572 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 573                 struct tty_struct *tty)
 574 {
 575         tty->port = port;
 576         return tty_standard_install(driver, tty);
 577 }
 578 EXPORT_SYMBOL_GPL(tty_port_install);
 579
 580 /**
 581  * tty_port_open
 582  *
 583  * Caller holds tty lock.
 584  *
 585  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 586  * tty and tty_port may have changed state (eg., may be hung up now)
 587  */
 588 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 589                                                         struct file *filp)
 590 {
 591         spin_lock_irq(&port->lock);
 592         if (!tty_hung_up_p(filp))
 593                 ++port->count;
 594         spin_unlock_irq(&port->lock);
 595         tty_port_tty_set(port, tty);
 596
 597         /*
 598          * Do the device-specific open only if the hardware isn't
 599          * already initialized. Serialize open and shutdown using the
 600          * port mutex.
 601          */
 602
 603         mutex_lock(&port->mutex);
 604
 605         if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 606                 clear_bit(TTY_IO_ERROR, &tty->flags);
 607                 if (port->ops->activate) {
 608                         int retval = port->ops->activate(port, tty);
 609                         if (retval) {
 610                                 mutex_unlock(&port->mutex);
 611                                 return retval;
 612                         }
 613                 }
 614                 set_bit(ASYNCB_INITIALIZED, &port->flags);
 615         }
 616         mutex_unlock(&port->mutex);
 617         return tty_port_block_til_ready(port, tty, filp);
 618 }
 619
 620 EXPORT_SYMBOL(tty_port_open);