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