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