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