1/* 2 * linux/drivers/char/core.c 3 * 4 * Driver core for serial ports 5 * 6 * Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o. 7 * 8 * Copyright 1999 ARM Limited 9 * Copyright (C) 2000-2001 Deep Blue Solutions Ltd. 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 24 */ 25#include <linux/module.h> 26#include <linux/tty.h> 27#include <linux/slab.h> 28#include <linux/init.h> 29#include <linux/console.h> 30#include <linux/serial_core.h> 31#include <linux/smp_lock.h> 32#include <linux/device.h> 33#include <linux/serial.h> /* for serial_state and serial_icounter_struct */ 34#include <linux/delay.h> 35#include <linux/mutex.h> 36 37#include <asm/irq.h> 38#include <asm/uaccess.h> 39 40/* 41 * This is used to lock changes in serial line configuration. 42 */ 43static DEFINE_MUTEX(port_mutex); 44 45/* 46 * lockdep: port->lock is initialized in two places, but we 47 * want only one lock-class: 48 */ 49static struct lock_class_key port_lock_key; 50 51#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8) 52 53#define uart_users(state) ((state)->count + ((state)->info ? (state)->info->blocked_open : 0)) 54 55#ifdef CONFIG_SERIAL_CORE_CONSOLE 56#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line) 57#else 58#define uart_console(port) (0) 59#endif 60 61static void uart_change_speed(struct uart_state *state, struct ktermios *old_termios); 62static void uart_wait_until_sent(struct tty_struct *tty, int timeout); 63static void uart_change_pm(struct uart_state *state, int pm_state); 64 65/* 66 * This routine is used by the interrupt handler to schedule processing in 67 * the software interrupt portion of the driver. 68 */ 69void uart_write_wakeup(struct uart_port *port) 70{ 71 struct uart_info *info = port->info; 72 /* 73 * This means you called this function _after_ the port was 74 * closed. No cookie for you. 75 */ 76 BUG_ON(!info); 77 tasklet_schedule(&info->tlet); 78} 79 80static void uart_stop(struct tty_struct *tty) 81{ 82 struct uart_state *state = tty->driver_data; 83 struct uart_port *port = state->port; 84 unsigned long flags; 85 86 spin_lock_irqsave(&port->lock, flags); 87 port->ops->stop_tx(port); 88 spin_unlock_irqrestore(&port->lock, flags); 89} 90 91static void __uart_start(struct tty_struct *tty) 92{ 93 struct uart_state *state = tty->driver_data; 94 struct uart_port *port = state->port; 95 96 if (!uart_circ_empty(&state->info->xmit) && state->info->xmit.buf && 97 !tty->stopped && !tty->hw_stopped) 98 port->ops->start_tx(port); 99} 100 101static void uart_start(struct tty_struct *tty) 102{ 103 struct uart_state *state = tty->driver_data; 104 struct uart_port *port = state->port; 105 unsigned long flags; 106 107 spin_lock_irqsave(&port->lock, flags); 108 __uart_start(tty); 109 spin_unlock_irqrestore(&port->lock, flags); 110} 111 112static void uart_tasklet_action(unsigned long data) 113{ 114 struct uart_state *state = (struct uart_state *)data; 115 tty_wakeup(state->info->tty); 116} 117 118static inline void 119uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear) 120{ 121 unsigned long flags; 122 unsigned int old; 123 124 spin_lock_irqsave(&port->lock, flags); 125 old = port->mctrl; 126 port->mctrl = (old & ~clear) | set; 127 if (old != port->mctrl) 128 port->ops->set_mctrl(port, port->mctrl); 129 spin_unlock_irqrestore(&port->lock, flags); 130} 131 132#define uart_set_mctrl(port,set) uart_update_mctrl(port,set,0) 133#define uart_clear_mctrl(port,clear) uart_update_mctrl(port,0,clear) 134 135/* 136 * Startup the port. This will be called once per open. All calls 137 * will be serialised by the per-port semaphore. 138 */ 139static int uart_startup(struct uart_state *state, int init_hw) 140{ 141 struct uart_info *info = state->info; 142 struct uart_port *port = state->port; 143 unsigned long page; 144 int retval = 0; 145 146 if (info->flags & UIF_INITIALIZED) 147 return 0; 148 149 /* 150 * Set the TTY IO error marker - we will only clear this 151 * once we have successfully opened the port. Also set 152 * up the tty->alt_speed kludge 153 */ 154 set_bit(TTY_IO_ERROR, &info->tty->flags); 155 156 if (port->type == PORT_UNKNOWN) 157 return 0; 158 159 /* 160 * Initialise and allocate the transmit and temporary 161 * buffer. 162 */ 163 if (!info->xmit.buf) { 164 page = get_zeroed_page(GFP_KERNEL); 165 if (!page) 166 return -ENOMEM; 167 168 info->xmit.buf = (unsigned char *) page; 169 uart_circ_clear(&info->xmit); 170 } 171 172 retval = port->ops->startup(port); 173 if (retval == 0) { 174 if (init_hw) { 175 /* 176 * Initialise the hardware port settings. 177 */ 178 uart_change_speed(state, NULL); 179 180 /* 181 * Setup the RTS and DTR signals once the 182 * port is open and ready to respond. 183 */ 184 if (info->tty->termios->c_cflag & CBAUD) 185 uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR); 186 } 187 188 if (info->flags & UIF_CTS_FLOW) { 189 spin_lock_irq(&port->lock); 190 if (!(port->ops->get_mctrl(port) & TIOCM_CTS)) 191 info->tty->hw_stopped = 1; 192 spin_unlock_irq(&port->lock); 193 } 194 195 info->flags |= UIF_INITIALIZED; 196 197 clear_bit(TTY_IO_ERROR, &info->tty->flags); 198 } 199 200 if (retval && capable(CAP_SYS_ADMIN)) 201 retval = 0; 202 203 return retval; 204} 205 206/* 207 * This routine will shutdown a serial port; interrupts are disabled, and 208 * DTR is dropped if the hangup on close termio flag is on. Calls to 209 * uart_shutdown are serialised by the per-port semaphore. 210 */ 211static void uart_shutdown(struct uart_state *state) 212{ 213 struct uart_info *info = state->info; 214 struct uart_port *port = state->port; 215 216 /* 217 * Set the TTY IO error marker 218 */ 219 if (info->tty) 220 set_bit(TTY_IO_ERROR, &info->tty->flags); 221 222 if (info->flags & UIF_INITIALIZED) { 223 info->flags &= ~UIF_INITIALIZED; 224 225 /* 226 * Turn off DTR and RTS early. 227 */ 228 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) 229 uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS); 230 231 /* 232 * clear delta_msr_wait queue to avoid mem leaks: we may free 233 * the irq here so the queue might never be woken up. Note 234 * that we won't end up waiting on delta_msr_wait again since 235 * any outstanding file descriptors should be pointing at 236 * hung_up_tty_fops now. 237 */ 238 wake_up_interruptible(&info->delta_msr_wait); 239 240 /* 241 * Free the IRQ and disable the port. 242 */ 243 port->ops->shutdown(port); 244 245 /* 246 * Ensure that the IRQ handler isn't running on another CPU. 247 */ 248 synchronize_irq(port->irq); 249 } 250 251 /* 252 * kill off our tasklet 253 */ 254 tasklet_kill(&info->tlet); 255 256 /* 257 * Free the transmit buffer page. 258 */ 259 if (info->xmit.buf) { 260 free_page((unsigned long)info->xmit.buf); 261 info->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. 332 */ 333unsigned int 334uart_get_baud_rate(struct uart_port *port, struct ktermios *termios, 335 struct ktermios *old, unsigned int min, unsigned int max) 336{ 337 unsigned int try, baud, altbaud = 38400; 338 upf_t flags = port->flags & UPF_SPD_MASK; 339 340 if (flags == UPF_SPD_HI) 341 altbaud = 57600; 342 if (flags == UPF_SPD_VHI) 343 altbaud = 115200; 344 if (flags == UPF_SPD_SHI) 345 altbaud = 230400; 346 if (flags == UPF_SPD_WARP) 347 altbaud = 460800; 348 349 for (try = 0; try < 2; try++) { 350 baud = tty_termios_baud_rate(termios); 351 352 /* 353 * The spd_hi, spd_vhi, spd_shi, spd_warp kludge... 354 * Die! Die! Die! 355 */ 356 if (baud == 38400) 357 baud = altbaud; 358 359 /* 360 * Special case: B0 rate. 361 */ 362 if (baud == 0) 363 baud = 9600; 364 365 if (baud >= min && baud <= max) 366 return baud; 367 368 /* 369 * Oops, the quotient was zero. Try again with 370 * the old baud rate if possible. 371 */ 372 termios->c_cflag &= ~CBAUD; 373 if (old) { 374 termios->c_cflag |= old->c_cflag & CBAUD; 375 old = NULL; 376 continue; 377 } 378 379 /* 380 * As a last resort, if the quotient is zero, 381 * default to 9600 bps 382 */ 383 termios->c_cflag |= B9600; 384 } 385 386 return 0; 387} 388 389EXPORT_SYMBOL(uart_get_baud_rate); 390 391/** 392 * uart_get_divisor - return uart clock divisor 393 * @port: uart_port structure describing the port. 394 * @baud: desired baud rate 395 * 396 * Calculate the uart clock divisor for the port. 397 */ 398unsigned int 399uart_get_divisor(struct uart_port *port, unsigned int baud) 400{ 401 unsigned int quot; 402 403 /* 404 * Old custom speed handling. 405 */ 406 if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST) 407 quot = port->custom_divisor; 408 else 409 quot = (port->uartclk + (8 * baud)) / (16 * baud); 410 411 return quot; 412} 413 414EXPORT_SYMBOL(uart_get_divisor); 415 416static void 417uart_change_speed(struct uart_state *state, struct ktermios *old_termios) 418{ 419 struct tty_struct *tty = state->info->tty; 420 struct uart_port *port = state->port; 421 struct ktermios *termios; 422 423 /* 424 * If we have no tty, termios, or the port does not exist, 425 * then we can't set the parameters for this port. 426 */ 427 if (!tty || !tty->termios || port->type == PORT_UNKNOWN) 428 return; 429 430 termios = tty->termios; 431 432 /* 433 * Set flags based on termios cflag 434 */ 435 if (termios->c_cflag & CRTSCTS) 436 state->info->flags |= UIF_CTS_FLOW; 437 else 438 state->info->flags &= ~UIF_CTS_FLOW; 439 440 if (termios->c_cflag & CLOCAL) 441 state->info->flags &= ~UIF_CHECK_CD; 442 else 443 state->info->flags |= UIF_CHECK_CD; 444 445 port->ops->set_termios(port, termios, old_termios); 446} 447 448static inline void 449__uart_put_char(struct uart_port *port, struct circ_buf *circ, unsigned char c) 450{ 451 unsigned long flags; 452 453 if (!circ->buf) 454 return; 455 456 spin_lock_irqsave(&port->lock, flags); 457 if (uart_circ_chars_free(circ) != 0) { 458 circ->buf[circ->head] = c; 459 circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1); 460 } 461 spin_unlock_irqrestore(&port->lock, flags); 462} 463 464static void uart_put_char(struct tty_struct *tty, unsigned char ch) 465{ 466 struct uart_state *state = tty->driver_data; 467 468 __uart_put_char(state->port, &state->info->xmit, ch); 469} 470 471static void uart_flush_chars(struct tty_struct *tty) 472{ 473 uart_start(tty); 474} 475 476static int 477uart_write(struct tty_struct *tty, const unsigned char *buf, int count) 478{ 479 struct uart_state *state = tty->driver_data; 480 struct uart_port *port; 481 struct circ_buf *circ; 482 unsigned long flags; 483 int c, ret = 0; 484 485 /* 486 * This means you called this function _after_ the port was 487 * closed. No cookie for you. 488 */ 489 if (!state || !state->info) { 490 WARN_ON(1); 491 return -EL3HLT; 492 } 493 494 port = state->port; 495 circ = &state->info->xmit; 496 497 if (!circ->buf) 498 return 0; 499 500 spin_lock_irqsave(&port->lock, flags); 501 while (1) { 502 c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE); 503 if (count < c) 504 c = count; 505 if (c <= 0) 506 break; 507 memcpy(circ->buf + circ->head, buf, c); 508 circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1); 509 buf += c; 510 count -= c; 511 ret += c; 512 } 513 spin_unlock_irqrestore(&port->lock, flags); 514 515 uart_start(tty); 516 return ret; 517} 518 519static int uart_write_room(struct tty_struct *tty) 520{ 521 struct uart_state *state = tty->driver_data; 522 523 return uart_circ_chars_free(&state->info->xmit); 524} 525 526static int uart_chars_in_buffer(struct tty_struct *tty) 527{ 528 struct uart_state *state = tty->driver_data; 529 530 return uart_circ_chars_pending(&state->info->xmit); 531} 532 533static void uart_flush_buffer(struct tty_struct *tty) 534{ 535 struct uart_state *state = tty->driver_data; 536 struct uart_port *port = state->port; 537 unsigned long flags; 538 539 /* 540 * This means you called this function _after_ the port was 541 * closed. No cookie for you. 542 */ 543 if (!state || !state->info) { 544 WARN_ON(1); 545 return; 546 } 547 548 pr_debug("uart_flush_buffer(%d) called\n", tty->index); 549 550 spin_lock_irqsave(&port->lock, flags); 551 uart_circ_clear(&state->info->xmit); 552 spin_unlock_irqrestore(&port->lock, flags); 553 tty_wakeup(tty); 554} 555 556/* 557 * This function is used to send a high-priority XON/XOFF character to 558 * the device 559 */ 560static void uart_send_xchar(struct tty_struct *tty, char ch) 561{ 562 struct uart_state *state = tty->driver_data; 563 struct uart_port *port = state->port; 564 unsigned long flags; 565 566 if (port->ops->send_xchar) 567 port->ops->send_xchar(port, ch); 568 else { 569 port->x_char = ch; 570 if (ch) { 571 spin_lock_irqsave(&port->lock, flags); 572 port->ops->start_tx(port); 573 spin_unlock_irqrestore(&port->lock, flags); 574 } 575 } 576} 577 578static void uart_throttle(struct tty_struct *tty) 579{ 580 struct uart_state *state = tty->driver_data; 581 582 if (I_IXOFF(tty)) 583 uart_send_xchar(tty, STOP_CHAR(tty)); 584 585 if (tty->termios->c_cflag & CRTSCTS) 586 uart_clear_mctrl(state->port, TIOCM_RTS); 587} 588 589static void uart_unthrottle(struct tty_struct *tty) 590{ 591 struct uart_state *state = tty->driver_data; 592 struct uart_port *port = state->port; 593 594 if (I_IXOFF(tty)) { 595 if (port->x_char) 596 port->x_char = 0; 597 else 598 uart_send_xchar(tty, START_CHAR(tty)); 599 } 600 601 if (tty->termios->c_cflag & CRTSCTS) 602 uart_set_mctrl(port, TIOCM_RTS); 603} 604 605static int uart_get_info(struct uart_state *state, 606 struct serial_struct __user *retinfo) 607{ 608 struct uart_port *port = state->port; 609 struct serial_struct tmp; 610 611 memset(&tmp, 0, sizeof(tmp)); 612 tmp.type = port->type; 613 tmp.line = port->line; 614 tmp.port = port->iobase; 615 if (HIGH_BITS_OFFSET) 616 tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET; 617 tmp.irq = port->irq; 618 tmp.flags = port->flags; 619 tmp.xmit_fifo_size = port->fifosize; 620 tmp.baud_base = port->uartclk / 16; 621 tmp.close_delay = state->close_delay / 10; 622 tmp.closing_wait = state->closing_wait == USF_CLOSING_WAIT_NONE ? 623 ASYNC_CLOSING_WAIT_NONE : 624 state->closing_wait / 10; 625 tmp.custom_divisor = port->custom_divisor; 626 tmp.hub6 = port->hub6; 627 tmp.io_type = port->iotype; 628 tmp.iomem_reg_shift = port->regshift; 629 tmp.iomem_base = (void *)port->mapbase; 630 631 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 632 return -EFAULT; 633 return 0; 634} 635 636static int uart_set_info(struct uart_state *state, 637 struct serial_struct __user *newinfo) 638{ 639 struct serial_struct new_serial; 640 struct uart_port *port = state->port; 641 unsigned long new_port; 642 unsigned int change_irq, change_port, closing_wait; 643 unsigned int old_custom_divisor, close_delay; 644 upf_t old_flags, new_flags; 645 int retval = 0; 646 647 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial))) 648 return -EFAULT; 649 650 new_port = new_serial.port; 651 if (HIGH_BITS_OFFSET) 652 new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET; 653 654 new_serial.irq = irq_canonicalize(new_serial.irq); 655 close_delay = new_serial.close_delay * 10; 656 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 657 USF_CLOSING_WAIT_NONE : new_serial.closing_wait * 10; 658 659 /* 660 * This semaphore protects state->count. It is also 661 * very useful to prevent opens. Also, take the 662 * port configuration semaphore to make sure that a 663 * module insertion/removal doesn't change anything 664 * under us. 665 */ 666 mutex_lock(&state->mutex); 667 668 change_irq = !(port->flags & UPF_FIXED_PORT) 669 && new_serial.irq != port->irq; 670 671 /* 672 * Since changing the 'type' of the port changes its resource 673 * allocations, we should treat type changes the same as 674 * IO port changes. 675 */ 676 change_port = !(port->flags & UPF_FIXED_PORT) 677 && (new_port != port->iobase || 678 (unsigned long)new_serial.iomem_base != port->mapbase || 679 new_serial.hub6 != port->hub6 || 680 new_serial.io_type != port->iotype || 681 new_serial.iomem_reg_shift != port->regshift || 682 new_serial.type != port->type); 683 684 old_flags = port->flags; 685 new_flags = new_serial.flags; 686 old_custom_divisor = port->custom_divisor; 687 688 if (!capable(CAP_SYS_ADMIN)) { 689 retval = -EPERM; 690 if (change_irq || change_port || 691 (new_serial.baud_base != port->uartclk / 16) || 692 (close_delay != state->close_delay) || 693 (closing_wait != state->closing_wait) || 694 (new_serial.xmit_fifo_size && 695 new_serial.xmit_fifo_size != port->fifosize) || 696 (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0)) 697 goto exit; 698 port->flags = ((port->flags & ~UPF_USR_MASK) | 699 (new_flags & UPF_USR_MASK)); 700 port->custom_divisor = new_serial.custom_divisor; 701 goto check_and_exit; 702 } 703 704 /* 705 * Ask the low level driver to verify the settings. 706 */ 707 if (port->ops->verify_port) 708 retval = port->ops->verify_port(port, &new_serial); 709 710 if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) || 711 (new_serial.baud_base < 9600)) 712 retval = -EINVAL; 713 714 if (retval) 715 goto exit; 716 717 if (change_port || change_irq) { 718 retval = -EBUSY; 719 720 /* 721 * Make sure that we are the sole user of this port. 722 */ 723 if (uart_users(state) > 1) 724 goto exit; 725 726 /* 727 * We need to shutdown the serial port at the old 728 * port/type/irq combination. 729 */ 730 uart_shutdown(state); 731 } 732 733 if (change_port) { 734 unsigned long old_iobase, old_mapbase; 735 unsigned int old_type, old_iotype, old_hub6, old_shift; 736 737 old_iobase = port->iobase; 738 old_mapbase = port->mapbase; 739 old_type = port->type; 740 old_hub6 = port->hub6; 741 old_iotype = port->iotype; 742 old_shift = port->regshift; 743 744 /* 745 * Free and release old regions 746 */ 747 if (old_type != PORT_UNKNOWN) 748 port->ops->release_port(port); 749 750 port->iobase = new_port; 751 port->type = new_serial.type; 752 port->hub6 = new_serial.hub6; 753 port->iotype = new_serial.io_type; 754 port->regshift = new_serial.iomem_reg_shift; 755 port->mapbase = (unsigned long)new_serial.iomem_base; 756 757 /* 758 * Claim and map the new regions 759 */ 760 if (port->type != PORT_UNKNOWN) { 761 retval = port->ops->request_port(port); 762 } else { 763 /* Always success - Jean II */ 764 retval = 0; 765 } 766 767 /* 768 * If we fail to request resources for the 769 * new port, try to restore the old settings. 770 */ 771 if (retval && old_type != PORT_UNKNOWN) { 772 port->iobase = old_iobase; 773 port->type = old_type; 774 port->hub6 = old_hub6; 775 port->iotype = old_iotype; 776 port->regshift = old_shift; 777 port->mapbase = old_mapbase; 778 retval = port->ops->request_port(port); 779 /* 780 * If we failed to restore the old settings, 781 * we fail like this. 782 */ 783 if (retval) 784 port->type = PORT_UNKNOWN; 785 786 /* 787 * We failed anyway. 788 */ 789 retval = -EBUSY; 790 goto exit; // Added to return the correct error -Ram Gupta 791 } 792 } 793 794 if (change_irq) 795 port->irq = new_serial.irq; 796 if (!(port->flags & UPF_FIXED_PORT)) 797 port->uartclk = new_serial.baud_base * 16; 798 port->flags = (port->flags & ~UPF_CHANGE_MASK) | 799 (new_flags & UPF_CHANGE_MASK); 800 port->custom_divisor = new_serial.custom_divisor; 801 state->close_delay = close_delay; 802 state->closing_wait = closing_wait; 803 if (new_serial.xmit_fifo_size) 804 port->fifosize = new_serial.xmit_fifo_size; 805 if (state->info->tty) 806 state->info->tty->low_latency = 807 (port->flags & UPF_LOW_LATENCY) ? 1 : 0; 808 809 check_and_exit: 810 retval = 0; 811 if (port->type == PORT_UNKNOWN) 812 goto exit; 813 if (state->info->flags & UIF_INITIALIZED) { 814 if (((old_flags ^ port->flags) & UPF_SPD_MASK) || 815 old_custom_divisor != port->custom_divisor) { 816 /* 817 * If they're setting up a custom divisor or speed, 818 * instead of clearing it, then bitch about it. No 819 * need to rate-limit; it's CAP_SYS_ADMIN only. 820 */ 821 if (port->flags & UPF_SPD_MASK) { 822 char buf[64]; 823 printk(KERN_NOTICE 824 "%s sets custom speed on %s. This " 825 "is deprecated.\n", current->comm, 826 tty_name(state->info->tty, buf)); 827 } 828 uart_change_speed(state, NULL); 829 } 830 } else 831 retval = uart_startup(state, 1); 832 exit: 833 mutex_unlock(&state->mutex); 834 return retval; 835} 836 837 838/* 839 * uart_get_lsr_info - get line status register info. 840 * Note: uart_ioctl protects us against hangups. 841 */ 842static int uart_get_lsr_info(struct uart_state *state, 843 unsigned int __user *value) 844{ 845 struct uart_port *port = state->port; 846 unsigned int result; 847 848 result = port->ops->tx_empty(port); 849 850 /* 851 * If we're about to load something into the transmit 852 * register, we'll pretend the transmitter isn't empty to 853 * avoid a race condition (depending on when the transmit 854 * interrupt happens). 855 */ 856 if (port->x_char || 857 ((uart_circ_chars_pending(&state->info->xmit) > 0) && 858 !state->info->tty->stopped && !state->info->tty->hw_stopped)) 859 result &= ~TIOCSER_TEMT; 860 861 return put_user(result, value); 862} 863 864static int uart_tiocmget(struct tty_struct *tty, struct file *file) 865{ 866 struct uart_state *state = tty->driver_data; 867 struct uart_port *port = state->port; 868 int result = -EIO; 869 870 mutex_lock(&state->mutex); 871 if ((!file || !tty_hung_up_p(file)) && 872 !(tty->flags & (1 << TTY_IO_ERROR))) { 873 result = port->mctrl; 874 875 spin_lock_irq(&port->lock); 876 result |= port->ops->get_mctrl(port); 877 spin_unlock_irq(&port->lock); 878 } 879 mutex_unlock(&state->mutex); 880 881 return result; 882} 883 884static int 885uart_tiocmset(struct tty_struct *tty, struct file *file, 886 unsigned int set, unsigned int clear) 887{ 888 struct uart_state *state = tty->driver_data; 889 struct uart_port *port = state->port; 890 int ret = -EIO; 891 892 mutex_lock(&state->mutex); 893 if ((!file || !tty_hung_up_p(file)) && 894 !(tty->flags & (1 << TTY_IO_ERROR))) { 895 uart_update_mctrl(port, set, clear); 896 ret = 0; 897 } 898 mutex_unlock(&state->mutex); 899 return ret; 900} 901 902static void uart_break_ctl(struct tty_struct *tty, int break_state) 903{ 904 struct uart_state *state = tty->driver_data; 905 struct uart_port *port = state->port; 906 907 BUG_ON(!kernel_locked()); 908 909 mutex_lock(&state->mutex); 910 911 if (port->type != PORT_UNKNOWN) 912 port->ops->break_ctl(port, break_state); 913 914 mutex_unlock(&state->mutex); 915} 916 917static int uart_do_autoconfig(struct uart_state *state) 918{ 919 struct uart_port *port = state->port; 920 int flags, ret; 921 922 if (!capable(CAP_SYS_ADMIN)) 923 return -EPERM; 924 925 /* 926 * Take the per-port semaphore. This prevents count from 927 * changing, and hence any extra opens of the port while 928 * we're auto-configuring. 929 */ 930 if (mutex_lock_interruptible(&state->mutex)) 931 return -ERESTARTSYS; 932 933 ret = -EBUSY; 934 if (uart_users(state) == 1) { 935 uart_shutdown(state); 936 937 /* 938 * If we already have a port type configured, 939 * we must release its resources. 940 */ 941 if (port->type != PORT_UNKNOWN) 942 port->ops->release_port(port); 943 944 flags = UART_CONFIG_TYPE; 945 if (port->flags & UPF_AUTO_IRQ) 946 flags |= UART_CONFIG_IRQ; 947 948 /* 949 * This will claim the ports resources if 950 * a port is found. 951 */ 952 port->ops->config_port(port, flags); 953 954 ret = uart_startup(state, 1); 955 } 956 mutex_unlock(&state->mutex); 957 return ret; 958} 959 960/* 961 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change 962 * - mask passed in arg for lines of interest 963 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) 964 * Caller should use TIOCGICOUNT to see which one it was 965 */ 966static int 967uart_wait_modem_status(struct uart_state *state, unsigned long arg) 968{ 969 struct uart_port *port = state->port; 970 DECLARE_WAITQUEUE(wait, current); 971 struct uart_icount cprev, cnow; 972 int ret; 973 974 /* 975 * note the counters on entry 976 */ 977 spin_lock_irq(&port->lock); 978 memcpy(&cprev, &port->icount, sizeof(struct uart_icount)); 979 980 /* 981 * Force modem status interrupts on 982 */ 983 port->ops->enable_ms(port); 984 spin_unlock_irq(&port->lock); 985 986 add_wait_queue(&state->info->delta_msr_wait, &wait); 987 for (;;) { 988 spin_lock_irq(&port->lock); 989 memcpy(&cnow, &port->icount, sizeof(struct uart_icount)); 990 spin_unlock_irq(&port->lock); 991 992 set_current_state(TASK_INTERRUPTIBLE); 993 994 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 995 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 996 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 997 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) { 998 ret = 0; 999 break; 1000 } 1001 1002 schedule(); 1003 1004 /* see if a signal did it */ 1005 if (signal_pending(current)) { 1006 ret = -ERESTARTSYS; 1007 break; 1008 } 1009 1010 cprev = cnow; 1011 } 1012 1013 current->state = TASK_RUNNING; 1014 remove_wait_queue(&state->info->delta_msr_wait, &wait); 1015 1016 return ret; 1017} 1018 1019/* 1020 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) 1021 * Return: write counters to the user passed counter struct 1022 * NB: both 1->0 and 0->1 transitions are counted except for 1023 * RI where only 0->1 is counted. 1024 */ 1025static int uart_get_count(struct uart_state *state, 1026 struct serial_icounter_struct __user *icnt) 1027{ 1028 struct serial_icounter_struct icount; 1029 struct uart_icount cnow; 1030 struct uart_port *port = state->port; 1031 1032 spin_lock_irq(&port->lock); 1033 memcpy(&cnow, &port->icount, sizeof(struct uart_icount)); 1034 spin_unlock_irq(&port->lock); 1035 1036 icount.cts = cnow.cts; 1037 icount.dsr = cnow.dsr; 1038 icount.rng = cnow.rng; 1039 icount.dcd = cnow.dcd; 1040 icount.rx = cnow.rx; 1041 icount.tx = cnow.tx; 1042 icount.frame = cnow.frame; 1043 icount.overrun = cnow.overrun; 1044 icount.parity = cnow.parity; 1045 icount.brk = cnow.brk; 1046 icount.buf_overrun = cnow.buf_overrun; 1047 1048 return copy_to_user(icnt, &icount, sizeof(icount)) ? -EFAULT : 0; 1049} 1050 1051/* 1052 * Called via sys_ioctl under the BKL. We can use spin_lock_irq() here. 1053 */ 1054static int 1055uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, 1056 unsigned long arg) 1057{ 1058 struct uart_state *state = tty->driver_data; 1059 void __user *uarg = (void __user *)arg; 1060 int ret = -ENOIOCTLCMD; 1061 1062 BUG_ON(!kernel_locked()); 1063 1064 /* 1065 * These ioctls don't rely on the hardware to be present. 1066 */ 1067 switch (cmd) { 1068 case TIOCGSERIAL: 1069 ret = uart_get_info(state, uarg); 1070 break; 1071 1072 case TIOCSSERIAL: 1073 ret = uart_set_info(state, uarg); 1074 break; 1075 1076 case TIOCSERCONFIG: 1077 ret = uart_do_autoconfig(state); 1078 break; 1079 1080 case TIOCSERGWILD: /* obsolete */ 1081 case TIOCSERSWILD: /* obsolete */ 1082 ret = 0; 1083 break; 1084 } 1085 1086 if (ret != -ENOIOCTLCMD) 1087 goto out; 1088 1089 if (tty->flags & (1 << TTY_IO_ERROR)) { 1090 ret = -EIO; 1091 goto out; 1092 } 1093 1094 /* 1095 * The following should only be used when hardware is present. 1096 */ 1097 switch (cmd) { 1098 case TIOCMIWAIT: 1099 ret = uart_wait_modem_status(state, arg); 1100 break; 1101 1102 case TIOCGICOUNT: 1103 ret = uart_get_count(state, uarg); 1104 break; 1105 } 1106 1107 if (ret != -ENOIOCTLCMD) 1108 goto out; 1109 1110 mutex_lock(&state->mutex); 1111 1112 if (tty_hung_up_p(filp)) { 1113 ret = -EIO; 1114 goto out_up; 1115 } 1116 1117 /* 1118 * All these rely on hardware being present and need to be 1119 * protected against the tty being hung up. 1120 */ 1121 switch (cmd) { 1122 case TIOCSERGETLSR: /* Get line status register */ 1123 ret = uart_get_lsr_info(state, uarg); 1124 break; 1125 1126 default: { 1127 struct uart_port *port = state->port; 1128 if (port->ops->ioctl) 1129 ret = port->ops->ioctl(port, cmd, arg); 1130 break; 1131 } 1132 } 1133 out_up: 1134 mutex_unlock(&state->mutex); 1135 out: 1136 return ret; 1137} 1138 1139static void uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios) 1140{ 1141 struct uart_state *state = tty->driver_data; 1142 unsigned long flags; 1143 unsigned int cflag = tty->termios->c_cflag; 1144 1145 BUG_ON(!kernel_locked()); 1146 1147 /* 1148 * These are the bits that are used to setup various 1149 * flags in the low level driver. 1150 */ 1151#define RELEVANT_IFLAG(iflag) ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK)) 1152 1153 if ((cflag ^ old_termios->c_cflag) == 0 && 1154 RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0) 1155 return; 1156 1157 uart_change_speed(state, old_termios); 1158 1159 /* Handle transition to B0 status */ 1160 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) 1161 uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR); 1162 1163 /* Handle transition away from B0 status */ 1164 if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) { 1165 unsigned int mask = TIOCM_DTR; 1166 if (!(cflag & CRTSCTS) || 1167 !test_bit(TTY_THROTTLED, &tty->flags)) 1168 mask |= TIOCM_RTS; 1169 uart_set_mctrl(state->port, mask); 1170 } 1171 1172 /* Handle turning off CRTSCTS */ 1173 if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) { 1174 spin_lock_irqsave(&state->port->lock, flags); 1175 tty->hw_stopped = 0; 1176 __uart_start(tty); 1177 spin_unlock_irqrestore(&state->port->lock, flags); 1178 } 1179 1180 /* Handle turning on CRTSCTS */ 1181 if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) { 1182 spin_lock_irqsave(&state->port->lock, flags); 1183 if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) { 1184 tty->hw_stopped = 1; 1185 state->port->ops->stop_tx(state->port); 1186 } 1187 spin_unlock_irqrestore(&state->port->lock, flags); 1188 } 1189 1190} 1191 1192/* 1193 * In 2.4.5, calls to this will be serialized via the BKL in 1194 * linux/drivers/char/tty_io.c:tty_release() 1195 * linux/drivers/char/tty_io.c:do_tty_handup() 1196 */ 1197static void uart_close(struct tty_struct *tty, struct file *filp) 1198{ 1199 struct uart_state *state = tty->driver_data; 1200 struct uart_port *port; 1201 1202 BUG_ON(!kernel_locked()); 1203 1204 if (!state || !state->port) 1205 return; 1206 1207 port = state->port; 1208 1209 pr_debug("uart_close(%d) called\n", port->line); 1210 1211 mutex_lock(&state->mutex); 1212 1213 if (tty_hung_up_p(filp)) 1214 goto done; 1215 1216 if ((tty->count == 1) && (state->count != 1)) { 1217 /* 1218 * Uh, oh. tty->count is 1, which means that the tty 1219 * structure will be freed. state->count should always 1220 * be one in these conditions. If it's greater than 1221 * one, we've got real problems, since it means the 1222 * serial port won't be shutdown. 1223 */ 1224 printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, " 1225 "state->count is %d\n", state->count); 1226 state->count = 1; 1227 } 1228 if (--state->count < 0) { 1229 printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n", 1230 tty->name, state->count); 1231 state->count = 0; 1232 } 1233 if (state->count) 1234 goto done; 1235 1236 /* 1237 * Now we wait for the transmit buffer to clear; and we notify 1238 * the line discipline to only process XON/XOFF characters by 1239 * setting tty->closing. 1240 */ 1241 tty->closing = 1; 1242 1243 if (state->closing_wait != USF_CLOSING_WAIT_NONE) 1244 tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait)); 1245 1246 /* 1247 * At this point, we stop accepting input. To do this, we 1248 * disable the receive line status interrupts. 1249 */ 1250 if (state->info->flags & UIF_INITIALIZED) { 1251 unsigned long flags; 1252 spin_lock_irqsave(&port->lock, flags); 1253 port->ops->stop_rx(port); 1254 spin_unlock_irqrestore(&port->lock, flags); 1255 /* 1256 * Before we drop DTR, make sure the UART transmitter 1257 * has completely drained; this is especially 1258 * important if there is a transmit FIFO! 1259 */ 1260 uart_wait_until_sent(tty, port->timeout); 1261 } 1262 1263 uart_shutdown(state); 1264 uart_flush_buffer(tty); 1265 1266 tty_ldisc_flush(tty); 1267 1268 tty->closing = 0; 1269 state->info->tty = NULL; 1270 1271 if (state->info->blocked_open) { 1272 if (state->close_delay) 1273 msleep_interruptible(state->close_delay); 1274 } else if (!uart_console(port)) { 1275 uart_change_pm(state, 3); 1276 } 1277 1278 /* 1279 * Wake up anyone trying to open this port. 1280 */ 1281 state->info->flags &= ~UIF_NORMAL_ACTIVE; 1282 wake_up_interruptible(&state->info->open_wait); 1283 1284 done: 1285 mutex_unlock(&state->mutex); 1286} 1287 1288static void uart_wait_until_sent(struct tty_struct *tty, int timeout) 1289{ 1290 struct uart_state *state = tty->driver_data; 1291 struct uart_port *port = state->port; 1292 unsigned long char_time, expire; 1293 1294 BUG_ON(!kernel_locked()); 1295 1296 if (port->type == PORT_UNKNOWN || port->fifosize == 0) 1297 return; 1298 1299 /* 1300 * Set the check interval to be 1/5 of the estimated time to 1301 * send a single character, and make it at least 1. The check 1302 * interval should also be less than the timeout. 1303 * 1304 * Note: we have to use pretty tight timings here to satisfy 1305 * the NIST-PCTS. 1306 */ 1307 char_time = (port->timeout - HZ/50) / port->fifosize; 1308 char_time = char_time / 5; 1309 if (char_time == 0) 1310 char_time = 1; 1311 if (timeout && timeout < char_time) 1312 char_time = timeout; 1313 1314 /* 1315 * If the transmitter hasn't cleared in twice the approximate 1316 * amount of time to send the entire FIFO, it probably won't 1317 * ever clear. This assumes the UART isn't doing flow 1318 * control, which is currently the case. Hence, if it ever 1319 * takes longer than port->timeout, this is probably due to a 1320 * UART bug of some kind. So, we clamp the timeout parameter at 1321 * 2*port->timeout. 1322 */ 1323 if (timeout == 0 || timeout > 2 * port->timeout) 1324 timeout = 2 * port->timeout; 1325 1326 expire = jiffies + timeout; 1327 1328 pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n", 1329 port->line, jiffies, expire); 1330 1331 /* 1332 * Check whether the transmitter is empty every 'char_time'. 1333 * 'timeout' / 'expire' give us the maximum amount of time 1334 * we wait. 1335 */ 1336 while (!port->ops->tx_empty(port)) { 1337 msleep_interruptible(jiffies_to_msecs(char_time)); 1338 if (signal_pending(current)) 1339 break; 1340 if (time_after(jiffies, expire)) 1341 break; 1342 } 1343 set_current_state(TASK_RUNNING); /* might not be needed */ 1344} 1345 1346/* 1347 * This is called with the BKL held in 1348 * linux/drivers/char/tty_io.c:do_tty_hangup() 1349 * We're called from the eventd thread, so we can sleep for 1350 * a _short_ time only. 1351 */ 1352static void uart_hangup(struct tty_struct *tty) 1353{ 1354 struct uart_state *state = tty->driver_data; 1355 1356 BUG_ON(!kernel_locked()); 1357 pr_debug("uart_hangup(%d)\n", state->port->line); 1358 1359 mutex_lock(&state->mutex); 1360 if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) { 1361 uart_flush_buffer(tty); 1362 uart_shutdown(state); 1363 state->count = 0; 1364 state->info->flags &= ~UIF_NORMAL_ACTIVE; 1365 state->info->tty = NULL; 1366 wake_up_interruptible(&state->info->open_wait); 1367 wake_up_interruptible(&state->info->delta_msr_wait); 1368 } 1369 mutex_unlock(&state->mutex); 1370} 1371 1372/* 1373 * Copy across the serial console cflag setting into the termios settings 1374 * for the initial open of the port. This allows continuity between the 1375 * kernel settings, and the settings init adopts when it opens the port 1376 * for the first time. 1377 */ 1378static void uart_update_termios(struct uart_state *state) 1379{ 1380 struct tty_struct *tty = state->info->tty; 1381 struct uart_port *port = state->port; 1382 1383 if (uart_console(port) && port->cons->cflag) { 1384 tty->termios->c_cflag = port->cons->cflag; 1385 port->cons->cflag = 0; 1386 } 1387 1388 /* 1389 * If the device failed to grab its irq resources, 1390 * or some other error occurred, don't try to talk 1391 * to the port hardware. 1392 */ 1393 if (!(tty->flags & (1 << TTY_IO_ERROR))) { 1394 /* 1395 * Make termios settings take effect. 1396 */ 1397 uart_change_speed(state, NULL); 1398 1399 /* 1400 * And finally enable the RTS and DTR signals. 1401 */ 1402 if (tty->termios->c_cflag & CBAUD) 1403 uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS); 1404 } 1405} 1406 1407/* 1408 * Block the open until the port is ready. We must be called with 1409 * the per-port semaphore held. 1410 */ 1411static int 1412uart_block_til_ready(struct file *filp, struct uart_state *state) 1413{ 1414 DECLARE_WAITQUEUE(wait, current); 1415 struct uart_info *info = state->info; 1416 struct uart_port *port = state->port; 1417 unsigned int mctrl; 1418 1419 info->blocked_open++; 1420 state->count--; 1421 1422 add_wait_queue(&info->open_wait, &wait); 1423 while (1) { 1424 set_current_state(TASK_INTERRUPTIBLE); 1425 1426 /* 1427 * If we have been hung up, tell userspace/restart open. 1428 */ 1429 if (tty_hung_up_p(filp) || info->tty == NULL) 1430 break; 1431 1432 /* 1433 * If the port has been closed, tell userspace/restart open. 1434 */ 1435 if (!(info->flags & UIF_INITIALIZED)) 1436 break; 1437 1438 /* 1439 * If non-blocking mode is set, or CLOCAL mode is set, 1440 * we don't want to wait for the modem status lines to 1441 * indicate that the port is ready. 1442 * 1443 * Also, if the port is not enabled/configured, we want 1444 * to allow the open to succeed here. Note that we will 1445 * have set TTY_IO_ERROR for a non-existant port. 1446 */ 1447 if ((filp->f_flags & O_NONBLOCK) || 1448 (info->tty->termios->c_cflag & CLOCAL) || 1449 (info->tty->flags & (1 << TTY_IO_ERROR))) { 1450 break; 1451 } 1452 1453 /* 1454 * Set DTR to allow modem to know we're waiting. Do 1455 * not set RTS here - we want to make sure we catch 1456 * the data from the modem. 1457 */ 1458 if (info->tty->termios->c_cflag & CBAUD) 1459 uart_set_mctrl(port, TIOCM_DTR); 1460 1461 /* 1462 * and wait for the carrier to indicate that the 1463 * modem is ready for us. 1464 */ 1465 spin_lock_irq(&port->lock); 1466 port->ops->enable_ms(port); 1467 mctrl = port->ops->get_mctrl(port); 1468 spin_unlock_irq(&port->lock); 1469 if (mctrl & TIOCM_CAR) 1470 break; 1471 1472 mutex_unlock(&state->mutex); 1473 schedule(); 1474 mutex_lock(&state->mutex); 1475 1476 if (signal_pending(current)) 1477 break; 1478 } 1479 set_current_state(TASK_RUNNING); 1480 remove_wait_queue(&info->open_wait, &wait); 1481 1482 state->count++; 1483 info->blocked_open--; 1484 1485 if (signal_pending(current)) 1486 return -ERESTARTSYS; 1487 1488 if (!info->tty || tty_hung_up_p(filp)) 1489 return -EAGAIN; 1490 1491 return 0; 1492} 1493 1494static struct uart_state *uart_get(struct uart_driver *drv, int line) 1495{ 1496 struct uart_state *state; 1497 int ret = 0; 1498 1499 state = drv->state + line; 1500 if (mutex_lock_interruptible(&state->mutex)) { 1501 ret = -ERESTARTSYS; 1502 goto err; 1503 } 1504 1505 state->count++; 1506 if (!state->port || state->port->flags & UPF_DEAD) { 1507 ret = -ENXIO; 1508 goto err_unlock; 1509 } 1510 1511 if (!state->info) { 1512 state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL); 1513 if (state->info) { 1514 init_waitqueue_head(&state->info->open_wait); 1515 init_waitqueue_head(&state->info->delta_msr_wait); 1516 1517 /* 1518 * Link the info into the other structures. 1519 */ 1520 state->port->info = state->info; 1521 1522 tasklet_init(&state->info->tlet, uart_tasklet_action, 1523 (unsigned long)state); 1524 } else { 1525 ret = -ENOMEM; 1526 goto err_unlock; 1527 } 1528 } 1529 return state; 1530 1531 err_unlock: 1532 state->count--; 1533 mutex_unlock(&state->mutex); 1534 err: 1535 return ERR_PTR(ret); 1536} 1537 1538/* 1539 * In 2.4.5, calls to uart_open are serialised by the BKL in 1540 * linux/fs/devices.c:chrdev_open() 1541 * Note that if this fails, then uart_close() _will_ be called. 1542 * 1543 * In time, we want to scrap the "opening nonpresent ports" 1544 * behaviour and implement an alternative way for setserial 1545 * to set base addresses/ports/types. This will allow us to 1546 * get rid of a certain amount of extra tests. 1547 */ 1548static int uart_open(struct tty_struct *tty, struct file *filp) 1549{ 1550 struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state; 1551 struct uart_state *state; 1552 int retval, line = tty->index; 1553 1554 BUG_ON(!kernel_locked()); 1555 pr_debug("uart_open(%d) called\n", line); 1556 1557 /* 1558 * tty->driver->num won't change, so we won't fail here with 1559 * tty->driver_data set to something non-NULL (and therefore 1560 * we won't get caught by uart_close()). 1561 */ 1562 retval = -ENODEV; 1563 if (line >= tty->driver->num) 1564 goto fail; 1565 1566 /* 1567 * We take the semaphore inside uart_get to guarantee that we won't 1568 * be re-entered while allocating the info structure, or while we 1569 * request any IRQs that the driver may need. This also has the nice 1570 * side-effect that it delays the action of uart_hangup, so we can 1571 * guarantee that info->tty will always contain something reasonable. 1572 */ 1573 state = uart_get(drv, line); 1574 if (IS_ERR(state)) { 1575 retval = PTR_ERR(state); 1576 goto fail; 1577 } 1578 1579 /* 1580 * Once we set tty->driver_data here, we are guaranteed that 1581 * uart_close() will decrement the driver module use count. 1582 * Any failures from here onwards should not touch the count. 1583 */ 1584 tty->driver_data = state; 1585 tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0; 1586 tty->alt_speed = 0; 1587 state->info->tty = tty; 1588 1589 /* 1590 * If the port is in the middle of closing, bail out now. 1591 */ 1592 if (tty_hung_up_p(filp)) { 1593 retval = -EAGAIN; 1594 state->count--; 1595 mutex_unlock(&state->mutex); 1596 goto fail; 1597 } 1598 1599 /* 1600 * Make sure the device is in D0 state. 1601 */ 1602 if (state->count == 1) 1603 uart_change_pm(state, 0); 1604 1605 /* 1606 * Start up the serial port. 1607 */ 1608 retval = uart_startup(state, 0); 1609 1610 /* 1611 * If we succeeded, wait until the port is ready. 1612 */ 1613 if (retval == 0) 1614 retval = uart_block_til_ready(filp, state); 1615 mutex_unlock(&state->mutex); 1616 1617 /* 1618 * If this is the first open to succeed, adjust things to suit. 1619 */ 1620 if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) { 1621 state->info->flags |= UIF_NORMAL_ACTIVE; 1622 1623 uart_update_termios(state); 1624 } 1625 1626 fail: 1627 return retval; 1628} 1629 1630static const char *uart_type(struct uart_port *port) 1631{ 1632 const char *str = NULL; 1633 1634 if (port->ops->type) 1635 str = port->ops->type(port); 1636 1637 if (!str) 1638 str = "unknown"; 1639 1640 return str; 1641} 1642 1643#ifdef CONFIG_PROC_FS 1644 1645static int uart_line_info(char *buf, struct uart_driver *drv, int i) 1646{ 1647 struct uart_state *state = drv->state + i; 1648 int pm_state; 1649 struct uart_port *port = state->port; 1650 char stat_buf[32]; 1651 unsigned int status; 1652 int mmio, ret; 1653 1654 if (!port) 1655 return 0; 1656 1657 mmio = port->iotype >= UPIO_MEM; 1658 ret = sprintf(buf, "%d: uart:%s %s%08lX irq:%d", 1659 port->line, uart_type(port), 1660 mmio ? "mmio:0x" : "port:", 1661 mmio ? port->mapbase : (unsigned long) port->iobase, 1662 port->irq); 1663 1664 if (port->type == PORT_UNKNOWN) { 1665 strcat(buf, "\n"); 1666 return ret + 1; 1667 } 1668 1669 if(capable(CAP_SYS_ADMIN)) 1670 { 1671 mutex_lock(&state->mutex); 1672 pm_state = state->pm_state; 1673 if (pm_state) 1674 uart_change_pm(state, 0); 1675 spin_lock_irq(&port->lock); 1676 status = port->ops->get_mctrl(port); 1677 spin_unlock_irq(&port->lock); 1678 if (pm_state) 1679 uart_change_pm(state, pm_state); 1680 mutex_unlock(&state->mutex); 1681 1682 ret += sprintf(buf + ret, " tx:%d rx:%d", 1683 port->icount.tx, port->icount.rx); 1684 if (port->icount.frame) 1685 ret += sprintf(buf + ret, " fe:%d", 1686 port->icount.frame); 1687 if (port->icount.parity) 1688 ret += sprintf(buf + ret, " pe:%d", 1689 port->icount.parity); 1690 if (port->icount.brk) 1691 ret += sprintf(buf + ret, " brk:%d", 1692 port->icount.brk); 1693 if (port->icount.overrun) 1694 ret += sprintf(buf + ret, " oe:%d", 1695 port->icount.overrun); 1696 1697#define INFOBIT(bit,str) \ 1698 if (port->mctrl & (bit)) \ 1699 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1700 strlen(stat_buf) - 2) 1701#define STATBIT(bit,str) \ 1702 if (status & (bit)) \ 1703 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1704 strlen(stat_buf) - 2) 1705 1706 stat_buf[0] = '\0'; 1707 stat_buf[1] = '\0'; 1708 INFOBIT(TIOCM_RTS, "|RTS"); 1709 STATBIT(TIOCM_CTS, "|CTS"); 1710 INFOBIT(TIOCM_DTR, "|DTR"); 1711 STATBIT(TIOCM_DSR, "|DSR"); 1712 STATBIT(TIOCM_CAR, "|CD"); 1713 STATBIT(TIOCM_RNG, "|RI"); 1714 if (stat_buf[0]) 1715 stat_buf[0] = ' '; 1716 strcat(stat_buf, "\n"); 1717 1718 ret += sprintf(buf + ret, stat_buf); 1719 } else { 1720 strcat(buf, "\n"); 1721 ret++; 1722 } 1723#undef STATBIT 1724#undef INFOBIT 1725 return ret; 1726} 1727 1728static int uart_read_proc(char *page, char **start, off_t off, 1729 int count, int *eof, void *data) 1730{ 1731 struct tty_driver *ttydrv = data; 1732 struct uart_driver *drv = ttydrv->driver_state; 1733 int i, len = 0, l; 1734 off_t begin = 0; 1735 1736 len += sprintf(page, "serinfo:1.0 driver%s%s revision:%s\n", 1737 "", "", ""); 1738 for (i = 0; i < drv->nr && len < PAGE_SIZE - 96; i++) { 1739 l = uart_line_info(page + len, drv, i); 1740 len += l; 1741 if (len + begin > off + count) 1742 goto done; 1743 if (len + begin < off) { 1744 begin += len; 1745 len = 0; 1746 } 1747 } 1748 *eof = 1; 1749 done: 1750 if (off >= len + begin) 1751 return 0; 1752 *start = page + (off - begin); 1753 return (count < begin + len - off) ? count : (begin + len - off); 1754} 1755#endif 1756 1757#ifdef CONFIG_SERIAL_CORE_CONSOLE 1758/* 1759 * uart_console_write - write a console message to a serial port 1760 * @port: the port to write the message 1761 * @s: array of characters 1762 * @count: number of characters in string to write 1763 * @write: function to write character to port 1764 */ 1765void uart_console_write(struct uart_port *port, const char *s, 1766 unsigned int count, 1767 void (*putchar)(struct uart_port *, int)) 1768{ 1769 unsigned int i; 1770 1771 for (i = 0; i < count; i++, s++) { 1772 if (*s == '\n') 1773 putchar(port, '\r'); 1774 putchar(port, *s); 1775 } 1776} 1777EXPORT_SYMBOL_GPL(uart_console_write); 1778 1779/* 1780 * Check whether an invalid uart number has been specified, and 1781 * if so, search for the first available port that does have 1782 * console support. 1783 */ 1784struct uart_port * __init 1785uart_get_console(struct uart_port *ports, int nr, struct console *co) 1786{ 1787 int idx = co->index; 1788 1789 if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 && 1790 ports[idx].membase == NULL)) 1791 for (idx = 0; idx < nr; idx++) 1792 if (ports[idx].iobase != 0 || 1793 ports[idx].membase != NULL) 1794 break; 1795 1796 co->index = idx; 1797 1798 return ports + idx; 1799} 1800 1801/** 1802 * uart_parse_options - Parse serial port baud/parity/bits/flow contro. 1803 * @options: pointer to option string 1804 * @baud: pointer to an 'int' variable for the baud rate. 1805 * @parity: pointer to an 'int' variable for the parity. 1806 * @bits: pointer to an 'int' variable for the number of data bits. 1807 * @flow: pointer to an 'int' variable for the flow control character. 1808 * 1809 * uart_parse_options decodes a string containing the serial console 1810 * options. The format of the string is <baud><parity><bits><flow>, 1811 * eg: 115200n8r 1812 */ 1813void __init 1814uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow) 1815{ 1816 char *s = options; 1817 1818 *baud = simple_strtoul(s, NULL, 10); 1819 while (*s >= '0' && *s <= '9') 1820 s++; 1821 if (*s) 1822 *parity = *s++; 1823 if (*s) 1824 *bits = *s++ - '0'; 1825 if (*s) 1826 *flow = *s; 1827} 1828 1829struct baud_rates { 1830 unsigned int rate; 1831 unsigned int cflag; 1832}; 1833 1834static const struct baud_rates baud_rates[] = { 1835 { 921600, B921600 }, 1836 { 460800, B460800 }, 1837 { 230400, B230400 }, 1838 { 115200, B115200 }, 1839 { 57600, B57600 }, 1840 { 38400, B38400 }, 1841 { 19200, B19200 }, 1842 { 9600, B9600 }, 1843 { 4800, B4800 }, 1844 { 2400, B2400 }, 1845 { 1200, B1200 }, 1846 { 0, B38400 } 1847}; 1848 1849/** 1850 * uart_set_options - setup the serial console parameters 1851 * @port: pointer to the serial ports uart_port structure 1852 * @co: console pointer 1853 * @baud: baud rate 1854 * @parity: parity character - 'n' (none), 'o' (odd), 'e' (even) 1855 * @bits: number of data bits 1856 * @flow: flow control character - 'r' (rts) 1857 */ 1858int __init 1859uart_set_options(struct uart_port *port, struct console *co, 1860 int baud, int parity, int bits, int flow) 1861{ 1862 struct ktermios termios; 1863 int i; 1864 1865 /* 1866 * Ensure that the serial console lock is initialised 1867 * early. 1868 */ 1869 spin_lock_init(&port->lock); 1870 lockdep_set_class(&port->lock, &port_lock_key); 1871 1872 memset(&termios, 0, sizeof(struct ktermios)); 1873 1874 termios.c_cflag = CREAD | HUPCL | CLOCAL; 1875 1876 /* 1877 * Construct a cflag setting. 1878 */ 1879 for (i = 0; baud_rates[i].rate; i++) 1880 if (baud_rates[i].rate <= baud) 1881 break; 1882 1883 termios.c_cflag |= baud_rates[i].cflag; 1884 1885 if (bits == 7) 1886 termios.c_cflag |= CS7; 1887 else 1888 termios.c_cflag |= CS8; 1889 1890 switch (parity) { 1891 case 'o': case 'O': 1892 termios.c_cflag |= PARODD; 1893 /*fall through*/ 1894 case 'e': case 'E': 1895 termios.c_cflag |= PARENB; 1896 break; 1897 } 1898 1899 if (flow == 'r') 1900 termios.c_cflag |= CRTSCTS; 1901 1902 port->ops->set_termios(port, &termios, NULL); 1903 co->cflag = termios.c_cflag; 1904 1905 return 0; 1906} 1907#endif /* CONFIG_SERIAL_CORE_CONSOLE */ 1908 1909static void uart_change_pm(struct uart_state *state, int pm_state) 1910{ 1911 struct uart_port *port = state->port; 1912 1913 if (state->pm_state != pm_state) { 1914 if (port->ops->pm) 1915 port->ops->pm(port, pm_state, state->pm_state); 1916 state->pm_state = pm_state; 1917 } 1918} 1919 1920int uart_suspend_port(struct uart_driver *drv, struct uart_port *port) 1921{ 1922 struct uart_state *state = drv->state + port->line; 1923 1924 mutex_lock(&state->mutex); 1925 1926#ifdef CONFIG_DISABLE_CONSOLE_SUSPEND 1927 if (uart_console(port)) { 1928 mutex_unlock(&state->mutex); 1929 return 0; 1930 } 1931#endif 1932 1933 if (state->info && state->info->flags & UIF_INITIALIZED) { 1934 const struct uart_ops *ops = port->ops; 1935 1936 state->info->flags = (state->info->flags & ~UIF_INITIALIZED) 1937 | UIF_SUSPENDED; 1938 1939 spin_lock_irq(&port->lock); 1940 ops->stop_tx(port); 1941 ops->set_mctrl(port, 0); 1942 ops->stop_rx(port); 1943 spin_unlock_irq(&port->lock); 1944 1945 /* 1946 * Wait for the transmitter to empty. 1947 */ 1948 while (!ops->tx_empty(port)) { 1949 msleep(10); 1950 } 1951 1952 ops->shutdown(port); 1953 } 1954 1955 /* 1956 * Disable the console device before suspending. 1957 */ 1958 if (uart_console(port)) 1959 console_stop(port->cons); 1960 1961 uart_change_pm(state, 3); 1962 1963 mutex_unlock(&state->mutex); 1964 1965 return 0; 1966} 1967 1968int uart_resume_port(struct uart_driver *drv, struct uart_port *port) 1969{ 1970 struct uart_state *state = drv->state + port->line; 1971 1972 mutex_lock(&state->mutex); 1973 1974#ifdef CONFIG_DISABLE_CONSOLE_SUSPEND 1975 if (uart_console(port)) { 1976 mutex_unlock(&state->mutex); 1977 return 0; 1978 } 1979#endif 1980 1981 uart_change_pm(state, 0); 1982 1983 /* 1984 * Re-enable the console device after suspending. 1985 */ 1986 if (uart_console(port)) { 1987 struct ktermios termios; 1988 1989 /* 1990 * First try to use the console cflag setting. 1991 */ 1992 memset(&termios, 0, sizeof(struct ktermios)); 1993 termios.c_cflag = port->cons->cflag; 1994 1995 /* 1996 * If that's unset, use the tty termios setting. 1997 */ 1998 if (state->info && state->info->tty && termios.c_cflag == 0) 1999 termios = *state->info->tty->termios; 2000 2001 port->ops->set_termios(port, &termios, NULL); 2002 console_start(port->cons); 2003 } 2004 2005 if (state->info && state->info->flags & UIF_SUSPENDED) { 2006 const struct uart_ops *ops = port->ops; 2007 int ret; 2008 2009 ops->set_mctrl(port, 0); 2010 ret = ops->startup(port); 2011 if (ret == 0) { 2012 uart_change_speed(state, NULL); 2013 spin_lock_irq(&port->lock); 2014 ops->set_mctrl(port, port->mctrl); 2015 ops->start_tx(port); 2016 spin_unlock_irq(&port->lock); 2017 state->info->flags |= UIF_INITIALIZED; 2018 } else { 2019 /* 2020 * Failed to resume - maybe hardware went away? 2021 * Clear the "initialized" flag so we won't try 2022 * to call the low level drivers shutdown method. 2023 */ 2024 uart_shutdown(state); 2025 } 2026 2027 state->info->flags &= ~UIF_SUSPENDED; 2028 } 2029 2030 mutex_unlock(&state->mutex); 2031 2032 return 0; 2033} 2034 2035static inline void 2036uart_report_port(struct uart_driver *drv, struct uart_port *port) 2037{ 2038 char address[64]; 2039 2040 switch (port->iotype) { 2041 case UPIO_PORT: 2042 snprintf(address, sizeof(address), 2043 "I/O 0x%x", port->iobase); 2044 break; 2045 case UPIO_HUB6: 2046 snprintf(address, sizeof(address), 2047 "I/O 0x%x offset 0x%x", port->iobase, port->hub6); 2048 break; 2049 case UPIO_MEM: 2050 case UPIO_MEM32: 2051 case UPIO_AU: 2052 case UPIO_TSI: 2053 case UPIO_DWAPB: 2054 snprintf(address, sizeof(address), 2055 "MMIO 0x%lx", port->mapbase); 2056 break; 2057 default: 2058 strlcpy(address, "*unknown*", sizeof(address)); 2059 break; 2060 } 2061 2062 printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n", 2063 port->dev ? port->dev->bus_id : "", 2064 port->dev ? ": " : "", 2065 drv->dev_name, port->line, address, port->irq, uart_type(port)); 2066} 2067 2068static void 2069uart_configure_port(struct uart_driver *drv, struct uart_state *state, 2070 struct uart_port *port) 2071{ 2072 unsigned int flags; 2073 2074 /* 2075 * If there isn't a port here, don't do anything further. 2076 */ 2077 if (!port->iobase && !port->mapbase && !port->membase) 2078 return; 2079 2080 /* 2081 * Now do the auto configuration stuff. Note that config_port 2082 * is expected to claim the resources and map the port for us. 2083 */ 2084 flags = UART_CONFIG_TYPE; 2085 if (port->flags & UPF_AUTO_IRQ) 2086 flags |= UART_CONFIG_IRQ; 2087 if (port->flags & UPF_BOOT_AUTOCONF) { 2088 port->type = PORT_UNKNOWN; 2089 port->ops->config_port(port, flags); 2090 } 2091 2092 if (port->type != PORT_UNKNOWN) { 2093 unsigned long flags; 2094 2095 uart_report_port(drv, port); 2096 2097 /* Power up port for set_mctrl() */ 2098 uart_change_pm(state, 0); 2099 2100 /* 2101 * Ensure that the modem control lines are de-activated. 2102 * We probably don't need a spinlock around this, but 2103 */ 2104 spin_lock_irqsave(&port->lock, flags); 2105 port->ops->set_mctrl(port, 0); 2106 spin_unlock_irqrestore(&port->lock, flags); 2107 2108 /* 2109 * Power down all ports by default, except the 2110 * console if we have one. 2111 */ 2112 if (!uart_console(port)) 2113 uart_change_pm(state, 3); 2114 } 2115} 2116 2117static const struct tty_operations uart_ops = { 2118 .open = uart_open, 2119 .close = uart_close, 2120 .write = uart_write, 2121 .put_char = uart_put_char, 2122 .flush_chars = uart_flush_chars, 2123 .write_room = uart_write_room, 2124 .chars_in_buffer= uart_chars_in_buffer, 2125 .flush_buffer = uart_flush_buffer, 2126 .ioctl = uart_ioctl, 2127 .throttle = uart_throttle, 2128 .unthrottle = uart_unthrottle, 2129 .send_xchar = uart_send_xchar, 2130 .set_termios = uart_set_termios, 2131 .stop = uart_stop, 2132 .start = uart_start, 2133 .hangup = uart_hangup, 2134 .break_ctl = uart_break_ctl, 2135 .wait_until_sent= uart_wait_until_sent, 2136#ifdef CONFIG_PROC_FS 2137 .read_proc = uart_read_proc, 2138#endif 2139 .tiocmget = uart_tiocmget, 2140 .tiocmset = uart_tiocmset, 2141}; 2142 2143/** 2144 * uart_register_driver - register a driver with the uart core layer 2145 * @drv: low level driver structure 2146 * 2147 * Register a uart driver with the core driver. We in turn register 2148 * with the tty layer, and initialise the core driver per-port state. 2149 * 2150 * We have a proc file in /proc/tty/driver which is named after the 2151 * normal driver. 2152 * 2153 * drv->port should be NULL, and the per-port structures should be 2154 * registered using uart_add_one_port after this call has succeeded. 2155 */ 2156int uart_register_driver(struct uart_driver *drv) 2157{ 2158 struct tty_driver *normal = NULL; 2159 int i, retval; 2160 2161 BUG_ON(drv->state); 2162 2163 /* 2164 * Maybe we should be using a slab cache for this, especially if 2165 * we have a large number of ports to handle. 2166 */ 2167 drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL); 2168 retval = -ENOMEM; 2169 if (!drv->state) 2170 goto out; 2171 2172 normal = alloc_tty_driver(drv->nr); 2173 if (!normal) 2174 goto out; 2175 2176 drv->tty_driver = normal; 2177 2178 normal->owner = drv->owner; 2179 normal->driver_name = drv->driver_name; 2180 normal->name = drv->dev_name; 2181 normal->major = drv->major; 2182 normal->minor_start = drv->minor; 2183 normal->type = TTY_DRIVER_TYPE_SERIAL; 2184 normal->subtype = SERIAL_TYPE_NORMAL; 2185 normal->init_termios = tty_std_termios; 2186 normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 2187 normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600; 2188 normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 2189 normal->driver_state = drv; 2190 tty_set_operations(normal, &uart_ops); 2191 2192 /* 2193 * Initialise the UART state(s). 2194 */ 2195 for (i = 0; i < drv->nr; i++) { 2196 struct uart_state *state = drv->state + i; 2197 2198 state->close_delay = 500; /* .5 seconds */ 2199 state->closing_wait = 30000; /* 30 seconds */ 2200 2201 mutex_init(&state->mutex); 2202 } 2203 2204 retval = tty_register_driver(normal); 2205 out: 2206 if (retval < 0) { 2207 put_tty_driver(normal); 2208 kfree(drv->state); 2209 } 2210 return retval; 2211} 2212 2213/** 2214 * uart_unregister_driver - remove a driver from the uart core layer 2215 * @drv: low level driver structure 2216 * 2217 * Remove all references to a driver from the core driver. The low 2218 * level driver must have removed all its ports via the 2219 * uart_remove_one_port() if it registered them with uart_add_one_port(). 2220 * (ie, drv->port == NULL) 2221 */ 2222void uart_unregister_driver(struct uart_driver *drv) 2223{ 2224 struct tty_driver *p = drv->tty_driver; 2225 tty_unregister_driver(p); 2226 put_tty_driver(p); 2227 kfree(drv->state); 2228 drv->tty_driver = NULL; 2229} 2230 2231struct tty_driver *uart_console_device(struct console *co, int *index) 2232{ 2233 struct uart_driver *p = co->data; 2234 *index = co->index; 2235 return p->tty_driver; 2236} 2237 2238/** 2239 * uart_add_one_port - attach a driver-defined port structure 2240 * @drv: pointer to the uart low level driver structure for this port 2241 * @port: uart port structure to use for this port. 2242 * 2243 * This allows the driver to register its own uart_port structure 2244 * with the core driver. The main purpose is to allow the low 2245 * level uart drivers to expand uart_port, rather than having yet 2246 * more levels of structures. 2247 */ 2248int uart_add_one_port(struct uart_driver *drv, struct uart_port *port) 2249{ 2250 struct uart_state *state; 2251 int ret = 0; 2252 2253 BUG_ON(in_interrupt()); 2254 2255 if (port->line >= drv->nr) 2256 return -EINVAL; 2257 2258 state = drv->state + port->line; 2259 2260 mutex_lock(&port_mutex); 2261 mutex_lock(&state->mutex); 2262 if (state->port) { 2263 ret = -EINVAL; 2264 goto out; 2265 } 2266 2267 state->port = port; 2268 2269 port->cons = drv->cons; 2270 port->info = state->info; 2271 2272 /* 2273 * If this port is a console, then the spinlock is already 2274 * initialised. 2275 */ 2276 if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) { 2277 spin_lock_init(&port->lock); 2278 lockdep_set_class(&port->lock, &port_lock_key); 2279 } 2280 2281 uart_configure_port(drv, state, port); 2282 2283 /* 2284 * Register the port whether it's detected or not. This allows 2285 * setserial to be used to alter this ports parameters. 2286 */ 2287 tty_register_device(drv->tty_driver, port->line, port->dev); 2288 2289 /* 2290 * If this driver supports console, and it hasn't been 2291 * successfully registered yet, try to re-register it. 2292 * It may be that the port was not available. 2293 */ 2294 if (port->type != PORT_UNKNOWN && 2295 port->cons && !(port->cons->flags & CON_ENABLED)) 2296 register_console(port->cons); 2297 2298 /* 2299 * Ensure UPF_DEAD is not set. 2300 */ 2301 port->flags &= ~UPF_DEAD; 2302 2303 out: 2304 mutex_unlock(&state->mutex); 2305 mutex_unlock(&port_mutex); 2306 2307 return ret; 2308} 2309 2310/** 2311 * uart_remove_one_port - detach a driver defined port structure 2312 * @drv: pointer to the uart low level driver structure for this port 2313 * @port: uart port structure for this port 2314 * 2315 * This unhooks (and hangs up) the specified port structure from the 2316 * core driver. No further calls will be made to the low-level code 2317 * for this port. 2318 */ 2319int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) 2320{ 2321 struct uart_state *state = drv->state + port->line; 2322 struct uart_info *info; 2323 2324 BUG_ON(in_interrupt()); 2325 2326 if (state->port != port) 2327 printk(KERN_ALERT "Removing wrong port: %p != %p\n", 2328 state->port, port); 2329 2330 mutex_lock(&port_mutex); 2331 2332 /* 2333 * Mark the port "dead" - this prevents any opens from 2334 * succeeding while we shut down the port. 2335 */ 2336 mutex_lock(&state->mutex); 2337 port->flags |= UPF_DEAD; 2338 mutex_unlock(&state->mutex); 2339 2340 /* 2341 * Remove the devices from the tty layer 2342 */ 2343 tty_unregister_device(drv->tty_driver, port->line); 2344 2345 info = state->info; 2346 if (info && info->tty) 2347 tty_vhangup(info->tty); 2348 2349 /* 2350 * All users of this port should now be disconnected from 2351 * this driver, and the port shut down. We should be the 2352 * only thread fiddling with this port from now on. 2353 */ 2354 state->info = NULL; 2355 2356 /* 2357 * Free the port IO and memory resources, if any. 2358 */ 2359 if (port->type != PORT_UNKNOWN) 2360 port->ops->release_port(port); 2361 2362 /* 2363 * Indicate that there isn't a port here anymore. 2364 */ 2365 port->type = PORT_UNKNOWN; 2366 2367 /* 2368 * Kill the tasklet, and free resources. 2369 */ 2370 if (info) { 2371 tasklet_kill(&info->tlet); 2372 kfree(info); 2373 } 2374 2375 state->port = NULL; 2376 mutex_unlock(&port_mutex); 2377 2378 return 0; 2379} 2380 2381/* 2382 * Are the two ports equivalent? 2383 */ 2384int uart_match_port(struct uart_port *port1, struct uart_port *port2) 2385{ 2386 if (port1->iotype != port2->iotype) 2387 return 0; 2388 2389 switch (port1->iotype) { 2390 case UPIO_PORT: 2391 return (port1->iobase == port2->iobase); 2392 case UPIO_HUB6: 2393 return (port1->iobase == port2->iobase) && 2394 (port1->hub6 == port2->hub6); 2395 case UPIO_MEM: 2396 case UPIO_MEM32: 2397 case UPIO_AU: 2398 case UPIO_TSI: 2399 case UPIO_DWAPB: 2400 return (port1->mapbase == port2->mapbase); 2401 } 2402 return 0; 2403} 2404EXPORT_SYMBOL(uart_match_port); 2405 2406EXPORT_SYMBOL(uart_write_wakeup); 2407EXPORT_SYMBOL(uart_register_driver); 2408EXPORT_SYMBOL(uart_unregister_driver); 2409EXPORT_SYMBOL(uart_suspend_port); 2410EXPORT_SYMBOL(uart_resume_port); 2411EXPORT_SYMBOL(uart_add_one_port); 2412EXPORT_SYMBOL(uart_remove_one_port); 2413 2414MODULE_DESCRIPTION("Serial driver core"); 2415MODULE_LICENSE("GPL"); 2416