1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver core for serial ports 4 * 5 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o. 6 * 7 * Copyright 1999 ARM Limited 8 * Copyright (C) 2000-2001 Deep Blue Solutions Ltd. 9 */ 10 #include <linux/module.h> 11 #include <linux/tty.h> 12 #include <linux/tty_flip.h> 13 #include <linux/slab.h> 14 #include <linux/sched/signal.h> 15 #include <linux/init.h> 16 #include <linux/console.h> 17 #include <linux/of.h> 18 #include <linux/proc_fs.h> 19 #include <linux/seq_file.h> 20 #include <linux/device.h> 21 #include <linux/serial.h> /* for serial_state and serial_icounter_struct */ 22 #include <linux/serial_core.h> 23 #include <linux/delay.h> 24 #include <linux/mutex.h> 25 #include <linux/security.h> 26 27 #include <linux/irq.h> 28 #include <linux/uaccess.h> 29 30 /* 31 * This is used to lock changes in serial line configuration. 32 */ 33 static DEFINE_MUTEX(port_mutex); 34 35 /* 36 * lockdep: port->lock is initialized in two places, but we 37 * want only one lock-class: 38 */ 39 static struct lock_class_key port_lock_key; 40 41 #define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8) 42 43 static void uart_change_speed(struct tty_struct *tty, struct uart_state *state, 44 struct ktermios *old_termios); 45 static void uart_wait_until_sent(struct tty_struct *tty, int timeout); 46 static void uart_change_pm(struct uart_state *state, 47 enum uart_pm_state pm_state); 48 49 static void uart_port_shutdown(struct tty_port *port); 50 51 static int uart_dcd_enabled(struct uart_port *uport) 52 { 53 return !!(uport->status & UPSTAT_DCD_ENABLE); 54 } 55 56 static inline struct uart_port *uart_port_ref(struct uart_state *state) 57 { 58 if (atomic_add_unless(&state->refcount, 1, 0)) 59 return state->uart_port; 60 return NULL; 61 } 62 63 static inline void uart_port_deref(struct uart_port *uport) 64 { 65 if (atomic_dec_and_test(&uport->state->refcount)) 66 wake_up(&uport->state->remove_wait); 67 } 68 69 #define uart_port_lock(state, flags) \ 70 ({ \ 71 struct uart_port *__uport = uart_port_ref(state); \ 72 if (__uport) \ 73 spin_lock_irqsave(&__uport->lock, flags); \ 74 __uport; \ 75 }) 76 77 #define uart_port_unlock(uport, flags) \ 78 ({ \ 79 struct uart_port *__uport = uport; \ 80 if (__uport) { \ 81 spin_unlock_irqrestore(&__uport->lock, flags); \ 82 uart_port_deref(__uport); \ 83 } \ 84 }) 85 86 static inline struct uart_port *uart_port_check(struct uart_state *state) 87 { 88 lockdep_assert_held(&state->port.mutex); 89 return state->uart_port; 90 } 91 92 /* 93 * This routine is used by the interrupt handler to schedule processing in 94 * the software interrupt portion of the driver. 95 */ 96 void uart_write_wakeup(struct uart_port *port) 97 { 98 struct uart_state *state = port->state; 99 /* 100 * This means you called this function _after_ the port was 101 * closed. No cookie for you. 102 */ 103 BUG_ON(!state); 104 tty_port_tty_wakeup(&state->port); 105 } 106 107 static void uart_stop(struct tty_struct *tty) 108 { 109 struct uart_state *state = tty->driver_data; 110 struct uart_port *port; 111 unsigned long flags; 112 113 port = uart_port_lock(state, flags); 114 if (port) 115 port->ops->stop_tx(port); 116 uart_port_unlock(port, flags); 117 } 118 119 static void __uart_start(struct tty_struct *tty) 120 { 121 struct uart_state *state = tty->driver_data; 122 struct uart_port *port = state->uart_port; 123 124 if (port && !uart_tx_stopped(port)) 125 port->ops->start_tx(port); 126 } 127 128 static void uart_start(struct tty_struct *tty) 129 { 130 struct uart_state *state = tty->driver_data; 131 struct uart_port *port; 132 unsigned long flags; 133 134 port = uart_port_lock(state, flags); 135 __uart_start(tty); 136 uart_port_unlock(port, flags); 137 } 138 139 static void 140 uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear) 141 { 142 unsigned long flags; 143 unsigned int old; 144 145 spin_lock_irqsave(&port->lock, flags); 146 old = port->mctrl; 147 port->mctrl = (old & ~clear) | set; 148 if (old != port->mctrl) 149 port->ops->set_mctrl(port, port->mctrl); 150 spin_unlock_irqrestore(&port->lock, flags); 151 } 152 153 #define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0) 154 #define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear) 155 156 static void uart_port_dtr_rts(struct uart_port *uport, int raise) 157 { 158 int rs485_on = uport->rs485_config && 159 (uport->rs485.flags & SER_RS485_ENABLED); 160 int RTS_after_send = !!(uport->rs485.flags & SER_RS485_RTS_AFTER_SEND); 161 162 if (raise) { 163 if (rs485_on && !RTS_after_send) { 164 uart_set_mctrl(uport, TIOCM_DTR); 165 uart_clear_mctrl(uport, TIOCM_RTS); 166 } else { 167 uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS); 168 } 169 } else { 170 unsigned int clear = TIOCM_DTR; 171 172 clear |= (!rs485_on || !RTS_after_send) ? TIOCM_RTS : 0; 173 uart_clear_mctrl(uport, clear); 174 } 175 } 176 177 /* 178 * Startup the port. This will be called once per open. All calls 179 * will be serialised by the per-port mutex. 180 */ 181 static int uart_port_startup(struct tty_struct *tty, struct uart_state *state, 182 int init_hw) 183 { 184 struct uart_port *uport = uart_port_check(state); 185 unsigned long page; 186 unsigned long flags = 0; 187 int retval = 0; 188 189 if (uport->type == PORT_UNKNOWN) 190 return 1; 191 192 /* 193 * Make sure the device is in D0 state. 194 */ 195 uart_change_pm(state, UART_PM_STATE_ON); 196 197 /* 198 * Initialise and allocate the transmit and temporary 199 * buffer. 200 */ 201 page = get_zeroed_page(GFP_KERNEL); 202 if (!page) 203 return -ENOMEM; 204 205 uart_port_lock(state, flags); 206 if (!state->xmit.buf) { 207 state->xmit.buf = (unsigned char *) page; 208 uart_circ_clear(&state->xmit); 209 uart_port_unlock(uport, flags); 210 } else { 211 uart_port_unlock(uport, flags); 212 /* 213 * Do not free() the page under the port lock, see 214 * uart_shutdown(). 215 */ 216 free_page(page); 217 } 218 219 retval = uport->ops->startup(uport); 220 if (retval == 0) { 221 if (uart_console(uport) && uport->cons->cflag) { 222 tty->termios.c_cflag = uport->cons->cflag; 223 uport->cons->cflag = 0; 224 } 225 /* 226 * Initialise the hardware port settings. 227 */ 228 uart_change_speed(tty, state, NULL); 229 230 /* 231 * Setup the RTS and DTR signals once the 232 * port is open and ready to respond. 233 */ 234 if (init_hw && C_BAUD(tty)) 235 uart_port_dtr_rts(uport, 1); 236 } 237 238 /* 239 * This is to allow setserial on this port. People may want to set 240 * port/irq/type and then reconfigure the port properly if it failed 241 * now. 242 */ 243 if (retval && capable(CAP_SYS_ADMIN)) 244 return 1; 245 246 return retval; 247 } 248 249 static int uart_startup(struct tty_struct *tty, struct uart_state *state, 250 int init_hw) 251 { 252 struct tty_port *port = &state->port; 253 int retval; 254 255 if (tty_port_initialized(port)) 256 return 0; 257 258 retval = uart_port_startup(tty, state, init_hw); 259 if (retval) 260 set_bit(TTY_IO_ERROR, &tty->flags); 261 262 return retval; 263 } 264 265 /* 266 * This routine will shutdown a serial port; interrupts are disabled, and 267 * DTR is dropped if the hangup on close termio flag is on. Calls to 268 * uart_shutdown are serialised by the per-port semaphore. 269 * 270 * uport == NULL if uart_port has already been removed 271 */ 272 static void uart_shutdown(struct tty_struct *tty, struct uart_state *state) 273 { 274 struct uart_port *uport = uart_port_check(state); 275 struct tty_port *port = &state->port; 276 unsigned long flags = 0; 277 char *xmit_buf = NULL; 278 279 /* 280 * Set the TTY IO error marker 281 */ 282 if (tty) 283 set_bit(TTY_IO_ERROR, &tty->flags); 284 285 if (tty_port_initialized(port)) { 286 tty_port_set_initialized(port, 0); 287 288 /* 289 * Turn off DTR and RTS early. 290 */ 291 if (uport && uart_console(uport) && tty) 292 uport->cons->cflag = tty->termios.c_cflag; 293 294 if (!tty || C_HUPCL(tty)) 295 uart_port_dtr_rts(uport, 0); 296 297 uart_port_shutdown(port); 298 } 299 300 /* 301 * It's possible for shutdown to be called after suspend if we get 302 * a DCD drop (hangup) at just the right time. Clear suspended bit so 303 * we don't try to resume a port that has been shutdown. 304 */ 305 tty_port_set_suspended(port, 0); 306 307 /* 308 * Do not free() the transmit buffer page under the port lock since 309 * this can create various circular locking scenarios. For instance, 310 * console driver may need to allocate/free a debug object, which 311 * can endup in printk() recursion. 312 */ 313 uart_port_lock(state, flags); 314 xmit_buf = state->xmit.buf; 315 state->xmit.buf = NULL; 316 uart_port_unlock(uport, flags); 317 318 if (xmit_buf) 319 free_page((unsigned long)xmit_buf); 320 } 321 322 /** 323 * uart_update_timeout - update per-port FIFO timeout. 324 * @port: uart_port structure describing the port 325 * @cflag: termios cflag value 326 * @baud: speed of the port 327 * 328 * Set the port FIFO timeout value. The @cflag value should 329 * reflect the actual hardware settings. 330 */ 331 void 332 uart_update_timeout(struct uart_port *port, unsigned int cflag, 333 unsigned int baud) 334 { 335 unsigned int bits; 336 337 /* byte size and parity */ 338 switch (cflag & CSIZE) { 339 case CS5: 340 bits = 7; 341 break; 342 case CS6: 343 bits = 8; 344 break; 345 case CS7: 346 bits = 9; 347 break; 348 default: 349 bits = 10; 350 break; /* CS8 */ 351 } 352 353 if (cflag & CSTOPB) 354 bits++; 355 if (cflag & PARENB) 356 bits++; 357 358 /* 359 * The total number of bits to be transmitted in the fifo. 360 */ 361 bits = bits * port->fifosize; 362 363 /* 364 * Figure the timeout to send the above number of bits. 365 * Add .02 seconds of slop 366 */ 367 port->timeout = (HZ * bits) / baud + HZ/50; 368 } 369 370 EXPORT_SYMBOL(uart_update_timeout); 371 372 /** 373 * uart_get_baud_rate - return baud rate for a particular port 374 * @port: uart_port structure describing the port in question. 375 * @termios: desired termios settings. 376 * @old: old termios (or NULL) 377 * @min: minimum acceptable baud rate 378 * @max: maximum acceptable baud rate 379 * 380 * Decode the termios structure into a numeric baud rate, 381 * taking account of the magic 38400 baud rate (with spd_* 382 * flags), and mapping the %B0 rate to 9600 baud. 383 * 384 * If the new baud rate is invalid, try the old termios setting. 385 * If it's still invalid, we try 9600 baud. 386 * 387 * Update the @termios structure to reflect the baud rate 388 * we're actually going to be using. Don't do this for the case 389 * where B0 is requested ("hang up"). 390 */ 391 unsigned int 392 uart_get_baud_rate(struct uart_port *port, struct ktermios *termios, 393 struct ktermios *old, unsigned int min, unsigned int max) 394 { 395 unsigned int try; 396 unsigned int baud; 397 unsigned int altbaud; 398 int hung_up = 0; 399 upf_t flags = port->flags & UPF_SPD_MASK; 400 401 switch (flags) { 402 case UPF_SPD_HI: 403 altbaud = 57600; 404 break; 405 case UPF_SPD_VHI: 406 altbaud = 115200; 407 break; 408 case UPF_SPD_SHI: 409 altbaud = 230400; 410 break; 411 case UPF_SPD_WARP: 412 altbaud = 460800; 413 break; 414 default: 415 altbaud = 38400; 416 break; 417 } 418 419 for (try = 0; try < 2; try++) { 420 baud = tty_termios_baud_rate(termios); 421 422 /* 423 * The spd_hi, spd_vhi, spd_shi, spd_warp kludge... 424 * Die! Die! Die! 425 */ 426 if (try == 0 && baud == 38400) 427 baud = altbaud; 428 429 /* 430 * Special case: B0 rate. 431 */ 432 if (baud == 0) { 433 hung_up = 1; 434 baud = 9600; 435 } 436 437 if (baud >= min && baud <= max) 438 return baud; 439 440 /* 441 * Oops, the quotient was zero. Try again with 442 * the old baud rate if possible. 443 */ 444 termios->c_cflag &= ~CBAUD; 445 if (old) { 446 baud = tty_termios_baud_rate(old); 447 if (!hung_up) 448 tty_termios_encode_baud_rate(termios, 449 baud, baud); 450 old = NULL; 451 continue; 452 } 453 454 /* 455 * As a last resort, if the range cannot be met then clip to 456 * the nearest chip supported rate. 457 */ 458 if (!hung_up) { 459 if (baud <= min) 460 tty_termios_encode_baud_rate(termios, 461 min + 1, min + 1); 462 else 463 tty_termios_encode_baud_rate(termios, 464 max - 1, max - 1); 465 } 466 } 467 /* Should never happen */ 468 WARN_ON(1); 469 return 0; 470 } 471 472 EXPORT_SYMBOL(uart_get_baud_rate); 473 474 /** 475 * uart_get_divisor - return uart clock divisor 476 * @port: uart_port structure describing the port. 477 * @baud: desired baud rate 478 * 479 * Calculate the uart clock divisor for the port. 480 */ 481 unsigned int 482 uart_get_divisor(struct uart_port *port, unsigned int baud) 483 { 484 unsigned int quot; 485 486 /* 487 * Old custom speed handling. 488 */ 489 if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST) 490 quot = port->custom_divisor; 491 else 492 quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud); 493 494 return quot; 495 } 496 497 EXPORT_SYMBOL(uart_get_divisor); 498 499 /* Caller holds port mutex */ 500 static void uart_change_speed(struct tty_struct *tty, struct uart_state *state, 501 struct ktermios *old_termios) 502 { 503 struct uart_port *uport = uart_port_check(state); 504 struct ktermios *termios; 505 int hw_stopped; 506 507 /* 508 * If we have no tty, termios, or the port does not exist, 509 * then we can't set the parameters for this port. 510 */ 511 if (!tty || uport->type == PORT_UNKNOWN) 512 return; 513 514 termios = &tty->termios; 515 uport->ops->set_termios(uport, termios, old_termios); 516 517 /* 518 * Set modem status enables based on termios cflag 519 */ 520 spin_lock_irq(&uport->lock); 521 if (termios->c_cflag & CRTSCTS) 522 uport->status |= UPSTAT_CTS_ENABLE; 523 else 524 uport->status &= ~UPSTAT_CTS_ENABLE; 525 526 if (termios->c_cflag & CLOCAL) 527 uport->status &= ~UPSTAT_DCD_ENABLE; 528 else 529 uport->status |= UPSTAT_DCD_ENABLE; 530 531 /* reset sw-assisted CTS flow control based on (possibly) new mode */ 532 hw_stopped = uport->hw_stopped; 533 uport->hw_stopped = uart_softcts_mode(uport) && 534 !(uport->ops->get_mctrl(uport) & TIOCM_CTS); 535 if (uport->hw_stopped) { 536 if (!hw_stopped) 537 uport->ops->stop_tx(uport); 538 } else { 539 if (hw_stopped) 540 __uart_start(tty); 541 } 542 spin_unlock_irq(&uport->lock); 543 } 544 545 static int uart_put_char(struct tty_struct *tty, unsigned char c) 546 { 547 struct uart_state *state = tty->driver_data; 548 struct uart_port *port; 549 struct circ_buf *circ; 550 unsigned long flags; 551 int ret = 0; 552 553 circ = &state->xmit; 554 port = uart_port_lock(state, flags); 555 if (!circ->buf) { 556 uart_port_unlock(port, flags); 557 return 0; 558 } 559 560 if (port && uart_circ_chars_free(circ) != 0) { 561 circ->buf[circ->head] = c; 562 circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1); 563 ret = 1; 564 } 565 uart_port_unlock(port, flags); 566 return ret; 567 } 568 569 static void uart_flush_chars(struct tty_struct *tty) 570 { 571 uart_start(tty); 572 } 573 574 static int uart_write(struct tty_struct *tty, 575 const unsigned char *buf, int count) 576 { 577 struct uart_state *state = tty->driver_data; 578 struct uart_port *port; 579 struct circ_buf *circ; 580 unsigned long flags; 581 int c, ret = 0; 582 583 /* 584 * This means you called this function _after_ the port was 585 * closed. No cookie for you. 586 */ 587 if (!state) { 588 WARN_ON(1); 589 return -EL3HLT; 590 } 591 592 port = uart_port_lock(state, flags); 593 circ = &state->xmit; 594 if (!circ->buf) { 595 uart_port_unlock(port, flags); 596 return 0; 597 } 598 599 while (port) { 600 c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE); 601 if (count < c) 602 c = count; 603 if (c <= 0) 604 break; 605 memcpy(circ->buf + circ->head, buf, c); 606 circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1); 607 buf += c; 608 count -= c; 609 ret += c; 610 } 611 612 __uart_start(tty); 613 uart_port_unlock(port, flags); 614 return ret; 615 } 616 617 static int uart_write_room(struct tty_struct *tty) 618 { 619 struct uart_state *state = tty->driver_data; 620 struct uart_port *port; 621 unsigned long flags; 622 int ret; 623 624 port = uart_port_lock(state, flags); 625 ret = uart_circ_chars_free(&state->xmit); 626 uart_port_unlock(port, flags); 627 return ret; 628 } 629 630 static int uart_chars_in_buffer(struct tty_struct *tty) 631 { 632 struct uart_state *state = tty->driver_data; 633 struct uart_port *port; 634 unsigned long flags; 635 int ret; 636 637 port = uart_port_lock(state, flags); 638 ret = uart_circ_chars_pending(&state->xmit); 639 uart_port_unlock(port, flags); 640 return ret; 641 } 642 643 static void uart_flush_buffer(struct tty_struct *tty) 644 { 645 struct uart_state *state = tty->driver_data; 646 struct uart_port *port; 647 unsigned long flags; 648 649 /* 650 * This means you called this function _after_ the port was 651 * closed. No cookie for you. 652 */ 653 if (!state) { 654 WARN_ON(1); 655 return; 656 } 657 658 pr_debug("uart_flush_buffer(%d) called\n", tty->index); 659 660 port = uart_port_lock(state, flags); 661 if (!port) 662 return; 663 uart_circ_clear(&state->xmit); 664 if (port->ops->flush_buffer) 665 port->ops->flush_buffer(port); 666 uart_port_unlock(port, flags); 667 tty_port_tty_wakeup(&state->port); 668 } 669 670 /* 671 * This function is used to send a high-priority XON/XOFF character to 672 * the device 673 */ 674 static void uart_send_xchar(struct tty_struct *tty, char ch) 675 { 676 struct uart_state *state = tty->driver_data; 677 struct uart_port *port; 678 unsigned long flags; 679 680 port = uart_port_ref(state); 681 if (!port) 682 return; 683 684 if (port->ops->send_xchar) 685 port->ops->send_xchar(port, ch); 686 else { 687 spin_lock_irqsave(&port->lock, flags); 688 port->x_char = ch; 689 if (ch) 690 port->ops->start_tx(port); 691 spin_unlock_irqrestore(&port->lock, flags); 692 } 693 uart_port_deref(port); 694 } 695 696 static void uart_throttle(struct tty_struct *tty) 697 { 698 struct uart_state *state = tty->driver_data; 699 upstat_t mask = UPSTAT_SYNC_FIFO; 700 struct uart_port *port; 701 702 port = uart_port_ref(state); 703 if (!port) 704 return; 705 706 if (I_IXOFF(tty)) 707 mask |= UPSTAT_AUTOXOFF; 708 if (C_CRTSCTS(tty)) 709 mask |= UPSTAT_AUTORTS; 710 711 if (port->status & mask) { 712 port->ops->throttle(port); 713 mask &= ~port->status; 714 } 715 716 if (mask & UPSTAT_AUTORTS) 717 uart_clear_mctrl(port, TIOCM_RTS); 718 719 if (mask & UPSTAT_AUTOXOFF) 720 uart_send_xchar(tty, STOP_CHAR(tty)); 721 722 uart_port_deref(port); 723 } 724 725 static void uart_unthrottle(struct tty_struct *tty) 726 { 727 struct uart_state *state = tty->driver_data; 728 upstat_t mask = UPSTAT_SYNC_FIFO; 729 struct uart_port *port; 730 731 port = uart_port_ref(state); 732 if (!port) 733 return; 734 735 if (I_IXOFF(tty)) 736 mask |= UPSTAT_AUTOXOFF; 737 if (C_CRTSCTS(tty)) 738 mask |= UPSTAT_AUTORTS; 739 740 if (port->status & mask) { 741 port->ops->unthrottle(port); 742 mask &= ~port->status; 743 } 744 745 if (mask & UPSTAT_AUTORTS) 746 uart_set_mctrl(port, TIOCM_RTS); 747 748 if (mask & UPSTAT_AUTOXOFF) 749 uart_send_xchar(tty, START_CHAR(tty)); 750 751 uart_port_deref(port); 752 } 753 754 static int uart_get_info(struct tty_port *port, struct serial_struct *retinfo) 755 { 756 struct uart_state *state = container_of(port, struct uart_state, port); 757 struct uart_port *uport; 758 int ret = -ENODEV; 759 760 memset(retinfo, 0, sizeof(*retinfo)); 761 762 /* 763 * Ensure the state we copy is consistent and no hardware changes 764 * occur as we go 765 */ 766 mutex_lock(&port->mutex); 767 uport = uart_port_check(state); 768 if (!uport) 769 goto out; 770 771 retinfo->type = uport->type; 772 retinfo->line = uport->line; 773 retinfo->port = uport->iobase; 774 if (HIGH_BITS_OFFSET) 775 retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET; 776 retinfo->irq = uport->irq; 777 retinfo->flags = (__force int)uport->flags; 778 retinfo->xmit_fifo_size = uport->fifosize; 779 retinfo->baud_base = uport->uartclk / 16; 780 retinfo->close_delay = jiffies_to_msecs(port->close_delay) / 10; 781 retinfo->closing_wait = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ? 782 ASYNC_CLOSING_WAIT_NONE : 783 jiffies_to_msecs(port->closing_wait) / 10; 784 retinfo->custom_divisor = uport->custom_divisor; 785 retinfo->hub6 = uport->hub6; 786 retinfo->io_type = uport->iotype; 787 retinfo->iomem_reg_shift = uport->regshift; 788 retinfo->iomem_base = (void *)(unsigned long)uport->mapbase; 789 790 ret = 0; 791 out: 792 mutex_unlock(&port->mutex); 793 return ret; 794 } 795 796 static int uart_get_info_user(struct tty_struct *tty, 797 struct serial_struct *ss) 798 { 799 struct uart_state *state = tty->driver_data; 800 struct tty_port *port = &state->port; 801 802 return uart_get_info(port, ss) < 0 ? -EIO : 0; 803 } 804 805 static int uart_set_info(struct tty_struct *tty, struct tty_port *port, 806 struct uart_state *state, 807 struct serial_struct *new_info) 808 { 809 struct uart_port *uport = uart_port_check(state); 810 unsigned long new_port; 811 unsigned int change_irq, change_port, closing_wait; 812 unsigned int old_custom_divisor, close_delay; 813 upf_t old_flags, new_flags; 814 int retval = 0; 815 816 if (!uport) 817 return -EIO; 818 819 new_port = new_info->port; 820 if (HIGH_BITS_OFFSET) 821 new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET; 822 823 new_info->irq = irq_canonicalize(new_info->irq); 824 close_delay = msecs_to_jiffies(new_info->close_delay * 10); 825 closing_wait = new_info->closing_wait == ASYNC_CLOSING_WAIT_NONE ? 826 ASYNC_CLOSING_WAIT_NONE : 827 msecs_to_jiffies(new_info->closing_wait * 10); 828 829 830 change_irq = !(uport->flags & UPF_FIXED_PORT) 831 && new_info->irq != uport->irq; 832 833 /* 834 * Since changing the 'type' of the port changes its resource 835 * allocations, we should treat type changes the same as 836 * IO port changes. 837 */ 838 change_port = !(uport->flags & UPF_FIXED_PORT) 839 && (new_port != uport->iobase || 840 (unsigned long)new_info->iomem_base != uport->mapbase || 841 new_info->hub6 != uport->hub6 || 842 new_info->io_type != uport->iotype || 843 new_info->iomem_reg_shift != uport->regshift || 844 new_info->type != uport->type); 845 846 old_flags = uport->flags; 847 new_flags = (__force upf_t)new_info->flags; 848 old_custom_divisor = uport->custom_divisor; 849 850 if (!capable(CAP_SYS_ADMIN)) { 851 retval = -EPERM; 852 if (change_irq || change_port || 853 (new_info->baud_base != uport->uartclk / 16) || 854 (close_delay != port->close_delay) || 855 (closing_wait != port->closing_wait) || 856 (new_info->xmit_fifo_size && 857 new_info->xmit_fifo_size != uport->fifosize) || 858 (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0)) 859 goto exit; 860 uport->flags = ((uport->flags & ~UPF_USR_MASK) | 861 (new_flags & UPF_USR_MASK)); 862 uport->custom_divisor = new_info->custom_divisor; 863 goto check_and_exit; 864 } 865 866 retval = security_locked_down(LOCKDOWN_TIOCSSERIAL); 867 if (retval && (change_irq || change_port)) 868 goto exit; 869 870 /* 871 * Ask the low level driver to verify the settings. 872 */ 873 if (uport->ops->verify_port) 874 retval = uport->ops->verify_port(uport, new_info); 875 876 if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) || 877 (new_info->baud_base < 9600)) 878 retval = -EINVAL; 879 880 if (retval) 881 goto exit; 882 883 if (change_port || change_irq) { 884 retval = -EBUSY; 885 886 /* 887 * Make sure that we are the sole user of this port. 888 */ 889 if (tty_port_users(port) > 1) 890 goto exit; 891 892 /* 893 * We need to shutdown the serial port at the old 894 * port/type/irq combination. 895 */ 896 uart_shutdown(tty, state); 897 } 898 899 if (change_port) { 900 unsigned long old_iobase, old_mapbase; 901 unsigned int old_type, old_iotype, old_hub6, old_shift; 902 903 old_iobase = uport->iobase; 904 old_mapbase = uport->mapbase; 905 old_type = uport->type; 906 old_hub6 = uport->hub6; 907 old_iotype = uport->iotype; 908 old_shift = uport->regshift; 909 910 /* 911 * Free and release old regions 912 */ 913 if (old_type != PORT_UNKNOWN && uport->ops->release_port) 914 uport->ops->release_port(uport); 915 916 uport->iobase = new_port; 917 uport->type = new_info->type; 918 uport->hub6 = new_info->hub6; 919 uport->iotype = new_info->io_type; 920 uport->regshift = new_info->iomem_reg_shift; 921 uport->mapbase = (unsigned long)new_info->iomem_base; 922 923 /* 924 * Claim and map the new regions 925 */ 926 if (uport->type != PORT_UNKNOWN && uport->ops->request_port) { 927 retval = uport->ops->request_port(uport); 928 } else { 929 /* Always success - Jean II */ 930 retval = 0; 931 } 932 933 /* 934 * If we fail to request resources for the 935 * new port, try to restore the old settings. 936 */ 937 if (retval) { 938 uport->iobase = old_iobase; 939 uport->type = old_type; 940 uport->hub6 = old_hub6; 941 uport->iotype = old_iotype; 942 uport->regshift = old_shift; 943 uport->mapbase = old_mapbase; 944 945 if (old_type != PORT_UNKNOWN) { 946 retval = uport->ops->request_port(uport); 947 /* 948 * If we failed to restore the old settings, 949 * we fail like this. 950 */ 951 if (retval) 952 uport->type = PORT_UNKNOWN; 953 954 /* 955 * We failed anyway. 956 */ 957 retval = -EBUSY; 958 } 959 960 /* Added to return the correct error -Ram Gupta */ 961 goto exit; 962 } 963 } 964 965 if (change_irq) 966 uport->irq = new_info->irq; 967 if (!(uport->flags & UPF_FIXED_PORT)) 968 uport->uartclk = new_info->baud_base * 16; 969 uport->flags = (uport->flags & ~UPF_CHANGE_MASK) | 970 (new_flags & UPF_CHANGE_MASK); 971 uport->custom_divisor = new_info->custom_divisor; 972 port->close_delay = close_delay; 973 port->closing_wait = closing_wait; 974 if (new_info->xmit_fifo_size) 975 uport->fifosize = new_info->xmit_fifo_size; 976 port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0; 977 978 check_and_exit: 979 retval = 0; 980 if (uport->type == PORT_UNKNOWN) 981 goto exit; 982 if (tty_port_initialized(port)) { 983 if (((old_flags ^ uport->flags) & UPF_SPD_MASK) || 984 old_custom_divisor != uport->custom_divisor) { 985 /* 986 * If they're setting up a custom divisor or speed, 987 * instead of clearing it, then bitch about it. 988 */ 989 if (uport->flags & UPF_SPD_MASK) { 990 dev_notice_ratelimited(uport->dev, 991 "%s sets custom speed on %s. This is deprecated.\n", 992 current->comm, 993 tty_name(port->tty)); 994 } 995 uart_change_speed(tty, state, NULL); 996 } 997 } else { 998 retval = uart_startup(tty, state, 1); 999 if (retval == 0) 1000 tty_port_set_initialized(port, true); 1001 if (retval > 0) 1002 retval = 0; 1003 } 1004 exit: 1005 return retval; 1006 } 1007 1008 static int uart_set_info_user(struct tty_struct *tty, struct serial_struct *ss) 1009 { 1010 struct uart_state *state = tty->driver_data; 1011 struct tty_port *port = &state->port; 1012 int retval; 1013 1014 down_write(&tty->termios_rwsem); 1015 /* 1016 * This semaphore protects port->count. It is also 1017 * very useful to prevent opens. Also, take the 1018 * port configuration semaphore to make sure that a 1019 * module insertion/removal doesn't change anything 1020 * under us. 1021 */ 1022 mutex_lock(&port->mutex); 1023 retval = uart_set_info(tty, port, state, ss); 1024 mutex_unlock(&port->mutex); 1025 up_write(&tty->termios_rwsem); 1026 return retval; 1027 } 1028 1029 /** 1030 * uart_get_lsr_info - get line status register info 1031 * @tty: tty associated with the UART 1032 * @state: UART being queried 1033 * @value: returned modem value 1034 */ 1035 static int uart_get_lsr_info(struct tty_struct *tty, 1036 struct uart_state *state, unsigned int __user *value) 1037 { 1038 struct uart_port *uport = uart_port_check(state); 1039 unsigned int result; 1040 1041 result = uport->ops->tx_empty(uport); 1042 1043 /* 1044 * If we're about to load something into the transmit 1045 * register, we'll pretend the transmitter isn't empty to 1046 * avoid a race condition (depending on when the transmit 1047 * interrupt happens). 1048 */ 1049 if (uport->x_char || 1050 ((uart_circ_chars_pending(&state->xmit) > 0) && 1051 !uart_tx_stopped(uport))) 1052 result &= ~TIOCSER_TEMT; 1053 1054 return put_user(result, value); 1055 } 1056 1057 static int uart_tiocmget(struct tty_struct *tty) 1058 { 1059 struct uart_state *state = tty->driver_data; 1060 struct tty_port *port = &state->port; 1061 struct uart_port *uport; 1062 int result = -EIO; 1063 1064 mutex_lock(&port->mutex); 1065 uport = uart_port_check(state); 1066 if (!uport) 1067 goto out; 1068 1069 if (!tty_io_error(tty)) { 1070 result = uport->mctrl; 1071 spin_lock_irq(&uport->lock); 1072 result |= uport->ops->get_mctrl(uport); 1073 spin_unlock_irq(&uport->lock); 1074 } 1075 out: 1076 mutex_unlock(&port->mutex); 1077 return result; 1078 } 1079 1080 static int 1081 uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear) 1082 { 1083 struct uart_state *state = tty->driver_data; 1084 struct tty_port *port = &state->port; 1085 struct uart_port *uport; 1086 int ret = -EIO; 1087 1088 mutex_lock(&port->mutex); 1089 uport = uart_port_check(state); 1090 if (!uport) 1091 goto out; 1092 1093 if (!tty_io_error(tty)) { 1094 uart_update_mctrl(uport, set, clear); 1095 ret = 0; 1096 } 1097 out: 1098 mutex_unlock(&port->mutex); 1099 return ret; 1100 } 1101 1102 static int uart_break_ctl(struct tty_struct *tty, int break_state) 1103 { 1104 struct uart_state *state = tty->driver_data; 1105 struct tty_port *port = &state->port; 1106 struct uart_port *uport; 1107 int ret = -EIO; 1108 1109 mutex_lock(&port->mutex); 1110 uport = uart_port_check(state); 1111 if (!uport) 1112 goto out; 1113 1114 if (uport->type != PORT_UNKNOWN) 1115 uport->ops->break_ctl(uport, break_state); 1116 ret = 0; 1117 out: 1118 mutex_unlock(&port->mutex); 1119 return ret; 1120 } 1121 1122 static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state) 1123 { 1124 struct tty_port *port = &state->port; 1125 struct uart_port *uport; 1126 int flags, ret; 1127 1128 if (!capable(CAP_SYS_ADMIN)) 1129 return -EPERM; 1130 1131 /* 1132 * Take the per-port semaphore. This prevents count from 1133 * changing, and hence any extra opens of the port while 1134 * we're auto-configuring. 1135 */ 1136 if (mutex_lock_interruptible(&port->mutex)) 1137 return -ERESTARTSYS; 1138 1139 uport = uart_port_check(state); 1140 if (!uport) { 1141 ret = -EIO; 1142 goto out; 1143 } 1144 1145 ret = -EBUSY; 1146 if (tty_port_users(port) == 1) { 1147 uart_shutdown(tty, state); 1148 1149 /* 1150 * If we already have a port type configured, 1151 * we must release its resources. 1152 */ 1153 if (uport->type != PORT_UNKNOWN && uport->ops->release_port) 1154 uport->ops->release_port(uport); 1155 1156 flags = UART_CONFIG_TYPE; 1157 if (uport->flags & UPF_AUTO_IRQ) 1158 flags |= UART_CONFIG_IRQ; 1159 1160 /* 1161 * This will claim the ports resources if 1162 * a port is found. 1163 */ 1164 uport->ops->config_port(uport, flags); 1165 1166 ret = uart_startup(tty, state, 1); 1167 if (ret == 0) 1168 tty_port_set_initialized(port, true); 1169 if (ret > 0) 1170 ret = 0; 1171 } 1172 out: 1173 mutex_unlock(&port->mutex); 1174 return ret; 1175 } 1176 1177 static void uart_enable_ms(struct uart_port *uport) 1178 { 1179 /* 1180 * Force modem status interrupts on 1181 */ 1182 if (uport->ops->enable_ms) 1183 uport->ops->enable_ms(uport); 1184 } 1185 1186 /* 1187 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change 1188 * - mask passed in arg for lines of interest 1189 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) 1190 * Caller should use TIOCGICOUNT to see which one it was 1191 * 1192 * FIXME: This wants extracting into a common all driver implementation 1193 * of TIOCMWAIT using tty_port. 1194 */ 1195 static int uart_wait_modem_status(struct uart_state *state, unsigned long arg) 1196 { 1197 struct uart_port *uport; 1198 struct tty_port *port = &state->port; 1199 DECLARE_WAITQUEUE(wait, current); 1200 struct uart_icount cprev, cnow; 1201 int ret; 1202 1203 /* 1204 * note the counters on entry 1205 */ 1206 uport = uart_port_ref(state); 1207 if (!uport) 1208 return -EIO; 1209 spin_lock_irq(&uport->lock); 1210 memcpy(&cprev, &uport->icount, sizeof(struct uart_icount)); 1211 uart_enable_ms(uport); 1212 spin_unlock_irq(&uport->lock); 1213 1214 add_wait_queue(&port->delta_msr_wait, &wait); 1215 for (;;) { 1216 spin_lock_irq(&uport->lock); 1217 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount)); 1218 spin_unlock_irq(&uport->lock); 1219 1220 set_current_state(TASK_INTERRUPTIBLE); 1221 1222 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 1223 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 1224 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 1225 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 1226 ret = 0; 1227 break; 1228 } 1229 1230 schedule(); 1231 1232 /* see if a signal did it */ 1233 if (signal_pending(current)) { 1234 ret = -ERESTARTSYS; 1235 break; 1236 } 1237 1238 cprev = cnow; 1239 } 1240 __set_current_state(TASK_RUNNING); 1241 remove_wait_queue(&port->delta_msr_wait, &wait); 1242 uart_port_deref(uport); 1243 1244 return ret; 1245 } 1246 1247 /* 1248 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) 1249 * Return: write counters to the user passed counter struct 1250 * NB: both 1->0 and 0->1 transitions are counted except for 1251 * RI where only 0->1 is counted. 1252 */ 1253 static int uart_get_icount(struct tty_struct *tty, 1254 struct serial_icounter_struct *icount) 1255 { 1256 struct uart_state *state = tty->driver_data; 1257 struct uart_icount cnow; 1258 struct uart_port *uport; 1259 1260 uport = uart_port_ref(state); 1261 if (!uport) 1262 return -EIO; 1263 spin_lock_irq(&uport->lock); 1264 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount)); 1265 spin_unlock_irq(&uport->lock); 1266 uart_port_deref(uport); 1267 1268 icount->cts = cnow.cts; 1269 icount->dsr = cnow.dsr; 1270 icount->rng = cnow.rng; 1271 icount->dcd = cnow.dcd; 1272 icount->rx = cnow.rx; 1273 icount->tx = cnow.tx; 1274 icount->frame = cnow.frame; 1275 icount->overrun = cnow.overrun; 1276 icount->parity = cnow.parity; 1277 icount->brk = cnow.brk; 1278 icount->buf_overrun = cnow.buf_overrun; 1279 1280 return 0; 1281 } 1282 1283 static int uart_get_rs485_config(struct uart_port *port, 1284 struct serial_rs485 __user *rs485) 1285 { 1286 unsigned long flags; 1287 struct serial_rs485 aux; 1288 1289 spin_lock_irqsave(&port->lock, flags); 1290 aux = port->rs485; 1291 spin_unlock_irqrestore(&port->lock, flags); 1292 1293 if (copy_to_user(rs485, &aux, sizeof(aux))) 1294 return -EFAULT; 1295 1296 return 0; 1297 } 1298 1299 static int uart_set_rs485_config(struct uart_port *port, 1300 struct serial_rs485 __user *rs485_user) 1301 { 1302 struct serial_rs485 rs485; 1303 int ret; 1304 unsigned long flags; 1305 1306 if (!port->rs485_config) 1307 return -ENOIOCTLCMD; 1308 1309 if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user))) 1310 return -EFAULT; 1311 1312 spin_lock_irqsave(&port->lock, flags); 1313 ret = port->rs485_config(port, &rs485); 1314 spin_unlock_irqrestore(&port->lock, flags); 1315 if (ret) 1316 return ret; 1317 1318 if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485))) 1319 return -EFAULT; 1320 1321 return 0; 1322 } 1323 1324 static int uart_get_iso7816_config(struct uart_port *port, 1325 struct serial_iso7816 __user *iso7816) 1326 { 1327 unsigned long flags; 1328 struct serial_iso7816 aux; 1329 1330 if (!port->iso7816_config) 1331 return -ENOIOCTLCMD; 1332 1333 spin_lock_irqsave(&port->lock, flags); 1334 aux = port->iso7816; 1335 spin_unlock_irqrestore(&port->lock, flags); 1336 1337 if (copy_to_user(iso7816, &aux, sizeof(aux))) 1338 return -EFAULT; 1339 1340 return 0; 1341 } 1342 1343 static int uart_set_iso7816_config(struct uart_port *port, 1344 struct serial_iso7816 __user *iso7816_user) 1345 { 1346 struct serial_iso7816 iso7816; 1347 int i, ret; 1348 unsigned long flags; 1349 1350 if (!port->iso7816_config) 1351 return -ENOIOCTLCMD; 1352 1353 if (copy_from_user(&iso7816, iso7816_user, sizeof(*iso7816_user))) 1354 return -EFAULT; 1355 1356 /* 1357 * There are 5 words reserved for future use. Check that userspace 1358 * doesn't put stuff in there to prevent breakages in the future. 1359 */ 1360 for (i = 0; i < 5; i++) 1361 if (iso7816.reserved[i]) 1362 return -EINVAL; 1363 1364 spin_lock_irqsave(&port->lock, flags); 1365 ret = port->iso7816_config(port, &iso7816); 1366 spin_unlock_irqrestore(&port->lock, flags); 1367 if (ret) 1368 return ret; 1369 1370 if (copy_to_user(iso7816_user, &port->iso7816, sizeof(port->iso7816))) 1371 return -EFAULT; 1372 1373 return 0; 1374 } 1375 1376 /* 1377 * Called via sys_ioctl. We can use spin_lock_irq() here. 1378 */ 1379 static int 1380 uart_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg) 1381 { 1382 struct uart_state *state = tty->driver_data; 1383 struct tty_port *port = &state->port; 1384 struct uart_port *uport; 1385 void __user *uarg = (void __user *)arg; 1386 int ret = -ENOIOCTLCMD; 1387 1388 1389 /* 1390 * These ioctls don't rely on the hardware to be present. 1391 */ 1392 switch (cmd) { 1393 case TIOCSERCONFIG: 1394 down_write(&tty->termios_rwsem); 1395 ret = uart_do_autoconfig(tty, state); 1396 up_write(&tty->termios_rwsem); 1397 break; 1398 } 1399 1400 if (ret != -ENOIOCTLCMD) 1401 goto out; 1402 1403 if (tty_io_error(tty)) { 1404 ret = -EIO; 1405 goto out; 1406 } 1407 1408 /* 1409 * The following should only be used when hardware is present. 1410 */ 1411 switch (cmd) { 1412 case TIOCMIWAIT: 1413 ret = uart_wait_modem_status(state, arg); 1414 break; 1415 } 1416 1417 if (ret != -ENOIOCTLCMD) 1418 goto out; 1419 1420 mutex_lock(&port->mutex); 1421 uport = uart_port_check(state); 1422 1423 if (!uport || tty_io_error(tty)) { 1424 ret = -EIO; 1425 goto out_up; 1426 } 1427 1428 /* 1429 * All these rely on hardware being present and need to be 1430 * protected against the tty being hung up. 1431 */ 1432 1433 switch (cmd) { 1434 case TIOCSERGETLSR: /* Get line status register */ 1435 ret = uart_get_lsr_info(tty, state, uarg); 1436 break; 1437 1438 case TIOCGRS485: 1439 ret = uart_get_rs485_config(uport, uarg); 1440 break; 1441 1442 case TIOCSRS485: 1443 ret = uart_set_rs485_config(uport, uarg); 1444 break; 1445 1446 case TIOCSISO7816: 1447 ret = uart_set_iso7816_config(state->uart_port, uarg); 1448 break; 1449 1450 case TIOCGISO7816: 1451 ret = uart_get_iso7816_config(state->uart_port, uarg); 1452 break; 1453 default: 1454 if (uport->ops->ioctl) 1455 ret = uport->ops->ioctl(uport, cmd, arg); 1456 break; 1457 } 1458 out_up: 1459 mutex_unlock(&port->mutex); 1460 out: 1461 return ret; 1462 } 1463 1464 static void uart_set_ldisc(struct tty_struct *tty) 1465 { 1466 struct uart_state *state = tty->driver_data; 1467 struct uart_port *uport; 1468 1469 mutex_lock(&state->port.mutex); 1470 uport = uart_port_check(state); 1471 if (uport && uport->ops->set_ldisc) 1472 uport->ops->set_ldisc(uport, &tty->termios); 1473 mutex_unlock(&state->port.mutex); 1474 } 1475 1476 static void uart_set_termios(struct tty_struct *tty, 1477 struct ktermios *old_termios) 1478 { 1479 struct uart_state *state = tty->driver_data; 1480 struct uart_port *uport; 1481 unsigned int cflag = tty->termios.c_cflag; 1482 unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK; 1483 bool sw_changed = false; 1484 1485 mutex_lock(&state->port.mutex); 1486 uport = uart_port_check(state); 1487 if (!uport) 1488 goto out; 1489 1490 /* 1491 * Drivers doing software flow control also need to know 1492 * about changes to these input settings. 1493 */ 1494 if (uport->flags & UPF_SOFT_FLOW) { 1495 iflag_mask |= IXANY|IXON|IXOFF; 1496 sw_changed = 1497 tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] || 1498 tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP]; 1499 } 1500 1501 /* 1502 * These are the bits that are used to setup various 1503 * flags in the low level driver. We can ignore the Bfoo 1504 * bits in c_cflag; c_[io]speed will always be set 1505 * appropriately by set_termios() in tty_ioctl.c 1506 */ 1507 if ((cflag ^ old_termios->c_cflag) == 0 && 1508 tty->termios.c_ospeed == old_termios->c_ospeed && 1509 tty->termios.c_ispeed == old_termios->c_ispeed && 1510 ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 && 1511 !sw_changed) { 1512 goto out; 1513 } 1514 1515 uart_change_speed(tty, state, old_termios); 1516 /* reload cflag from termios; port driver may have overridden flags */ 1517 cflag = tty->termios.c_cflag; 1518 1519 /* Handle transition to B0 status */ 1520 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) 1521 uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR); 1522 /* Handle transition away from B0 status */ 1523 else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) { 1524 unsigned int mask = TIOCM_DTR; 1525 if (!(cflag & CRTSCTS) || !tty_throttled(tty)) 1526 mask |= TIOCM_RTS; 1527 uart_set_mctrl(uport, mask); 1528 } 1529 out: 1530 mutex_unlock(&state->port.mutex); 1531 } 1532 1533 /* 1534 * Calls to uart_close() are serialised via the tty_lock in 1535 * drivers/tty/tty_io.c:tty_release() 1536 * drivers/tty/tty_io.c:do_tty_hangup() 1537 */ 1538 static void uart_close(struct tty_struct *tty, struct file *filp) 1539 { 1540 struct uart_state *state = tty->driver_data; 1541 1542 if (!state) { 1543 struct uart_driver *drv = tty->driver->driver_state; 1544 struct tty_port *port; 1545 1546 state = drv->state + tty->index; 1547 port = &state->port; 1548 spin_lock_irq(&port->lock); 1549 --port->count; 1550 spin_unlock_irq(&port->lock); 1551 return; 1552 } 1553 1554 pr_debug("uart_close(%d) called\n", tty->index); 1555 1556 tty_port_close(tty->port, tty, filp); 1557 } 1558 1559 static void uart_tty_port_shutdown(struct tty_port *port) 1560 { 1561 struct uart_state *state = container_of(port, struct uart_state, port); 1562 struct uart_port *uport = uart_port_check(state); 1563 1564 /* 1565 * At this point, we stop accepting input. To do this, we 1566 * disable the receive line status interrupts. 1567 */ 1568 if (WARN(!uport, "detached port still initialized!\n")) 1569 return; 1570 1571 spin_lock_irq(&uport->lock); 1572 uport->ops->stop_rx(uport); 1573 spin_unlock_irq(&uport->lock); 1574 1575 uart_port_shutdown(port); 1576 1577 /* 1578 * It's possible for shutdown to be called after suspend if we get 1579 * a DCD drop (hangup) at just the right time. Clear suspended bit so 1580 * we don't try to resume a port that has been shutdown. 1581 */ 1582 tty_port_set_suspended(port, 0); 1583 1584 uart_change_pm(state, UART_PM_STATE_OFF); 1585 1586 } 1587 1588 static void uart_wait_until_sent(struct tty_struct *tty, int timeout) 1589 { 1590 struct uart_state *state = tty->driver_data; 1591 struct uart_port *port; 1592 unsigned long char_time, expire; 1593 1594 port = uart_port_ref(state); 1595 if (!port) 1596 return; 1597 1598 if (port->type == PORT_UNKNOWN || port->fifosize == 0) { 1599 uart_port_deref(port); 1600 return; 1601 } 1602 1603 /* 1604 * Set the check interval to be 1/5 of the estimated time to 1605 * send a single character, and make it at least 1. The check 1606 * interval should also be less than the timeout. 1607 * 1608 * Note: we have to use pretty tight timings here to satisfy 1609 * the NIST-PCTS. 1610 */ 1611 char_time = (port->timeout - HZ/50) / port->fifosize; 1612 char_time = char_time / 5; 1613 if (char_time == 0) 1614 char_time = 1; 1615 if (timeout && timeout < char_time) 1616 char_time = timeout; 1617 1618 /* 1619 * If the transmitter hasn't cleared in twice the approximate 1620 * amount of time to send the entire FIFO, it probably won't 1621 * ever clear. This assumes the UART isn't doing flow 1622 * control, which is currently the case. Hence, if it ever 1623 * takes longer than port->timeout, this is probably due to a 1624 * UART bug of some kind. So, we clamp the timeout parameter at 1625 * 2*port->timeout. 1626 */ 1627 if (timeout == 0 || timeout > 2 * port->timeout) 1628 timeout = 2 * port->timeout; 1629 1630 expire = jiffies + timeout; 1631 1632 pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n", 1633 port->line, jiffies, expire); 1634 1635 /* 1636 * Check whether the transmitter is empty every 'char_time'. 1637 * 'timeout' / 'expire' give us the maximum amount of time 1638 * we wait. 1639 */ 1640 while (!port->ops->tx_empty(port)) { 1641 msleep_interruptible(jiffies_to_msecs(char_time)); 1642 if (signal_pending(current)) 1643 break; 1644 if (time_after(jiffies, expire)) 1645 break; 1646 } 1647 uart_port_deref(port); 1648 } 1649 1650 /* 1651 * Calls to uart_hangup() are serialised by the tty_lock in 1652 * drivers/tty/tty_io.c:do_tty_hangup() 1653 * This runs from a workqueue and can sleep for a _short_ time only. 1654 */ 1655 static void uart_hangup(struct tty_struct *tty) 1656 { 1657 struct uart_state *state = tty->driver_data; 1658 struct tty_port *port = &state->port; 1659 struct uart_port *uport; 1660 unsigned long flags; 1661 1662 pr_debug("uart_hangup(%d)\n", tty->index); 1663 1664 mutex_lock(&port->mutex); 1665 uport = uart_port_check(state); 1666 WARN(!uport, "hangup of detached port!\n"); 1667 1668 if (tty_port_active(port)) { 1669 uart_flush_buffer(tty); 1670 uart_shutdown(tty, state); 1671 spin_lock_irqsave(&port->lock, flags); 1672 port->count = 0; 1673 spin_unlock_irqrestore(&port->lock, flags); 1674 tty_port_set_active(port, 0); 1675 tty_port_tty_set(port, NULL); 1676 if (uport && !uart_console(uport)) 1677 uart_change_pm(state, UART_PM_STATE_OFF); 1678 wake_up_interruptible(&port->open_wait); 1679 wake_up_interruptible(&port->delta_msr_wait); 1680 } 1681 mutex_unlock(&port->mutex); 1682 } 1683 1684 /* uport == NULL if uart_port has already been removed */ 1685 static void uart_port_shutdown(struct tty_port *port) 1686 { 1687 struct uart_state *state = container_of(port, struct uart_state, port); 1688 struct uart_port *uport = uart_port_check(state); 1689 1690 /* 1691 * clear delta_msr_wait queue to avoid mem leaks: we may free 1692 * the irq here so the queue might never be woken up. Note 1693 * that we won't end up waiting on delta_msr_wait again since 1694 * any outstanding file descriptors should be pointing at 1695 * hung_up_tty_fops now. 1696 */ 1697 wake_up_interruptible(&port->delta_msr_wait); 1698 1699 /* 1700 * Free the IRQ and disable the port. 1701 */ 1702 if (uport) 1703 uport->ops->shutdown(uport); 1704 1705 /* 1706 * Ensure that the IRQ handler isn't running on another CPU. 1707 */ 1708 if (uport) 1709 synchronize_irq(uport->irq); 1710 } 1711 1712 static int uart_carrier_raised(struct tty_port *port) 1713 { 1714 struct uart_state *state = container_of(port, struct uart_state, port); 1715 struct uart_port *uport; 1716 int mctrl; 1717 1718 uport = uart_port_ref(state); 1719 /* 1720 * Should never observe uport == NULL since checks for hangup should 1721 * abort the tty_port_block_til_ready() loop before checking for carrier 1722 * raised -- but report carrier raised if it does anyway so open will 1723 * continue and not sleep 1724 */ 1725 if (WARN_ON(!uport)) 1726 return 1; 1727 spin_lock_irq(&uport->lock); 1728 uart_enable_ms(uport); 1729 mctrl = uport->ops->get_mctrl(uport); 1730 spin_unlock_irq(&uport->lock); 1731 uart_port_deref(uport); 1732 if (mctrl & TIOCM_CAR) 1733 return 1; 1734 return 0; 1735 } 1736 1737 static void uart_dtr_rts(struct tty_port *port, int raise) 1738 { 1739 struct uart_state *state = container_of(port, struct uart_state, port); 1740 struct uart_port *uport; 1741 1742 uport = uart_port_ref(state); 1743 if (!uport) 1744 return; 1745 uart_port_dtr_rts(uport, raise); 1746 uart_port_deref(uport); 1747 } 1748 1749 static int uart_install(struct tty_driver *driver, struct tty_struct *tty) 1750 { 1751 struct uart_driver *drv = driver->driver_state; 1752 struct uart_state *state = drv->state + tty->index; 1753 1754 tty->driver_data = state; 1755 1756 return tty_standard_install(driver, tty); 1757 } 1758 1759 /* 1760 * Calls to uart_open are serialised by the tty_lock in 1761 * drivers/tty/tty_io.c:tty_open() 1762 * Note that if this fails, then uart_close() _will_ be called. 1763 * 1764 * In time, we want to scrap the "opening nonpresent ports" 1765 * behaviour and implement an alternative way for setserial 1766 * to set base addresses/ports/types. This will allow us to 1767 * get rid of a certain amount of extra tests. 1768 */ 1769 static int uart_open(struct tty_struct *tty, struct file *filp) 1770 { 1771 struct uart_state *state = tty->driver_data; 1772 int retval; 1773 1774 retval = tty_port_open(&state->port, tty, filp); 1775 if (retval > 0) 1776 retval = 0; 1777 1778 return retval; 1779 } 1780 1781 static int uart_port_activate(struct tty_port *port, struct tty_struct *tty) 1782 { 1783 struct uart_state *state = container_of(port, struct uart_state, port); 1784 struct uart_port *uport; 1785 int ret; 1786 1787 uport = uart_port_check(state); 1788 if (!uport || uport->flags & UPF_DEAD) 1789 return -ENXIO; 1790 1791 port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0; 1792 1793 /* 1794 * Start up the serial port. 1795 */ 1796 ret = uart_startup(tty, state, 0); 1797 if (ret > 0) 1798 tty_port_set_active(port, 1); 1799 1800 return ret; 1801 } 1802 1803 static const char *uart_type(struct uart_port *port) 1804 { 1805 const char *str = NULL; 1806 1807 if (port->ops->type) 1808 str = port->ops->type(port); 1809 1810 if (!str) 1811 str = "unknown"; 1812 1813 return str; 1814 } 1815 1816 #ifdef CONFIG_PROC_FS 1817 1818 static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i) 1819 { 1820 struct uart_state *state = drv->state + i; 1821 struct tty_port *port = &state->port; 1822 enum uart_pm_state pm_state; 1823 struct uart_port *uport; 1824 char stat_buf[32]; 1825 unsigned int status; 1826 int mmio; 1827 1828 mutex_lock(&port->mutex); 1829 uport = uart_port_check(state); 1830 if (!uport) 1831 goto out; 1832 1833 mmio = uport->iotype >= UPIO_MEM; 1834 seq_printf(m, "%d: uart:%s %s%08llX irq:%d", 1835 uport->line, uart_type(uport), 1836 mmio ? "mmio:0x" : "port:", 1837 mmio ? (unsigned long long)uport->mapbase 1838 : (unsigned long long)uport->iobase, 1839 uport->irq); 1840 1841 if (uport->type == PORT_UNKNOWN) { 1842 seq_putc(m, '\n'); 1843 goto out; 1844 } 1845 1846 if (capable(CAP_SYS_ADMIN)) { 1847 pm_state = state->pm_state; 1848 if (pm_state != UART_PM_STATE_ON) 1849 uart_change_pm(state, UART_PM_STATE_ON); 1850 spin_lock_irq(&uport->lock); 1851 status = uport->ops->get_mctrl(uport); 1852 spin_unlock_irq(&uport->lock); 1853 if (pm_state != UART_PM_STATE_ON) 1854 uart_change_pm(state, pm_state); 1855 1856 seq_printf(m, " tx:%d rx:%d", 1857 uport->icount.tx, uport->icount.rx); 1858 if (uport->icount.frame) 1859 seq_printf(m, " fe:%d", uport->icount.frame); 1860 if (uport->icount.parity) 1861 seq_printf(m, " pe:%d", uport->icount.parity); 1862 if (uport->icount.brk) 1863 seq_printf(m, " brk:%d", uport->icount.brk); 1864 if (uport->icount.overrun) 1865 seq_printf(m, " oe:%d", uport->icount.overrun); 1866 if (uport->icount.buf_overrun) 1867 seq_printf(m, " bo:%d", uport->icount.buf_overrun); 1868 1869 #define INFOBIT(bit, str) \ 1870 if (uport->mctrl & (bit)) \ 1871 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1872 strlen(stat_buf) - 2) 1873 #define STATBIT(bit, str) \ 1874 if (status & (bit)) \ 1875 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1876 strlen(stat_buf) - 2) 1877 1878 stat_buf[0] = '\0'; 1879 stat_buf[1] = '\0'; 1880 INFOBIT(TIOCM_RTS, "|RTS"); 1881 STATBIT(TIOCM_CTS, "|CTS"); 1882 INFOBIT(TIOCM_DTR, "|DTR"); 1883 STATBIT(TIOCM_DSR, "|DSR"); 1884 STATBIT(TIOCM_CAR, "|CD"); 1885 STATBIT(TIOCM_RNG, "|RI"); 1886 if (stat_buf[0]) 1887 stat_buf[0] = ' '; 1888 1889 seq_puts(m, stat_buf); 1890 } 1891 seq_putc(m, '\n'); 1892 #undef STATBIT 1893 #undef INFOBIT 1894 out: 1895 mutex_unlock(&port->mutex); 1896 } 1897 1898 static int uart_proc_show(struct seq_file *m, void *v) 1899 { 1900 struct tty_driver *ttydrv = m->private; 1901 struct uart_driver *drv = ttydrv->driver_state; 1902 int i; 1903 1904 seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n", "", "", ""); 1905 for (i = 0; i < drv->nr; i++) 1906 uart_line_info(m, drv, i); 1907 return 0; 1908 } 1909 #endif 1910 1911 #if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL) 1912 /** 1913 * uart_console_write - write a console message to a serial port 1914 * @port: the port to write the message 1915 * @s: array of characters 1916 * @count: number of characters in string to write 1917 * @putchar: function to write character to port 1918 */ 1919 void uart_console_write(struct uart_port *port, const char *s, 1920 unsigned int count, 1921 void (*putchar)(struct uart_port *, int)) 1922 { 1923 unsigned int i; 1924 1925 for (i = 0; i < count; i++, s++) { 1926 if (*s == '\n') 1927 putchar(port, '\r'); 1928 putchar(port, *s); 1929 } 1930 } 1931 EXPORT_SYMBOL_GPL(uart_console_write); 1932 1933 /* 1934 * Check whether an invalid uart number has been specified, and 1935 * if so, search for the first available port that does have 1936 * console support. 1937 */ 1938 struct uart_port * __init 1939 uart_get_console(struct uart_port *ports, int nr, struct console *co) 1940 { 1941 int idx = co->index; 1942 1943 if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 && 1944 ports[idx].membase == NULL)) 1945 for (idx = 0; idx < nr; idx++) 1946 if (ports[idx].iobase != 0 || 1947 ports[idx].membase != NULL) 1948 break; 1949 1950 co->index = idx; 1951 1952 return ports + idx; 1953 } 1954 1955 /** 1956 * uart_parse_earlycon - Parse earlycon options 1957 * @p: ptr to 2nd field (ie., just beyond '<name>,') 1958 * @iotype: ptr for decoded iotype (out) 1959 * @addr: ptr for decoded mapbase/iobase (out) 1960 * @options: ptr for <options> field; NULL if not present (out) 1961 * 1962 * Decodes earlycon kernel command line parameters of the form 1963 * earlycon=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options> 1964 * console=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options> 1965 * 1966 * The optional form 1967 * earlycon=<name>,0x<addr>,<options> 1968 * console=<name>,0x<addr>,<options> 1969 * is also accepted; the returned @iotype will be UPIO_MEM. 1970 * 1971 * Returns 0 on success or -EINVAL on failure 1972 */ 1973 int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr, 1974 char **options) 1975 { 1976 if (strncmp(p, "mmio,", 5) == 0) { 1977 *iotype = UPIO_MEM; 1978 p += 5; 1979 } else if (strncmp(p, "mmio16,", 7) == 0) { 1980 *iotype = UPIO_MEM16; 1981 p += 7; 1982 } else if (strncmp(p, "mmio32,", 7) == 0) { 1983 *iotype = UPIO_MEM32; 1984 p += 7; 1985 } else if (strncmp(p, "mmio32be,", 9) == 0) { 1986 *iotype = UPIO_MEM32BE; 1987 p += 9; 1988 } else if (strncmp(p, "mmio32native,", 13) == 0) { 1989 *iotype = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) ? 1990 UPIO_MEM32BE : UPIO_MEM32; 1991 p += 13; 1992 } else if (strncmp(p, "io,", 3) == 0) { 1993 *iotype = UPIO_PORT; 1994 p += 3; 1995 } else if (strncmp(p, "0x", 2) == 0) { 1996 *iotype = UPIO_MEM; 1997 } else { 1998 return -EINVAL; 1999 } 2000 2001 /* 2002 * Before you replace it with kstrtoull(), think about options separator 2003 * (',') it will not tolerate 2004 */ 2005 *addr = simple_strtoull(p, NULL, 0); 2006 p = strchr(p, ','); 2007 if (p) 2008 p++; 2009 2010 *options = p; 2011 return 0; 2012 } 2013 EXPORT_SYMBOL_GPL(uart_parse_earlycon); 2014 2015 /** 2016 * uart_parse_options - Parse serial port baud/parity/bits/flow control. 2017 * @options: pointer to option string 2018 * @baud: pointer to an 'int' variable for the baud rate. 2019 * @parity: pointer to an 'int' variable for the parity. 2020 * @bits: pointer to an 'int' variable for the number of data bits. 2021 * @flow: pointer to an 'int' variable for the flow control character. 2022 * 2023 * uart_parse_options decodes a string containing the serial console 2024 * options. The format of the string is <baud><parity><bits><flow>, 2025 * eg: 115200n8r 2026 */ 2027 void 2028 uart_parse_options(const char *options, int *baud, int *parity, 2029 int *bits, int *flow) 2030 { 2031 const char *s = options; 2032 2033 *baud = simple_strtoul(s, NULL, 10); 2034 while (*s >= '0' && *s <= '9') 2035 s++; 2036 if (*s) 2037 *parity = *s++; 2038 if (*s) 2039 *bits = *s++ - '0'; 2040 if (*s) 2041 *flow = *s; 2042 } 2043 EXPORT_SYMBOL_GPL(uart_parse_options); 2044 2045 /** 2046 * uart_set_options - setup the serial console parameters 2047 * @port: pointer to the serial ports uart_port structure 2048 * @co: console pointer 2049 * @baud: baud rate 2050 * @parity: parity character - 'n' (none), 'o' (odd), 'e' (even) 2051 * @bits: number of data bits 2052 * @flow: flow control character - 'r' (rts) 2053 */ 2054 int 2055 uart_set_options(struct uart_port *port, struct console *co, 2056 int baud, int parity, int bits, int flow) 2057 { 2058 struct ktermios termios; 2059 static struct ktermios dummy; 2060 2061 /* 2062 * Ensure that the serial console lock is initialised 2063 * early. 2064 * If this port is a console, then the spinlock is already 2065 * initialised. 2066 */ 2067 if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) { 2068 spin_lock_init(&port->lock); 2069 lockdep_set_class(&port->lock, &port_lock_key); 2070 } 2071 2072 memset(&termios, 0, sizeof(struct ktermios)); 2073 2074 termios.c_cflag |= CREAD | HUPCL | CLOCAL; 2075 tty_termios_encode_baud_rate(&termios, baud, baud); 2076 2077 if (bits == 7) 2078 termios.c_cflag |= CS7; 2079 else 2080 termios.c_cflag |= CS8; 2081 2082 switch (parity) { 2083 case 'o': case 'O': 2084 termios.c_cflag |= PARODD; 2085 /*fall through*/ 2086 case 'e': case 'E': 2087 termios.c_cflag |= PARENB; 2088 break; 2089 } 2090 2091 if (flow == 'r') 2092 termios.c_cflag |= CRTSCTS; 2093 2094 /* 2095 * some uarts on other side don't support no flow control. 2096 * So we set * DTR in host uart to make them happy 2097 */ 2098 port->mctrl |= TIOCM_DTR; 2099 2100 port->ops->set_termios(port, &termios, &dummy); 2101 /* 2102 * Allow the setting of the UART parameters with a NULL console 2103 * too: 2104 */ 2105 if (co) 2106 co->cflag = termios.c_cflag; 2107 2108 return 0; 2109 } 2110 EXPORT_SYMBOL_GPL(uart_set_options); 2111 #endif /* CONFIG_SERIAL_CORE_CONSOLE */ 2112 2113 /** 2114 * uart_change_pm - set power state of the port 2115 * 2116 * @state: port descriptor 2117 * @pm_state: new state 2118 * 2119 * Locking: port->mutex has to be held 2120 */ 2121 static void uart_change_pm(struct uart_state *state, 2122 enum uart_pm_state pm_state) 2123 { 2124 struct uart_port *port = uart_port_check(state); 2125 2126 if (state->pm_state != pm_state) { 2127 if (port && port->ops->pm) 2128 port->ops->pm(port, pm_state, state->pm_state); 2129 state->pm_state = pm_state; 2130 } 2131 } 2132 2133 struct uart_match { 2134 struct uart_port *port; 2135 struct uart_driver *driver; 2136 }; 2137 2138 static int serial_match_port(struct device *dev, void *data) 2139 { 2140 struct uart_match *match = data; 2141 struct tty_driver *tty_drv = match->driver->tty_driver; 2142 dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) + 2143 match->port->line; 2144 2145 return dev->devt == devt; /* Actually, only one tty per port */ 2146 } 2147 2148 int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport) 2149 { 2150 struct uart_state *state = drv->state + uport->line; 2151 struct tty_port *port = &state->port; 2152 struct device *tty_dev; 2153 struct uart_match match = {uport, drv}; 2154 2155 mutex_lock(&port->mutex); 2156 2157 tty_dev = device_find_child(uport->dev, &match, serial_match_port); 2158 if (tty_dev && device_may_wakeup(tty_dev)) { 2159 enable_irq_wake(uport->irq); 2160 put_device(tty_dev); 2161 mutex_unlock(&port->mutex); 2162 return 0; 2163 } 2164 put_device(tty_dev); 2165 2166 /* Nothing to do if the console is not suspending */ 2167 if (!console_suspend_enabled && uart_console(uport)) 2168 goto unlock; 2169 2170 uport->suspended = 1; 2171 2172 if (tty_port_initialized(port)) { 2173 const struct uart_ops *ops = uport->ops; 2174 int tries; 2175 2176 tty_port_set_suspended(port, 1); 2177 tty_port_set_initialized(port, 0); 2178 2179 spin_lock_irq(&uport->lock); 2180 ops->stop_tx(uport); 2181 ops->set_mctrl(uport, 0); 2182 ops->stop_rx(uport); 2183 spin_unlock_irq(&uport->lock); 2184 2185 /* 2186 * Wait for the transmitter to empty. 2187 */ 2188 for (tries = 3; !ops->tx_empty(uport) && tries; tries--) 2189 msleep(10); 2190 if (!tries) 2191 dev_err(uport->dev, "%s: Unable to drain transmitter\n", 2192 uport->name); 2193 2194 ops->shutdown(uport); 2195 } 2196 2197 /* 2198 * Disable the console device before suspending. 2199 */ 2200 if (uart_console(uport)) 2201 console_stop(uport->cons); 2202 2203 uart_change_pm(state, UART_PM_STATE_OFF); 2204 unlock: 2205 mutex_unlock(&port->mutex); 2206 2207 return 0; 2208 } 2209 2210 int uart_resume_port(struct uart_driver *drv, struct uart_port *uport) 2211 { 2212 struct uart_state *state = drv->state + uport->line; 2213 struct tty_port *port = &state->port; 2214 struct device *tty_dev; 2215 struct uart_match match = {uport, drv}; 2216 struct ktermios termios; 2217 2218 mutex_lock(&port->mutex); 2219 2220 tty_dev = device_find_child(uport->dev, &match, serial_match_port); 2221 if (!uport->suspended && device_may_wakeup(tty_dev)) { 2222 if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) 2223 disable_irq_wake(uport->irq); 2224 put_device(tty_dev); 2225 mutex_unlock(&port->mutex); 2226 return 0; 2227 } 2228 put_device(tty_dev); 2229 uport->suspended = 0; 2230 2231 /* 2232 * Re-enable the console device after suspending. 2233 */ 2234 if (uart_console(uport)) { 2235 /* 2236 * First try to use the console cflag setting. 2237 */ 2238 memset(&termios, 0, sizeof(struct ktermios)); 2239 termios.c_cflag = uport->cons->cflag; 2240 2241 /* 2242 * If that's unset, use the tty termios setting. 2243 */ 2244 if (port->tty && termios.c_cflag == 0) 2245 termios = port->tty->termios; 2246 2247 if (console_suspend_enabled) 2248 uart_change_pm(state, UART_PM_STATE_ON); 2249 uport->ops->set_termios(uport, &termios, NULL); 2250 if (console_suspend_enabled) 2251 console_start(uport->cons); 2252 } 2253 2254 if (tty_port_suspended(port)) { 2255 const struct uart_ops *ops = uport->ops; 2256 int ret; 2257 2258 uart_change_pm(state, UART_PM_STATE_ON); 2259 spin_lock_irq(&uport->lock); 2260 ops->set_mctrl(uport, 0); 2261 spin_unlock_irq(&uport->lock); 2262 if (console_suspend_enabled || !uart_console(uport)) { 2263 /* Protected by port mutex for now */ 2264 struct tty_struct *tty = port->tty; 2265 ret = ops->startup(uport); 2266 if (ret == 0) { 2267 if (tty) 2268 uart_change_speed(tty, state, NULL); 2269 spin_lock_irq(&uport->lock); 2270 ops->set_mctrl(uport, uport->mctrl); 2271 ops->start_tx(uport); 2272 spin_unlock_irq(&uport->lock); 2273 tty_port_set_initialized(port, 1); 2274 } else { 2275 /* 2276 * Failed to resume - maybe hardware went away? 2277 * Clear the "initialized" flag so we won't try 2278 * to call the low level drivers shutdown method. 2279 */ 2280 uart_shutdown(tty, state); 2281 } 2282 } 2283 2284 tty_port_set_suspended(port, 0); 2285 } 2286 2287 mutex_unlock(&port->mutex); 2288 2289 return 0; 2290 } 2291 2292 static inline void 2293 uart_report_port(struct uart_driver *drv, struct uart_port *port) 2294 { 2295 char address[64]; 2296 2297 switch (port->iotype) { 2298 case UPIO_PORT: 2299 snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase); 2300 break; 2301 case UPIO_HUB6: 2302 snprintf(address, sizeof(address), 2303 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6); 2304 break; 2305 case UPIO_MEM: 2306 case UPIO_MEM16: 2307 case UPIO_MEM32: 2308 case UPIO_MEM32BE: 2309 case UPIO_AU: 2310 case UPIO_TSI: 2311 snprintf(address, sizeof(address), 2312 "MMIO 0x%llx", (unsigned long long)port->mapbase); 2313 break; 2314 default: 2315 strlcpy(address, "*unknown*", sizeof(address)); 2316 break; 2317 } 2318 2319 pr_info("%s%s%s at %s (irq = %d, base_baud = %d) is a %s\n", 2320 port->dev ? dev_name(port->dev) : "", 2321 port->dev ? ": " : "", 2322 port->name, 2323 address, port->irq, port->uartclk / 16, uart_type(port)); 2324 } 2325 2326 static void 2327 uart_configure_port(struct uart_driver *drv, struct uart_state *state, 2328 struct uart_port *port) 2329 { 2330 unsigned int flags; 2331 2332 /* 2333 * If there isn't a port here, don't do anything further. 2334 */ 2335 if (!port->iobase && !port->mapbase && !port->membase) 2336 return; 2337 2338 /* 2339 * Now do the auto configuration stuff. Note that config_port 2340 * is expected to claim the resources and map the port for us. 2341 */ 2342 flags = 0; 2343 if (port->flags & UPF_AUTO_IRQ) 2344 flags |= UART_CONFIG_IRQ; 2345 if (port->flags & UPF_BOOT_AUTOCONF) { 2346 if (!(port->flags & UPF_FIXED_TYPE)) { 2347 port->type = PORT_UNKNOWN; 2348 flags |= UART_CONFIG_TYPE; 2349 } 2350 port->ops->config_port(port, flags); 2351 } 2352 2353 if (port->type != PORT_UNKNOWN) { 2354 unsigned long flags; 2355 2356 uart_report_port(drv, port); 2357 2358 /* Power up port for set_mctrl() */ 2359 uart_change_pm(state, UART_PM_STATE_ON); 2360 2361 /* 2362 * Ensure that the modem control lines are de-activated. 2363 * keep the DTR setting that is set in uart_set_options() 2364 * We probably don't need a spinlock around this, but 2365 */ 2366 spin_lock_irqsave(&port->lock, flags); 2367 port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR); 2368 spin_unlock_irqrestore(&port->lock, flags); 2369 2370 /* 2371 * If this driver supports console, and it hasn't been 2372 * successfully registered yet, try to re-register it. 2373 * It may be that the port was not available. 2374 */ 2375 if (port->cons && !(port->cons->flags & CON_ENABLED)) 2376 register_console(port->cons); 2377 2378 /* 2379 * Power down all ports by default, except the 2380 * console if we have one. 2381 */ 2382 if (!uart_console(port)) 2383 uart_change_pm(state, UART_PM_STATE_OFF); 2384 } 2385 } 2386 2387 #ifdef CONFIG_CONSOLE_POLL 2388 2389 static int uart_poll_init(struct tty_driver *driver, int line, char *options) 2390 { 2391 struct uart_driver *drv = driver->driver_state; 2392 struct uart_state *state = drv->state + line; 2393 struct tty_port *tport; 2394 struct uart_port *port; 2395 int baud = 9600; 2396 int bits = 8; 2397 int parity = 'n'; 2398 int flow = 'n'; 2399 int ret = 0; 2400 2401 tport = &state->port; 2402 mutex_lock(&tport->mutex); 2403 2404 port = uart_port_check(state); 2405 if (!port || !(port->ops->poll_get_char && port->ops->poll_put_char)) { 2406 ret = -1; 2407 goto out; 2408 } 2409 2410 if (port->ops->poll_init) { 2411 /* 2412 * We don't set initialized as we only initialized the hw, 2413 * e.g. state->xmit is still uninitialized. 2414 */ 2415 if (!tty_port_initialized(tport)) 2416 ret = port->ops->poll_init(port); 2417 } 2418 2419 if (!ret && options) { 2420 uart_parse_options(options, &baud, &parity, &bits, &flow); 2421 ret = uart_set_options(port, NULL, baud, parity, bits, flow); 2422 } 2423 out: 2424 mutex_unlock(&tport->mutex); 2425 return ret; 2426 } 2427 2428 static int uart_poll_get_char(struct tty_driver *driver, int line) 2429 { 2430 struct uart_driver *drv = driver->driver_state; 2431 struct uart_state *state = drv->state + line; 2432 struct uart_port *port; 2433 int ret = -1; 2434 2435 port = uart_port_ref(state); 2436 if (port) { 2437 ret = port->ops->poll_get_char(port); 2438 uart_port_deref(port); 2439 } 2440 2441 return ret; 2442 } 2443 2444 static void uart_poll_put_char(struct tty_driver *driver, int line, char ch) 2445 { 2446 struct uart_driver *drv = driver->driver_state; 2447 struct uart_state *state = drv->state + line; 2448 struct uart_port *port; 2449 2450 port = uart_port_ref(state); 2451 if (!port) 2452 return; 2453 2454 if (ch == '\n') 2455 port->ops->poll_put_char(port, '\r'); 2456 port->ops->poll_put_char(port, ch); 2457 uart_port_deref(port); 2458 } 2459 #endif 2460 2461 static const struct tty_operations uart_ops = { 2462 .install = uart_install, 2463 .open = uart_open, 2464 .close = uart_close, 2465 .write = uart_write, 2466 .put_char = uart_put_char, 2467 .flush_chars = uart_flush_chars, 2468 .write_room = uart_write_room, 2469 .chars_in_buffer= uart_chars_in_buffer, 2470 .flush_buffer = uart_flush_buffer, 2471 .ioctl = uart_ioctl, 2472 .throttle = uart_throttle, 2473 .unthrottle = uart_unthrottle, 2474 .send_xchar = uart_send_xchar, 2475 .set_termios = uart_set_termios, 2476 .set_ldisc = uart_set_ldisc, 2477 .stop = uart_stop, 2478 .start = uart_start, 2479 .hangup = uart_hangup, 2480 .break_ctl = uart_break_ctl, 2481 .wait_until_sent= uart_wait_until_sent, 2482 #ifdef CONFIG_PROC_FS 2483 .proc_show = uart_proc_show, 2484 #endif 2485 .tiocmget = uart_tiocmget, 2486 .tiocmset = uart_tiocmset, 2487 .set_serial = uart_set_info_user, 2488 .get_serial = uart_get_info_user, 2489 .get_icount = uart_get_icount, 2490 #ifdef CONFIG_CONSOLE_POLL 2491 .poll_init = uart_poll_init, 2492 .poll_get_char = uart_poll_get_char, 2493 .poll_put_char = uart_poll_put_char, 2494 #endif 2495 }; 2496 2497 static const struct tty_port_operations uart_port_ops = { 2498 .carrier_raised = uart_carrier_raised, 2499 .dtr_rts = uart_dtr_rts, 2500 .activate = uart_port_activate, 2501 .shutdown = uart_tty_port_shutdown, 2502 }; 2503 2504 /** 2505 * uart_register_driver - register a driver with the uart core layer 2506 * @drv: low level driver structure 2507 * 2508 * Register a uart driver with the core driver. We in turn register 2509 * with the tty layer, and initialise the core driver per-port state. 2510 * 2511 * We have a proc file in /proc/tty/driver which is named after the 2512 * normal driver. 2513 * 2514 * drv->port should be NULL, and the per-port structures should be 2515 * registered using uart_add_one_port after this call has succeeded. 2516 */ 2517 int uart_register_driver(struct uart_driver *drv) 2518 { 2519 struct tty_driver *normal; 2520 int i, retval = -ENOMEM; 2521 2522 BUG_ON(drv->state); 2523 2524 /* 2525 * Maybe we should be using a slab cache for this, especially if 2526 * we have a large number of ports to handle. 2527 */ 2528 drv->state = kcalloc(drv->nr, sizeof(struct uart_state), GFP_KERNEL); 2529 if (!drv->state) 2530 goto out; 2531 2532 normal = alloc_tty_driver(drv->nr); 2533 if (!normal) 2534 goto out_kfree; 2535 2536 drv->tty_driver = normal; 2537 2538 normal->driver_name = drv->driver_name; 2539 normal->name = drv->dev_name; 2540 normal->major = drv->major; 2541 normal->minor_start = drv->minor; 2542 normal->type = TTY_DRIVER_TYPE_SERIAL; 2543 normal->subtype = SERIAL_TYPE_NORMAL; 2544 normal->init_termios = tty_std_termios; 2545 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 2546 normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600; 2547 normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 2548 normal->driver_state = drv; 2549 tty_set_operations(normal, &uart_ops); 2550 2551 /* 2552 * Initialise the UART state(s). 2553 */ 2554 for (i = 0; i < drv->nr; i++) { 2555 struct uart_state *state = drv->state + i; 2556 struct tty_port *port = &state->port; 2557 2558 tty_port_init(port); 2559 port->ops = &uart_port_ops; 2560 } 2561 2562 retval = tty_register_driver(normal); 2563 if (retval >= 0) 2564 return retval; 2565 2566 for (i = 0; i < drv->nr; i++) 2567 tty_port_destroy(&drv->state[i].port); 2568 put_tty_driver(normal); 2569 out_kfree: 2570 kfree(drv->state); 2571 out: 2572 return retval; 2573 } 2574 2575 /** 2576 * uart_unregister_driver - remove a driver from the uart core layer 2577 * @drv: low level driver structure 2578 * 2579 * Remove all references to a driver from the core driver. The low 2580 * level driver must have removed all its ports via the 2581 * uart_remove_one_port() if it registered them with uart_add_one_port(). 2582 * (ie, drv->port == NULL) 2583 */ 2584 void uart_unregister_driver(struct uart_driver *drv) 2585 { 2586 struct tty_driver *p = drv->tty_driver; 2587 unsigned int i; 2588 2589 tty_unregister_driver(p); 2590 put_tty_driver(p); 2591 for (i = 0; i < drv->nr; i++) 2592 tty_port_destroy(&drv->state[i].port); 2593 kfree(drv->state); 2594 drv->state = NULL; 2595 drv->tty_driver = NULL; 2596 } 2597 2598 struct tty_driver *uart_console_device(struct console *co, int *index) 2599 { 2600 struct uart_driver *p = co->data; 2601 *index = co->index; 2602 return p->tty_driver; 2603 } 2604 2605 static ssize_t uart_get_attr_uartclk(struct device *dev, 2606 struct device_attribute *attr, char *buf) 2607 { 2608 struct serial_struct tmp; 2609 struct tty_port *port = dev_get_drvdata(dev); 2610 2611 uart_get_info(port, &tmp); 2612 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16); 2613 } 2614 2615 static ssize_t uart_get_attr_type(struct device *dev, 2616 struct device_attribute *attr, char *buf) 2617 { 2618 struct serial_struct tmp; 2619 struct tty_port *port = dev_get_drvdata(dev); 2620 2621 uart_get_info(port, &tmp); 2622 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type); 2623 } 2624 static ssize_t uart_get_attr_line(struct device *dev, 2625 struct device_attribute *attr, char *buf) 2626 { 2627 struct serial_struct tmp; 2628 struct tty_port *port = dev_get_drvdata(dev); 2629 2630 uart_get_info(port, &tmp); 2631 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line); 2632 } 2633 2634 static ssize_t uart_get_attr_port(struct device *dev, 2635 struct device_attribute *attr, char *buf) 2636 { 2637 struct serial_struct tmp; 2638 struct tty_port *port = dev_get_drvdata(dev); 2639 unsigned long ioaddr; 2640 2641 uart_get_info(port, &tmp); 2642 ioaddr = tmp.port; 2643 if (HIGH_BITS_OFFSET) 2644 ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET; 2645 return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr); 2646 } 2647 2648 static ssize_t uart_get_attr_irq(struct device *dev, 2649 struct device_attribute *attr, char *buf) 2650 { 2651 struct serial_struct tmp; 2652 struct tty_port *port = dev_get_drvdata(dev); 2653 2654 uart_get_info(port, &tmp); 2655 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq); 2656 } 2657 2658 static ssize_t uart_get_attr_flags(struct device *dev, 2659 struct device_attribute *attr, char *buf) 2660 { 2661 struct serial_struct tmp; 2662 struct tty_port *port = dev_get_drvdata(dev); 2663 2664 uart_get_info(port, &tmp); 2665 return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags); 2666 } 2667 2668 static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev, 2669 struct device_attribute *attr, char *buf) 2670 { 2671 struct serial_struct tmp; 2672 struct tty_port *port = dev_get_drvdata(dev); 2673 2674 uart_get_info(port, &tmp); 2675 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size); 2676 } 2677 2678 2679 static ssize_t uart_get_attr_close_delay(struct device *dev, 2680 struct device_attribute *attr, char *buf) 2681 { 2682 struct serial_struct tmp; 2683 struct tty_port *port = dev_get_drvdata(dev); 2684 2685 uart_get_info(port, &tmp); 2686 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay); 2687 } 2688 2689 2690 static ssize_t uart_get_attr_closing_wait(struct device *dev, 2691 struct device_attribute *attr, char *buf) 2692 { 2693 struct serial_struct tmp; 2694 struct tty_port *port = dev_get_drvdata(dev); 2695 2696 uart_get_info(port, &tmp); 2697 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait); 2698 } 2699 2700 static ssize_t uart_get_attr_custom_divisor(struct device *dev, 2701 struct device_attribute *attr, char *buf) 2702 { 2703 struct serial_struct tmp; 2704 struct tty_port *port = dev_get_drvdata(dev); 2705 2706 uart_get_info(port, &tmp); 2707 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor); 2708 } 2709 2710 static ssize_t uart_get_attr_io_type(struct device *dev, 2711 struct device_attribute *attr, char *buf) 2712 { 2713 struct serial_struct tmp; 2714 struct tty_port *port = dev_get_drvdata(dev); 2715 2716 uart_get_info(port, &tmp); 2717 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type); 2718 } 2719 2720 static ssize_t uart_get_attr_iomem_base(struct device *dev, 2721 struct device_attribute *attr, char *buf) 2722 { 2723 struct serial_struct tmp; 2724 struct tty_port *port = dev_get_drvdata(dev); 2725 2726 uart_get_info(port, &tmp); 2727 return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base); 2728 } 2729 2730 static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev, 2731 struct device_attribute *attr, char *buf) 2732 { 2733 struct serial_struct tmp; 2734 struct tty_port *port = dev_get_drvdata(dev); 2735 2736 uart_get_info(port, &tmp); 2737 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift); 2738 } 2739 2740 static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL); 2741 static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL); 2742 static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL); 2743 static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL); 2744 static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL); 2745 static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL); 2746 static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL); 2747 static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL); 2748 static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL); 2749 static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL); 2750 static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL); 2751 static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL); 2752 static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL); 2753 2754 static struct attribute *tty_dev_attrs[] = { 2755 &dev_attr_type.attr, 2756 &dev_attr_line.attr, 2757 &dev_attr_port.attr, 2758 &dev_attr_irq.attr, 2759 &dev_attr_flags.attr, 2760 &dev_attr_xmit_fifo_size.attr, 2761 &dev_attr_uartclk.attr, 2762 &dev_attr_close_delay.attr, 2763 &dev_attr_closing_wait.attr, 2764 &dev_attr_custom_divisor.attr, 2765 &dev_attr_io_type.attr, 2766 &dev_attr_iomem_base.attr, 2767 &dev_attr_iomem_reg_shift.attr, 2768 NULL, 2769 }; 2770 2771 static const struct attribute_group tty_dev_attr_group = { 2772 .attrs = tty_dev_attrs, 2773 }; 2774 2775 /** 2776 * uart_add_one_port - attach a driver-defined port structure 2777 * @drv: pointer to the uart low level driver structure for this port 2778 * @uport: uart port structure to use for this port. 2779 * 2780 * This allows the driver to register its own uart_port structure 2781 * with the core driver. The main purpose is to allow the low 2782 * level uart drivers to expand uart_port, rather than having yet 2783 * more levels of structures. 2784 */ 2785 int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport) 2786 { 2787 struct uart_state *state; 2788 struct tty_port *port; 2789 int ret = 0; 2790 struct device *tty_dev; 2791 int num_groups; 2792 2793 BUG_ON(in_interrupt()); 2794 2795 if (uport->line >= drv->nr) 2796 return -EINVAL; 2797 2798 state = drv->state + uport->line; 2799 port = &state->port; 2800 2801 mutex_lock(&port_mutex); 2802 mutex_lock(&port->mutex); 2803 if (state->uart_port) { 2804 ret = -EINVAL; 2805 goto out; 2806 } 2807 2808 /* Link the port to the driver state table and vice versa */ 2809 atomic_set(&state->refcount, 1); 2810 init_waitqueue_head(&state->remove_wait); 2811 state->uart_port = uport; 2812 uport->state = state; 2813 2814 state->pm_state = UART_PM_STATE_UNDEFINED; 2815 uport->cons = drv->cons; 2816 uport->minor = drv->tty_driver->minor_start + uport->line; 2817 uport->name = kasprintf(GFP_KERNEL, "%s%d", drv->dev_name, 2818 drv->tty_driver->name_base + uport->line); 2819 if (!uport->name) { 2820 ret = -ENOMEM; 2821 goto out; 2822 } 2823 2824 /* 2825 * If this port is a console, then the spinlock is already 2826 * initialised. 2827 */ 2828 if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) { 2829 spin_lock_init(&uport->lock); 2830 lockdep_set_class(&uport->lock, &port_lock_key); 2831 } 2832 if (uport->cons && uport->dev) 2833 of_console_check(uport->dev->of_node, uport->cons->name, uport->line); 2834 2835 uart_configure_port(drv, state, uport); 2836 2837 port->console = uart_console(uport); 2838 2839 num_groups = 2; 2840 if (uport->attr_group) 2841 num_groups++; 2842 2843 uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups), 2844 GFP_KERNEL); 2845 if (!uport->tty_groups) { 2846 ret = -ENOMEM; 2847 goto out; 2848 } 2849 uport->tty_groups[0] = &tty_dev_attr_group; 2850 if (uport->attr_group) 2851 uport->tty_groups[1] = uport->attr_group; 2852 2853 /* 2854 * Register the port whether it's detected or not. This allows 2855 * setserial to be used to alter this port's parameters. 2856 */ 2857 tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver, 2858 uport->line, uport->dev, port, uport->tty_groups); 2859 if (!IS_ERR(tty_dev)) { 2860 device_set_wakeup_capable(tty_dev, 1); 2861 } else { 2862 dev_err(uport->dev, "Cannot register tty device on line %d\n", 2863 uport->line); 2864 } 2865 2866 /* 2867 * Ensure UPF_DEAD is not set. 2868 */ 2869 uport->flags &= ~UPF_DEAD; 2870 2871 out: 2872 mutex_unlock(&port->mutex); 2873 mutex_unlock(&port_mutex); 2874 2875 return ret; 2876 } 2877 2878 /** 2879 * uart_remove_one_port - detach a driver defined port structure 2880 * @drv: pointer to the uart low level driver structure for this port 2881 * @uport: uart port structure for this port 2882 * 2883 * This unhooks (and hangs up) the specified port structure from the 2884 * core driver. No further calls will be made to the low-level code 2885 * for this port. 2886 */ 2887 int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport) 2888 { 2889 struct uart_state *state = drv->state + uport->line; 2890 struct tty_port *port = &state->port; 2891 struct uart_port *uart_port; 2892 struct tty_struct *tty; 2893 int ret = 0; 2894 2895 BUG_ON(in_interrupt()); 2896 2897 mutex_lock(&port_mutex); 2898 2899 /* 2900 * Mark the port "dead" - this prevents any opens from 2901 * succeeding while we shut down the port. 2902 */ 2903 mutex_lock(&port->mutex); 2904 uart_port = uart_port_check(state); 2905 if (uart_port != uport) 2906 dev_alert(uport->dev, "Removing wrong port: %p != %p\n", 2907 uart_port, uport); 2908 2909 if (!uart_port) { 2910 mutex_unlock(&port->mutex); 2911 ret = -EINVAL; 2912 goto out; 2913 } 2914 uport->flags |= UPF_DEAD; 2915 mutex_unlock(&port->mutex); 2916 2917 /* 2918 * Remove the devices from the tty layer 2919 */ 2920 tty_port_unregister_device(port, drv->tty_driver, uport->line); 2921 2922 tty = tty_port_tty_get(port); 2923 if (tty) { 2924 tty_vhangup(port->tty); 2925 tty_kref_put(tty); 2926 } 2927 2928 /* 2929 * If the port is used as a console, unregister it 2930 */ 2931 if (uart_console(uport)) 2932 unregister_console(uport->cons); 2933 2934 /* 2935 * Free the port IO and memory resources, if any. 2936 */ 2937 if (uport->type != PORT_UNKNOWN && uport->ops->release_port) 2938 uport->ops->release_port(uport); 2939 kfree(uport->tty_groups); 2940 kfree(uport->name); 2941 2942 /* 2943 * Indicate that there isn't a port here anymore. 2944 */ 2945 uport->type = PORT_UNKNOWN; 2946 2947 mutex_lock(&port->mutex); 2948 WARN_ON(atomic_dec_return(&state->refcount) < 0); 2949 wait_event(state->remove_wait, !atomic_read(&state->refcount)); 2950 state->uart_port = NULL; 2951 mutex_unlock(&port->mutex); 2952 out: 2953 mutex_unlock(&port_mutex); 2954 2955 return ret; 2956 } 2957 2958 /* 2959 * Are the two ports equivalent? 2960 */ 2961 int uart_match_port(struct uart_port *port1, struct uart_port *port2) 2962 { 2963 if (port1->iotype != port2->iotype) 2964 return 0; 2965 2966 switch (port1->iotype) { 2967 case UPIO_PORT: 2968 return (port1->iobase == port2->iobase); 2969 case UPIO_HUB6: 2970 return (port1->iobase == port2->iobase) && 2971 (port1->hub6 == port2->hub6); 2972 case UPIO_MEM: 2973 case UPIO_MEM16: 2974 case UPIO_MEM32: 2975 case UPIO_MEM32BE: 2976 case UPIO_AU: 2977 case UPIO_TSI: 2978 return (port1->mapbase == port2->mapbase); 2979 } 2980 return 0; 2981 } 2982 EXPORT_SYMBOL(uart_match_port); 2983 2984 /** 2985 * uart_handle_dcd_change - handle a change of carrier detect state 2986 * @uport: uart_port structure for the open port 2987 * @status: new carrier detect status, nonzero if active 2988 * 2989 * Caller must hold uport->lock 2990 */ 2991 void uart_handle_dcd_change(struct uart_port *uport, unsigned int status) 2992 { 2993 struct tty_port *port = &uport->state->port; 2994 struct tty_struct *tty = port->tty; 2995 struct tty_ldisc *ld; 2996 2997 lockdep_assert_held_once(&uport->lock); 2998 2999 if (tty) { 3000 ld = tty_ldisc_ref(tty); 3001 if (ld) { 3002 if (ld->ops->dcd_change) 3003 ld->ops->dcd_change(tty, status); 3004 tty_ldisc_deref(ld); 3005 } 3006 } 3007 3008 uport->icount.dcd++; 3009 3010 if (uart_dcd_enabled(uport)) { 3011 if (status) 3012 wake_up_interruptible(&port->open_wait); 3013 else if (tty) 3014 tty_hangup(tty); 3015 } 3016 } 3017 EXPORT_SYMBOL_GPL(uart_handle_dcd_change); 3018 3019 /** 3020 * uart_handle_cts_change - handle a change of clear-to-send state 3021 * @uport: uart_port structure for the open port 3022 * @status: new clear to send status, nonzero if active 3023 * 3024 * Caller must hold uport->lock 3025 */ 3026 void uart_handle_cts_change(struct uart_port *uport, unsigned int status) 3027 { 3028 lockdep_assert_held_once(&uport->lock); 3029 3030 uport->icount.cts++; 3031 3032 if (uart_softcts_mode(uport)) { 3033 if (uport->hw_stopped) { 3034 if (status) { 3035 uport->hw_stopped = 0; 3036 uport->ops->start_tx(uport); 3037 uart_write_wakeup(uport); 3038 } 3039 } else { 3040 if (!status) { 3041 uport->hw_stopped = 1; 3042 uport->ops->stop_tx(uport); 3043 } 3044 } 3045 3046 } 3047 } 3048 EXPORT_SYMBOL_GPL(uart_handle_cts_change); 3049 3050 /** 3051 * uart_insert_char - push a char to the uart layer 3052 * 3053 * User is responsible to call tty_flip_buffer_push when they are done with 3054 * insertion. 3055 * 3056 * @port: corresponding port 3057 * @status: state of the serial port RX buffer (LSR for 8250) 3058 * @overrun: mask of overrun bits in @status 3059 * @ch: character to push 3060 * @flag: flag for the character (see TTY_NORMAL and friends) 3061 */ 3062 void uart_insert_char(struct uart_port *port, unsigned int status, 3063 unsigned int overrun, unsigned int ch, unsigned int flag) 3064 { 3065 struct tty_port *tport = &port->state->port; 3066 3067 if ((status & port->ignore_status_mask & ~overrun) == 0) 3068 if (tty_insert_flip_char(tport, ch, flag) == 0) 3069 ++port->icount.buf_overrun; 3070 3071 /* 3072 * Overrun is special. Since it's reported immediately, 3073 * it doesn't affect the current character. 3074 */ 3075 if (status & ~port->ignore_status_mask & overrun) 3076 if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0) 3077 ++port->icount.buf_overrun; 3078 } 3079 EXPORT_SYMBOL_GPL(uart_insert_char); 3080 3081 EXPORT_SYMBOL(uart_write_wakeup); 3082 EXPORT_SYMBOL(uart_register_driver); 3083 EXPORT_SYMBOL(uart_unregister_driver); 3084 EXPORT_SYMBOL(uart_suspend_port); 3085 EXPORT_SYMBOL(uart_resume_port); 3086 EXPORT_SYMBOL(uart_add_one_port); 3087 EXPORT_SYMBOL(uart_remove_one_port); 3088 3089 /** 3090 * uart_get_rs485_mode() - retrieve rs485 properties for given uart 3091 * @dev: uart device 3092 * @rs485conf: output parameter 3093 * 3094 * This function implements the device tree binding described in 3095 * Documentation/devicetree/bindings/serial/rs485.txt. 3096 */ 3097 void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf) 3098 { 3099 u32 rs485_delay[2]; 3100 int ret; 3101 3102 ret = device_property_read_u32_array(dev, "rs485-rts-delay", 3103 rs485_delay, 2); 3104 if (!ret) { 3105 rs485conf->delay_rts_before_send = rs485_delay[0]; 3106 rs485conf->delay_rts_after_send = rs485_delay[1]; 3107 } else { 3108 rs485conf->delay_rts_before_send = 0; 3109 rs485conf->delay_rts_after_send = 0; 3110 } 3111 3112 /* 3113 * Clear full-duplex and enabled flags, set RTS polarity to active high 3114 * to get to a defined state with the following properties: 3115 */ 3116 rs485conf->flags &= ~(SER_RS485_RX_DURING_TX | SER_RS485_ENABLED | 3117 SER_RS485_RTS_AFTER_SEND); 3118 rs485conf->flags |= SER_RS485_RTS_ON_SEND; 3119 3120 if (device_property_read_bool(dev, "rs485-rx-during-tx")) 3121 rs485conf->flags |= SER_RS485_RX_DURING_TX; 3122 3123 if (device_property_read_bool(dev, "linux,rs485-enabled-at-boot-time")) 3124 rs485conf->flags |= SER_RS485_ENABLED; 3125 3126 if (device_property_read_bool(dev, "rs485-rts-active-low")) { 3127 rs485conf->flags &= ~SER_RS485_RTS_ON_SEND; 3128 rs485conf->flags |= SER_RS485_RTS_AFTER_SEND; 3129 } 3130 } 3131 EXPORT_SYMBOL_GPL(uart_get_rs485_mode); 3132 3133 MODULE_DESCRIPTION("Serial driver core"); 3134 MODULE_LICENSE("GPL"); 3135