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 232 void tty_port_hangup(struct tty_port *port) 233 { 234 struct tty_struct *tty; 235 unsigned long flags; 236 237 spin_lock_irqsave(&port->lock, flags); 238 port->count = 0; 239 port->flags &= ~ASYNC_NORMAL_ACTIVE; 240 tty = port->tty; 241 if (tty) 242 set_bit(TTY_IO_ERROR, &tty->flags); 243 port->tty = NULL; 244 spin_unlock_irqrestore(&port->lock, flags); 245 tty_port_shutdown(port, tty); 246 tty_kref_put(tty); 247 wake_up_interruptible(&port->open_wait); 248 wake_up_interruptible(&port->delta_msr_wait); 249 } 250 EXPORT_SYMBOL(tty_port_hangup); 251 252 /** 253 * tty_port_tty_hangup - helper to hang up a tty 254 * 255 * @port: tty port 256 * @check_clocal: hang only ttys with CLOCAL unset? 257 */ 258 void tty_port_tty_hangup(struct tty_port *port, bool check_clocal) 259 { 260 struct tty_struct *tty = tty_port_tty_get(port); 261 262 if (tty && (!check_clocal || !C_CLOCAL(tty))) 263 tty_hangup(tty); 264 tty_kref_put(tty); 265 } 266 EXPORT_SYMBOL_GPL(tty_port_tty_hangup); 267 268 /** 269 * tty_port_tty_wakeup - helper to wake up a tty 270 * 271 * @port: tty port 272 */ 273 void tty_port_tty_wakeup(struct tty_port *port) 274 { 275 struct tty_struct *tty = tty_port_tty_get(port); 276 277 if (tty) { 278 tty_wakeup(tty); 279 tty_kref_put(tty); 280 } 281 } 282 EXPORT_SYMBOL_GPL(tty_port_tty_wakeup); 283 284 /** 285 * tty_port_carrier_raised - carrier raised check 286 * @port: tty port 287 * 288 * Wrapper for the carrier detect logic. For the moment this is used 289 * to hide some internal details. This will eventually become entirely 290 * internal to the tty port. 291 */ 292 293 int tty_port_carrier_raised(struct tty_port *port) 294 { 295 if (port->ops->carrier_raised == NULL) 296 return 1; 297 return port->ops->carrier_raised(port); 298 } 299 EXPORT_SYMBOL(tty_port_carrier_raised); 300 301 /** 302 * tty_port_raise_dtr_rts - Raise DTR/RTS 303 * @port: tty port 304 * 305 * Wrapper for the DTR/RTS raise logic. For the moment this is used 306 * to hide some internal details. This will eventually become entirely 307 * internal to the tty port. 308 */ 309 310 void tty_port_raise_dtr_rts(struct tty_port *port) 311 { 312 if (port->ops->dtr_rts) 313 port->ops->dtr_rts(port, 1); 314 } 315 EXPORT_SYMBOL(tty_port_raise_dtr_rts); 316 317 /** 318 * tty_port_lower_dtr_rts - Lower DTR/RTS 319 * @port: tty port 320 * 321 * Wrapper for the DTR/RTS raise logic. For the moment this is used 322 * to hide some internal details. This will eventually become entirely 323 * internal to the tty port. 324 */ 325 326 void tty_port_lower_dtr_rts(struct tty_port *port) 327 { 328 if (port->ops->dtr_rts) 329 port->ops->dtr_rts(port, 0); 330 } 331 EXPORT_SYMBOL(tty_port_lower_dtr_rts); 332 333 /** 334 * tty_port_block_til_ready - Waiting logic for tty open 335 * @port: the tty port being opened 336 * @tty: the tty device being bound 337 * @filp: the file pointer of the opener 338 * 339 * Implement the core POSIX/SuS tty behaviour when opening a tty device. 340 * Handles: 341 * - hangup (both before and during) 342 * - non blocking open 343 * - rts/dtr/dcd 344 * - signals 345 * - port flags and counts 346 * 347 * The passed tty_port must implement the carrier_raised method if it can 348 * do carrier detect and the dtr_rts method if it supports software 349 * management of these lines. Note that the dtr/rts raise is done each 350 * iteration as a hangup may have previously dropped them while we wait. 351 */ 352 353 int tty_port_block_til_ready(struct tty_port *port, 354 struct tty_struct *tty, struct file *filp) 355 { 356 int do_clocal = 0, retval; 357 unsigned long flags; 358 DEFINE_WAIT(wait); 359 360 /* block if port is in the process of being closed */ 361 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) { 362 wait_event_interruptible_tty(tty, port->close_wait, 363 !(port->flags & ASYNC_CLOSING)); 364 if (port->flags & ASYNC_HUP_NOTIFY) 365 return -EAGAIN; 366 else 367 return -ERESTARTSYS; 368 } 369 370 /* if non-blocking mode is set we can pass directly to open unless 371 the port has just hung up or is in another error state */ 372 if (tty->flags & (1 << TTY_IO_ERROR)) { 373 port->flags |= ASYNC_NORMAL_ACTIVE; 374 return 0; 375 } 376 if (filp->f_flags & O_NONBLOCK) { 377 /* Indicate we are open */ 378 if (tty->termios.c_cflag & CBAUD) 379 tty_port_raise_dtr_rts(port); 380 port->flags |= ASYNC_NORMAL_ACTIVE; 381 return 0; 382 } 383 384 if (C_CLOCAL(tty)) 385 do_clocal = 1; 386 387 /* Block waiting until we can proceed. We may need to wait for the 388 carrier, but we must also wait for any close that is in progress 389 before the next open may complete */ 390 391 retval = 0; 392 393 /* The port lock protects the port counts */ 394 spin_lock_irqsave(&port->lock, flags); 395 if (!tty_hung_up_p(filp)) 396 port->count--; 397 port->blocked_open++; 398 spin_unlock_irqrestore(&port->lock, flags); 399 400 while (1) { 401 /* Indicate we are open */ 402 if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags)) 403 tty_port_raise_dtr_rts(port); 404 405 prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE); 406 /* Check for a hangup or uninitialised port. 407 Return accordingly */ 408 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) { 409 if (port->flags & ASYNC_HUP_NOTIFY) 410 retval = -EAGAIN; 411 else 412 retval = -ERESTARTSYS; 413 break; 414 } 415 /* 416 * Probe the carrier. For devices with no carrier detect 417 * tty_port_carrier_raised will always return true. 418 * Never ask drivers if CLOCAL is set, this causes troubles 419 * on some hardware. 420 */ 421 if (!(port->flags & ASYNC_CLOSING) && 422 (do_clocal || tty_port_carrier_raised(port))) 423 break; 424 if (signal_pending(current)) { 425 retval = -ERESTARTSYS; 426 break; 427 } 428 tty_unlock(tty); 429 schedule(); 430 tty_lock(tty); 431 } 432 finish_wait(&port->open_wait, &wait); 433 434 /* Update counts. A parallel hangup will have set count to zero and 435 we must not mess that up further */ 436 spin_lock_irqsave(&port->lock, flags); 437 if (!tty_hung_up_p(filp)) 438 port->count++; 439 port->blocked_open--; 440 if (retval == 0) 441 port->flags |= ASYNC_NORMAL_ACTIVE; 442 spin_unlock_irqrestore(&port->lock, flags); 443 return retval; 444 } 445 EXPORT_SYMBOL(tty_port_block_til_ready); 446 447 static void tty_port_drain_delay(struct tty_port *port, struct tty_struct *tty) 448 { 449 unsigned int bps = tty_get_baud_rate(tty); 450 long timeout; 451 452 if (bps > 1200) { 453 timeout = (HZ * 10 * port->drain_delay) / bps; 454 timeout = max_t(long, timeout, HZ / 10); 455 } else { 456 timeout = 2 * HZ; 457 } 458 schedule_timeout_interruptible(timeout); 459 } 460 461 int tty_port_close_start(struct tty_port *port, 462 struct tty_struct *tty, struct file *filp) 463 { 464 unsigned long flags; 465 466 spin_lock_irqsave(&port->lock, flags); 467 if (tty_hung_up_p(filp)) { 468 spin_unlock_irqrestore(&port->lock, flags); 469 return 0; 470 } 471 472 if (tty->count == 1 && port->count != 1) { 473 printk(KERN_WARNING 474 "tty_port_close_start: tty->count = 1 port count = %d.\n", 475 port->count); 476 port->count = 1; 477 } 478 if (--port->count < 0) { 479 printk(KERN_WARNING "tty_port_close_start: count = %d\n", 480 port->count); 481 port->count = 0; 482 } 483 484 if (port->count) { 485 spin_unlock_irqrestore(&port->lock, flags); 486 return 0; 487 } 488 set_bit(ASYNCB_CLOSING, &port->flags); 489 tty->closing = 1; 490 spin_unlock_irqrestore(&port->lock, flags); 491 492 if (test_bit(ASYNCB_INITIALIZED, &port->flags)) { 493 /* Don't block on a stalled port, just pull the chain */ 494 if (tty->flow_stopped) 495 tty_driver_flush_buffer(tty); 496 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE) 497 tty_wait_until_sent_from_close(tty, port->closing_wait); 498 if (port->drain_delay) 499 tty_port_drain_delay(port, tty); 500 } 501 /* Flush the ldisc buffering */ 502 tty_ldisc_flush(tty); 503 504 /* Report to caller this is the last port reference */ 505 return 1; 506 } 507 EXPORT_SYMBOL(tty_port_close_start); 508 509 void tty_port_close_end(struct tty_port *port, struct tty_struct *tty) 510 { 511 unsigned long flags; 512 513 spin_lock_irqsave(&port->lock, flags); 514 tty->closing = 0; 515 516 if (port->blocked_open) { 517 spin_unlock_irqrestore(&port->lock, flags); 518 if (port->close_delay) { 519 msleep_interruptible( 520 jiffies_to_msecs(port->close_delay)); 521 } 522 spin_lock_irqsave(&port->lock, flags); 523 wake_up_interruptible(&port->open_wait); 524 } 525 port->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING); 526 wake_up_interruptible(&port->close_wait); 527 spin_unlock_irqrestore(&port->lock, flags); 528 } 529 EXPORT_SYMBOL(tty_port_close_end); 530 531 void tty_port_close(struct tty_port *port, struct tty_struct *tty, 532 struct file *filp) 533 { 534 if (tty_port_close_start(port, tty, filp) == 0) 535 return; 536 tty_port_shutdown(port, tty); 537 set_bit(TTY_IO_ERROR, &tty->flags); 538 tty_port_close_end(port, tty); 539 tty_port_tty_set(port, NULL); 540 } 541 EXPORT_SYMBOL(tty_port_close); 542 543 /** 544 * tty_port_install - generic tty->ops->install handler 545 * @port: tty_port of the device 546 * @driver: tty_driver for this device 547 * @tty: tty to be installed 548 * 549 * It is the same as tty_standard_install except the provided @port is linked 550 * to a concrete tty specified by @tty. Use this or tty_port_register_device 551 * (or both). Call tty_port_link_device as a last resort. 552 */ 553 int tty_port_install(struct tty_port *port, struct tty_driver *driver, 554 struct tty_struct *tty) 555 { 556 tty->port = port; 557 return tty_standard_install(driver, tty); 558 } 559 EXPORT_SYMBOL_GPL(tty_port_install); 560 561 int tty_port_open(struct tty_port *port, struct tty_struct *tty, 562 struct file *filp) 563 { 564 spin_lock_irq(&port->lock); 565 if (!tty_hung_up_p(filp)) 566 ++port->count; 567 spin_unlock_irq(&port->lock); 568 tty_port_tty_set(port, tty); 569 570 /* 571 * Do the device-specific open only if the hardware isn't 572 * already initialized. Serialize open and shutdown using the 573 * port mutex. 574 */ 575 576 mutex_lock(&port->mutex); 577 578 if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) { 579 clear_bit(TTY_IO_ERROR, &tty->flags); 580 if (port->ops->activate) { 581 int retval = port->ops->activate(port, tty); 582 if (retval) { 583 mutex_unlock(&port->mutex); 584 return retval; 585 } 586 } 587 set_bit(ASYNCB_INITIALIZED, &port->flags); 588 } 589 mutex_unlock(&port->mutex); 590 return tty_port_block_til_ready(port, tty, filp); 591 } 592 593 EXPORT_SYMBOL(tty_port_open); 594