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