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