drivers/tty/tty_port.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Tty port functions
   4  */
   5
   6 #include <linux/types.h>
   7 #include <linux/errno.h>
   8 #include <linux/tty.h>
   9 #include <linux/tty_driver.h>
  10 #include <linux/tty_flip.h>
  11 #include <linux/serial.h>
  12 #include <linux/timer.h>
  13 #include <linux/string.h>
  14 #include <linux/slab.h>
  15 #include <linux/sched/signal.h>
  16 #include <linux/wait.h>
  17 #include <linux/bitops.h>
  18 #include <linux/delay.h>
  19 #include <linux/module.h>
  20 #include <linux/serdev.h>
  21 #include "tty.h"
  22
  23 static size_t tty_port_default_receive_buf(struct tty_port *port, const u8 *p,
  24                                            const u8 *f, size_t count)
  25 {
  26         struct tty_struct *tty;
  27         struct tty_ldisc *ld;
  28
  29         tty = READ_ONCE(port->itty);
  30         if (!tty)
  31                 return 0;
  32
  33         ld = tty_ldisc_ref(tty);
  34         if (!ld)
  35                 return 0;
  36
  37         count = tty_ldisc_receive_buf(ld, p, f, count);
  38
  39         tty_ldisc_deref(ld);
  40
  41         return count;
  42 }
  43
  44 static void tty_port_default_lookahead_buf(struct tty_port *port, const u8 *p,
  45                                            const u8 *f, size_t count)
  46 {
  47         struct tty_struct *tty;
  48         struct tty_ldisc *ld;
  49
  50         tty = READ_ONCE(port->itty);
  51         if (!tty)
  52                 return;
  53
  54         ld = tty_ldisc_ref(tty);
  55         if (!ld)
  56                 return;
  57
  58         if (ld->ops->lookahead_buf)
  59                 ld->ops->lookahead_buf(ld->tty, p, f, count);
  60
  61         tty_ldisc_deref(ld);
  62 }
  63
  64 static void tty_port_default_wakeup(struct tty_port *port)
  65 {
  66         struct tty_struct *tty = tty_port_tty_get(port);
  67
  68         if (tty) {
  69                 tty_wakeup(tty);
  70                 tty_kref_put(tty);
  71         }
  72 }
  73
  74 const struct tty_port_client_operations tty_port_default_client_ops = {
  75         .receive_buf = tty_port_default_receive_buf,
  76         .lookahead_buf = tty_port_default_lookahead_buf,
  77         .write_wakeup = tty_port_default_wakeup,
  78 };
  79 EXPORT_SYMBOL_GPL(tty_port_default_client_ops);
  80
  81 /**
  82  * tty_port_init - initialize tty_port
  83  * @port: tty_port to initialize
  84  *
  85  * Initializes the state of struct tty_port. When a port was initialized using
  86  * this function, one has to destroy the port by tty_port_destroy(). Either
  87  * indirectly by using &tty_port refcounting (tty_port_put()) or directly if
  88  * refcounting is not used.
  89  */
  90 void tty_port_init(struct tty_port *port)
  91 {
  92         memset(port, 0, sizeof(*port));
  93         tty_buffer_init(port);
  94         init_waitqueue_head(&port->open_wait);
  95         init_waitqueue_head(&port->delta_msr_wait);
  96         mutex_init(&port->mutex);
  97         mutex_init(&port->buf_mutex);
  98         spin_lock_init(&port->lock);
  99         port->close_delay = (50 * HZ) / 100;
 100         port->closing_wait = (3000 * HZ) / 100;
 101         port->client_ops = &tty_port_default_client_ops;
 102         kref_init(&port->kref);
 103 }
 104 EXPORT_SYMBOL(tty_port_init);
 105
 106 /**
 107  * tty_port_link_device - link tty and tty_port
 108  * @port: tty_port of the device
 109  * @driver: tty_driver for this device
 110  * @index: index of the tty
 111  *
 112  * Provide the tty layer with a link from a tty (specified by @index) to a
 113  * tty_port (@port). Use this only if neither tty_port_register_device() nor
 114  * tty_port_install() is used in the driver. If used, this has to be called
 115  * before tty_register_driver().
 116  */
 117 void tty_port_link_device(struct tty_port *port,
 118                 struct tty_driver *driver, unsigned index)
 119 {
 120         if (WARN_ON(index >= driver->num))
 121                 return;
 122         driver->ports[index] = port;
 123 }
 124 EXPORT_SYMBOL_GPL(tty_port_link_device);
 125
 126 /**
 127  * tty_port_register_device - register tty device
 128  * @port: tty_port of the device
 129  * @driver: tty_driver for this device
 130  * @index: index of the tty
 131  * @device: parent if exists, otherwise NULL
 132  *
 133  * It is the same as tty_register_device() except the provided @port is linked
 134  * to a concrete tty specified by @index. Use this or tty_port_install() (or
 135  * both). Call tty_port_link_device() as a last resort.
 136  */
 137 struct device *tty_port_register_device(struct tty_port *port,
 138                 struct tty_driver *driver, unsigned index,
 139                 struct device *device)
 140 {
 141         return tty_port_register_device_attr(port, driver, index, device, NULL, NULL);
 142 }
 143 EXPORT_SYMBOL_GPL(tty_port_register_device);
 144
 145 /**
 146  * tty_port_register_device_attr - register tty device
 147  * @port: tty_port of the device
 148  * @driver: tty_driver for this device
 149  * @index: index of the tty
 150  * @device: parent if exists, otherwise NULL
 151  * @drvdata: Driver data to be set to device.
 152  * @attr_grp: Attribute group to be set on device.
 153  *
 154  * It is the same as tty_register_device_attr() except the provided @port is
 155  * linked to a concrete tty specified by @index. Use this or tty_port_install()
 156  * (or both). Call tty_port_link_device() as a last resort.
 157  */
 158 struct device *tty_port_register_device_attr(struct tty_port *port,
 159                 struct tty_driver *driver, unsigned index,
 160                 struct device *device, void *drvdata,
 161                 const struct attribute_group **attr_grp)
 162 {
 163         tty_port_link_device(port, driver, index);
 164         return tty_register_device_attr(driver, index, device, drvdata,
 165                         attr_grp);
 166 }
 167 EXPORT_SYMBOL_GPL(tty_port_register_device_attr);
 168
 169 /**
 170  * tty_port_register_device_attr_serdev - register tty or serdev device
 171  * @port: tty_port of the device
 172  * @driver: tty_driver for this device
 173  * @index: index of the tty
 174  * @device: parent if exists, otherwise NULL
 175  * @drvdata: driver data for the device
 176  * @attr_grp: attribute group for the device
 177  *
 178  * Register a serdev or tty device depending on if the parent device has any
 179  * defined serdev clients or not.
 180  */
 181 struct device *tty_port_register_device_attr_serdev(struct tty_port *port,
 182                 struct tty_driver *driver, unsigned index,
 183                 struct device *device, void *drvdata,
 184                 const struct attribute_group **attr_grp)
 185 {
 186         struct device *dev;
 187
 188         tty_port_link_device(port, driver, index);
 189
 190         dev = serdev_tty_port_register(port, device, driver, index);
 191         if (PTR_ERR(dev) != -ENODEV) {
 192                 /* Skip creating cdev if we registered a serdev device */
 193                 return dev;
 194         }
 195
 196         return tty_register_device_attr(driver, index, device, drvdata,
 197                         attr_grp);
 198 }
 199 EXPORT_SYMBOL_GPL(tty_port_register_device_attr_serdev);
 200
 201 /**
 202  * tty_port_register_device_serdev - register tty or serdev device
 203  * @port: tty_port of the device
 204  * @driver: tty_driver for this device
 205  * @index: index of the tty
 206  * @device: parent if exists, otherwise NULL
 207  *
 208  * Register a serdev or tty device depending on if the parent device has any
 209  * defined serdev clients or not.
 210  */
 211 struct device *tty_port_register_device_serdev(struct tty_port *port,
 212                 struct tty_driver *driver, unsigned index,
 213                 struct device *device)
 214 {
 215         return tty_port_register_device_attr_serdev(port, driver, index,
 216                         device, NULL, NULL);
 217 }
 218 EXPORT_SYMBOL_GPL(tty_port_register_device_serdev);
 219
 220 /**
 221  * tty_port_unregister_device - deregister a tty or serdev device
 222  * @port: tty_port of the device
 223  * @driver: tty_driver for this device
 224  * @index: index of the tty
 225  *
 226  * If a tty or serdev device is registered with a call to
 227  * tty_port_register_device_serdev() then this function must be called when
 228  * the device is gone.
 229  */
 230 void tty_port_unregister_device(struct tty_port *port,
 231                 struct tty_driver *driver, unsigned index)
 232 {
 233         int ret;
 234
 235         ret = serdev_tty_port_unregister(port);
 236         if (ret == 0)
 237                 return;
 238
 239         tty_unregister_device(driver, index);
 240 }
 241 EXPORT_SYMBOL_GPL(tty_port_unregister_device);
 242
 243 int tty_port_alloc_xmit_buf(struct tty_port *port)
 244 {
 245         /* We may sleep in get_zeroed_page() */
 246         mutex_lock(&port->buf_mutex);
 247         if (port->xmit_buf == NULL) {
 248                 port->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
 249                 if (port->xmit_buf)
 250                         kfifo_init(&port->xmit_fifo, port->xmit_buf, PAGE_SIZE);
 251         }
 252         mutex_unlock(&port->buf_mutex);
 253         if (port->xmit_buf == NULL)
 254                 return -ENOMEM;
 255         return 0;
 256 }
 257 EXPORT_SYMBOL(tty_port_alloc_xmit_buf);
 258
 259 void tty_port_free_xmit_buf(struct tty_port *port)
 260 {
 261         mutex_lock(&port->buf_mutex);
 262         free_page((unsigned long)port->xmit_buf);
 263         port->xmit_buf = NULL;
 264         INIT_KFIFO(port->xmit_fifo);
 265         mutex_unlock(&port->buf_mutex);
 266 }
 267 EXPORT_SYMBOL(tty_port_free_xmit_buf);
 268
 269 /**
 270  * tty_port_destroy - destroy inited port
 271  * @port: tty port to be destroyed
 272  *
 273  * When a port was initialized using tty_port_init(), one has to destroy the
 274  * port by this function. Either indirectly by using &tty_port refcounting
 275  * (tty_port_put()) or directly if refcounting is not used.
 276  */
 277 void tty_port_destroy(struct tty_port *port)
 278 {
 279         tty_buffer_cancel_work(port);
 280         tty_buffer_free_all(port);
 281 }
 282 EXPORT_SYMBOL(tty_port_destroy);
 283
 284 static void tty_port_destructor(struct kref *kref)
 285 {
 286         struct tty_port *port = container_of(kref, struct tty_port, kref);
 287
 288         /* check if last port ref was dropped before tty release */
 289         if (WARN_ON(port->itty))
 290                 return;
 291         free_page((unsigned long)port->xmit_buf);
 292         tty_port_destroy(port);
 293         if (port->ops && port->ops->destruct)
 294                 port->ops->destruct(port);
 295         else
 296                 kfree(port);
 297 }
 298
 299 /**
 300  * tty_port_put - drop a reference to tty_port
 301  * @port: port to drop a reference of (can be NULL)
 302  *
 303  * The final put will destroy and free up the @port using
 304  * @port->ops->destruct() hook, or using kfree() if not provided.
 305  */
 306 void tty_port_put(struct tty_port *port)
 307 {
 308         if (port)
 309                 kref_put(&port->kref, tty_port_destructor);
 310 }
 311 EXPORT_SYMBOL(tty_port_put);
 312
 313 /**
 314  * tty_port_tty_get     -       get a tty reference
 315  * @port: tty port
 316  *
 317  * Return a refcount protected tty instance or %NULL if the port is not
 318  * associated with a tty (eg due to close or hangup).
 319  */
 320 struct tty_struct *tty_port_tty_get(struct tty_port *port)
 321 {
 322         unsigned long flags;
 323         struct tty_struct *tty;
 324
 325         spin_lock_irqsave(&port->lock, flags);
 326         tty = tty_kref_get(port->tty);
 327         spin_unlock_irqrestore(&port->lock, flags);
 328         return tty;
 329 }
 330 EXPORT_SYMBOL(tty_port_tty_get);
 331
 332 /**
 333  * tty_port_tty_set     -       set the tty of a port
 334  * @port: tty port
 335  * @tty: the tty
 336  *
 337  * Associate the port and tty pair. Manages any internal refcounts. Pass %NULL
 338  * to deassociate a port.
 339  */
 340 void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
 341 {
 342         unsigned long flags;
 343
 344         spin_lock_irqsave(&port->lock, flags);
 345         tty_kref_put(port->tty);
 346         port->tty = tty_kref_get(tty);
 347         spin_unlock_irqrestore(&port->lock, flags);
 348 }
 349 EXPORT_SYMBOL(tty_port_tty_set);
 350
 351 /**
 352  * tty_port_shutdown - internal helper to shutdown the device
 353  * @port: tty port to be shut down
 354  * @tty: the associated tty
 355  *
 356  * It is used by tty_port_hangup() and tty_port_close(). Its task is to
 357  * shutdown the device if it was initialized (note consoles remain
 358  * functioning). It lowers DTR/RTS (if @tty has HUPCL set) and invokes
 359  * @port->ops->shutdown().
 360  */
 361 static void tty_port_shutdown(struct tty_port *port, struct tty_struct *tty)
 362 {
 363         mutex_lock(&port->mutex);
 364         if (port->console)
 365                 goto out;
 366
 367         if (tty_port_initialized(port)) {
 368                 tty_port_set_initialized(port, false);
 369                 /*
 370                  * Drop DTR/RTS if HUPCL is set. This causes any attached
 371                  * modem to hang up the line.
 372                  */
 373                 if (tty && C_HUPCL(tty))
 374                         tty_port_lower_dtr_rts(port);
 375
 376                 if (port->ops->shutdown)
 377                         port->ops->shutdown(port);
 378         }
 379 out:
 380         mutex_unlock(&port->mutex);
 381 }
 382
 383 /**
 384  * tty_port_hangup              -       hangup helper
 385  * @port: tty port
 386  *
 387  * Perform port level tty hangup flag and count changes. Drop the tty
 388  * reference.
 389  *
 390  * Caller holds tty lock.
 391  */
 392 void tty_port_hangup(struct tty_port *port)
 393 {
 394         struct tty_struct *tty;
 395         unsigned long flags;
 396
 397         spin_lock_irqsave(&port->lock, flags);
 398         port->count = 0;
 399         tty = port->tty;
 400         if (tty)
 401                 set_bit(TTY_IO_ERROR, &tty->flags);
 402         port->tty = NULL;
 403         spin_unlock_irqrestore(&port->lock, flags);
 404         tty_port_set_active(port, false);
 405         tty_port_shutdown(port, tty);
 406         tty_kref_put(tty);
 407         wake_up_interruptible(&port->open_wait);
 408         wake_up_interruptible(&port->delta_msr_wait);
 409 }
 410 EXPORT_SYMBOL(tty_port_hangup);
 411
 412 /**
 413  * tty_port_tty_hangup - helper to hang up a tty
 414  * @port: tty port
 415  * @check_clocal: hang only ttys with %CLOCAL unset?
 416  */
 417 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal)
 418 {
 419         struct tty_struct *tty = tty_port_tty_get(port);
 420
 421         if (tty && (!check_clocal || !C_CLOCAL(tty)))
 422                 tty_hangup(tty);
 423         tty_kref_put(tty);
 424 }
 425 EXPORT_SYMBOL_GPL(tty_port_tty_hangup);
 426
 427 /**
 428  * tty_port_tty_wakeup - helper to wake up a tty
 429  * @port: tty port
 430  */
 431 void tty_port_tty_wakeup(struct tty_port *port)
 432 {
 433         port->client_ops->write_wakeup(port);
 434 }
 435 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup);
 436
 437 /**
 438  * tty_port_carrier_raised      -       carrier raised check
 439  * @port: tty port
 440  *
 441  * Wrapper for the carrier detect logic. For the moment this is used
 442  * to hide some internal details. This will eventually become entirely
 443  * internal to the tty port.
 444  */
 445 bool tty_port_carrier_raised(struct tty_port *port)
 446 {
 447         if (port->ops->carrier_raised == NULL)
 448                 return true;
 449         return port->ops->carrier_raised(port);
 450 }
 451 EXPORT_SYMBOL(tty_port_carrier_raised);
 452
 453 /**
 454  * tty_port_raise_dtr_rts       -       Raise DTR/RTS
 455  * @port: tty port
 456  *
 457  * Wrapper for the DTR/RTS raise logic. For the moment this is used to hide
 458  * some internal details. This will eventually become entirely internal to the
 459  * tty port.
 460  */
 461 void tty_port_raise_dtr_rts(struct tty_port *port)
 462 {
 463         if (port->ops->dtr_rts)
 464                 port->ops->dtr_rts(port, true);
 465 }
 466 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
 467
 468 /**
 469  * tty_port_lower_dtr_rts       -       Lower DTR/RTS
 470  * @port: tty port
 471  *
 472  * Wrapper for the DTR/RTS raise logic. For the moment this is used to hide
 473  * some internal details. This will eventually become entirely internal to the
 474  * tty port.
 475  */
 476 void tty_port_lower_dtr_rts(struct tty_port *port)
 477 {
 478         if (port->ops->dtr_rts)
 479                 port->ops->dtr_rts(port, false);
 480 }
 481 EXPORT_SYMBOL(tty_port_lower_dtr_rts);
 482
 483 /**
 484  * tty_port_block_til_ready     -       Waiting logic for tty open
 485  * @port: the tty port being opened
 486  * @tty: the tty device being bound
 487  * @filp: the file pointer of the opener or %NULL
 488  *
 489  * Implement the core POSIX/SuS tty behaviour when opening a tty device.
 490  * Handles:
 491  *
 492  *      - hangup (both before and during)
 493  *      - non blocking open
 494  *      - rts/dtr/dcd
 495  *      - signals
 496  *      - port flags and counts
 497  *
 498  * The passed @port must implement the @port->ops->carrier_raised method if it
 499  * can do carrier detect and the @port->ops->dtr_rts method if it supports
 500  * software management of these lines. Note that the dtr/rts raise is done each
 501  * iteration as a hangup may have previously dropped them while we wait.
 502  *
 503  * Caller holds tty lock.
 504  *
 505  * Note: May drop and reacquire tty lock when blocking, so @tty and @port may
 506  * have changed state (eg., may have been hung up).
 507  */
 508 int tty_port_block_til_ready(struct tty_port *port,
 509                                 struct tty_struct *tty, struct file *filp)
 510 {
 511         int do_clocal = 0, retval;
 512         unsigned long flags;
 513         DEFINE_WAIT(wait);
 514
 515         /* if non-blocking mode is set we can pass directly to open unless
 516          * the port has just hung up or is in another error state.
 517          */
 518         if (tty_io_error(tty)) {
 519                 tty_port_set_active(port, true);
 520                 return 0;
 521         }
 522         if (filp == NULL || (filp->f_flags & O_NONBLOCK)) {
 523                 /* Indicate we are open */
 524                 if (C_BAUD(tty))
 525                         tty_port_raise_dtr_rts(port);
 526                 tty_port_set_active(port, true);
 527                 return 0;
 528         }
 529
 530         if (C_CLOCAL(tty))
 531                 do_clocal = 1;
 532
 533         /* Block waiting until we can proceed. We may need to wait for the
 534          * carrier, but we must also wait for any close that is in progress
 535          * before the next open may complete.
 536          */
 537
 538         retval = 0;
 539
 540         /* The port lock protects the port counts */
 541         spin_lock_irqsave(&port->lock, flags);
 542         port->count--;
 543         port->blocked_open++;
 544         spin_unlock_irqrestore(&port->lock, flags);
 545
 546         while (1) {
 547                 /* Indicate we are open */
 548                 if (C_BAUD(tty) && tty_port_initialized(port))
 549                         tty_port_raise_dtr_rts(port);
 550
 551                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 552                 /* Check for a hangup or uninitialised port.
 553                  * Return accordingly.
 554                  */
 555                 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
 556                         if (port->flags & ASYNC_HUP_NOTIFY)
 557                                 retval = -EAGAIN;
 558                         else
 559                                 retval = -ERESTARTSYS;
 560                         break;
 561                 }
 562                 /*
 563                  * Probe the carrier. For devices with no carrier detect
 564                  * tty_port_carrier_raised will always return true.
 565                  * Never ask drivers if CLOCAL is set, this causes troubles
 566                  * on some hardware.
 567                  */
 568                 if (do_clocal || tty_port_carrier_raised(port))
 569                         break;
 570                 if (signal_pending(current)) {
 571                         retval = -ERESTARTSYS;
 572                         break;
 573                 }
 574                 tty_unlock(tty);
 575                 schedule();
 576                 tty_lock(tty);
 577         }
 578         finish_wait(&port->open_wait, &wait);
 579
 580         /* Update counts. A parallel hangup will have set count to zero and
 581          * we must not mess that up further.
 582          */
 583         spin_lock_irqsave(&port->lock, flags);
 584         if (!tty_hung_up_p(filp))
 585                 port->count++;
 586         port->blocked_open--;
 587         spin_unlock_irqrestore(&port->lock, flags);
 588         if (retval == 0)
 589                 tty_port_set_active(port, true);
 590         return retval;
 591 }
 592 EXPORT_SYMBOL(tty_port_block_til_ready);
 593
 594 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
 595 {
 596         unsigned int bps = tty_get_baud_rate(tty);
 597         long timeout;
 598
 599         if (bps > 1200) {
 600                 timeout = (HZ * 10 * port->drain_delay) / bps;
 601                 timeout = max_t(long, timeout, HZ / 10);
 602         } else {
 603                 timeout = 2 * HZ;
 604         }
 605         schedule_timeout_interruptible(timeout);
 606 }
 607
 608 /**
 609  * tty_port_close_start - helper for tty->ops->close, part 1/2
 610  * @port: tty_port of the device
 611  * @tty: tty being closed
 612  * @filp: passed file pointer
 613  *
 614  * Decrements and checks open count. Flushes the port if this is the last
 615  * close. That means, dropping the data from the outpu buffer on the device and
 616  * waiting for sending logic to finish. The rest of close handling is performed
 617  * in tty_port_close_end().
 618  *
 619  * Locking: Caller holds tty lock.
 620  *
 621  * Return: 1 if this is the last close, otherwise 0
 622  */
 623 int tty_port_close_start(struct tty_port *port,
 624                                 struct tty_struct *tty, struct file *filp)
 625 {
 626         unsigned long flags;
 627
 628         if (tty_hung_up_p(filp))
 629                 return 0;
 630
 631         spin_lock_irqsave(&port->lock, flags);
 632         if (tty->count == 1 && port->count != 1) {
 633                 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
 634                          port->count);
 635                 port->count = 1;
 636         }
 637         if (--port->count < 0) {
 638                 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
 639                          port->count);
 640                 port->count = 0;
 641         }
 642
 643         if (port->count) {
 644                 spin_unlock_irqrestore(&port->lock, flags);
 645                 return 0;
 646         }
 647         spin_unlock_irqrestore(&port->lock, flags);
 648
 649         tty->closing = 1;
 650
 651         if (tty_port_initialized(port)) {
 652                 /* Don't block on a stalled port, just pull the chain */
 653                 if (tty->flow.tco_stopped)
 654                         tty_driver_flush_buffer(tty);
 655                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 656                         tty_wait_until_sent(tty, port->closing_wait);
 657                 if (port->drain_delay)
 658                         tty_port_drain_delay(port, tty);
 659         }
 660         /* Flush the ldisc buffering */
 661         tty_ldisc_flush(tty);
 662
 663         /* Report to caller this is the last port reference */
 664         return 1;
 665 }
 666 EXPORT_SYMBOL(tty_port_close_start);
 667
 668 /**
 669  * tty_port_close_end - helper for tty->ops->close, part 2/2
 670  * @port: tty_port of the device
 671  * @tty: tty being closed
 672  *
 673  * This is a continuation of the first part: tty_port_close_start(). This
 674  * should be called after turning off the device. It flushes the data from the
 675  * line discipline and delays the close by @port->close_delay.
 676  *
 677  * Locking: Caller holds tty lock.
 678  */
 679 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 680 {
 681         unsigned long flags;
 682
 683         tty_ldisc_flush(tty);
 684         tty->closing = 0;
 685
 686         spin_lock_irqsave(&port->lock, flags);
 687
 688         if (port->blocked_open) {
 689                 spin_unlock_irqrestore(&port->lock, flags);
 690                 if (port->close_delay)
 691                         msleep_interruptible(jiffies_to_msecs(port->close_delay));
 692                 spin_lock_irqsave(&port->lock, flags);
 693                 wake_up_interruptible(&port->open_wait);
 694         }
 695         spin_unlock_irqrestore(&port->lock, flags);
 696         tty_port_set_active(port, false);
 697 }
 698 EXPORT_SYMBOL(tty_port_close_end);
 699
 700 /**
 701  * tty_port_close - generic tty->ops->close handler
 702  * @port: tty_port of the device
 703  * @tty: tty being closed
 704  * @filp: passed file pointer
 705  *
 706  * It is a generic helper to be used in driver's @tty->ops->close. It wraps a
 707  * sequence of tty_port_close_start(), tty_port_shutdown(), and
 708  * tty_port_close_end(). The latter two are called only if this is the last
 709  * close. See the respective functions for the details.
 710  *
 711  * Locking: Caller holds tty lock
 712  */
 713 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 714                                                         struct file *filp)
 715 {
 716         if (tty_port_close_start(port, tty, filp) == 0)
 717                 return;
 718         tty_port_shutdown(port, tty);
 719         if (!port->console)
 720                 set_bit(TTY_IO_ERROR, &tty->flags);
 721         tty_port_close_end(port, tty);
 722         tty_port_tty_set(port, NULL);
 723 }
 724 EXPORT_SYMBOL(tty_port_close);
 725
 726 /**
 727  * tty_port_install - generic tty->ops->install handler
 728  * @port: tty_port of the device
 729  * @driver: tty_driver for this device
 730  * @tty: tty to be installed
 731  *
 732  * It is the same as tty_standard_install() except the provided @port is linked
 733  * to a concrete tty specified by @tty. Use this or tty_port_register_device()
 734  * (or both). Call tty_port_link_device() as a last resort.
 735  */
 736 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 737                 struct tty_struct *tty)
 738 {
 739         tty->port = port;
 740         return tty_standard_install(driver, tty);
 741 }
 742 EXPORT_SYMBOL_GPL(tty_port_install);
 743
 744 /**
 745  * tty_port_open - generic tty->ops->open handler
 746  * @port: tty_port of the device
 747  * @tty: tty to be opened
 748  * @filp: passed file pointer
 749  *
 750  * It is a generic helper to be used in driver's @tty->ops->open. It activates
 751  * the devices using @port->ops->activate if not active already. And waits for
 752  * the device to be ready using tty_port_block_til_ready() (e.g.  raises
 753  * DTR/CTS and waits for carrier).
 754  *
 755  * Note that @port->ops->shutdown is not called when @port->ops->activate
 756  * returns an error (on the contrary, @tty->ops->close is).
 757  *
 758  * Locking: Caller holds tty lock.
 759  *
 760  * Note: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 761  * @tty and @port may have changed state (eg., may be hung up now).
 762  */
 763 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 764                                                         struct file *filp)
 765 {
 766         spin_lock_irq(&port->lock);
 767         ++port->count;
 768         spin_unlock_irq(&port->lock);
 769         tty_port_tty_set(port, tty);
 770
 771         /*
 772          * Do the device-specific open only if the hardware isn't
 773          * already initialized. Serialize open and shutdown using the
 774          * port mutex.
 775          */
 776
 777         mutex_lock(&port->mutex);
 778
 779         if (!tty_port_initialized(port)) {
 780                 clear_bit(TTY_IO_ERROR, &tty->flags);
 781                 if (port->ops->activate) {
 782                         int retval = port->ops->activate(port, tty);
 783
 784                         if (retval) {
 785                                 mutex_unlock(&port->mutex);
 786                                 return retval;
 787                         }
 788                 }
 789                 tty_port_set_initialized(port, true);
 790         }
 791         mutex_unlock(&port->mutex);
 792         return tty_port_block_til_ready(port, tty, filp);
 793 }
 794 EXPORT_SYMBOL(tty_port_open);