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 (tty_port_initialized(port)) {
 208                 tty_port_set_initialized(port, 0);
 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         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_set_active(port, 0);
 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         /* if non-blocking mode is set we can pass directly to open unless
 367            the port has just hung up or is in another error state */
 368         if (tty_io_error(tty)) {
 369                 tty_port_set_active(port, 1);
 370                 return 0;
 371         }
 372         if (filp->f_flags & O_NONBLOCK) {
 373                 /* Indicate we are open */
 374                 if (C_BAUD(tty))
 375                         tty_port_raise_dtr_rts(port);
 376                 tty_port_set_active(port, 1);
 377                 return 0;
 378         }
 379
 380         if (C_CLOCAL(tty))
 381                 do_clocal = 1;
 382
 383         /* Block waiting until we can proceed. We may need to wait for the
 384            carrier, but we must also wait for any close that is in progress
 385            before the next open may complete */
 386
 387         retval = 0;
 388
 389         /* The port lock protects the port counts */
 390         spin_lock_irqsave(&port->lock, flags);
 391         port->count--;
 392         port->blocked_open++;
 393         spin_unlock_irqrestore(&port->lock, flags);
 394
 395         while (1) {
 396                 /* Indicate we are open */
 397                 if (C_BAUD(tty) && tty_port_initialized(port))
 398                         tty_port_raise_dtr_rts(port);
 399
 400                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 401                 /* Check for a hangup or uninitialised port.
 402                                                         Return accordingly */
 403                 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
 404                         if (port->flags & ASYNC_HUP_NOTIFY)
 405                                 retval = -EAGAIN;
 406                         else
 407                                 retval = -ERESTARTSYS;
 408                         break;
 409                 }
 410                 /*
 411                  * Probe the carrier. For devices with no carrier detect
 412                  * tty_port_carrier_raised will always return true.
 413                  * Never ask drivers if CLOCAL is set, this causes troubles
 414                  * on some hardware.
 415                  */
 416                 if (do_clocal || tty_port_carrier_raised(port))
 417                         break;
 418                 if (signal_pending(current)) {
 419                         retval = -ERESTARTSYS;
 420                         break;
 421                 }
 422                 tty_unlock(tty);
 423                 schedule();
 424                 tty_lock(tty);
 425         }
 426         finish_wait(&port->open_wait, &wait);
 427
 428         /* Update counts. A parallel hangup will have set count to zero and
 429            we must not mess that up further */
 430         spin_lock_irqsave(&port->lock, flags);
 431         if (!tty_hung_up_p(filp))
 432                 port->count++;
 433         port->blocked_open--;
 434         spin_unlock_irqrestore(&port->lock, flags);
 435         if (retval == 0)
 436                 tty_port_set_active(port, 1);
 437         return retval;
 438 }
 439 EXPORT_SYMBOL(tty_port_block_til_ready);
 440
 441 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
 442 {
 443         unsigned int bps = tty_get_baud_rate(tty);
 444         long timeout;
 445
 446         if (bps > 1200) {
 447                 timeout = (HZ * 10 * port->drain_delay) / bps;
 448                 timeout = max_t(long, timeout, HZ / 10);
 449         } else {
 450                 timeout = 2 * HZ;
 451         }
 452         schedule_timeout_interruptible(timeout);
 453 }
 454
 455 /* Caller holds tty lock. */
 456 int tty_port_close_start(struct tty_port *port,
 457                                 struct tty_struct *tty, struct file *filp)
 458 {
 459         unsigned long flags;
 460
 461         if (tty_hung_up_p(filp))
 462                 return 0;
 463
 464         spin_lock_irqsave(&port->lock, flags);
 465         if (tty->count == 1 && port->count != 1) {
 466                 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
 467                          port->count);
 468                 port->count = 1;
 469         }
 470         if (--port->count < 0) {
 471                 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
 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         spin_unlock_irqrestore(&port->lock, flags);
 481
 482         tty->closing = 1;
 483
 484         if (tty_port_initialized(port)) {
 485                 /* Don't block on a stalled port, just pull the chain */
 486                 if (tty->flow_stopped)
 487                         tty_driver_flush_buffer(tty);
 488                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 489                         tty_wait_until_sent(tty, port->closing_wait);
 490                 if (port->drain_delay)
 491                         tty_port_drain_delay(port, tty);
 492         }
 493         /* Flush the ldisc buffering */
 494         tty_ldisc_flush(tty);
 495
 496         /* Report to caller this is the last port reference */
 497         return 1;
 498 }
 499 EXPORT_SYMBOL(tty_port_close_start);
 500
 501 /* Caller holds tty lock */
 502 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 503 {
 504         unsigned long flags;
 505
 506         tty_ldisc_flush(tty);
 507         tty->closing = 0;
 508
 509         spin_lock_irqsave(&port->lock, flags);
 510
 511         if (port->blocked_open) {
 512                 spin_unlock_irqrestore(&port->lock, flags);
 513                 if (port->close_delay)
 514                         msleep_interruptible(jiffies_to_msecs(port->close_delay));
 515                 spin_lock_irqsave(&port->lock, flags);
 516                 wake_up_interruptible(&port->open_wait);
 517         }
 518         spin_unlock_irqrestore(&port->lock, flags);
 519         tty_port_set_active(port, 0);
 520 }
 521 EXPORT_SYMBOL(tty_port_close_end);
 522
 523 /**
 524  * tty_port_close
 525  *
 526  * Caller holds tty lock
 527  */
 528 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 529                                                         struct file *filp)
 530 {
 531         if (tty_port_close_start(port, tty, filp) == 0)
 532                 return;
 533         tty_port_shutdown(port, tty);
 534         set_bit(TTY_IO_ERROR, &tty->flags);
 535         tty_port_close_end(port, tty);
 536         tty_port_tty_set(port, NULL);
 537 }
 538 EXPORT_SYMBOL(tty_port_close);
 539
 540 /**
 541  * tty_port_install - generic tty->ops->install handler
 542  * @port: tty_port of the device
 543  * @driver: tty_driver for this device
 544  * @tty: tty to be installed
 545  *
 546  * It is the same as tty_standard_install except the provided @port is linked
 547  * to a concrete tty specified by @tty. Use this or tty_port_register_device
 548  * (or both). Call tty_port_link_device as a last resort.
 549  */
 550 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 551                 struct tty_struct *tty)
 552 {
 553         tty->port = port;
 554         return tty_standard_install(driver, tty);
 555 }
 556 EXPORT_SYMBOL_GPL(tty_port_install);
 557
 558 /**
 559  * tty_port_open
 560  *
 561  * Caller holds tty lock.
 562  *
 563  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 564  * tty and tty_port may have changed state (eg., may be hung up now)
 565  */
 566 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 567                                                         struct file *filp)
 568 {
 569         spin_lock_irq(&port->lock);
 570         ++port->count;
 571         spin_unlock_irq(&port->lock);
 572         tty_port_tty_set(port, tty);
 573
 574         /*
 575          * Do the device-specific open only if the hardware isn't
 576          * already initialized. Serialize open and shutdown using the
 577          * port mutex.
 578          */
 579
 580         mutex_lock(&port->mutex);
 581
 582         if (!tty_port_initialized(port)) {
 583                 clear_bit(TTY_IO_ERROR, &tty->flags);
 584                 if (port->ops->activate) {
 585                         int retval = port->ops->activate(port, tty);
 586                         if (retval) {
 587                                 mutex_unlock(&port->mutex);
 588                                 return retval;
 589                         }
 590                 }
 591                 tty_port_set_initialized(port, 1);
 592         }
 593         mutex_unlock(&port->mutex);
 594         return tty_port_block_til_ready(port, tty, filp);
 595 }
 596
 597 EXPORT_SYMBOL(tty_port_open);