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