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