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