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         if (tty_io_error(tty)) {
 473                 tty_port_set_active(port, 1);
 474                 return 0;
 475         }
 476         if (filp == NULL || (filp->f_flags & O_NONBLOCK)) {
 477                 /* Indicate we are open */
 478                 if (C_BAUD(tty))
 479                         tty_port_raise_dtr_rts(port);
 480                 tty_port_set_active(port, 1);
 481                 return 0;
 482         }
 483
 484         if (C_CLOCAL(tty))
 485                 do_clocal = 1;
 486
 487         /* Block waiting until we can proceed. We may need to wait for the
 488            carrier, but we must also wait for any close that is in progress
 489            before the next open may complete */
 490
 491         retval = 0;
 492
 493         /* The port lock protects the port counts */
 494         spin_lock_irqsave(&port->lock, flags);
 495         port->count--;
 496         port->blocked_open++;
 497         spin_unlock_irqrestore(&port->lock, flags);
 498
 499         while (1) {
 500                 /* Indicate we are open */
 501                 if (C_BAUD(tty) && tty_port_initialized(port))
 502                         tty_port_raise_dtr_rts(port);
 503
 504                 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
 505                 /* Check for a hangup or uninitialised port.
 506                                                         Return accordingly */
 507                 if (tty_hung_up_p(filp) || !tty_port_initialized(port)) {
 508                         if (port->flags & ASYNC_HUP_NOTIFY)
 509                                 retval = -EAGAIN;
 510                         else
 511                                 retval = -ERESTARTSYS;
 512                         break;
 513                 }
 514                 /*
 515                  * Probe the carrier. For devices with no carrier detect
 516                  * tty_port_carrier_raised will always return true.
 517                  * Never ask drivers if CLOCAL is set, this causes troubles
 518                  * on some hardware.
 519                  */
 520                 if (do_clocal || tty_port_carrier_raised(port))
 521                         break;
 522                 if (signal_pending(current)) {
 523                         retval = -ERESTARTSYS;
 524                         break;
 525                 }
 526                 tty_unlock(tty);
 527                 schedule();
 528                 tty_lock(tty);
 529         }
 530         finish_wait(&port->open_wait, &wait);
 531
 532         /* Update counts. A parallel hangup will have set count to zero and
 533            we must not mess that up further */
 534         spin_lock_irqsave(&port->lock, flags);
 535         if (!tty_hung_up_p(filp))
 536                 port->count++;
 537         port->blocked_open--;
 538         spin_unlock_irqrestore(&port->lock, flags);
 539         if (retval == 0)
 540                 tty_port_set_active(port, 1);
 541         return retval;
 542 }
 543 EXPORT_SYMBOL(tty_port_block_til_ready);
 544
 545 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty)
 546 {
 547         unsigned int bps = tty_get_baud_rate(tty);
 548         long timeout;
 549
 550         if (bps > 1200) {
 551                 timeout = (HZ * 10 * port->drain_delay) / bps;
 552                 timeout = max_t(long, timeout, HZ / 10);
 553         } else {
 554                 timeout = 2 * HZ;
 555         }
 556         schedule_timeout_interruptible(timeout);
 557 }
 558
 559 /* Caller holds tty lock. */
 560 int tty_port_close_start(struct tty_port *port,
 561                                 struct tty_struct *tty, struct file *filp)
 562 {
 563         unsigned long flags;
 564
 565         if (tty_hung_up_p(filp))
 566                 return 0;
 567
 568         spin_lock_irqsave(&port->lock, flags);
 569         if (tty->count == 1 && port->count != 1) {
 570                 tty_warn(tty, "%s: tty->count = 1 port count = %d\n", __func__,
 571                          port->count);
 572                 port->count = 1;
 573         }
 574         if (--port->count < 0) {
 575                 tty_warn(tty, "%s: bad port count (%d)\n", __func__,
 576                          port->count);
 577                 port->count = 0;
 578         }
 579
 580         if (port->count) {
 581                 spin_unlock_irqrestore(&port->lock, flags);
 582                 return 0;
 583         }
 584         spin_unlock_irqrestore(&port->lock, flags);
 585
 586         tty->closing = 1;
 587
 588         if (tty_port_initialized(port)) {
 589                 /* Don't block on a stalled port, just pull the chain */
 590                 if (tty->flow_stopped)
 591                         tty_driver_flush_buffer(tty);
 592                 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
 593                         tty_wait_until_sent(tty, port->closing_wait);
 594                 if (port->drain_delay)
 595                         tty_port_drain_delay(port, tty);
 596         }
 597         /* Flush the ldisc buffering */
 598         tty_ldisc_flush(tty);
 599
 600         /* Report to caller this is the last port reference */
 601         return 1;
 602 }
 603 EXPORT_SYMBOL(tty_port_close_start);
 604
 605 /* Caller holds tty lock */
 606 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 607 {
 608         unsigned long flags;
 609
 610         tty_ldisc_flush(tty);
 611         tty->closing = 0;
 612
 613         spin_lock_irqsave(&port->lock, flags);
 614
 615         if (port->blocked_open) {
 616                 spin_unlock_irqrestore(&port->lock, flags);
 617                 if (port->close_delay)
 618                         msleep_interruptible(jiffies_to_msecs(port->close_delay));
 619                 spin_lock_irqsave(&port->lock, flags);
 620                 wake_up_interruptible(&port->open_wait);
 621         }
 622         spin_unlock_irqrestore(&port->lock, flags);
 623         tty_port_set_active(port, 0);
 624 }
 625 EXPORT_SYMBOL(tty_port_close_end);
 626
 627 /*
 628  * tty_port_close
 629  *
 630  * Caller holds tty lock
 631  */
 632 void tty_port_close(struct tty_port *port, struct tty_struct *tty,
 633                                                         struct file *filp)
 634 {
 635         if (tty_port_close_start(port, tty, filp) == 0)
 636                 return;
 637         tty_port_shutdown(port, tty);
 638         if (!port->console)
 639                 set_bit(TTY_IO_ERROR, &tty->flags);
 640         tty_port_close_end(port, tty);
 641         tty_port_tty_set(port, NULL);
 642 }
 643 EXPORT_SYMBOL(tty_port_close);
 644
 645 /**
 646  * tty_port_install - generic tty->ops->install handler
 647  * @port: tty_port of the device
 648  * @driver: tty_driver for this device
 649  * @tty: tty to be installed
 650  *
 651  * It is the same as tty_standard_install except the provided @port is linked
 652  * to a concrete tty specified by @tty. Use this or tty_port_register_device
 653  * (or both). Call tty_port_link_device as a last resort.
 654  */
 655 int tty_port_install(struct tty_port *port, struct tty_driver *driver,
 656                 struct tty_struct *tty)
 657 {
 658         tty->port = port;
 659         return tty_standard_install(driver, tty);
 660 }
 661 EXPORT_SYMBOL_GPL(tty_port_install);
 662
 663 /*
 664  * tty_port_open
 665  *
 666  * Caller holds tty lock.
 667  *
 668  * NB: may drop and reacquire tty lock (in tty_port_block_til_ready()) so
 669  * tty and tty_port may have changed state (eg., may be hung up now)
 670  */
 671 int tty_port_open(struct tty_port *port, struct tty_struct *tty,
 672                                                         struct file *filp)
 673 {
 674         spin_lock_irq(&port->lock);
 675         ++port->count;
 676         spin_unlock_irq(&port->lock);
 677         tty_port_tty_set(port, tty);
 678
 679         /*
 680          * Do the device-specific open only if the hardware isn't
 681          * already initialized. Serialize open and shutdown using the
 682          * port mutex.
 683          */
 684
 685         mutex_lock(&port->mutex);
 686
 687         if (!tty_port_initialized(port)) {
 688                 clear_bit(TTY_IO_ERROR, &tty->flags);
 689                 if (port->ops->activate) {
 690                         int retval = port->ops->activate(port, tty);
 691                         if (retval) {
 692                                 mutex_unlock(&port->mutex);
 693                                 return retval;
 694                         }
 695                 }
 696                 tty_port_set_initialized(port, 1);
 697         }
 698         mutex_unlock(&port->mutex);
 699         return tty_port_block_til_ready(port, tty, filp);
 700 }
 701
 702 EXPORT_SYMBOL(tty_port_open);