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 && uport->ops->break_ctl) 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 * 1968 * earlycon=<name>,0x<addr>,<options> 1969 * console=<name>,0x<addr>,<options> 1970 * 1971 * is also accepted; the returned @iotype will be UPIO_MEM. 1972 * 1973 * Returns 0 on success or -EINVAL on failure 1974 */ 1975 int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr, 1976 char **options) 1977 { 1978 if (strncmp(p, "mmio,", 5) == 0) { 1979 *iotype = UPIO_MEM; 1980 p += 5; 1981 } else if (strncmp(p, "mmio16,", 7) == 0) { 1982 *iotype = UPIO_MEM16; 1983 p += 7; 1984 } else if (strncmp(p, "mmio32,", 7) == 0) { 1985 *iotype = UPIO_MEM32; 1986 p += 7; 1987 } else if (strncmp(p, "mmio32be,", 9) == 0) { 1988 *iotype = UPIO_MEM32BE; 1989 p += 9; 1990 } else if (strncmp(p, "mmio32native,", 13) == 0) { 1991 *iotype = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) ? 1992 UPIO_MEM32BE : UPIO_MEM32; 1993 p += 13; 1994 } else if (strncmp(p, "io,", 3) == 0) { 1995 *iotype = UPIO_PORT; 1996 p += 3; 1997 } else if (strncmp(p, "0x", 2) == 0) { 1998 *iotype = UPIO_MEM; 1999 } else { 2000 return -EINVAL; 2001 } 2002 2003 /* 2004 * Before you replace it with kstrtoull(), think about options separator 2005 * (',') it will not tolerate 2006 */ 2007 *addr = simple_strtoull(p, NULL, 0); 2008 p = strchr(p, ','); 2009 if (p) 2010 p++; 2011 2012 *options = p; 2013 return 0; 2014 } 2015 EXPORT_SYMBOL_GPL(uart_parse_earlycon); 2016 2017 /** 2018 * uart_parse_options - Parse serial port baud/parity/bits/flow control. 2019 * @options: pointer to option string 2020 * @baud: pointer to an 'int' variable for the baud rate. 2021 * @parity: pointer to an 'int' variable for the parity. 2022 * @bits: pointer to an 'int' variable for the number of data bits. 2023 * @flow: pointer to an 'int' variable for the flow control character. 2024 * 2025 * uart_parse_options decodes a string containing the serial console 2026 * options. The format of the string is <baud><parity><bits><flow>, 2027 * eg: 115200n8r 2028 */ 2029 void 2030 uart_parse_options(const char *options, int *baud, int *parity, 2031 int *bits, int *flow) 2032 { 2033 const char *s = options; 2034 2035 *baud = simple_strtoul(s, NULL, 10); 2036 while (*s >= '0' && *s <= '9') 2037 s++; 2038 if (*s) 2039 *parity = *s++; 2040 if (*s) 2041 *bits = *s++ - '0'; 2042 if (*s) 2043 *flow = *s; 2044 } 2045 EXPORT_SYMBOL_GPL(uart_parse_options); 2046 2047 /** 2048 * uart_set_options - setup the serial console parameters 2049 * @port: pointer to the serial ports uart_port structure 2050 * @co: console pointer 2051 * @baud: baud rate 2052 * @parity: parity character - 'n' (none), 'o' (odd), 'e' (even) 2053 * @bits: number of data bits 2054 * @flow: flow control character - 'r' (rts) 2055 */ 2056 int 2057 uart_set_options(struct uart_port *port, struct console *co, 2058 int baud, int parity, int bits, int flow) 2059 { 2060 struct ktermios termios; 2061 static struct ktermios dummy; 2062 2063 /* 2064 * Ensure that the serial console lock is initialised 2065 * early. 2066 * If this port is a console, then the spinlock is already 2067 * initialised. 2068 */ 2069 if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) { 2070 spin_lock_init(&port->lock); 2071 lockdep_set_class(&port->lock, &port_lock_key); 2072 } 2073 2074 memset(&termios, 0, sizeof(struct ktermios)); 2075 2076 termios.c_cflag |= CREAD | HUPCL | CLOCAL; 2077 tty_termios_encode_baud_rate(&termios, baud, baud); 2078 2079 if (bits == 7) 2080 termios.c_cflag |= CS7; 2081 else 2082 termios.c_cflag |= CS8; 2083 2084 switch (parity) { 2085 case 'o': case 'O': 2086 termios.c_cflag |= PARODD; 2087 /*fall through*/ 2088 case 'e': case 'E': 2089 termios.c_cflag |= PARENB; 2090 break; 2091 } 2092 2093 if (flow == 'r') 2094 termios.c_cflag |= CRTSCTS; 2095 2096 /* 2097 * some uarts on other side don't support no flow control. 2098 * So we set * DTR in host uart to make them happy 2099 */ 2100 port->mctrl |= TIOCM_DTR; 2101 2102 port->ops->set_termios(port, &termios, &dummy); 2103 /* 2104 * Allow the setting of the UART parameters with a NULL console 2105 * too: 2106 */ 2107 if (co) 2108 co->cflag = termios.c_cflag; 2109 2110 return 0; 2111 } 2112 EXPORT_SYMBOL_GPL(uart_set_options); 2113 #endif /* CONFIG_SERIAL_CORE_CONSOLE */ 2114 2115 /** 2116 * uart_change_pm - set power state of the port 2117 * 2118 * @state: port descriptor 2119 * @pm_state: new state 2120 * 2121 * Locking: port->mutex has to be held 2122 */ 2123 static void uart_change_pm(struct uart_state *state, 2124 enum uart_pm_state pm_state) 2125 { 2126 struct uart_port *port = uart_port_check(state); 2127 2128 if (state->pm_state != pm_state) { 2129 if (port && port->ops->pm) 2130 port->ops->pm(port, pm_state, state->pm_state); 2131 state->pm_state = pm_state; 2132 } 2133 } 2134 2135 struct uart_match { 2136 struct uart_port *port; 2137 struct uart_driver *driver; 2138 }; 2139 2140 static int serial_match_port(struct device *dev, void *data) 2141 { 2142 struct uart_match *match = data; 2143 struct tty_driver *tty_drv = match->driver->tty_driver; 2144 dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) + 2145 match->port->line; 2146 2147 return dev->devt == devt; /* Actually, only one tty per port */ 2148 } 2149 2150 int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport) 2151 { 2152 struct uart_state *state = drv->state + uport->line; 2153 struct tty_port *port = &state->port; 2154 struct device *tty_dev; 2155 struct uart_match match = {uport, drv}; 2156 2157 mutex_lock(&port->mutex); 2158 2159 tty_dev = device_find_child(uport->dev, &match, serial_match_port); 2160 if (tty_dev && device_may_wakeup(tty_dev)) { 2161 enable_irq_wake(uport->irq); 2162 put_device(tty_dev); 2163 mutex_unlock(&port->mutex); 2164 return 0; 2165 } 2166 put_device(tty_dev); 2167 2168 /* Nothing to do if the console is not suspending */ 2169 if (!console_suspend_enabled && uart_console(uport)) 2170 goto unlock; 2171 2172 uport->suspended = 1; 2173 2174 if (tty_port_initialized(port)) { 2175 const struct uart_ops *ops = uport->ops; 2176 int tries; 2177 2178 tty_port_set_suspended(port, 1); 2179 tty_port_set_initialized(port, 0); 2180 2181 spin_lock_irq(&uport->lock); 2182 ops->stop_tx(uport); 2183 ops->set_mctrl(uport, 0); 2184 ops->stop_rx(uport); 2185 spin_unlock_irq(&uport->lock); 2186 2187 /* 2188 * Wait for the transmitter to empty. 2189 */ 2190 for (tries = 3; !ops->tx_empty(uport) && tries; tries--) 2191 msleep(10); 2192 if (!tries) 2193 dev_err(uport->dev, "%s: Unable to drain transmitter\n", 2194 uport->name); 2195 2196 ops->shutdown(uport); 2197 } 2198 2199 /* 2200 * Disable the console device before suspending. 2201 */ 2202 if (uart_console(uport)) 2203 console_stop(uport->cons); 2204 2205 uart_change_pm(state, UART_PM_STATE_OFF); 2206 unlock: 2207 mutex_unlock(&port->mutex); 2208 2209 return 0; 2210 } 2211 2212 int uart_resume_port(struct uart_driver *drv, struct uart_port *uport) 2213 { 2214 struct uart_state *state = drv->state + uport->line; 2215 struct tty_port *port = &state->port; 2216 struct device *tty_dev; 2217 struct uart_match match = {uport, drv}; 2218 struct ktermios termios; 2219 2220 mutex_lock(&port->mutex); 2221 2222 tty_dev = device_find_child(uport->dev, &match, serial_match_port); 2223 if (!uport->suspended && device_may_wakeup(tty_dev)) { 2224 if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) 2225 disable_irq_wake(uport->irq); 2226 put_device(tty_dev); 2227 mutex_unlock(&port->mutex); 2228 return 0; 2229 } 2230 put_device(tty_dev); 2231 uport->suspended = 0; 2232 2233 /* 2234 * Re-enable the console device after suspending. 2235 */ 2236 if (uart_console(uport)) { 2237 /* 2238 * First try to use the console cflag setting. 2239 */ 2240 memset(&termios, 0, sizeof(struct ktermios)); 2241 termios.c_cflag = uport->cons->cflag; 2242 2243 /* 2244 * If that's unset, use the tty termios setting. 2245 */ 2246 if (port->tty && termios.c_cflag == 0) 2247 termios = port->tty->termios; 2248 2249 if (console_suspend_enabled) 2250 uart_change_pm(state, UART_PM_STATE_ON); 2251 uport->ops->set_termios(uport, &termios, NULL); 2252 if (console_suspend_enabled) 2253 console_start(uport->cons); 2254 } 2255 2256 if (tty_port_suspended(port)) { 2257 const struct uart_ops *ops = uport->ops; 2258 int ret; 2259 2260 uart_change_pm(state, UART_PM_STATE_ON); 2261 spin_lock_irq(&uport->lock); 2262 ops->set_mctrl(uport, 0); 2263 spin_unlock_irq(&uport->lock); 2264 if (console_suspend_enabled || !uart_console(uport)) { 2265 /* Protected by port mutex for now */ 2266 struct tty_struct *tty = port->tty; 2267 ret = ops->startup(uport); 2268 if (ret == 0) { 2269 if (tty) 2270 uart_change_speed(tty, state, NULL); 2271 spin_lock_irq(&uport->lock); 2272 ops->set_mctrl(uport, uport->mctrl); 2273 ops->start_tx(uport); 2274 spin_unlock_irq(&uport->lock); 2275 tty_port_set_initialized(port, 1); 2276 } else { 2277 /* 2278 * Failed to resume - maybe hardware went away? 2279 * Clear the "initialized" flag so we won't try 2280 * to call the low level drivers shutdown method. 2281 */ 2282 uart_shutdown(tty, state); 2283 } 2284 } 2285 2286 tty_port_set_suspended(port, 0); 2287 } 2288 2289 mutex_unlock(&port->mutex); 2290 2291 return 0; 2292 } 2293 2294 static inline void 2295 uart_report_port(struct uart_driver *drv, struct uart_port *port) 2296 { 2297 char address[64]; 2298 2299 switch (port->iotype) { 2300 case UPIO_PORT: 2301 snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase); 2302 break; 2303 case UPIO_HUB6: 2304 snprintf(address, sizeof(address), 2305 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6); 2306 break; 2307 case UPIO_MEM: 2308 case UPIO_MEM16: 2309 case UPIO_MEM32: 2310 case UPIO_MEM32BE: 2311 case UPIO_AU: 2312 case UPIO_TSI: 2313 snprintf(address, sizeof(address), 2314 "MMIO 0x%llx", (unsigned long long)port->mapbase); 2315 break; 2316 default: 2317 strlcpy(address, "*unknown*", sizeof(address)); 2318 break; 2319 } 2320 2321 pr_info("%s%s%s at %s (irq = %d, base_baud = %d) is a %s\n", 2322 port->dev ? dev_name(port->dev) : "", 2323 port->dev ? ": " : "", 2324 port->name, 2325 address, port->irq, port->uartclk / 16, uart_type(port)); 2326 } 2327 2328 static void 2329 uart_configure_port(struct uart_driver *drv, struct uart_state *state, 2330 struct uart_port *port) 2331 { 2332 unsigned int flags; 2333 2334 /* 2335 * If there isn't a port here, don't do anything further. 2336 */ 2337 if (!port->iobase && !port->mapbase && !port->membase) 2338 return; 2339 2340 /* 2341 * Now do the auto configuration stuff. Note that config_port 2342 * is expected to claim the resources and map the port for us. 2343 */ 2344 flags = 0; 2345 if (port->flags & UPF_AUTO_IRQ) 2346 flags |= UART_CONFIG_IRQ; 2347 if (port->flags & UPF_BOOT_AUTOCONF) { 2348 if (!(port->flags & UPF_FIXED_TYPE)) { 2349 port->type = PORT_UNKNOWN; 2350 flags |= UART_CONFIG_TYPE; 2351 } 2352 port->ops->config_port(port, flags); 2353 } 2354 2355 if (port->type != PORT_UNKNOWN) { 2356 unsigned long flags; 2357 2358 uart_report_port(drv, port); 2359 2360 /* Power up port for set_mctrl() */ 2361 uart_change_pm(state, UART_PM_STATE_ON); 2362 2363 /* 2364 * Ensure that the modem control lines are de-activated. 2365 * keep the DTR setting that is set in uart_set_options() 2366 * We probably don't need a spinlock around this, but 2367 */ 2368 spin_lock_irqsave(&port->lock, flags); 2369 port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR); 2370 spin_unlock_irqrestore(&port->lock, flags); 2371 2372 /* 2373 * If this driver supports console, and it hasn't been 2374 * successfully registered yet, try to re-register it. 2375 * It may be that the port was not available. 2376 */ 2377 if (port->cons && !(port->cons->flags & CON_ENABLED)) 2378 register_console(port->cons); 2379 2380 /* 2381 * Power down all ports by default, except the 2382 * console if we have one. 2383 */ 2384 if (!uart_console(port)) 2385 uart_change_pm(state, UART_PM_STATE_OFF); 2386 } 2387 } 2388 2389 #ifdef CONFIG_CONSOLE_POLL 2390 2391 static int uart_poll_init(struct tty_driver *driver, int line, char *options) 2392 { 2393 struct uart_driver *drv = driver->driver_state; 2394 struct uart_state *state = drv->state + line; 2395 struct tty_port *tport; 2396 struct uart_port *port; 2397 int baud = 9600; 2398 int bits = 8; 2399 int parity = 'n'; 2400 int flow = 'n'; 2401 int ret = 0; 2402 2403 tport = &state->port; 2404 mutex_lock(&tport->mutex); 2405 2406 port = uart_port_check(state); 2407 if (!port || !(port->ops->poll_get_char && port->ops->poll_put_char)) { 2408 ret = -1; 2409 goto out; 2410 } 2411 2412 if (port->ops->poll_init) { 2413 /* 2414 * We don't set initialized as we only initialized the hw, 2415 * e.g. state->xmit is still uninitialized. 2416 */ 2417 if (!tty_port_initialized(tport)) 2418 ret = port->ops->poll_init(port); 2419 } 2420 2421 if (!ret && options) { 2422 uart_parse_options(options, &baud, &parity, &bits, &flow); 2423 ret = uart_set_options(port, NULL, baud, parity, bits, flow); 2424 } 2425 out: 2426 mutex_unlock(&tport->mutex); 2427 return ret; 2428 } 2429 2430 static int uart_poll_get_char(struct tty_driver *driver, int line) 2431 { 2432 struct uart_driver *drv = driver->driver_state; 2433 struct uart_state *state = drv->state + line; 2434 struct uart_port *port; 2435 int ret = -1; 2436 2437 port = uart_port_ref(state); 2438 if (port) { 2439 ret = port->ops->poll_get_char(port); 2440 uart_port_deref(port); 2441 } 2442 2443 return ret; 2444 } 2445 2446 static void uart_poll_put_char(struct tty_driver *driver, int line, char ch) 2447 { 2448 struct uart_driver *drv = driver->driver_state; 2449 struct uart_state *state = drv->state + line; 2450 struct uart_port *port; 2451 2452 port = uart_port_ref(state); 2453 if (!port) 2454 return; 2455 2456 if (ch == '\n') 2457 port->ops->poll_put_char(port, '\r'); 2458 port->ops->poll_put_char(port, ch); 2459 uart_port_deref(port); 2460 } 2461 #endif 2462 2463 static const struct tty_operations uart_ops = { 2464 .install = uart_install, 2465 .open = uart_open, 2466 .close = uart_close, 2467 .write = uart_write, 2468 .put_char = uart_put_char, 2469 .flush_chars = uart_flush_chars, 2470 .write_room = uart_write_room, 2471 .chars_in_buffer= uart_chars_in_buffer, 2472 .flush_buffer = uart_flush_buffer, 2473 .ioctl = uart_ioctl, 2474 .throttle = uart_throttle, 2475 .unthrottle = uart_unthrottle, 2476 .send_xchar = uart_send_xchar, 2477 .set_termios = uart_set_termios, 2478 .set_ldisc = uart_set_ldisc, 2479 .stop = uart_stop, 2480 .start = uart_start, 2481 .hangup = uart_hangup, 2482 .break_ctl = uart_break_ctl, 2483 .wait_until_sent= uart_wait_until_sent, 2484 #ifdef CONFIG_PROC_FS 2485 .proc_show = uart_proc_show, 2486 #endif 2487 .tiocmget = uart_tiocmget, 2488 .tiocmset = uart_tiocmset, 2489 .set_serial = uart_set_info_user, 2490 .get_serial = uart_get_info_user, 2491 .get_icount = uart_get_icount, 2492 #ifdef CONFIG_CONSOLE_POLL 2493 .poll_init = uart_poll_init, 2494 .poll_get_char = uart_poll_get_char, 2495 .poll_put_char = uart_poll_put_char, 2496 #endif 2497 }; 2498 2499 static const struct tty_port_operations uart_port_ops = { 2500 .carrier_raised = uart_carrier_raised, 2501 .dtr_rts = uart_dtr_rts, 2502 .activate = uart_port_activate, 2503 .shutdown = uart_tty_port_shutdown, 2504 }; 2505 2506 /** 2507 * uart_register_driver - register a driver with the uart core layer 2508 * @drv: low level driver structure 2509 * 2510 * Register a uart driver with the core driver. We in turn register 2511 * with the tty layer, and initialise the core driver per-port state. 2512 * 2513 * We have a proc file in /proc/tty/driver which is named after the 2514 * normal driver. 2515 * 2516 * drv->port should be NULL, and the per-port structures should be 2517 * registered using uart_add_one_port after this call has succeeded. 2518 */ 2519 int uart_register_driver(struct uart_driver *drv) 2520 { 2521 struct tty_driver *normal; 2522 int i, retval = -ENOMEM; 2523 2524 BUG_ON(drv->state); 2525 2526 /* 2527 * Maybe we should be using a slab cache for this, especially if 2528 * we have a large number of ports to handle. 2529 */ 2530 drv->state = kcalloc(drv->nr, sizeof(struct uart_state), GFP_KERNEL); 2531 if (!drv->state) 2532 goto out; 2533 2534 normal = alloc_tty_driver(drv->nr); 2535 if (!normal) 2536 goto out_kfree; 2537 2538 drv->tty_driver = normal; 2539 2540 normal->driver_name = drv->driver_name; 2541 normal->name = drv->dev_name; 2542 normal->major = drv->major; 2543 normal->minor_start = drv->minor; 2544 normal->type = TTY_DRIVER_TYPE_SERIAL; 2545 normal->subtype = SERIAL_TYPE_NORMAL; 2546 normal->init_termios = tty_std_termios; 2547 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 2548 normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600; 2549 normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 2550 normal->driver_state = drv; 2551 tty_set_operations(normal, &uart_ops); 2552 2553 /* 2554 * Initialise the UART state(s). 2555 */ 2556 for (i = 0; i < drv->nr; i++) { 2557 struct uart_state *state = drv->state + i; 2558 struct tty_port *port = &state->port; 2559 2560 tty_port_init(port); 2561 port->ops = &uart_port_ops; 2562 } 2563 2564 retval = tty_register_driver(normal); 2565 if (retval >= 0) 2566 return retval; 2567 2568 for (i = 0; i < drv->nr; i++) 2569 tty_port_destroy(&drv->state[i].port); 2570 put_tty_driver(normal); 2571 out_kfree: 2572 kfree(drv->state); 2573 out: 2574 return retval; 2575 } 2576 2577 /** 2578 * uart_unregister_driver - remove a driver from the uart core layer 2579 * @drv: low level driver structure 2580 * 2581 * Remove all references to a driver from the core driver. The low 2582 * level driver must have removed all its ports via the 2583 * uart_remove_one_port() if it registered them with uart_add_one_port(). 2584 * (ie, drv->port == NULL) 2585 */ 2586 void uart_unregister_driver(struct uart_driver *drv) 2587 { 2588 struct tty_driver *p = drv->tty_driver; 2589 unsigned int i; 2590 2591 tty_unregister_driver(p); 2592 put_tty_driver(p); 2593 for (i = 0; i < drv->nr; i++) 2594 tty_port_destroy(&drv->state[i].port); 2595 kfree(drv->state); 2596 drv->state = NULL; 2597 drv->tty_driver = NULL; 2598 } 2599 2600 struct tty_driver *uart_console_device(struct console *co, int *index) 2601 { 2602 struct uart_driver *p = co->data; 2603 *index = co->index; 2604 return p->tty_driver; 2605 } 2606 EXPORT_SYMBOL_GPL(uart_console_device); 2607 2608 static ssize_t uart_get_attr_uartclk(struct device *dev, 2609 struct device_attribute *attr, char *buf) 2610 { 2611 struct serial_struct tmp; 2612 struct tty_port *port = dev_get_drvdata(dev); 2613 2614 uart_get_info(port, &tmp); 2615 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16); 2616 } 2617 2618 static ssize_t uart_get_attr_type(struct device *dev, 2619 struct device_attribute *attr, char *buf) 2620 { 2621 struct serial_struct tmp; 2622 struct tty_port *port = dev_get_drvdata(dev); 2623 2624 uart_get_info(port, &tmp); 2625 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type); 2626 } 2627 static ssize_t uart_get_attr_line(struct device *dev, 2628 struct device_attribute *attr, char *buf) 2629 { 2630 struct serial_struct tmp; 2631 struct tty_port *port = dev_get_drvdata(dev); 2632 2633 uart_get_info(port, &tmp); 2634 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line); 2635 } 2636 2637 static ssize_t uart_get_attr_port(struct device *dev, 2638 struct device_attribute *attr, char *buf) 2639 { 2640 struct serial_struct tmp; 2641 struct tty_port *port = dev_get_drvdata(dev); 2642 unsigned long ioaddr; 2643 2644 uart_get_info(port, &tmp); 2645 ioaddr = tmp.port; 2646 if (HIGH_BITS_OFFSET) 2647 ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET; 2648 return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr); 2649 } 2650 2651 static ssize_t uart_get_attr_irq(struct device *dev, 2652 struct device_attribute *attr, char *buf) 2653 { 2654 struct serial_struct tmp; 2655 struct tty_port *port = dev_get_drvdata(dev); 2656 2657 uart_get_info(port, &tmp); 2658 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq); 2659 } 2660 2661 static ssize_t uart_get_attr_flags(struct device *dev, 2662 struct device_attribute *attr, char *buf) 2663 { 2664 struct serial_struct tmp; 2665 struct tty_port *port = dev_get_drvdata(dev); 2666 2667 uart_get_info(port, &tmp); 2668 return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags); 2669 } 2670 2671 static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev, 2672 struct device_attribute *attr, char *buf) 2673 { 2674 struct serial_struct tmp; 2675 struct tty_port *port = dev_get_drvdata(dev); 2676 2677 uart_get_info(port, &tmp); 2678 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size); 2679 } 2680 2681 2682 static ssize_t uart_get_attr_close_delay(struct device *dev, 2683 struct device_attribute *attr, char *buf) 2684 { 2685 struct serial_struct tmp; 2686 struct tty_port *port = dev_get_drvdata(dev); 2687 2688 uart_get_info(port, &tmp); 2689 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay); 2690 } 2691 2692 2693 static ssize_t uart_get_attr_closing_wait(struct device *dev, 2694 struct device_attribute *attr, char *buf) 2695 { 2696 struct serial_struct tmp; 2697 struct tty_port *port = dev_get_drvdata(dev); 2698 2699 uart_get_info(port, &tmp); 2700 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait); 2701 } 2702 2703 static ssize_t uart_get_attr_custom_divisor(struct device *dev, 2704 struct device_attribute *attr, char *buf) 2705 { 2706 struct serial_struct tmp; 2707 struct tty_port *port = dev_get_drvdata(dev); 2708 2709 uart_get_info(port, &tmp); 2710 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor); 2711 } 2712 2713 static ssize_t uart_get_attr_io_type(struct device *dev, 2714 struct device_attribute *attr, char *buf) 2715 { 2716 struct serial_struct tmp; 2717 struct tty_port *port = dev_get_drvdata(dev); 2718 2719 uart_get_info(port, &tmp); 2720 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type); 2721 } 2722 2723 static ssize_t uart_get_attr_iomem_base(struct device *dev, 2724 struct device_attribute *attr, char *buf) 2725 { 2726 struct serial_struct tmp; 2727 struct tty_port *port = dev_get_drvdata(dev); 2728 2729 uart_get_info(port, &tmp); 2730 return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base); 2731 } 2732 2733 static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev, 2734 struct device_attribute *attr, char *buf) 2735 { 2736 struct serial_struct tmp; 2737 struct tty_port *port = dev_get_drvdata(dev); 2738 2739 uart_get_info(port, &tmp); 2740 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift); 2741 } 2742 2743 static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL); 2744 static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL); 2745 static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL); 2746 static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL); 2747 static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL); 2748 static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL); 2749 static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL); 2750 static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL); 2751 static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL); 2752 static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL); 2753 static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL); 2754 static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL); 2755 static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL); 2756 2757 static struct attribute *tty_dev_attrs[] = { 2758 &dev_attr_type.attr, 2759 &dev_attr_line.attr, 2760 &dev_attr_port.attr, 2761 &dev_attr_irq.attr, 2762 &dev_attr_flags.attr, 2763 &dev_attr_xmit_fifo_size.attr, 2764 &dev_attr_uartclk.attr, 2765 &dev_attr_close_delay.attr, 2766 &dev_attr_closing_wait.attr, 2767 &dev_attr_custom_divisor.attr, 2768 &dev_attr_io_type.attr, 2769 &dev_attr_iomem_base.attr, 2770 &dev_attr_iomem_reg_shift.attr, 2771 NULL, 2772 }; 2773 2774 static const struct attribute_group tty_dev_attr_group = { 2775 .attrs = tty_dev_attrs, 2776 }; 2777 2778 /** 2779 * uart_add_one_port - attach a driver-defined port structure 2780 * @drv: pointer to the uart low level driver structure for this port 2781 * @uport: uart port structure to use for this port. 2782 * 2783 * This allows the driver to register its own uart_port structure 2784 * with the core driver. The main purpose is to allow the low 2785 * level uart drivers to expand uart_port, rather than having yet 2786 * more levels of structures. 2787 */ 2788 int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport) 2789 { 2790 struct uart_state *state; 2791 struct tty_port *port; 2792 int ret = 0; 2793 struct device *tty_dev; 2794 int num_groups; 2795 2796 BUG_ON(in_interrupt()); 2797 2798 if (uport->line >= drv->nr) 2799 return -EINVAL; 2800 2801 state = drv->state + uport->line; 2802 port = &state->port; 2803 2804 mutex_lock(&port_mutex); 2805 mutex_lock(&port->mutex); 2806 if (state->uart_port) { 2807 ret = -EINVAL; 2808 goto out; 2809 } 2810 2811 /* Link the port to the driver state table and vice versa */ 2812 atomic_set(&state->refcount, 1); 2813 init_waitqueue_head(&state->remove_wait); 2814 state->uart_port = uport; 2815 uport->state = state; 2816 2817 state->pm_state = UART_PM_STATE_UNDEFINED; 2818 uport->cons = drv->cons; 2819 uport->minor = drv->tty_driver->minor_start + uport->line; 2820 uport->name = kasprintf(GFP_KERNEL, "%s%d", drv->dev_name, 2821 drv->tty_driver->name_base + uport->line); 2822 if (!uport->name) { 2823 ret = -ENOMEM; 2824 goto out; 2825 } 2826 2827 /* 2828 * If this port is a console, then the spinlock is already 2829 * initialised. 2830 */ 2831 if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) { 2832 spin_lock_init(&uport->lock); 2833 lockdep_set_class(&uport->lock, &port_lock_key); 2834 } 2835 if (uport->cons && uport->dev) 2836 of_console_check(uport->dev->of_node, uport->cons->name, uport->line); 2837 2838 tty_port_link_device(port, drv->tty_driver, uport->line); 2839 uart_configure_port(drv, state, uport); 2840 2841 port->console = uart_console(uport); 2842 2843 num_groups = 2; 2844 if (uport->attr_group) 2845 num_groups++; 2846 2847 uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups), 2848 GFP_KERNEL); 2849 if (!uport->tty_groups) { 2850 ret = -ENOMEM; 2851 goto out; 2852 } 2853 uport->tty_groups[0] = &tty_dev_attr_group; 2854 if (uport->attr_group) 2855 uport->tty_groups[1] = uport->attr_group; 2856 2857 /* 2858 * Register the port whether it's detected or not. This allows 2859 * setserial to be used to alter this port's parameters. 2860 */ 2861 tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver, 2862 uport->line, uport->dev, port, uport->tty_groups); 2863 if (!IS_ERR(tty_dev)) { 2864 device_set_wakeup_capable(tty_dev, 1); 2865 } else { 2866 dev_err(uport->dev, "Cannot register tty device on line %d\n", 2867 uport->line); 2868 } 2869 2870 /* 2871 * Ensure UPF_DEAD is not set. 2872 */ 2873 uport->flags &= ~UPF_DEAD; 2874 2875 out: 2876 mutex_unlock(&port->mutex); 2877 mutex_unlock(&port_mutex); 2878 2879 return ret; 2880 } 2881 2882 /** 2883 * uart_remove_one_port - detach a driver defined port structure 2884 * @drv: pointer to the uart low level driver structure for this port 2885 * @uport: uart port structure for this port 2886 * 2887 * This unhooks (and hangs up) the specified port structure from the 2888 * core driver. No further calls will be made to the low-level code 2889 * for this port. 2890 */ 2891 int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport) 2892 { 2893 struct uart_state *state = drv->state + uport->line; 2894 struct tty_port *port = &state->port; 2895 struct uart_port *uart_port; 2896 struct tty_struct *tty; 2897 int ret = 0; 2898 2899 BUG_ON(in_interrupt()); 2900 2901 mutex_lock(&port_mutex); 2902 2903 /* 2904 * Mark the port "dead" - this prevents any opens from 2905 * succeeding while we shut down the port. 2906 */ 2907 mutex_lock(&port->mutex); 2908 uart_port = uart_port_check(state); 2909 if (uart_port != uport) 2910 dev_alert(uport->dev, "Removing wrong port: %p != %p\n", 2911 uart_port, uport); 2912 2913 if (!uart_port) { 2914 mutex_unlock(&port->mutex); 2915 ret = -EINVAL; 2916 goto out; 2917 } 2918 uport->flags |= UPF_DEAD; 2919 mutex_unlock(&port->mutex); 2920 2921 /* 2922 * Remove the devices from the tty layer 2923 */ 2924 tty_port_unregister_device(port, drv->tty_driver, uport->line); 2925 2926 tty = tty_port_tty_get(port); 2927 if (tty) { 2928 tty_vhangup(port->tty); 2929 tty_kref_put(tty); 2930 } 2931 2932 /* 2933 * If the port is used as a console, unregister it 2934 */ 2935 if (uart_console(uport)) 2936 unregister_console(uport->cons); 2937 2938 /* 2939 * Free the port IO and memory resources, if any. 2940 */ 2941 if (uport->type != PORT_UNKNOWN && uport->ops->release_port) 2942 uport->ops->release_port(uport); 2943 kfree(uport->tty_groups); 2944 kfree(uport->name); 2945 2946 /* 2947 * Indicate that there isn't a port here anymore. 2948 */ 2949 uport->type = PORT_UNKNOWN; 2950 2951 mutex_lock(&port->mutex); 2952 WARN_ON(atomic_dec_return(&state->refcount) < 0); 2953 wait_event(state->remove_wait, !atomic_read(&state->refcount)); 2954 state->uart_port = NULL; 2955 mutex_unlock(&port->mutex); 2956 out: 2957 mutex_unlock(&port_mutex); 2958 2959 return ret; 2960 } 2961 2962 /* 2963 * Are the two ports equivalent? 2964 */ 2965 int uart_match_port(struct uart_port *port1, struct uart_port *port2) 2966 { 2967 if (port1->iotype != port2->iotype) 2968 return 0; 2969 2970 switch (port1->iotype) { 2971 case UPIO_PORT: 2972 return (port1->iobase == port2->iobase); 2973 case UPIO_HUB6: 2974 return (port1->iobase == port2->iobase) && 2975 (port1->hub6 == port2->hub6); 2976 case UPIO_MEM: 2977 case UPIO_MEM16: 2978 case UPIO_MEM32: 2979 case UPIO_MEM32BE: 2980 case UPIO_AU: 2981 case UPIO_TSI: 2982 return (port1->mapbase == port2->mapbase); 2983 } 2984 return 0; 2985 } 2986 EXPORT_SYMBOL(uart_match_port); 2987 2988 /** 2989 * uart_handle_dcd_change - handle a change of carrier detect state 2990 * @uport: uart_port structure for the open port 2991 * @status: new carrier detect status, nonzero if active 2992 * 2993 * Caller must hold uport->lock 2994 */ 2995 void uart_handle_dcd_change(struct uart_port *uport, unsigned int status) 2996 { 2997 struct tty_port *port = &uport->state->port; 2998 struct tty_struct *tty = port->tty; 2999 struct tty_ldisc *ld; 3000 3001 lockdep_assert_held_once(&uport->lock); 3002 3003 if (tty) { 3004 ld = tty_ldisc_ref(tty); 3005 if (ld) { 3006 if (ld->ops->dcd_change) 3007 ld->ops->dcd_change(tty, status); 3008 tty_ldisc_deref(ld); 3009 } 3010 } 3011 3012 uport->icount.dcd++; 3013 3014 if (uart_dcd_enabled(uport)) { 3015 if (status) 3016 wake_up_interruptible(&port->open_wait); 3017 else if (tty) 3018 tty_hangup(tty); 3019 } 3020 } 3021 EXPORT_SYMBOL_GPL(uart_handle_dcd_change); 3022 3023 /** 3024 * uart_handle_cts_change - handle a change of clear-to-send state 3025 * @uport: uart_port structure for the open port 3026 * @status: new clear to send status, nonzero if active 3027 * 3028 * Caller must hold uport->lock 3029 */ 3030 void uart_handle_cts_change(struct uart_port *uport, unsigned int status) 3031 { 3032 lockdep_assert_held_once(&uport->lock); 3033 3034 uport->icount.cts++; 3035 3036 if (uart_softcts_mode(uport)) { 3037 if (uport->hw_stopped) { 3038 if (status) { 3039 uport->hw_stopped = 0; 3040 uport->ops->start_tx(uport); 3041 uart_write_wakeup(uport); 3042 } 3043 } else { 3044 if (!status) { 3045 uport->hw_stopped = 1; 3046 uport->ops->stop_tx(uport); 3047 } 3048 } 3049 3050 } 3051 } 3052 EXPORT_SYMBOL_GPL(uart_handle_cts_change); 3053 3054 /** 3055 * uart_insert_char - push a char to the uart layer 3056 * 3057 * User is responsible to call tty_flip_buffer_push when they are done with 3058 * insertion. 3059 * 3060 * @port: corresponding port 3061 * @status: state of the serial port RX buffer (LSR for 8250) 3062 * @overrun: mask of overrun bits in @status 3063 * @ch: character to push 3064 * @flag: flag for the character (see TTY_NORMAL and friends) 3065 */ 3066 void uart_insert_char(struct uart_port *port, unsigned int status, 3067 unsigned int overrun, unsigned int ch, unsigned int flag) 3068 { 3069 struct tty_port *tport = &port->state->port; 3070 3071 if ((status & port->ignore_status_mask & ~overrun) == 0) 3072 if (tty_insert_flip_char(tport, ch, flag) == 0) 3073 ++port->icount.buf_overrun; 3074 3075 /* 3076 * Overrun is special. Since it's reported immediately, 3077 * it doesn't affect the current character. 3078 */ 3079 if (status & ~port->ignore_status_mask & overrun) 3080 if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0) 3081 ++port->icount.buf_overrun; 3082 } 3083 EXPORT_SYMBOL_GPL(uart_insert_char); 3084 3085 int uart_handle_sysrq_char(struct uart_port *port, unsigned int ch) 3086 { 3087 if (!IS_ENABLED(CONFIG_MAGIC_SYSRQ_SERIAL)) 3088 return 0; 3089 3090 if (!port->has_sysrq || !port->sysrq) 3091 return 0; 3092 3093 if (ch && time_before(jiffies, port->sysrq)) { 3094 handle_sysrq(ch); 3095 port->sysrq = 0; 3096 return 1; 3097 } 3098 port->sysrq = 0; 3099 3100 return 0; 3101 } 3102 EXPORT_SYMBOL_GPL(uart_handle_sysrq_char); 3103 3104 int uart_prepare_sysrq_char(struct uart_port *port, unsigned int ch) 3105 { 3106 if (!IS_ENABLED(CONFIG_MAGIC_SYSRQ_SERIAL)) 3107 return 0; 3108 3109 if (!port->has_sysrq || !port->sysrq) 3110 return 0; 3111 3112 if (ch && time_before(jiffies, port->sysrq)) { 3113 port->sysrq_ch = ch; 3114 port->sysrq = 0; 3115 return 1; 3116 } 3117 port->sysrq = 0; 3118 3119 return 0; 3120 } 3121 EXPORT_SYMBOL_GPL(uart_prepare_sysrq_char); 3122 3123 void uart_unlock_and_check_sysrq(struct uart_port *port, unsigned long irqflags) 3124 { 3125 int sysrq_ch; 3126 3127 if (!port->has_sysrq) { 3128 spin_unlock_irqrestore(&port->lock, irqflags); 3129 return; 3130 } 3131 3132 sysrq_ch = port->sysrq_ch; 3133 port->sysrq_ch = 0; 3134 3135 spin_unlock_irqrestore(&port->lock, irqflags); 3136 3137 if (sysrq_ch) 3138 handle_sysrq(sysrq_ch); 3139 } 3140 EXPORT_SYMBOL_GPL(uart_unlock_and_check_sysrq); 3141 3142 /* 3143 * We do the SysRQ and SAK checking like this... 3144 */ 3145 int uart_handle_break(struct uart_port *port) 3146 { 3147 struct uart_state *state = port->state; 3148 3149 if (port->handle_break) 3150 port->handle_break(port); 3151 3152 if (port->has_sysrq) { 3153 if (port->cons && port->cons->index == port->line) { 3154 if (!port->sysrq) { 3155 port->sysrq = jiffies + HZ*5; 3156 return 1; 3157 } 3158 port->sysrq = 0; 3159 } 3160 } 3161 3162 if (port->flags & UPF_SAK) 3163 do_SAK(state->port.tty); 3164 return 0; 3165 } 3166 EXPORT_SYMBOL_GPL(uart_handle_break); 3167 3168 EXPORT_SYMBOL(uart_write_wakeup); 3169 EXPORT_SYMBOL(uart_register_driver); 3170 EXPORT_SYMBOL(uart_unregister_driver); 3171 EXPORT_SYMBOL(uart_suspend_port); 3172 EXPORT_SYMBOL(uart_resume_port); 3173 EXPORT_SYMBOL(uart_add_one_port); 3174 EXPORT_SYMBOL(uart_remove_one_port); 3175 3176 /** 3177 * uart_get_rs485_mode() - retrieve rs485 properties for given uart 3178 * @dev: uart device 3179 * @rs485conf: output parameter 3180 * 3181 * This function implements the device tree binding described in 3182 * Documentation/devicetree/bindings/serial/rs485.txt. 3183 */ 3184 void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf) 3185 { 3186 u32 rs485_delay[2]; 3187 int ret; 3188 3189 ret = device_property_read_u32_array(dev, "rs485-rts-delay", 3190 rs485_delay, 2); 3191 if (!ret) { 3192 rs485conf->delay_rts_before_send = rs485_delay[0]; 3193 rs485conf->delay_rts_after_send = rs485_delay[1]; 3194 } else { 3195 rs485conf->delay_rts_before_send = 0; 3196 rs485conf->delay_rts_after_send = 0; 3197 } 3198 3199 /* 3200 * Clear full-duplex and enabled flags, set RTS polarity to active high 3201 * to get to a defined state with the following properties: 3202 */ 3203 rs485conf->flags &= ~(SER_RS485_RX_DURING_TX | SER_RS485_ENABLED | 3204 SER_RS485_RTS_AFTER_SEND); 3205 rs485conf->flags |= SER_RS485_RTS_ON_SEND; 3206 3207 if (device_property_read_bool(dev, "rs485-rx-during-tx")) 3208 rs485conf->flags |= SER_RS485_RX_DURING_TX; 3209 3210 if (device_property_read_bool(dev, "linux,rs485-enabled-at-boot-time")) 3211 rs485conf->flags |= SER_RS485_ENABLED; 3212 3213 if (device_property_read_bool(dev, "rs485-rts-active-low")) { 3214 rs485conf->flags &= ~SER_RS485_RTS_ON_SEND; 3215 rs485conf->flags |= SER_RS485_RTS_AFTER_SEND; 3216 } 3217 } 3218 EXPORT_SYMBOL_GPL(uart_get_rs485_mode); 3219 3220 MODULE_DESCRIPTION("Serial driver core"); 3221 MODULE_LICENSE("GPL"); 3222