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. 958 */ 959 if (uport->flags & UPF_SPD_MASK) { 960 dev_notice_ratelimited(uport->dev, 961 "%s sets custom speed on %s. This is deprecated.\n", 962 current->comm, 963 tty_name(port->tty)); 964 } 965 uart_change_speed(tty, state, NULL); 966 } 967 } else { 968 retval = uart_startup(tty, state, 1); 969 if (retval > 0) 970 retval = 0; 971 } 972 exit: 973 return retval; 974 } 975 976 static int uart_set_info_user(struct tty_struct *tty, struct uart_state *state, 977 struct serial_struct __user *newinfo) 978 { 979 struct serial_struct new_serial; 980 struct tty_port *port = &state->port; 981 int retval; 982 983 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial))) 984 return -EFAULT; 985 986 /* 987 * This semaphore protects port->count. It is also 988 * very useful to prevent opens. Also, take the 989 * port configuration semaphore to make sure that a 990 * module insertion/removal doesn't change anything 991 * under us. 992 */ 993 mutex_lock(&port->mutex); 994 retval = uart_set_info(tty, port, state, &new_serial); 995 mutex_unlock(&port->mutex); 996 return retval; 997 } 998 999 /** 1000 * uart_get_lsr_info - get line status register info 1001 * @tty: tty associated with the UART 1002 * @state: UART being queried 1003 * @value: returned modem value 1004 */ 1005 static int uart_get_lsr_info(struct tty_struct *tty, 1006 struct uart_state *state, unsigned int __user *value) 1007 { 1008 struct uart_port *uport = uart_port_check(state); 1009 unsigned int result; 1010 1011 result = uport->ops->tx_empty(uport); 1012 1013 /* 1014 * If we're about to load something into the transmit 1015 * register, we'll pretend the transmitter isn't empty to 1016 * avoid a race condition (depending on when the transmit 1017 * interrupt happens). 1018 */ 1019 if (uport->x_char || 1020 ((uart_circ_chars_pending(&state->xmit) > 0) && 1021 !uart_tx_stopped(uport))) 1022 result &= ~TIOCSER_TEMT; 1023 1024 return put_user(result, value); 1025 } 1026 1027 static int uart_tiocmget(struct tty_struct *tty) 1028 { 1029 struct uart_state *state = tty->driver_data; 1030 struct tty_port *port = &state->port; 1031 struct uart_port *uport; 1032 int result = -EIO; 1033 1034 mutex_lock(&port->mutex); 1035 uport = uart_port_check(state); 1036 if (!uport) 1037 goto out; 1038 1039 if (!tty_io_error(tty)) { 1040 result = uport->mctrl; 1041 spin_lock_irq(&uport->lock); 1042 result |= uport->ops->get_mctrl(uport); 1043 spin_unlock_irq(&uport->lock); 1044 } 1045 out: 1046 mutex_unlock(&port->mutex); 1047 return result; 1048 } 1049 1050 static int 1051 uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear) 1052 { 1053 struct uart_state *state = tty->driver_data; 1054 struct tty_port *port = &state->port; 1055 struct uart_port *uport; 1056 int ret = -EIO; 1057 1058 mutex_lock(&port->mutex); 1059 uport = uart_port_check(state); 1060 if (!uport) 1061 goto out; 1062 1063 if (!tty_io_error(tty)) { 1064 uart_update_mctrl(uport, set, clear); 1065 ret = 0; 1066 } 1067 out: 1068 mutex_unlock(&port->mutex); 1069 return ret; 1070 } 1071 1072 static int uart_break_ctl(struct tty_struct *tty, int break_state) 1073 { 1074 struct uart_state *state = tty->driver_data; 1075 struct tty_port *port = &state->port; 1076 struct uart_port *uport; 1077 int ret = -EIO; 1078 1079 mutex_lock(&port->mutex); 1080 uport = uart_port_check(state); 1081 if (!uport) 1082 goto out; 1083 1084 if (uport->type != PORT_UNKNOWN) 1085 uport->ops->break_ctl(uport, break_state); 1086 ret = 0; 1087 out: 1088 mutex_unlock(&port->mutex); 1089 return ret; 1090 } 1091 1092 static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state) 1093 { 1094 struct tty_port *port = &state->port; 1095 struct uart_port *uport; 1096 int flags, ret; 1097 1098 if (!capable(CAP_SYS_ADMIN)) 1099 return -EPERM; 1100 1101 /* 1102 * Take the per-port semaphore. This prevents count from 1103 * changing, and hence any extra opens of the port while 1104 * we're auto-configuring. 1105 */ 1106 if (mutex_lock_interruptible(&port->mutex)) 1107 return -ERESTARTSYS; 1108 1109 uport = uart_port_check(state); 1110 if (!uport) { 1111 ret = -EIO; 1112 goto out; 1113 } 1114 1115 ret = -EBUSY; 1116 if (tty_port_users(port) == 1) { 1117 uart_shutdown(tty, state); 1118 1119 /* 1120 * If we already have a port type configured, 1121 * we must release its resources. 1122 */ 1123 if (uport->type != PORT_UNKNOWN && uport->ops->release_port) 1124 uport->ops->release_port(uport); 1125 1126 flags = UART_CONFIG_TYPE; 1127 if (uport->flags & UPF_AUTO_IRQ) 1128 flags |= UART_CONFIG_IRQ; 1129 1130 /* 1131 * This will claim the ports resources if 1132 * a port is found. 1133 */ 1134 uport->ops->config_port(uport, flags); 1135 1136 ret = uart_startup(tty, state, 1); 1137 if (ret > 0) 1138 ret = 0; 1139 } 1140 out: 1141 mutex_unlock(&port->mutex); 1142 return ret; 1143 } 1144 1145 static void uart_enable_ms(struct uart_port *uport) 1146 { 1147 /* 1148 * Force modem status interrupts on 1149 */ 1150 if (uport->ops->enable_ms) 1151 uport->ops->enable_ms(uport); 1152 } 1153 1154 /* 1155 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change 1156 * - mask passed in arg for lines of interest 1157 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) 1158 * Caller should use TIOCGICOUNT to see which one it was 1159 * 1160 * FIXME: This wants extracting into a common all driver implementation 1161 * of TIOCMWAIT using tty_port. 1162 */ 1163 static int uart_wait_modem_status(struct uart_state *state, unsigned long arg) 1164 { 1165 struct uart_port *uport; 1166 struct tty_port *port = &state->port; 1167 DECLARE_WAITQUEUE(wait, current); 1168 struct uart_icount cprev, cnow; 1169 int ret; 1170 1171 /* 1172 * note the counters on entry 1173 */ 1174 uport = uart_port_ref(state); 1175 if (!uport) 1176 return -EIO; 1177 spin_lock_irq(&uport->lock); 1178 memcpy(&cprev, &uport->icount, sizeof(struct uart_icount)); 1179 uart_enable_ms(uport); 1180 spin_unlock_irq(&uport->lock); 1181 1182 add_wait_queue(&port->delta_msr_wait, &wait); 1183 for (;;) { 1184 spin_lock_irq(&uport->lock); 1185 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount)); 1186 spin_unlock_irq(&uport->lock); 1187 1188 set_current_state(TASK_INTERRUPTIBLE); 1189 1190 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 1191 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 1192 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 1193 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 1194 ret = 0; 1195 break; 1196 } 1197 1198 schedule(); 1199 1200 /* see if a signal did it */ 1201 if (signal_pending(current)) { 1202 ret = -ERESTARTSYS; 1203 break; 1204 } 1205 1206 cprev = cnow; 1207 } 1208 __set_current_state(TASK_RUNNING); 1209 remove_wait_queue(&port->delta_msr_wait, &wait); 1210 uart_port_deref(uport); 1211 1212 return ret; 1213 } 1214 1215 /* 1216 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) 1217 * Return: write counters to the user passed counter struct 1218 * NB: both 1->0 and 0->1 transitions are counted except for 1219 * RI where only 0->1 is counted. 1220 */ 1221 static int uart_get_icount(struct tty_struct *tty, 1222 struct serial_icounter_struct *icount) 1223 { 1224 struct uart_state *state = tty->driver_data; 1225 struct uart_icount cnow; 1226 struct uart_port *uport; 1227 1228 uport = uart_port_ref(state); 1229 if (!uport) 1230 return -EIO; 1231 spin_lock_irq(&uport->lock); 1232 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount)); 1233 spin_unlock_irq(&uport->lock); 1234 uart_port_deref(uport); 1235 1236 icount->cts = cnow.cts; 1237 icount->dsr = cnow.dsr; 1238 icount->rng = cnow.rng; 1239 icount->dcd = cnow.dcd; 1240 icount->rx = cnow.rx; 1241 icount->tx = cnow.tx; 1242 icount->frame = cnow.frame; 1243 icount->overrun = cnow.overrun; 1244 icount->parity = cnow.parity; 1245 icount->brk = cnow.brk; 1246 icount->buf_overrun = cnow.buf_overrun; 1247 1248 return 0; 1249 } 1250 1251 static int uart_get_rs485_config(struct uart_port *port, 1252 struct serial_rs485 __user *rs485) 1253 { 1254 unsigned long flags; 1255 struct serial_rs485 aux; 1256 1257 spin_lock_irqsave(&port->lock, flags); 1258 aux = port->rs485; 1259 spin_unlock_irqrestore(&port->lock, flags); 1260 1261 if (copy_to_user(rs485, &aux, sizeof(aux))) 1262 return -EFAULT; 1263 1264 return 0; 1265 } 1266 1267 static int uart_set_rs485_config(struct uart_port *port, 1268 struct serial_rs485 __user *rs485_user) 1269 { 1270 struct serial_rs485 rs485; 1271 int ret; 1272 unsigned long flags; 1273 1274 if (!port->rs485_config) 1275 return -ENOIOCTLCMD; 1276 1277 if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user))) 1278 return -EFAULT; 1279 1280 spin_lock_irqsave(&port->lock, flags); 1281 ret = port->rs485_config(port, &rs485); 1282 spin_unlock_irqrestore(&port->lock, flags); 1283 if (ret) 1284 return ret; 1285 1286 if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485))) 1287 return -EFAULT; 1288 1289 return 0; 1290 } 1291 1292 /* 1293 * Called via sys_ioctl. We can use spin_lock_irq() here. 1294 */ 1295 static int 1296 uart_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg) 1297 { 1298 struct uart_state *state = tty->driver_data; 1299 struct tty_port *port = &state->port; 1300 struct uart_port *uport; 1301 void __user *uarg = (void __user *)arg; 1302 int ret = -ENOIOCTLCMD; 1303 1304 1305 /* 1306 * These ioctls don't rely on the hardware to be present. 1307 */ 1308 switch (cmd) { 1309 case TIOCGSERIAL: 1310 ret = uart_get_info_user(port, uarg); 1311 break; 1312 1313 case TIOCSSERIAL: 1314 down_write(&tty->termios_rwsem); 1315 ret = uart_set_info_user(tty, state, uarg); 1316 up_write(&tty->termios_rwsem); 1317 break; 1318 1319 case TIOCSERCONFIG: 1320 down_write(&tty->termios_rwsem); 1321 ret = uart_do_autoconfig(tty, state); 1322 up_write(&tty->termios_rwsem); 1323 break; 1324 1325 case TIOCSERGWILD: /* obsolete */ 1326 case TIOCSERSWILD: /* obsolete */ 1327 ret = 0; 1328 break; 1329 } 1330 1331 if (ret != -ENOIOCTLCMD) 1332 goto out; 1333 1334 if (tty_io_error(tty)) { 1335 ret = -EIO; 1336 goto out; 1337 } 1338 1339 /* 1340 * The following should only be used when hardware is present. 1341 */ 1342 switch (cmd) { 1343 case TIOCMIWAIT: 1344 ret = uart_wait_modem_status(state, arg); 1345 break; 1346 } 1347 1348 if (ret != -ENOIOCTLCMD) 1349 goto out; 1350 1351 mutex_lock(&port->mutex); 1352 uport = uart_port_check(state); 1353 1354 if (!uport || tty_io_error(tty)) { 1355 ret = -EIO; 1356 goto out_up; 1357 } 1358 1359 /* 1360 * All these rely on hardware being present and need to be 1361 * protected against the tty being hung up. 1362 */ 1363 1364 switch (cmd) { 1365 case TIOCSERGETLSR: /* Get line status register */ 1366 ret = uart_get_lsr_info(tty, state, uarg); 1367 break; 1368 1369 case TIOCGRS485: 1370 ret = uart_get_rs485_config(uport, uarg); 1371 break; 1372 1373 case TIOCSRS485: 1374 ret = uart_set_rs485_config(uport, uarg); 1375 break; 1376 default: 1377 if (uport->ops->ioctl) 1378 ret = uport->ops->ioctl(uport, cmd, arg); 1379 break; 1380 } 1381 out_up: 1382 mutex_unlock(&port->mutex); 1383 out: 1384 return ret; 1385 } 1386 1387 static void uart_set_ldisc(struct tty_struct *tty) 1388 { 1389 struct uart_state *state = tty->driver_data; 1390 struct uart_port *uport; 1391 1392 mutex_lock(&state->port.mutex); 1393 uport = uart_port_check(state); 1394 if (uport && uport->ops->set_ldisc) 1395 uport->ops->set_ldisc(uport, &tty->termios); 1396 mutex_unlock(&state->port.mutex); 1397 } 1398 1399 static void uart_set_termios(struct tty_struct *tty, 1400 struct ktermios *old_termios) 1401 { 1402 struct uart_state *state = tty->driver_data; 1403 struct uart_port *uport; 1404 unsigned int cflag = tty->termios.c_cflag; 1405 unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK; 1406 bool sw_changed = false; 1407 1408 mutex_lock(&state->port.mutex); 1409 uport = uart_port_check(state); 1410 if (!uport) 1411 goto out; 1412 1413 /* 1414 * Drivers doing software flow control also need to know 1415 * about changes to these input settings. 1416 */ 1417 if (uport->flags & UPF_SOFT_FLOW) { 1418 iflag_mask |= IXANY|IXON|IXOFF; 1419 sw_changed = 1420 tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] || 1421 tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP]; 1422 } 1423 1424 /* 1425 * These are the bits that are used to setup various 1426 * flags in the low level driver. We can ignore the Bfoo 1427 * bits in c_cflag; c_[io]speed will always be set 1428 * appropriately by set_termios() in tty_ioctl.c 1429 */ 1430 if ((cflag ^ old_termios->c_cflag) == 0 && 1431 tty->termios.c_ospeed == old_termios->c_ospeed && 1432 tty->termios.c_ispeed == old_termios->c_ispeed && 1433 ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 && 1434 !sw_changed) { 1435 goto out; 1436 } 1437 1438 uart_change_speed(tty, state, old_termios); 1439 /* reload cflag from termios; port driver may have overriden flags */ 1440 cflag = tty->termios.c_cflag; 1441 1442 /* Handle transition to B0 status */ 1443 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) 1444 uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR); 1445 /* Handle transition away from B0 status */ 1446 else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) { 1447 unsigned int mask = TIOCM_DTR; 1448 if (!(cflag & CRTSCTS) || !tty_throttled(tty)) 1449 mask |= TIOCM_RTS; 1450 uart_set_mctrl(uport, mask); 1451 } 1452 out: 1453 mutex_unlock(&state->port.mutex); 1454 } 1455 1456 /* 1457 * Calls to uart_close() are serialised via the tty_lock in 1458 * drivers/tty/tty_io.c:tty_release() 1459 * drivers/tty/tty_io.c:do_tty_hangup() 1460 */ 1461 static void uart_close(struct tty_struct *tty, struct file *filp) 1462 { 1463 struct uart_state *state = tty->driver_data; 1464 struct tty_port *port; 1465 1466 if (!state) { 1467 struct uart_driver *drv = tty->driver->driver_state; 1468 1469 state = drv->state + tty->index; 1470 port = &state->port; 1471 spin_lock_irq(&port->lock); 1472 --port->count; 1473 spin_unlock_irq(&port->lock); 1474 return; 1475 } 1476 1477 port = &state->port; 1478 pr_debug("uart_close(%d) called\n", tty->index); 1479 1480 tty_port_close(tty->port, tty, filp); 1481 } 1482 1483 static void uart_tty_port_shutdown(struct tty_port *port) 1484 { 1485 struct uart_state *state = container_of(port, struct uart_state, port); 1486 struct uart_port *uport = uart_port_check(state); 1487 1488 /* 1489 * At this point, we stop accepting input. To do this, we 1490 * disable the receive line status interrupts. 1491 */ 1492 if (WARN(!uport, "detached port still initialized!\n")) 1493 return; 1494 1495 spin_lock_irq(&uport->lock); 1496 uport->ops->stop_rx(uport); 1497 spin_unlock_irq(&uport->lock); 1498 1499 uart_port_shutdown(port); 1500 1501 /* 1502 * It's possible for shutdown to be called after suspend if we get 1503 * a DCD drop (hangup) at just the right time. Clear suspended bit so 1504 * we don't try to resume a port that has been shutdown. 1505 */ 1506 tty_port_set_suspended(port, 0); 1507 1508 uart_change_pm(state, UART_PM_STATE_OFF); 1509 1510 } 1511 1512 static void uart_wait_until_sent(struct tty_struct *tty, int timeout) 1513 { 1514 struct uart_state *state = tty->driver_data; 1515 struct uart_port *port; 1516 unsigned long char_time, expire; 1517 1518 port = uart_port_ref(state); 1519 if (!port) 1520 return; 1521 1522 if (port->type == PORT_UNKNOWN || port->fifosize == 0) { 1523 uart_port_deref(port); 1524 return; 1525 } 1526 1527 /* 1528 * Set the check interval to be 1/5 of the estimated time to 1529 * send a single character, and make it at least 1. The check 1530 * interval should also be less than the timeout. 1531 * 1532 * Note: we have to use pretty tight timings here to satisfy 1533 * the NIST-PCTS. 1534 */ 1535 char_time = (port->timeout - HZ/50) / port->fifosize; 1536 char_time = char_time / 5; 1537 if (char_time == 0) 1538 char_time = 1; 1539 if (timeout && timeout < char_time) 1540 char_time = timeout; 1541 1542 /* 1543 * If the transmitter hasn't cleared in twice the approximate 1544 * amount of time to send the entire FIFO, it probably won't 1545 * ever clear. This assumes the UART isn't doing flow 1546 * control, which is currently the case. Hence, if it ever 1547 * takes longer than port->timeout, this is probably due to a 1548 * UART bug of some kind. So, we clamp the timeout parameter at 1549 * 2*port->timeout. 1550 */ 1551 if (timeout == 0 || timeout > 2 * port->timeout) 1552 timeout = 2 * port->timeout; 1553 1554 expire = jiffies + timeout; 1555 1556 pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n", 1557 port->line, jiffies, expire); 1558 1559 /* 1560 * Check whether the transmitter is empty every 'char_time'. 1561 * 'timeout' / 'expire' give us the maximum amount of time 1562 * we wait. 1563 */ 1564 while (!port->ops->tx_empty(port)) { 1565 msleep_interruptible(jiffies_to_msecs(char_time)); 1566 if (signal_pending(current)) 1567 break; 1568 if (time_after(jiffies, expire)) 1569 break; 1570 } 1571 uart_port_deref(port); 1572 } 1573 1574 /* 1575 * Calls to uart_hangup() are serialised by the tty_lock in 1576 * drivers/tty/tty_io.c:do_tty_hangup() 1577 * This runs from a workqueue and can sleep for a _short_ time only. 1578 */ 1579 static void uart_hangup(struct tty_struct *tty) 1580 { 1581 struct uart_state *state = tty->driver_data; 1582 struct tty_port *port = &state->port; 1583 struct uart_port *uport; 1584 unsigned long flags; 1585 1586 pr_debug("uart_hangup(%d)\n", tty->index); 1587 1588 mutex_lock(&port->mutex); 1589 uport = uart_port_check(state); 1590 WARN(!uport, "hangup of detached port!\n"); 1591 1592 if (tty_port_active(port)) { 1593 uart_flush_buffer(tty); 1594 uart_shutdown(tty, state); 1595 spin_lock_irqsave(&port->lock, flags); 1596 port->count = 0; 1597 spin_unlock_irqrestore(&port->lock, flags); 1598 tty_port_set_active(port, 0); 1599 tty_port_tty_set(port, NULL); 1600 if (uport && !uart_console(uport)) 1601 uart_change_pm(state, UART_PM_STATE_OFF); 1602 wake_up_interruptible(&port->open_wait); 1603 wake_up_interruptible(&port->delta_msr_wait); 1604 } 1605 mutex_unlock(&port->mutex); 1606 } 1607 1608 /* uport == NULL if uart_port has already been removed */ 1609 static void uart_port_shutdown(struct tty_port *port) 1610 { 1611 struct uart_state *state = container_of(port, struct uart_state, port); 1612 struct uart_port *uport = uart_port_check(state); 1613 1614 /* 1615 * clear delta_msr_wait queue to avoid mem leaks: we may free 1616 * the irq here so the queue might never be woken up. Note 1617 * that we won't end up waiting on delta_msr_wait again since 1618 * any outstanding file descriptors should be pointing at 1619 * hung_up_tty_fops now. 1620 */ 1621 wake_up_interruptible(&port->delta_msr_wait); 1622 1623 /* 1624 * Free the IRQ and disable the port. 1625 */ 1626 if (uport) 1627 uport->ops->shutdown(uport); 1628 1629 /* 1630 * Ensure that the IRQ handler isn't running on another CPU. 1631 */ 1632 if (uport) 1633 synchronize_irq(uport->irq); 1634 } 1635 1636 static int uart_carrier_raised(struct tty_port *port) 1637 { 1638 struct uart_state *state = container_of(port, struct uart_state, port); 1639 struct uart_port *uport; 1640 int mctrl; 1641 1642 uport = uart_port_ref(state); 1643 /* 1644 * Should never observe uport == NULL since checks for hangup should 1645 * abort the tty_port_block_til_ready() loop before checking for carrier 1646 * raised -- but report carrier raised if it does anyway so open will 1647 * continue and not sleep 1648 */ 1649 if (WARN_ON(!uport)) 1650 return 1; 1651 spin_lock_irq(&uport->lock); 1652 uart_enable_ms(uport); 1653 mctrl = uport->ops->get_mctrl(uport); 1654 spin_unlock_irq(&uport->lock); 1655 uart_port_deref(uport); 1656 if (mctrl & TIOCM_CAR) 1657 return 1; 1658 return 0; 1659 } 1660 1661 static void uart_dtr_rts(struct tty_port *port, int onoff) 1662 { 1663 struct uart_state *state = container_of(port, struct uart_state, port); 1664 struct uart_port *uport; 1665 1666 uport = uart_port_ref(state); 1667 if (!uport) 1668 return; 1669 1670 if (onoff) 1671 uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS); 1672 else 1673 uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS); 1674 1675 uart_port_deref(uport); 1676 } 1677 1678 /* 1679 * Calls to uart_open are serialised by the tty_lock in 1680 * drivers/tty/tty_io.c:tty_open() 1681 * Note that if this fails, then uart_close() _will_ be called. 1682 * 1683 * In time, we want to scrap the "opening nonpresent ports" 1684 * behaviour and implement an alternative way for setserial 1685 * to set base addresses/ports/types. This will allow us to 1686 * get rid of a certain amount of extra tests. 1687 */ 1688 static int uart_open(struct tty_struct *tty, struct file *filp) 1689 { 1690 struct uart_driver *drv = tty->driver->driver_state; 1691 int retval, line = tty->index; 1692 struct uart_state *state = drv->state + line; 1693 1694 tty->driver_data = state; 1695 1696 retval = tty_port_open(&state->port, tty, filp); 1697 if (retval > 0) 1698 retval = 0; 1699 1700 return retval; 1701 } 1702 1703 static int uart_port_activate(struct tty_port *port, struct tty_struct *tty) 1704 { 1705 struct uart_state *state = container_of(port, struct uart_state, port); 1706 struct uart_port *uport; 1707 1708 uport = uart_port_check(state); 1709 if (!uport || uport->flags & UPF_DEAD) 1710 return -ENXIO; 1711 1712 port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0; 1713 1714 /* 1715 * Start up the serial port. 1716 */ 1717 return uart_startup(tty, state, 0); 1718 } 1719 1720 static const char *uart_type(struct uart_port *port) 1721 { 1722 const char *str = NULL; 1723 1724 if (port->ops->type) 1725 str = port->ops->type(port); 1726 1727 if (!str) 1728 str = "unknown"; 1729 1730 return str; 1731 } 1732 1733 #ifdef CONFIG_PROC_FS 1734 1735 static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i) 1736 { 1737 struct uart_state *state = drv->state + i; 1738 struct tty_port *port = &state->port; 1739 enum uart_pm_state pm_state; 1740 struct uart_port *uport; 1741 char stat_buf[32]; 1742 unsigned int status; 1743 int mmio; 1744 1745 mutex_lock(&port->mutex); 1746 uport = uart_port_check(state); 1747 if (!uport) 1748 goto out; 1749 1750 mmio = uport->iotype >= UPIO_MEM; 1751 seq_printf(m, "%d: uart:%s %s%08llX irq:%d", 1752 uport->line, uart_type(uport), 1753 mmio ? "mmio:0x" : "port:", 1754 mmio ? (unsigned long long)uport->mapbase 1755 : (unsigned long long)uport->iobase, 1756 uport->irq); 1757 1758 if (uport->type == PORT_UNKNOWN) { 1759 seq_putc(m, '\n'); 1760 goto out; 1761 } 1762 1763 if (capable(CAP_SYS_ADMIN)) { 1764 pm_state = state->pm_state; 1765 if (pm_state != UART_PM_STATE_ON) 1766 uart_change_pm(state, UART_PM_STATE_ON); 1767 spin_lock_irq(&uport->lock); 1768 status = uport->ops->get_mctrl(uport); 1769 spin_unlock_irq(&uport->lock); 1770 if (pm_state != UART_PM_STATE_ON) 1771 uart_change_pm(state, pm_state); 1772 1773 seq_printf(m, " tx:%d rx:%d", 1774 uport->icount.tx, uport->icount.rx); 1775 if (uport->icount.frame) 1776 seq_printf(m, " fe:%d", uport->icount.frame); 1777 if (uport->icount.parity) 1778 seq_printf(m, " pe:%d", uport->icount.parity); 1779 if (uport->icount.brk) 1780 seq_printf(m, " brk:%d", uport->icount.brk); 1781 if (uport->icount.overrun) 1782 seq_printf(m, " oe:%d", uport->icount.overrun); 1783 1784 #define INFOBIT(bit, str) \ 1785 if (uport->mctrl & (bit)) \ 1786 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1787 strlen(stat_buf) - 2) 1788 #define STATBIT(bit, str) \ 1789 if (status & (bit)) \ 1790 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1791 strlen(stat_buf) - 2) 1792 1793 stat_buf[0] = '\0'; 1794 stat_buf[1] = '\0'; 1795 INFOBIT(TIOCM_RTS, "|RTS"); 1796 STATBIT(TIOCM_CTS, "|CTS"); 1797 INFOBIT(TIOCM_DTR, "|DTR"); 1798 STATBIT(TIOCM_DSR, "|DSR"); 1799 STATBIT(TIOCM_CAR, "|CD"); 1800 STATBIT(TIOCM_RNG, "|RI"); 1801 if (stat_buf[0]) 1802 stat_buf[0] = ' '; 1803 1804 seq_puts(m, stat_buf); 1805 } 1806 seq_putc(m, '\n'); 1807 #undef STATBIT 1808 #undef INFOBIT 1809 out: 1810 mutex_unlock(&port->mutex); 1811 } 1812 1813 static int uart_proc_show(struct seq_file *m, void *v) 1814 { 1815 struct tty_driver *ttydrv = m->private; 1816 struct uart_driver *drv = ttydrv->driver_state; 1817 int i; 1818 1819 seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n", "", "", ""); 1820 for (i = 0; i < drv->nr; i++) 1821 uart_line_info(m, drv, i); 1822 return 0; 1823 } 1824 1825 static int uart_proc_open(struct inode *inode, struct file *file) 1826 { 1827 return single_open(file, uart_proc_show, PDE_DATA(inode)); 1828 } 1829 1830 static const struct file_operations uart_proc_fops = { 1831 .owner = THIS_MODULE, 1832 .open = uart_proc_open, 1833 .read = seq_read, 1834 .llseek = seq_lseek, 1835 .release = single_release, 1836 }; 1837 #endif 1838 1839 #if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL) 1840 /** 1841 * uart_console_write - write a console message to a serial port 1842 * @port: the port to write the message 1843 * @s: array of characters 1844 * @count: number of characters in string to write 1845 * @putchar: function to write character to port 1846 */ 1847 void uart_console_write(struct uart_port *port, const char *s, 1848 unsigned int count, 1849 void (*putchar)(struct uart_port *, int)) 1850 { 1851 unsigned int i; 1852 1853 for (i = 0; i < count; i++, s++) { 1854 if (*s == '\n') 1855 putchar(port, '\r'); 1856 putchar(port, *s); 1857 } 1858 } 1859 EXPORT_SYMBOL_GPL(uart_console_write); 1860 1861 /* 1862 * Check whether an invalid uart number has been specified, and 1863 * if so, search for the first available port that does have 1864 * console support. 1865 */ 1866 struct uart_port * __init 1867 uart_get_console(struct uart_port *ports, int nr, struct console *co) 1868 { 1869 int idx = co->index; 1870 1871 if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 && 1872 ports[idx].membase == NULL)) 1873 for (idx = 0; idx < nr; idx++) 1874 if (ports[idx].iobase != 0 || 1875 ports[idx].membase != NULL) 1876 break; 1877 1878 co->index = idx; 1879 1880 return ports + idx; 1881 } 1882 1883 /** 1884 * uart_parse_earlycon - Parse earlycon options 1885 * @p: ptr to 2nd field (ie., just beyond '<name>,') 1886 * @iotype: ptr for decoded iotype (out) 1887 * @addr: ptr for decoded mapbase/iobase (out) 1888 * @options: ptr for <options> field; NULL if not present (out) 1889 * 1890 * Decodes earlycon kernel command line parameters of the form 1891 * earlycon=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options> 1892 * console=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options> 1893 * 1894 * The optional form 1895 * earlycon=<name>,0x<addr>,<options> 1896 * console=<name>,0x<addr>,<options> 1897 * is also accepted; the returned @iotype will be UPIO_MEM. 1898 * 1899 * Returns 0 on success or -EINVAL on failure 1900 */ 1901 int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr, 1902 char **options) 1903 { 1904 if (strncmp(p, "mmio,", 5) == 0) { 1905 *iotype = UPIO_MEM; 1906 p += 5; 1907 } else if (strncmp(p, "mmio16,", 7) == 0) { 1908 *iotype = UPIO_MEM16; 1909 p += 7; 1910 } else if (strncmp(p, "mmio32,", 7) == 0) { 1911 *iotype = UPIO_MEM32; 1912 p += 7; 1913 } else if (strncmp(p, "mmio32be,", 9) == 0) { 1914 *iotype = UPIO_MEM32BE; 1915 p += 9; 1916 } else if (strncmp(p, "mmio32native,", 13) == 0) { 1917 *iotype = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) ? 1918 UPIO_MEM32BE : UPIO_MEM32; 1919 p += 13; 1920 } else if (strncmp(p, "io,", 3) == 0) { 1921 *iotype = UPIO_PORT; 1922 p += 3; 1923 } else if (strncmp(p, "0x", 2) == 0) { 1924 *iotype = UPIO_MEM; 1925 } else { 1926 return -EINVAL; 1927 } 1928 1929 /* 1930 * Before you replace it with kstrtoull(), think about options separator 1931 * (',') it will not tolerate 1932 */ 1933 *addr = simple_strtoull(p, NULL, 0); 1934 p = strchr(p, ','); 1935 if (p) 1936 p++; 1937 1938 *options = p; 1939 return 0; 1940 } 1941 EXPORT_SYMBOL_GPL(uart_parse_earlycon); 1942 1943 /** 1944 * uart_parse_options - Parse serial port baud/parity/bits/flow control. 1945 * @options: pointer to option string 1946 * @baud: pointer to an 'int' variable for the baud rate. 1947 * @parity: pointer to an 'int' variable for the parity. 1948 * @bits: pointer to an 'int' variable for the number of data bits. 1949 * @flow: pointer to an 'int' variable for the flow control character. 1950 * 1951 * uart_parse_options decodes a string containing the serial console 1952 * options. The format of the string is <baud><parity><bits><flow>, 1953 * eg: 115200n8r 1954 */ 1955 void 1956 uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow) 1957 { 1958 char *s = options; 1959 1960 *baud = simple_strtoul(s, NULL, 10); 1961 while (*s >= '0' && *s <= '9') 1962 s++; 1963 if (*s) 1964 *parity = *s++; 1965 if (*s) 1966 *bits = *s++ - '0'; 1967 if (*s) 1968 *flow = *s; 1969 } 1970 EXPORT_SYMBOL_GPL(uart_parse_options); 1971 1972 /** 1973 * uart_set_options - setup the serial console parameters 1974 * @port: pointer to the serial ports uart_port structure 1975 * @co: console pointer 1976 * @baud: baud rate 1977 * @parity: parity character - 'n' (none), 'o' (odd), 'e' (even) 1978 * @bits: number of data bits 1979 * @flow: flow control character - 'r' (rts) 1980 */ 1981 int 1982 uart_set_options(struct uart_port *port, struct console *co, 1983 int baud, int parity, int bits, int flow) 1984 { 1985 struct ktermios termios; 1986 static struct ktermios dummy; 1987 1988 /* 1989 * Ensure that the serial console lock is initialised 1990 * early. 1991 * If this port is a console, then the spinlock is already 1992 * initialised. 1993 */ 1994 if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) { 1995 spin_lock_init(&port->lock); 1996 lockdep_set_class(&port->lock, &port_lock_key); 1997 } 1998 1999 memset(&termios, 0, sizeof(struct ktermios)); 2000 2001 termios.c_cflag |= CREAD | HUPCL | CLOCAL; 2002 tty_termios_encode_baud_rate(&termios, baud, baud); 2003 2004 if (bits == 7) 2005 termios.c_cflag |= CS7; 2006 else 2007 termios.c_cflag |= CS8; 2008 2009 switch (parity) { 2010 case 'o': case 'O': 2011 termios.c_cflag |= PARODD; 2012 /*fall through*/ 2013 case 'e': case 'E': 2014 termios.c_cflag |= PARENB; 2015 break; 2016 } 2017 2018 if (flow == 'r') 2019 termios.c_cflag |= CRTSCTS; 2020 2021 /* 2022 * some uarts on other side don't support no flow control. 2023 * So we set * DTR in host uart to make them happy 2024 */ 2025 port->mctrl |= TIOCM_DTR; 2026 2027 port->ops->set_termios(port, &termios, &dummy); 2028 /* 2029 * Allow the setting of the UART parameters with a NULL console 2030 * too: 2031 */ 2032 if (co) 2033 co->cflag = termios.c_cflag; 2034 2035 return 0; 2036 } 2037 EXPORT_SYMBOL_GPL(uart_set_options); 2038 #endif /* CONFIG_SERIAL_CORE_CONSOLE */ 2039 2040 /** 2041 * uart_change_pm - set power state of the port 2042 * 2043 * @state: port descriptor 2044 * @pm_state: new state 2045 * 2046 * Locking: port->mutex has to be held 2047 */ 2048 static void uart_change_pm(struct uart_state *state, 2049 enum uart_pm_state pm_state) 2050 { 2051 struct uart_port *port = uart_port_check(state); 2052 2053 if (state->pm_state != pm_state) { 2054 if (port && port->ops->pm) 2055 port->ops->pm(port, pm_state, state->pm_state); 2056 state->pm_state = pm_state; 2057 } 2058 } 2059 2060 struct uart_match { 2061 struct uart_port *port; 2062 struct uart_driver *driver; 2063 }; 2064 2065 static int serial_match_port(struct device *dev, void *data) 2066 { 2067 struct uart_match *match = data; 2068 struct tty_driver *tty_drv = match->driver->tty_driver; 2069 dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) + 2070 match->port->line; 2071 2072 return dev->devt == devt; /* Actually, only one tty per port */ 2073 } 2074 2075 int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport) 2076 { 2077 struct uart_state *state = drv->state + uport->line; 2078 struct tty_port *port = &state->port; 2079 struct device *tty_dev; 2080 struct uart_match match = {uport, drv}; 2081 2082 mutex_lock(&port->mutex); 2083 2084 tty_dev = device_find_child(uport->dev, &match, serial_match_port); 2085 if (tty_dev && device_may_wakeup(tty_dev)) { 2086 if (!enable_irq_wake(uport->irq)) 2087 uport->irq_wake = 1; 2088 put_device(tty_dev); 2089 mutex_unlock(&port->mutex); 2090 return 0; 2091 } 2092 put_device(tty_dev); 2093 2094 /* Nothing to do if the console is not suspending */ 2095 if (!console_suspend_enabled && uart_console(uport)) 2096 goto unlock; 2097 2098 uport->suspended = 1; 2099 2100 if (tty_port_initialized(port)) { 2101 const struct uart_ops *ops = uport->ops; 2102 int tries; 2103 2104 tty_port_set_suspended(port, 1); 2105 tty_port_set_initialized(port, 0); 2106 2107 spin_lock_irq(&uport->lock); 2108 ops->stop_tx(uport); 2109 ops->set_mctrl(uport, 0); 2110 ops->stop_rx(uport); 2111 spin_unlock_irq(&uport->lock); 2112 2113 /* 2114 * Wait for the transmitter to empty. 2115 */ 2116 for (tries = 3; !ops->tx_empty(uport) && tries; tries--) 2117 msleep(10); 2118 if (!tries) 2119 dev_err(uport->dev, "%s: Unable to drain transmitter\n", 2120 uport->name); 2121 2122 ops->shutdown(uport); 2123 } 2124 2125 /* 2126 * Disable the console device before suspending. 2127 */ 2128 if (uart_console(uport)) 2129 console_stop(uport->cons); 2130 2131 uart_change_pm(state, UART_PM_STATE_OFF); 2132 unlock: 2133 mutex_unlock(&port->mutex); 2134 2135 return 0; 2136 } 2137 2138 int uart_resume_port(struct uart_driver *drv, struct uart_port *uport) 2139 { 2140 struct uart_state *state = drv->state + uport->line; 2141 struct tty_port *port = &state->port; 2142 struct device *tty_dev; 2143 struct uart_match match = {uport, drv}; 2144 struct ktermios termios; 2145 2146 mutex_lock(&port->mutex); 2147 2148 tty_dev = device_find_child(uport->dev, &match, serial_match_port); 2149 if (!uport->suspended && device_may_wakeup(tty_dev)) { 2150 if (uport->irq_wake) { 2151 disable_irq_wake(uport->irq); 2152 uport->irq_wake = 0; 2153 } 2154 put_device(tty_dev); 2155 mutex_unlock(&port->mutex); 2156 return 0; 2157 } 2158 put_device(tty_dev); 2159 uport->suspended = 0; 2160 2161 /* 2162 * Re-enable the console device after suspending. 2163 */ 2164 if (uart_console(uport)) { 2165 /* 2166 * First try to use the console cflag setting. 2167 */ 2168 memset(&termios, 0, sizeof(struct ktermios)); 2169 termios.c_cflag = uport->cons->cflag; 2170 2171 /* 2172 * If that's unset, use the tty termios setting. 2173 */ 2174 if (port->tty && termios.c_cflag == 0) 2175 termios = port->tty->termios; 2176 2177 if (console_suspend_enabled) 2178 uart_change_pm(state, UART_PM_STATE_ON); 2179 uport->ops->set_termios(uport, &termios, NULL); 2180 if (console_suspend_enabled) 2181 console_start(uport->cons); 2182 } 2183 2184 if (tty_port_suspended(port)) { 2185 const struct uart_ops *ops = uport->ops; 2186 int ret; 2187 2188 uart_change_pm(state, UART_PM_STATE_ON); 2189 spin_lock_irq(&uport->lock); 2190 ops->set_mctrl(uport, 0); 2191 spin_unlock_irq(&uport->lock); 2192 if (console_suspend_enabled || !uart_console(uport)) { 2193 /* Protected by port mutex for now */ 2194 struct tty_struct *tty = port->tty; 2195 ret = ops->startup(uport); 2196 if (ret == 0) { 2197 if (tty) 2198 uart_change_speed(tty, state, NULL); 2199 spin_lock_irq(&uport->lock); 2200 ops->set_mctrl(uport, uport->mctrl); 2201 ops->start_tx(uport); 2202 spin_unlock_irq(&uport->lock); 2203 tty_port_set_initialized(port, 1); 2204 } else { 2205 /* 2206 * Failed to resume - maybe hardware went away? 2207 * Clear the "initialized" flag so we won't try 2208 * to call the low level drivers shutdown method. 2209 */ 2210 uart_shutdown(tty, state); 2211 } 2212 } 2213 2214 tty_port_set_suspended(port, 0); 2215 } 2216 2217 mutex_unlock(&port->mutex); 2218 2219 return 0; 2220 } 2221 2222 static inline void 2223 uart_report_port(struct uart_driver *drv, struct uart_port *port) 2224 { 2225 char address[64]; 2226 2227 switch (port->iotype) { 2228 case UPIO_PORT: 2229 snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase); 2230 break; 2231 case UPIO_HUB6: 2232 snprintf(address, sizeof(address), 2233 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6); 2234 break; 2235 case UPIO_MEM: 2236 case UPIO_MEM16: 2237 case UPIO_MEM32: 2238 case UPIO_MEM32BE: 2239 case UPIO_AU: 2240 case UPIO_TSI: 2241 snprintf(address, sizeof(address), 2242 "MMIO 0x%llx", (unsigned long long)port->mapbase); 2243 break; 2244 default: 2245 strlcpy(address, "*unknown*", sizeof(address)); 2246 break; 2247 } 2248 2249 pr_info("%s%s%s at %s (irq = %d, base_baud = %d) is a %s\n", 2250 port->dev ? dev_name(port->dev) : "", 2251 port->dev ? ": " : "", 2252 port->name, 2253 address, port->irq, port->uartclk / 16, uart_type(port)); 2254 } 2255 2256 static void 2257 uart_configure_port(struct uart_driver *drv, struct uart_state *state, 2258 struct uart_port *port) 2259 { 2260 unsigned int flags; 2261 2262 /* 2263 * If there isn't a port here, don't do anything further. 2264 */ 2265 if (!port->iobase && !port->mapbase && !port->membase) 2266 return; 2267 2268 /* 2269 * Now do the auto configuration stuff. Note that config_port 2270 * is expected to claim the resources and map the port for us. 2271 */ 2272 flags = 0; 2273 if (port->flags & UPF_AUTO_IRQ) 2274 flags |= UART_CONFIG_IRQ; 2275 if (port->flags & UPF_BOOT_AUTOCONF) { 2276 if (!(port->flags & UPF_FIXED_TYPE)) { 2277 port->type = PORT_UNKNOWN; 2278 flags |= UART_CONFIG_TYPE; 2279 } 2280 port->ops->config_port(port, flags); 2281 } 2282 2283 if (port->type != PORT_UNKNOWN) { 2284 unsigned long flags; 2285 2286 uart_report_port(drv, port); 2287 2288 /* Power up port for set_mctrl() */ 2289 uart_change_pm(state, UART_PM_STATE_ON); 2290 2291 /* 2292 * Ensure that the modem control lines are de-activated. 2293 * keep the DTR setting that is set in uart_set_options() 2294 * We probably don't need a spinlock around this, but 2295 */ 2296 spin_lock_irqsave(&port->lock, flags); 2297 port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR); 2298 spin_unlock_irqrestore(&port->lock, flags); 2299 2300 /* 2301 * If this driver supports console, and it hasn't been 2302 * successfully registered yet, try to re-register it. 2303 * It may be that the port was not available. 2304 */ 2305 if (port->cons && !(port->cons->flags & CON_ENABLED)) 2306 register_console(port->cons); 2307 2308 /* 2309 * Power down all ports by default, except the 2310 * console if we have one. 2311 */ 2312 if (!uart_console(port)) 2313 uart_change_pm(state, UART_PM_STATE_OFF); 2314 } 2315 } 2316 2317 #ifdef CONFIG_CONSOLE_POLL 2318 2319 static int uart_poll_init(struct tty_driver *driver, int line, char *options) 2320 { 2321 struct uart_driver *drv = driver->driver_state; 2322 struct uart_state *state = drv->state + line; 2323 struct tty_port *tport; 2324 struct uart_port *port; 2325 int baud = 9600; 2326 int bits = 8; 2327 int parity = 'n'; 2328 int flow = 'n'; 2329 int ret = 0; 2330 2331 tport = &state->port; 2332 mutex_lock(&tport->mutex); 2333 2334 port = uart_port_check(state); 2335 if (!port || !(port->ops->poll_get_char && port->ops->poll_put_char)) { 2336 ret = -1; 2337 goto out; 2338 } 2339 2340 if (port->ops->poll_init) { 2341 /* 2342 * We don't set initialized as we only initialized the hw, 2343 * e.g. state->xmit is still uninitialized. 2344 */ 2345 if (!tty_port_initialized(tport)) 2346 ret = port->ops->poll_init(port); 2347 } 2348 2349 if (!ret && options) { 2350 uart_parse_options(options, &baud, &parity, &bits, &flow); 2351 ret = uart_set_options(port, NULL, baud, parity, bits, flow); 2352 } 2353 out: 2354 mutex_unlock(&tport->mutex); 2355 return ret; 2356 } 2357 2358 static int uart_poll_get_char(struct tty_driver *driver, int line) 2359 { 2360 struct uart_driver *drv = driver->driver_state; 2361 struct uart_state *state = drv->state + line; 2362 struct uart_port *port; 2363 int ret = -1; 2364 2365 port = uart_port_ref(state); 2366 if (port) { 2367 ret = port->ops->poll_get_char(port); 2368 uart_port_deref(port); 2369 } 2370 2371 return ret; 2372 } 2373 2374 static void uart_poll_put_char(struct tty_driver *driver, int line, char ch) 2375 { 2376 struct uart_driver *drv = driver->driver_state; 2377 struct uart_state *state = drv->state + line; 2378 struct uart_port *port; 2379 2380 port = uart_port_ref(state); 2381 if (!port) 2382 return; 2383 2384 if (ch == '\n') 2385 port->ops->poll_put_char(port, '\r'); 2386 port->ops->poll_put_char(port, ch); 2387 uart_port_deref(port); 2388 } 2389 #endif 2390 2391 static const struct tty_operations uart_ops = { 2392 .open = uart_open, 2393 .close = uart_close, 2394 .write = uart_write, 2395 .put_char = uart_put_char, 2396 .flush_chars = uart_flush_chars, 2397 .write_room = uart_write_room, 2398 .chars_in_buffer= uart_chars_in_buffer, 2399 .flush_buffer = uart_flush_buffer, 2400 .ioctl = uart_ioctl, 2401 .throttle = uart_throttle, 2402 .unthrottle = uart_unthrottle, 2403 .send_xchar = uart_send_xchar, 2404 .set_termios = uart_set_termios, 2405 .set_ldisc = uart_set_ldisc, 2406 .stop = uart_stop, 2407 .start = uart_start, 2408 .hangup = uart_hangup, 2409 .break_ctl = uart_break_ctl, 2410 .wait_until_sent= uart_wait_until_sent, 2411 #ifdef CONFIG_PROC_FS 2412 .proc_fops = &uart_proc_fops, 2413 #endif 2414 .tiocmget = uart_tiocmget, 2415 .tiocmset = uart_tiocmset, 2416 .get_icount = uart_get_icount, 2417 #ifdef CONFIG_CONSOLE_POLL 2418 .poll_init = uart_poll_init, 2419 .poll_get_char = uart_poll_get_char, 2420 .poll_put_char = uart_poll_put_char, 2421 #endif 2422 }; 2423 2424 static const struct tty_port_operations uart_port_ops = { 2425 .carrier_raised = uart_carrier_raised, 2426 .dtr_rts = uart_dtr_rts, 2427 .activate = uart_port_activate, 2428 .shutdown = uart_tty_port_shutdown, 2429 }; 2430 2431 /** 2432 * uart_register_driver - register a driver with the uart core layer 2433 * @drv: low level driver structure 2434 * 2435 * Register a uart driver with the core driver. We in turn register 2436 * with the tty layer, and initialise the core driver per-port state. 2437 * 2438 * We have a proc file in /proc/tty/driver which is named after the 2439 * normal driver. 2440 * 2441 * drv->port should be NULL, and the per-port structures should be 2442 * registered using uart_add_one_port after this call has succeeded. 2443 */ 2444 int uart_register_driver(struct uart_driver *drv) 2445 { 2446 struct tty_driver *normal; 2447 int i, retval; 2448 2449 BUG_ON(drv->state); 2450 2451 /* 2452 * Maybe we should be using a slab cache for this, especially if 2453 * we have a large number of ports to handle. 2454 */ 2455 drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL); 2456 if (!drv->state) 2457 goto out; 2458 2459 normal = alloc_tty_driver(drv->nr); 2460 if (!normal) 2461 goto out_kfree; 2462 2463 drv->tty_driver = normal; 2464 2465 normal->driver_name = drv->driver_name; 2466 normal->name = drv->dev_name; 2467 normal->major = drv->major; 2468 normal->minor_start = drv->minor; 2469 normal->type = TTY_DRIVER_TYPE_SERIAL; 2470 normal->subtype = SERIAL_TYPE_NORMAL; 2471 normal->init_termios = tty_std_termios; 2472 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 2473 normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600; 2474 normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 2475 normal->driver_state = drv; 2476 tty_set_operations(normal, &uart_ops); 2477 2478 /* 2479 * Initialise the UART state(s). 2480 */ 2481 for (i = 0; i < drv->nr; i++) { 2482 struct uart_state *state = drv->state + i; 2483 struct tty_port *port = &state->port; 2484 2485 tty_port_init(port); 2486 port->ops = &uart_port_ops; 2487 } 2488 2489 retval = tty_register_driver(normal); 2490 if (retval >= 0) 2491 return retval; 2492 2493 for (i = 0; i < drv->nr; i++) 2494 tty_port_destroy(&drv->state[i].port); 2495 put_tty_driver(normal); 2496 out_kfree: 2497 kfree(drv->state); 2498 out: 2499 return -ENOMEM; 2500 } 2501 2502 /** 2503 * uart_unregister_driver - remove a driver from the uart core layer 2504 * @drv: low level driver structure 2505 * 2506 * Remove all references to a driver from the core driver. The low 2507 * level driver must have removed all its ports via the 2508 * uart_remove_one_port() if it registered them with uart_add_one_port(). 2509 * (ie, drv->port == NULL) 2510 */ 2511 void uart_unregister_driver(struct uart_driver *drv) 2512 { 2513 struct tty_driver *p = drv->tty_driver; 2514 unsigned int i; 2515 2516 tty_unregister_driver(p); 2517 put_tty_driver(p); 2518 for (i = 0; i < drv->nr; i++) 2519 tty_port_destroy(&drv->state[i].port); 2520 kfree(drv->state); 2521 drv->state = NULL; 2522 drv->tty_driver = NULL; 2523 } 2524 2525 struct tty_driver *uart_console_device(struct console *co, int *index) 2526 { 2527 struct uart_driver *p = co->data; 2528 *index = co->index; 2529 return p->tty_driver; 2530 } 2531 2532 static ssize_t uart_get_attr_uartclk(struct device *dev, 2533 struct device_attribute *attr, char *buf) 2534 { 2535 struct serial_struct tmp; 2536 struct tty_port *port = dev_get_drvdata(dev); 2537 2538 uart_get_info(port, &tmp); 2539 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16); 2540 } 2541 2542 static ssize_t uart_get_attr_type(struct device *dev, 2543 struct device_attribute *attr, char *buf) 2544 { 2545 struct serial_struct tmp; 2546 struct tty_port *port = dev_get_drvdata(dev); 2547 2548 uart_get_info(port, &tmp); 2549 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type); 2550 } 2551 static ssize_t uart_get_attr_line(struct device *dev, 2552 struct device_attribute *attr, char *buf) 2553 { 2554 struct serial_struct tmp; 2555 struct tty_port *port = dev_get_drvdata(dev); 2556 2557 uart_get_info(port, &tmp); 2558 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line); 2559 } 2560 2561 static ssize_t uart_get_attr_port(struct device *dev, 2562 struct device_attribute *attr, char *buf) 2563 { 2564 struct serial_struct tmp; 2565 struct tty_port *port = dev_get_drvdata(dev); 2566 unsigned long ioaddr; 2567 2568 uart_get_info(port, &tmp); 2569 ioaddr = tmp.port; 2570 if (HIGH_BITS_OFFSET) 2571 ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET; 2572 return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr); 2573 } 2574 2575 static ssize_t uart_get_attr_irq(struct device *dev, 2576 struct device_attribute *attr, char *buf) 2577 { 2578 struct serial_struct tmp; 2579 struct tty_port *port = dev_get_drvdata(dev); 2580 2581 uart_get_info(port, &tmp); 2582 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq); 2583 } 2584 2585 static ssize_t uart_get_attr_flags(struct device *dev, 2586 struct device_attribute *attr, char *buf) 2587 { 2588 struct serial_struct tmp; 2589 struct tty_port *port = dev_get_drvdata(dev); 2590 2591 uart_get_info(port, &tmp); 2592 return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags); 2593 } 2594 2595 static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev, 2596 struct device_attribute *attr, char *buf) 2597 { 2598 struct serial_struct tmp; 2599 struct tty_port *port = dev_get_drvdata(dev); 2600 2601 uart_get_info(port, &tmp); 2602 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size); 2603 } 2604 2605 2606 static ssize_t uart_get_attr_close_delay(struct device *dev, 2607 struct device_attribute *attr, char *buf) 2608 { 2609 struct serial_struct tmp; 2610 struct tty_port *port = dev_get_drvdata(dev); 2611 2612 uart_get_info(port, &tmp); 2613 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay); 2614 } 2615 2616 2617 static ssize_t uart_get_attr_closing_wait(struct device *dev, 2618 struct device_attribute *attr, char *buf) 2619 { 2620 struct serial_struct tmp; 2621 struct tty_port *port = dev_get_drvdata(dev); 2622 2623 uart_get_info(port, &tmp); 2624 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait); 2625 } 2626 2627 static ssize_t uart_get_attr_custom_divisor(struct device *dev, 2628 struct device_attribute *attr, char *buf) 2629 { 2630 struct serial_struct tmp; 2631 struct tty_port *port = dev_get_drvdata(dev); 2632 2633 uart_get_info(port, &tmp); 2634 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor); 2635 } 2636 2637 static ssize_t uart_get_attr_io_type(struct device *dev, 2638 struct device_attribute *attr, char *buf) 2639 { 2640 struct serial_struct tmp; 2641 struct tty_port *port = dev_get_drvdata(dev); 2642 2643 uart_get_info(port, &tmp); 2644 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type); 2645 } 2646 2647 static ssize_t uart_get_attr_iomem_base(struct device *dev, 2648 struct device_attribute *attr, char *buf) 2649 { 2650 struct serial_struct tmp; 2651 struct tty_port *port = dev_get_drvdata(dev); 2652 2653 uart_get_info(port, &tmp); 2654 return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base); 2655 } 2656 2657 static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev, 2658 struct device_attribute *attr, char *buf) 2659 { 2660 struct serial_struct tmp; 2661 struct tty_port *port = dev_get_drvdata(dev); 2662 2663 uart_get_info(port, &tmp); 2664 return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift); 2665 } 2666 2667 static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL); 2668 static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL); 2669 static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL); 2670 static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL); 2671 static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL); 2672 static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL); 2673 static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL); 2674 static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL); 2675 static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL); 2676 static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL); 2677 static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL); 2678 static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL); 2679 static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL); 2680 2681 static struct attribute *tty_dev_attrs[] = { 2682 &dev_attr_type.attr, 2683 &dev_attr_line.attr, 2684 &dev_attr_port.attr, 2685 &dev_attr_irq.attr, 2686 &dev_attr_flags.attr, 2687 &dev_attr_xmit_fifo_size.attr, 2688 &dev_attr_uartclk.attr, 2689 &dev_attr_close_delay.attr, 2690 &dev_attr_closing_wait.attr, 2691 &dev_attr_custom_divisor.attr, 2692 &dev_attr_io_type.attr, 2693 &dev_attr_iomem_base.attr, 2694 &dev_attr_iomem_reg_shift.attr, 2695 NULL, 2696 }; 2697 2698 static const struct attribute_group tty_dev_attr_group = { 2699 .attrs = tty_dev_attrs, 2700 }; 2701 2702 /** 2703 * uart_add_one_port - attach a driver-defined port structure 2704 * @drv: pointer to the uart low level driver structure for this port 2705 * @uport: uart port structure to use for this port. 2706 * 2707 * This allows the driver to register its own uart_port structure 2708 * with the core driver. The main purpose is to allow the low 2709 * level uart drivers to expand uart_port, rather than having yet 2710 * more levels of structures. 2711 */ 2712 int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport) 2713 { 2714 struct uart_state *state; 2715 struct tty_port *port; 2716 int ret = 0; 2717 struct device *tty_dev; 2718 int num_groups; 2719 2720 BUG_ON(in_interrupt()); 2721 2722 if (uport->line >= drv->nr) 2723 return -EINVAL; 2724 2725 state = drv->state + uport->line; 2726 port = &state->port; 2727 2728 mutex_lock(&port_mutex); 2729 mutex_lock(&port->mutex); 2730 if (state->uart_port) { 2731 ret = -EINVAL; 2732 goto out; 2733 } 2734 2735 /* Link the port to the driver state table and vice versa */ 2736 atomic_set(&state->refcount, 1); 2737 init_waitqueue_head(&state->remove_wait); 2738 state->uart_port = uport; 2739 uport->state = state; 2740 2741 state->pm_state = UART_PM_STATE_UNDEFINED; 2742 uport->cons = drv->cons; 2743 uport->minor = drv->tty_driver->minor_start + uport->line; 2744 uport->name = kasprintf(GFP_KERNEL, "%s%d", drv->dev_name, 2745 drv->tty_driver->name_base + uport->line); 2746 if (!uport->name) { 2747 ret = -ENOMEM; 2748 goto out; 2749 } 2750 2751 /* 2752 * If this port is a console, then the spinlock is already 2753 * initialised. 2754 */ 2755 if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) { 2756 spin_lock_init(&uport->lock); 2757 lockdep_set_class(&uport->lock, &port_lock_key); 2758 } 2759 if (uport->cons && uport->dev) 2760 of_console_check(uport->dev->of_node, uport->cons->name, uport->line); 2761 2762 uart_configure_port(drv, state, uport); 2763 2764 port->console = uart_console(uport); 2765 2766 num_groups = 2; 2767 if (uport->attr_group) 2768 num_groups++; 2769 2770 uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups), 2771 GFP_KERNEL); 2772 if (!uport->tty_groups) { 2773 ret = -ENOMEM; 2774 goto out; 2775 } 2776 uport->tty_groups[0] = &tty_dev_attr_group; 2777 if (uport->attr_group) 2778 uport->tty_groups[1] = uport->attr_group; 2779 2780 /* 2781 * Register the port whether it's detected or not. This allows 2782 * setserial to be used to alter this port's parameters. 2783 */ 2784 tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver, 2785 uport->line, uport->dev, port, uport->tty_groups); 2786 if (likely(!IS_ERR(tty_dev))) { 2787 device_set_wakeup_capable(tty_dev, 1); 2788 } else { 2789 dev_err(uport->dev, "Cannot register tty device on line %d\n", 2790 uport->line); 2791 } 2792 2793 /* 2794 * Ensure UPF_DEAD is not set. 2795 */ 2796 uport->flags &= ~UPF_DEAD; 2797 2798 out: 2799 mutex_unlock(&port->mutex); 2800 mutex_unlock(&port_mutex); 2801 2802 return ret; 2803 } 2804 2805 /** 2806 * uart_remove_one_port - detach a driver defined port structure 2807 * @drv: pointer to the uart low level driver structure for this port 2808 * @uport: uart port structure for this port 2809 * 2810 * This unhooks (and hangs up) the specified port structure from the 2811 * core driver. No further calls will be made to the low-level code 2812 * for this port. 2813 */ 2814 int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport) 2815 { 2816 struct uart_state *state = drv->state + uport->line; 2817 struct tty_port *port = &state->port; 2818 struct uart_port *uart_port; 2819 struct tty_struct *tty; 2820 int ret = 0; 2821 2822 BUG_ON(in_interrupt()); 2823 2824 mutex_lock(&port_mutex); 2825 2826 /* 2827 * Mark the port "dead" - this prevents any opens from 2828 * succeeding while we shut down the port. 2829 */ 2830 mutex_lock(&port->mutex); 2831 uart_port = uart_port_check(state); 2832 if (uart_port != uport) 2833 dev_alert(uport->dev, "Removing wrong port: %p != %p\n", 2834 uart_port, uport); 2835 2836 if (!uart_port) { 2837 mutex_unlock(&port->mutex); 2838 ret = -EINVAL; 2839 goto out; 2840 } 2841 uport->flags |= UPF_DEAD; 2842 mutex_unlock(&port->mutex); 2843 2844 /* 2845 * Remove the devices from the tty layer 2846 */ 2847 tty_port_unregister_device(port, drv->tty_driver, uport->line); 2848 2849 tty = tty_port_tty_get(port); 2850 if (tty) { 2851 tty_vhangup(port->tty); 2852 tty_kref_put(tty); 2853 } 2854 2855 /* 2856 * If the port is used as a console, unregister it 2857 */ 2858 if (uart_console(uport)) 2859 unregister_console(uport->cons); 2860 2861 /* 2862 * Free the port IO and memory resources, if any. 2863 */ 2864 if (uport->type != PORT_UNKNOWN && uport->ops->release_port) 2865 uport->ops->release_port(uport); 2866 kfree(uport->tty_groups); 2867 kfree(uport->name); 2868 2869 /* 2870 * Indicate that there isn't a port here anymore. 2871 */ 2872 uport->type = PORT_UNKNOWN; 2873 2874 mutex_lock(&port->mutex); 2875 WARN_ON(atomic_dec_return(&state->refcount) < 0); 2876 wait_event(state->remove_wait, !atomic_read(&state->refcount)); 2877 state->uart_port = NULL; 2878 mutex_unlock(&port->mutex); 2879 out: 2880 mutex_unlock(&port_mutex); 2881 2882 return ret; 2883 } 2884 2885 /* 2886 * Are the two ports equivalent? 2887 */ 2888 int uart_match_port(struct uart_port *port1, struct uart_port *port2) 2889 { 2890 if (port1->iotype != port2->iotype) 2891 return 0; 2892 2893 switch (port1->iotype) { 2894 case UPIO_PORT: 2895 return (port1->iobase == port2->iobase); 2896 case UPIO_HUB6: 2897 return (port1->iobase == port2->iobase) && 2898 (port1->hub6 == port2->hub6); 2899 case UPIO_MEM: 2900 case UPIO_MEM16: 2901 case UPIO_MEM32: 2902 case UPIO_MEM32BE: 2903 case UPIO_AU: 2904 case UPIO_TSI: 2905 return (port1->mapbase == port2->mapbase); 2906 } 2907 return 0; 2908 } 2909 EXPORT_SYMBOL(uart_match_port); 2910 2911 /** 2912 * uart_handle_dcd_change - handle a change of carrier detect state 2913 * @uport: uart_port structure for the open port 2914 * @status: new carrier detect status, nonzero if active 2915 * 2916 * Caller must hold uport->lock 2917 */ 2918 void uart_handle_dcd_change(struct uart_port *uport, unsigned int status) 2919 { 2920 struct tty_port *port = &uport->state->port; 2921 struct tty_struct *tty = port->tty; 2922 struct tty_ldisc *ld; 2923 2924 lockdep_assert_held_once(&uport->lock); 2925 2926 if (tty) { 2927 ld = tty_ldisc_ref(tty); 2928 if (ld) { 2929 if (ld->ops->dcd_change) 2930 ld->ops->dcd_change(tty, status); 2931 tty_ldisc_deref(ld); 2932 } 2933 } 2934 2935 uport->icount.dcd++; 2936 2937 if (uart_dcd_enabled(uport)) { 2938 if (status) 2939 wake_up_interruptible(&port->open_wait); 2940 else if (tty) 2941 tty_hangup(tty); 2942 } 2943 } 2944 EXPORT_SYMBOL_GPL(uart_handle_dcd_change); 2945 2946 /** 2947 * uart_handle_cts_change - handle a change of clear-to-send state 2948 * @uport: uart_port structure for the open port 2949 * @status: new clear to send status, nonzero if active 2950 * 2951 * Caller must hold uport->lock 2952 */ 2953 void uart_handle_cts_change(struct uart_port *uport, unsigned int status) 2954 { 2955 lockdep_assert_held_once(&uport->lock); 2956 2957 uport->icount.cts++; 2958 2959 if (uart_softcts_mode(uport)) { 2960 if (uport->hw_stopped) { 2961 if (status) { 2962 uport->hw_stopped = 0; 2963 uport->ops->start_tx(uport); 2964 uart_write_wakeup(uport); 2965 } 2966 } else { 2967 if (!status) { 2968 uport->hw_stopped = 1; 2969 uport->ops->stop_tx(uport); 2970 } 2971 } 2972 2973 } 2974 } 2975 EXPORT_SYMBOL_GPL(uart_handle_cts_change); 2976 2977 /** 2978 * uart_insert_char - push a char to the uart layer 2979 * 2980 * User is responsible to call tty_flip_buffer_push when they are done with 2981 * insertion. 2982 * 2983 * @port: corresponding port 2984 * @status: state of the serial port RX buffer (LSR for 8250) 2985 * @overrun: mask of overrun bits in @status 2986 * @ch: character to push 2987 * @flag: flag for the character (see TTY_NORMAL and friends) 2988 */ 2989 void uart_insert_char(struct uart_port *port, unsigned int status, 2990 unsigned int overrun, unsigned int ch, unsigned int flag) 2991 { 2992 struct tty_port *tport = &port->state->port; 2993 2994 if ((status & port->ignore_status_mask & ~overrun) == 0) 2995 if (tty_insert_flip_char(tport, ch, flag) == 0) 2996 ++port->icount.buf_overrun; 2997 2998 /* 2999 * Overrun is special. Since it's reported immediately, 3000 * it doesn't affect the current character. 3001 */ 3002 if (status & ~port->ignore_status_mask & overrun) 3003 if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0) 3004 ++port->icount.buf_overrun; 3005 } 3006 EXPORT_SYMBOL_GPL(uart_insert_char); 3007 3008 EXPORT_SYMBOL(uart_write_wakeup); 3009 EXPORT_SYMBOL(uart_register_driver); 3010 EXPORT_SYMBOL(uart_unregister_driver); 3011 EXPORT_SYMBOL(uart_suspend_port); 3012 EXPORT_SYMBOL(uart_resume_port); 3013 EXPORT_SYMBOL(uart_add_one_port); 3014 EXPORT_SYMBOL(uart_remove_one_port); 3015 3016 MODULE_DESCRIPTION("Serial driver core"); 3017 MODULE_LICENSE("GPL"); 3018