drivers/tty/tty_port.c

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