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