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