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