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         tty_kref_put(port->tty);
 197         port->tty = tty_kref_get(tty);
 198         spin_unlock_irqrestore(&port->lock, flags);
 199 }
 200 EXPORT_SYMBOL(tty_port_tty_set);
 201
 202 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
 203 {
 204         mutex_lock(&port->mutex);
 205         if (port->console)
 206                 goto out;
 207
 208         if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
 209                 /*
 210                  * Drop DTR/RTS if HUPCL is set. This causes any attached
 211                  * modem to hang up the line.
 212                  */
 213                 if (tty && C_HUPCL(tty))
 214                         tty_port_lower_dtr_rts(port);
 215
 216                 if (port->ops->shutdown)
 217                         port->ops->shutdown(port);
 218         }
 219 out:
 220         mutex_unlock(&port->mutex);
 221 }
 222
 223 /**
 224  *      tty_port_hangup         -       hangup helper
 225  *      @port: tty port
 226  *
 227  *      Perform port level tty hangup flag and count changes. Drop the tty
 228  *      reference.
 229  *
 230  *      Caller holds tty lock.
 231  */
 232
 233 void tty_port_hangup(struct tty_port *port)
 234 {
 235         struct tty_struct *tty;
 236         unsigned long flags;
 237
 238         spin_lock_irqsave(&port->lock, flags);
 239         port->count = 0;
 240         port->flags &= ~ASYNC_NORMAL_ACTIVE;
 241         tty = port->tty;
 242         if (tty)
 243                 set_bit(TTY_IO_ERROR, &tty->flags);
 244         port->tty = NULL;
 245         spin_unlock_irqrestore(&port->lock, flags);
 246         tty_port_shutdown(port, tty);
 247         tty_kref_put(tty);
 248         wake_up_interruptible(&port->open_wait);
 249         wake_up_interruptible(&port->delta_msr_wait);
 250 }
 251 EXPORT_SYMBOL(tty_port_hangup);
 252
 253 /**
 254  * tty_port_tty_hangup - helper to hang up a tty
 255  *
 256  * @port: tty port
 257  * @check_clocal: hang only ttys with CLOCAL unset?
 258  */
 259 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
 260 {
 261         struct tty_struct *tty = tty_port_tty_get(port);
 262
 263         if (tty && (!check_clocal || !C_CLOCAL(tty)))
 264                 tty_hangup(tty);
 265         tty_kref_put(tty);
 266 }
 267 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
 268
 269 /**
 270  * tty_port_tty_wakeup - helper to wake up a tty
 271  *
 272  * @port: tty port
 273  */
 274 void tty_port_tty_wakeup(struct tty_port *port)
 275 {
 276         struct tty_struct *tty = tty_port_tty_get(port);
 277
 278         if (tty) {
 279                 tty_wakeup(tty);
 280                 tty_kref_put(tty);
 281         }
 282 }
 283 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
 284
 285 /**
 286  *      tty_port_carrier_raised -       carrier raised check
 287  *      @port: tty port
 288  *
 289  *      Wrapper for the carrier detect logic. For the moment this is used
 290  *      to hide some internal details. This will eventually become entirely
 291  *      internal to the tty port.
 292  */
 293
 294 int tty_port_carrier_raised(struct tty_port *port)
 295 {
 296         if (port->ops->carrier_raised == NULL)
 297                 return 1;
 298         return port->ops->carrier_raised(port);
 299 }
 300 EXPORT_SYMBOL(tty_port_carrier_raised);
 301
 302 /**
 303  *      tty_port_raise_dtr_rts  -       Raise DTR/RTS
 304  *      @port: tty port
 305  *
 306  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
 307  *      to hide some internal details. This will eventually become entirely
 308  *      internal to the tty port.
 309  */
 310
 311 void tty_port_raise_dtr_rts(struct tty_port *port)
 312 {
 313         if (port->ops->dtr_rts)
 314                 port->ops->dtr_rts(port, 1);
 315 }
 316 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
 317
 318 /**
 319  *      tty_port_lower_dtr_rts  -       Lower DTR/RTS
 320  *      @port: tty port
 321  *
 322  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
 323  *      to hide some internal details. This will eventually become entirely
 324  *      internal to the tty port.
 325  */
 326
 327 void tty_port_lower_dtr_rts(struct tty_port *port)
 328 {
 329         if (port->ops->dtr_rts)
 330                 port->ops->dtr_rts(port, 0);
 331 }
 332 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
 333
 334 /**
 335  *      tty_port_block_til_ready        -       Waiting logic for tty open
 336  *      @port: the tty port being opened
 337  *      @tty: the tty device being bound
 338  *      @filp: the file pointer of the opener
 339  *
 340  *      Implement the core POSIX/SuS tty behaviour when opening a tty device.
 341  *      Handles:
 342  *              - hangup (both before and during)
 343  *              - non blocking open
 344  *              - rts/dtr/dcd
 345  *              - signals
 346  *              - port flags and counts
 347  *
 348  *      The passed tty_port must implement the carrier_raised method if it can
 349  *      do carrier detect and the dtr_rts method if it supports software
 350  *      management of these lines. Note that the dtr/rts raise is done each
 351  *      iteration as a hangup may have previously dropped them while we wait.
 352  *
 353  *      Caller holds tty lock.
 354  *
 355  *      NB: May drop and reacquire tty lock when blocking, so tty and tty_port
 356  *      may have changed state (eg., may have been hung up).
 357  */
 358
 359 int tty_port_block_til_ready(struct tty_port *port,
 360                                 struct tty_struct *tty, struct file *filp)
 361 {
 362         int do_clocal = 0, retval;
 363         unsigned long flags;
 364         DEFINE_WAIT(wait);
 365
 366         /* block if port is in the process of being closed */
 367         if (port->flags & ASYNC_CLOSING) {
 368                 wait_event_interruptible_tty(tty, port->close_wait,
 369                                 !(port->flags & ASYNC_CLOSING));
 370                 if (port->flags & ASYNC_HUP_NOTIFY)
 371                         return -EAGAIN;
 372                 else
 373                         return -ERESTARTSYS;
 374         }
 375
 376         /* if non-blocking mode is set we can pass directly to open unless
 377            the port has just hung up or is in another error state */
 378         if (tty->flags & (1 << TTY_IO_ERROR)) {
 379                 port->flags |= ASYNC_NORMAL_ACTIVE;
 380                 return 0;
 381         }
 382         if (filp->f_flags & O_NONBLOCK) {
 383                 /* Indicate we are open */
 384                 if (tty->termios.c_cflag & CBAUD)
 385                         tty_port_raise_dtr_rts(port);
 386                 port->flags |= ASYNC_NORMAL_ACTIVE;
 387                 return 0;
 388         }
 389
 390         if (C_CLOCAL(tty))
 391                 do_clocal = 1;
 392
 393         /* Block waiting until we can proceed. We may need to wait for the
 394            carrier, but we must also wait for any close that is in progress
 395            before the next open may complete */
 396
 397         retval = 0;
 398
 399         /* The port lock protects the port counts */
 400         spin_lock_irqsave(&port->lock, flags);
 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         if (tty_hung_up_p(filp))
 476                 return 0;
 477
 478         spin_lock_irqsave(&port->lock, flags);
 479         if (tty->count == 1 && port->count != 1) {
 480                 printk(KERN_WARNING
 481                     "tty_port_close_start: tty->count = 1 port count = %d.\n",
 482                                                                 port->count);
 483                 port->count = 1;
 484         }
 485         if (--port->count < 0) {
 486                 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
 487                                                                 port->count);
 488                 port->count = 0;
 489         }
 490
 491         if (port->count) {
 492                 spin_unlock_irqrestore(&port->lock, flags);
 493                 return 0;
 494         }
 495         set_bit(ASYNCB_CLOSING, &port->flags);
 496         spin_unlock_irqrestore(&port->lock, flags);
 497
 498         tty->closing = 1;
 499
 500         if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 501                 /* Don't block on a stalled port, just pull the chain */
 502                 if (tty->flow_stopped)
 503                         tty_driver_flush_buffer(tty);
 504                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 505                         tty_wait_until_sent_from_close(tty, port->closing_wait);
 506                 if (port->drain_delay)
 507                         tty_port_drain_delay(port, tty);
 508         }
 509         /* Flush the ldisc buffering */
 510         tty_ldisc_flush(tty);
 511
 512         /* Report to caller this is the last port reference */
 513         return 1;
 514 }
 515 EXPORT_SYMBOL(tty_port_close_start);
 516
 517 /* Caller holds tty lock */
 518 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 519 {
 520         unsigned long flags;
 521
 522         tty_ldisc_flush(tty);
 523         tty->closing = 0;
 524
 525         spin_lock_irqsave(&port->lock, flags);
 526
 527         if (port->blocked_open) {
 528                 spin_unlock_irqrestore(&port->lock, flags);
 529                 if (port->close_delay) {
 530                         msleep_interruptible(
 531                                 jiffies_to_msecs(port->close_delay));
 532                 }
 533                 spin_lock_irqsave(&port->lock, flags);
 534                 wake_up_interruptible(&port->open_wait);
 535         }
 536         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
 537         wake_up_interruptible(&port->close_wait);
 538         spin_unlock_irqrestore(&port->lock, flags);
 539 }
 540 EXPORT_SYMBOL(tty_port_close_end);
 541
 542 /**
 543  * tty_port_close
 544  *
 545  * Caller holds tty lock
 546  *
 547  * NB: may drop and reacquire tty lock (in tty_port_close_start()->
 548  * tty_wait_until_sent_from_close()) so tty and tty_port may have changed
 549  * state (but not hung up or reopened).
 550  */
 551 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 552                                                         struct file *filp)
 553 {
 554         if (tty_port_close_start(port, tty, filp) == 0)
 555                 return;
 556         tty_port_shutdown(port, tty);
 557         set_bit(TTY_IO_ERROR, &tty->flags);
 558         tty_port_close_end(port, tty);
 559         tty_port_tty_set(port, NULL);
 560 }
 561 EXPORT_SYMBOL(tty_port_close);
 562
 563 /**
 564  * tty_port_install - generic tty->ops->install handler
 565  * @port: tty_port of the device
 566  * @driver: tty_driver for this device
 567  * @tty: tty to be installed
 568  *
 569  * It is the same as tty_standard_install except the provided @port is linked
 570  * to a concrete tty specified by @tty. Use this or tty_port_register_device
 571  * (or both). Call tty_port_link_device as a last resort.
 572  */
 573 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 574                 struct tty_struct *tty)
 575 {
 576         tty->port = port;
 577         return tty_standard_install(driver, tty);
 578 }
 579 EXPORT_SYMBOL_GPL(tty_port_install);
 580
 581 /**
 582  * tty_port_open
 583  *
 584  * Caller holds tty lock.
 585  *
 586  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 587  * tty and tty_port may have changed state (eg., may be hung up now)
 588  */
 589 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 590                                                         struct file *filp)
 591 {
 592         spin_lock_irq(&port->lock);
 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);