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