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