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