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