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->delta_msr_wait);
  26         mutex_init(&port->mutex);
  27         mutex_init(&port->buf_mutex);
  28         spin_lock_init(&port->lock);
  29         port->close_delay = (50 * HZ) / 100;
  30         port->closing_wait = (3000 * HZ) / 100;
  31         kref_init(&port->kref);
  32 }
  33 EXPORT_SYMBOL(tty_port_init);
  34
  35 /**
  36  * tty_port_link_device - link tty and tty_port
  37  * @port: tty_port of the device
  38  * @driver: tty_driver for this device
  39  * @index: index of the tty
  40  *
  41  * Provide the tty layer wit ha link from a tty (specified by @index) to a
  42  * tty_port (@port). Use this only if neither tty_port_register_device nor
  43  * tty_port_install is used in the driver. If used, this has to be called before
  44  * tty_register_driver.
  45  */
  46 void tty_port_link_device(struct tty_port *port,
  47                 struct tty_driver *driver, unsigned index)
  48 {
  49         if (WARN_ON(index >= driver->num))
  50                 return;
  51         driver->ports[index] = port;
  52 }
  53 EXPORT_SYMBOL_GPL(tty_port_link_device);
  54
  55 /**
  56  * tty_port_register_device - register tty device
  57  * @port: tty_port of the device
  58  * @driver: tty_driver for this device
  59  * @index: index of the tty
  60  * @device: parent if exists, otherwise NULL
  61  *
  62  * It is the same as tty_register_device except the provided @port is linked to
  63  * a concrete tty specified by @index. Use this or tty_port_install (or both).
  64  * Call tty_port_link_device as a last resort.
  65  */
  66 struct device *tty_port_register_device(struct tty_port *port,
  67                 struct tty_driver *driver, unsigned index,
  68                 struct device *device)
  69 {
  70         tty_port_link_device(port, driver, index);
  71         return tty_register_device(driver, index, device);
  72 }
  73 EXPORT_SYMBOL_GPL(tty_port_register_device);
  74
  75 /**
  76  * tty_port_register_device_attr - register tty device
  77  * @port: tty_port of the device
  78  * @driver: tty_driver for this device
  79  * @index: index of the tty
  80  * @device: parent if exists, otherwise NULL
  81  * @drvdata: Driver data to be set to device.
  82  * @attr_grp: Attribute group to be set on device.
  83  *
  84  * It is the same as tty_register_device_attr except the provided @port is
  85  * linked to a concrete tty specified by @index. Use this or tty_port_install
  86  * (or both). Call tty_port_link_device as a last resort.
  87  */
  88 struct device *tty_port_register_device_attr(struct tty_port *port,
  89                 struct tty_driver *driver, unsigned index,
  90                 struct device *device, void *drvdata,
  91                 const struct attribute_group **attr_grp)
  92 {
  93         tty_port_link_device(port, driver, index);
  94         return tty_register_device_attr(driver, index, device, drvdata,
  95                         attr_grp);
  96 }
  97 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
  98
  99 int tty_port_alloc_xmit_buf(struct tty_port *port)
 100 {
 101         /* We may sleep in get_zeroed_page() */
 102         mutex_lock(&port->buf_mutex);
 103         if (port->xmit_buf == NULL)
 104                 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
 105         mutex_unlock(&port->buf_mutex);
 106         if (port->xmit_buf == NULL)
 107                 return -ENOMEM;
 108         return 0;
 109 }
 110 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
 111
 112 void tty_port_free_xmit_buf(struct tty_port *port)
 113 {
 114         mutex_lock(&port->buf_mutex);
 115         if (port->xmit_buf != NULL) {
 116                 free_page((unsigned long)port->xmit_buf);
 117                 port->xmit_buf = NULL;
 118         }
 119         mutex_unlock(&port->buf_mutex);
 120 }
 121 EXPORT_SYMBOL(tty_port_free_xmit_buf);
 122
 123 /**
 124  * tty_port_destroy -- destroy inited port
 125  * @port: tty port to be doestroyed
 126  *
 127  * When a port was initialized using tty_port_init, one has to destroy the
 128  * port by this function. Either indirectly by using tty_port refcounting
 129  * (tty_port_put) or directly if refcounting is not used.
 130  */
 131 void tty_port_destroy(struct tty_port *port)
 132 {
 133         tty_buffer_cancel_work(port);
 134         tty_buffer_free_all(port);
 135 }
 136 EXPORT_SYMBOL(tty_port_destroy);
 137
 138 static void tty_port_destructor(struct kref *kref)
 139 {
 140         struct tty_port *port = container_of(kref, struct tty_port, kref);
 141
 142         /* check if last port ref was dropped before tty release */
 143         if (WARN_ON(port->itty))
 144                 return;
 145         if (port->xmit_buf)
 146                 free_page((unsigned long)port->xmit_buf);
 147         tty_port_destroy(port);
 148         if (port->ops && port->ops->destruct)
 149                 port->ops->destruct(port);
 150         else
 151                 kfree(port);
 152 }
 153
 154 void tty_port_put(struct tty_port *port)
 155 {
 156         if (port)
 157                 kref_put(&port->kref, tty_port_destructor);
 158 }
 159 EXPORT_SYMBOL(tty_port_put);
 160
 161 /**
 162  *      tty_port_tty_get        -       get a tty reference
 163  *      @port: tty port
 164  *
 165  *      Return a refcount protected tty instance or NULL if the port is not
 166  *      associated with a tty (eg due to close or hangup)
 167  */
 168
 169 struct tty_struct *tty_port_tty_get(struct tty_port *port)
 170 {
 171         unsigned long flags;
 172         struct tty_struct *tty;
 173
 174         spin_lock_irqsave(&port->lock, flags);
 175         tty = tty_kref_get(port->tty);
 176         spin_unlock_irqrestore(&port->lock, flags);
 177         return tty;
 178 }
 179 EXPORT_SYMBOL(tty_port_tty_get);
 180
 181 /**
 182  *      tty_port_tty_set        -       set the tty of a port
 183  *      @port: tty port
 184  *      @tty: the tty
 185  *
 186  *      Associate the port and tty pair. Manages any internal refcounts.
 187  *      Pass NULL to deassociate a port
 188  */
 189
 190 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
 191 {
 192         unsigned long flags;
 193
 194         spin_lock_irqsave(&port->lock, flags);
 195         tty_kref_put(port->tty);
 196         port->tty = tty_kref_get(tty);
 197         spin_unlock_irqrestore(&port->lock, flags);
 198 }
 199 EXPORT_SYMBOL(tty_port_tty_set);
 200
 201 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
 202 {
 203         mutex_lock(&port->mutex);
 204         if (port->console)
 205                 goto out;
 206
 207         if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
 208                 /*
 209                  * Drop DTR/RTS if HUPCL is set. This causes any attached
 210                  * modem to hang up the line.
 211                  */
 212                 if (tty && C_HUPCL(tty))
 213                         tty_port_lower_dtr_rts(port);
 214
 215                 if (port->ops->shutdown)
 216                         port->ops->shutdown(port);
 217         }
 218 out:
 219         mutex_unlock(&port->mutex);
 220 }
 221
 222 /**
 223  *      tty_port_hangup         -       hangup helper
 224  *      @port: tty port
 225  *
 226  *      Perform port level tty hangup flag and count changes. Drop the tty
 227  *      reference.
 228  *
 229  *      Caller holds tty lock.
 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         /* if non-blocking mode is set we can pass directly to open unless
 366            the port has just hung up or is in another error state */
 367         if (tty->flags & (1 << TTY_IO_ERROR)) {
 368                 port->flags |= ASYNC_NORMAL_ACTIVE;
 369                 return 0;
 370         }
 371         if (filp->f_flags & O_NONBLOCK) {
 372                 /* Indicate we are open */
 373                 if (tty->termios.c_cflag & CBAUD)
 374                         tty_port_raise_dtr_rts(port);
 375                 port->flags |= ASYNC_NORMAL_ACTIVE;
 376                 return 0;
 377         }
 378
 379         if (C_CLOCAL(tty))
 380                 do_clocal = 1;
 381
 382         /* Block waiting until we can proceed. We may need to wait for the
 383            carrier, but we must also wait for any close that is in progress
 384            before the next open may complete */
 385
 386         retval = 0;
 387
 388         /* The port lock protects the port counts */
 389         spin_lock_irqsave(&port->lock, flags);
 390         port->count--;
 391         port->blocked_open++;
 392         spin_unlock_irqrestore(&port->lock, flags);
 393
 394         while (1) {
 395                 /* Indicate we are open */
 396                 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
 397                         tty_port_raise_dtr_rts(port);
 398
 399                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 400                 /* Check for a hangup or uninitialised port.
 401                                                         Return accordingly */
 402                 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
 403                         if (port->flags & ASYNC_HUP_NOTIFY)
 404                                 retval = -EAGAIN;
 405                         else
 406                                 retval = -ERESTARTSYS;
 407                         break;
 408                 }
 409                 /*
 410                  * Probe the carrier. For devices with no carrier detect
 411                  * tty_port_carrier_raised will always return true.
 412                  * Never ask drivers if CLOCAL is set, this causes troubles
 413                  * on some hardware.
 414                  */
 415                 if (do_clocal || tty_port_carrier_raised(port))
 416                         break;
 417                 if (signal_pending(current)) {
 418                         retval = -ERESTARTSYS;
 419                         break;
 420                 }
 421                 tty_unlock(tty);
 422                 schedule();
 423                 tty_lock(tty);
 424         }
 425         finish_wait(&port->open_wait, &wait);
 426
 427         /* Update counts. A parallel hangup will have set count to zero and
 428            we must not mess that up further */
 429         spin_lock_irqsave(&port->lock, flags);
 430         if (!tty_hung_up_p(filp))
 431                 port->count++;
 432         port->blocked_open--;
 433         if (retval == 0)
 434                 port->flags |= ASYNC_NORMAL_ACTIVE;
 435         spin_unlock_irqrestore(&port->lock, flags);
 436         return retval;
 437 }
 438 EXPORT_SYMBOL(tty_port_block_til_ready);
 439
 440 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
 441 {
 442         unsigned int bps = tty_get_baud_rate(tty);
 443         long timeout;
 444
 445         if (bps > 1200) {
 446                 timeout = (HZ * 10 * port->drain_delay) / bps;
 447                 timeout = max_t(long, timeout, HZ / 10);
 448         } else {
 449                 timeout = 2 * HZ;
 450         }
 451         schedule_timeout_interruptible(timeout);
 452 }
 453
 454 /* Caller holds tty lock. */
 455 int tty_port_close_start(struct tty_port *port,
 456                                 struct tty_struct *tty, struct file *filp)
 457 {
 458         unsigned long flags;
 459
 460         if (tty_hung_up_p(filp))
 461                 return 0;
 462
 463         spin_lock_irqsave(&port->lock, flags);
 464         if (tty->count == 1 && port->count != 1) {
 465                 printk(KERN_WARNING
 466                     "tty_port_close_start: tty->count = 1 port count = %d.\n",
 467                                                                 port->count);
 468                 port->count = 1;
 469         }
 470         if (--port->count < 0) {
 471                 printk(KERN_WARNING "tty_port_close_start: count = %d\n",
 472                                                                 port->count);
 473                 port->count = 0;
 474         }
 475
 476         if (port->count) {
 477                 spin_unlock_irqrestore(&port->lock, flags);
 478                 return 0;
 479         }
 480         set_bit(ASYNCB_CLOSING, &port->flags);
 481         spin_unlock_irqrestore(&port->lock, flags);
 482
 483         tty->closing = 1;
 484
 485         if (test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 486                 /* Don't block on a stalled port, just pull the chain */
 487                 if (tty->flow_stopped)
 488                         tty_driver_flush_buffer(tty);
 489                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 490                         tty_wait_until_sent(tty, port->closing_wait);
 491                 if (port->drain_delay)
 492                         tty_port_drain_delay(port, tty);
 493         }
 494         /* Flush the ldisc buffering */
 495         tty_ldisc_flush(tty);
 496
 497         /* Report to caller this is the last port reference */
 498         return 1;
 499 }
 500 EXPORT_SYMBOL(tty_port_close_start);
 501
 502 /* Caller holds tty lock */
 503 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 504 {
 505         unsigned long flags;
 506
 507         tty_ldisc_flush(tty);
 508         tty->closing = 0;
 509
 510         spin_lock_irqsave(&port->lock, flags);
 511
 512         if (port->blocked_open) {
 513                 spin_unlock_irqrestore(&port->lock, flags);
 514                 if (port->close_delay) {
 515                         msleep_interruptible(
 516                                 jiffies_to_msecs(port->close_delay));
 517                 }
 518                 spin_lock_irqsave(&port->lock, flags);
 519                 wake_up_interruptible(&port->open_wait);
 520         }
 521         port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
 522         spin_unlock_irqrestore(&port->lock, flags);
 523 }
 524 EXPORT_SYMBOL(tty_port_close_end);
 525
 526 /**
 527  * tty_port_close
 528  *
 529  * Caller holds tty lock
 530  */
 531 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 532                                                         struct file *filp)
 533 {
 534         if (tty_port_close_start(port, tty, filp) == 0)
 535                 return;
 536         tty_port_shutdown(port, tty);
 537         set_bit(TTY_IO_ERROR, &tty->flags);
 538         tty_port_close_end(port, tty);
 539         tty_port_tty_set(port, NULL);
 540 }
 541 EXPORT_SYMBOL(tty_port_close);
 542
 543 /**
 544  * tty_port_install - generic tty->ops->install handler
 545  * @port: tty_port of the device
 546  * @driver: tty_driver for this device
 547  * @tty: tty to be installed
 548  *
 549  * It is the same as tty_standard_install except the provided @port is linked
 550  * to a concrete tty specified by @tty. Use this or tty_port_register_device
 551  * (or both). Call tty_port_link_device as a last resort.
 552  */
 553 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 554                 struct tty_struct *tty)
 555 {
 556         tty->port = port;
 557         return tty_standard_install(driver, tty);
 558 }
 559 EXPORT_SYMBOL_GPL(tty_port_install);
 560
 561 /**
 562  * tty_port_open
 563  *
 564  * Caller holds tty lock.
 565  *
 566  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 567  * tty and tty_port may have changed state (eg., may be hung up now)
 568  */
 569 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 570                                                         struct file *filp)
 571 {
 572         spin_lock_irq(&port->lock);
 573         ++port->count;
 574         spin_unlock_irq(&port->lock);
 575         tty_port_tty_set(port, tty);
 576
 577         /*
 578          * Do the device-specific open only if the hardware isn't
 579          * already initialized. Serialize open and shutdown using the
 580          * port mutex.
 581          */
 582
 583         mutex_lock(&port->mutex);
 584
 585         if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 586                 clear_bit(TTY_IO_ERROR, &tty->flags);
 587                 if (port->ops->activate) {
 588                         int retval = port->ops->activate(port, tty);
 589                         if (retval) {
 590                                 mutex_unlock(&port->mutex);
 591                                 return retval;
 592                         }
 593                 }
 594                 set_bit(ASYNCB_INITIALIZED, &port->flags);
 595         }
 596         mutex_unlock(&port->mutex);
 597         return tty_port_block_til_ready(port, tty, filp);
 598 }
 599
 600 EXPORT_SYMBOL(tty_port_open);