drivers/serial/serial_core.c

   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  */
  43 static DEFINE_MUTEX(port_mutex);
  44
  45 /*
  46  * lockdep: port->lock is initialized in two places, but we
  47  *          want only one lock-class:
  48  */
  49 static 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
  61 static void uart_change_speed(struct uart_state *state, struct ktermios *old_termios);
  62 static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
  63 static 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  */
  69 void 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
  80 static 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
  91 static 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
 101 static 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
 112 static 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
 118 static inline void
 119 uart_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  */
 139 static 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  */
 211 static 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  */
 274 void
 275 uart_update_timeout(struct uart_port *port, unsigned int cflag,
 276                     unsigned int baud)
 277 {
 278         unsigned int bits;
 279
 280         /* byte size and parity */
 281         switch (cflag & CSIZE) {
 282         case CS5:
 283                 bits = 7;
 284                 break;
 285         case CS6:
 286                 bits = 8;
 287                 break;
 288         case CS7:
 289                 bits = 9;
 290                 break;
 291         default:
 292                 bits = 10;
 293                 break; // CS8
 294         }
 295
 296         if (cflag & CSTOPB)
 297                 bits++;
 298         if (cflag & PARENB)
 299                 bits++;
 300
 301         /*
 302          * The total number of bits to be transmitted in the fifo.
 303          */
 304         bits = bits * port->fifosize;
 305
 306         /*
 307          * Figure the timeout to send the above number of bits.
 308          * Add .02 seconds of slop
 309          */
 310         port->timeout = (HZ * bits) / baud + HZ/50;
 311 }
 312
 313 EXPORT_SYMBOL(uart_update_timeout);
 314
 315 /**
 316  *      uart_get_baud_rate - return baud rate for a particular port
 317  *      @port: uart_port structure describing the port in question.
 318  *      @termios: desired termios settings.
 319  *      @old: old termios (or NULL)
 320  *      @min: minimum acceptable baud rate
 321  *      @max: maximum acceptable baud rate
 322  *
 323  *      Decode the termios structure into a numeric baud rate,
 324  *      taking account of the magic 38400 baud rate (with spd_*
 325  *      flags), and mapping the %B0 rate to 9600 baud.
 326  *
 327  *      If the new baud rate is invalid, try the old termios setting.
 328  *      If it's still invalid, we try 9600 baud.
 329  *
 330  *      Update the @termios structure to reflect the baud rate
 331  *      we're actually going to be using.
 332  */
 333 unsigned int
 334 uart_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
 389 EXPORT_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  */
 398 unsigned int
 399 uart_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
 414 EXPORT_SYMBOL(uart_get_divisor);
 415
 416 static void
 417 uart_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
 448 static 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
 464 static 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
 471 static void uart_flush_chars(struct tty_struct *tty)
 472 {
 473         uart_start(tty);
 474 }
 475
 476 static int
 477 uart_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
 519 static 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
 526 static 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
 533 static 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  */
 560 static 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
 578 static 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
 589 static 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
 605 static 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 *)(unsigned long)port->mapbase;
 630
 631         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
 632                 return -EFAULT;
 633         return 0;
 634 }
 635
 636 static 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  */
 842 static 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
 864 static 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
 884 static int
 885 uart_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
 902 static 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
 917 static 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  */
 966 static int
 967 uart_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  */
1025 static 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  */
1054 static int
1055 uart_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
1139 static 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. We can ignore the Bfoo
1150          * bits in c_cflag; c_[io]speed will always be set
1151          * appropriately by set_termios() in tty_ioctl.c
1152          */
1153 #define RELEVANT_IFLAG(iflag)   ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
1154         if ((cflag ^ old_termios->c_cflag) == 0 &&
1155             tty->termios->c_ospeed == old_termios->c_ospeed &&
1156             tty->termios->c_ispeed == old_termios->c_ispeed &&
1157             RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
1158                 return;
1159
1160         uart_change_speed(state, old_termios);
1161
1162         /* Handle transition to B0 status */
1163         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1164                 uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR);
1165
1166         /* Handle transition away from B0 status */
1167         if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1168                 unsigned int mask = TIOCM_DTR;
1169                 if (!(cflag & CRTSCTS) ||
1170                     !test_bit(TTY_THROTTLED, &tty->flags))
1171                         mask |= TIOCM_RTS;
1172                 uart_set_mctrl(state->port, mask);
1173         }
1174
1175         /* Handle turning off CRTSCTS */
1176         if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1177                 spin_lock_irqsave(&state->port->lock, flags);
1178                 tty->hw_stopped = 0;
1179                 __uart_start(tty);
1180                 spin_unlock_irqrestore(&state->port->lock, flags);
1181         }
1182
1183         /* Handle turning on CRTSCTS */
1184         if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1185                 spin_lock_irqsave(&state->port->lock, flags);
1186                 if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {
1187                         tty->hw_stopped = 1;
1188                         state->port->ops->stop_tx(state->port);
1189                 }
1190                 spin_unlock_irqrestore(&state->port->lock, flags);
1191         }
1192
1193 #if 0
1194         /*
1195          * No need to wake up processes in open wait, since they
1196          * sample the CLOCAL flag once, and don't recheck it.
1197          * XXX  It's not clear whether the current behavior is correct
1198          * or not.  Hence, this may change.....
1199          */
1200         if (!(old_termios->c_cflag & CLOCAL) &&
1201             (tty->termios->c_cflag & CLOCAL))
1202                 wake_up_interruptible(&state->info->open_wait);
1203 #endif
1204 }
1205
1206 /*
1207  * In 2.4.5, calls to this will be serialized via the BKL in
1208  *  linux/drivers/char/tty_io.c:tty_release()
1209  *  linux/drivers/char/tty_io.c:do_tty_handup()
1210  */
1211 static void uart_close(struct tty_struct *tty, struct file *filp)
1212 {
1213         struct uart_state *state = tty->driver_data;
1214         struct uart_port *port;
1215
1216         BUG_ON(!kernel_locked());
1217
1218         if (!state || !state->port)
1219                 return;
1220
1221         port = state->port;
1222
1223         pr_debug("uart_close(%d) called\n", port->line);
1224
1225         mutex_lock(&state->mutex);
1226
1227         if (tty_hung_up_p(filp))
1228                 goto done;
1229
1230         if ((tty->count == 1) && (state->count != 1)) {
1231                 /*
1232                  * Uh, oh.  tty->count is 1, which means that the tty
1233                  * structure will be freed.  state->count should always
1234                  * be one in these conditions.  If it's greater than
1235                  * one, we've got real problems, since it means the
1236                  * serial port won't be shutdown.
1237                  */
1238                 printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, "
1239                        "state->count is %d\n", state->count);
1240                 state->count = 1;
1241         }
1242         if (--state->count < 0) {
1243                 printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n",
1244                        tty->name, state->count);
1245                 state->count = 0;
1246         }
1247         if (state->count)
1248                 goto done;
1249
1250         /*
1251          * Now we wait for the transmit buffer to clear; and we notify
1252          * the line discipline to only process XON/XOFF characters by
1253          * setting tty->closing.
1254          */
1255         tty->closing = 1;
1256
1257         if (state->closing_wait != USF_CLOSING_WAIT_NONE)
1258                 tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait));
1259
1260         /*
1261          * At this point, we stop accepting input.  To do this, we
1262          * disable the receive line status interrupts.
1263          */
1264         if (state->info->flags & UIF_INITIALIZED) {
1265                 unsigned long flags;
1266                 spin_lock_irqsave(&port->lock, flags);
1267                 port->ops->stop_rx(port);
1268                 spin_unlock_irqrestore(&port->lock, flags);
1269                 /*
1270                  * Before we drop DTR, make sure the UART transmitter
1271                  * has completely drained; this is especially
1272                  * important if there is a transmit FIFO!
1273                  */
1274                 uart_wait_until_sent(tty, port->timeout);
1275         }
1276
1277         uart_shutdown(state);
1278         uart_flush_buffer(tty);
1279
1280         tty_ldisc_flush(tty);
1281
1282         tty->closing = 0;
1283         state->info->tty = NULL;
1284
1285         if (state->info->blocked_open) {
1286                 if (state->close_delay)
1287                         msleep_interruptible(state->close_delay);
1288         } else if (!uart_console(port)) {
1289                 uart_change_pm(state, 3);
1290         }
1291
1292         /*
1293          * Wake up anyone trying to open this port.
1294          */
1295         state->info->flags &= ~UIF_NORMAL_ACTIVE;
1296         wake_up_interruptible(&state->info->open_wait);
1297
1298  done:
1299         mutex_unlock(&state->mutex);
1300 }
1301
1302 static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1303 {
1304         struct uart_state *state = tty->driver_data;
1305         struct uart_port *port = state->port;
1306         unsigned long char_time, expire;
1307
1308         BUG_ON(!kernel_locked());
1309
1310         if (port->type == PORT_UNKNOWN || port->fifosize == 0)
1311                 return;
1312
1313         /*
1314          * Set the check interval to be 1/5 of the estimated time to
1315          * send a single character, and make it at least 1.  The check
1316          * interval should also be less than the timeout.
1317          *
1318          * Note: we have to use pretty tight timings here to satisfy
1319          * the NIST-PCTS.
1320          */
1321         char_time = (port->timeout - HZ/50) / port->fifosize;
1322         char_time = char_time / 5;
1323         if (char_time == 0)
1324                 char_time = 1;
1325         if (timeout && timeout < char_time)
1326                 char_time = timeout;
1327
1328         /*
1329          * If the transmitter hasn't cleared in twice the approximate
1330          * amount of time to send the entire FIFO, it probably won't
1331          * ever clear.  This assumes the UART isn't doing flow
1332          * control, which is currently the case.  Hence, if it ever
1333          * takes longer than port->timeout, this is probably due to a
1334          * UART bug of some kind.  So, we clamp the timeout parameter at
1335          * 2*port->timeout.
1336          */
1337         if (timeout == 0 || timeout > 2 * port->timeout)
1338                 timeout = 2 * port->timeout;
1339
1340         expire = jiffies + timeout;
1341
1342         pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1343                 port->line, jiffies, expire);
1344
1345         /*
1346          * Check whether the transmitter is empty every 'char_time'.
1347          * 'timeout' / 'expire' give us the maximum amount of time
1348          * we wait.
1349          */
1350         while (!port->ops->tx_empty(port)) {
1351                 msleep_interruptible(jiffies_to_msecs(char_time));
1352                 if (signal_pending(current))
1353                         break;
1354                 if (time_after(jiffies, expire))
1355                         break;
1356         }
1357         set_current_state(TASK_RUNNING); /* might not be needed */
1358 }
1359
1360 /*
1361  * This is called with the BKL held in
1362  *  linux/drivers/char/tty_io.c:do_tty_hangup()
1363  * We're called from the eventd thread, so we can sleep for
1364  * a _short_ time only.
1365  */
1366 static void uart_hangup(struct tty_struct *tty)
1367 {
1368         struct uart_state *state = tty->driver_data;
1369
1370         BUG_ON(!kernel_locked());
1371         pr_debug("uart_hangup(%d)\n", state->port->line);
1372
1373         mutex_lock(&state->mutex);
1374         if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) {
1375                 uart_flush_buffer(tty);
1376                 uart_shutdown(state);
1377                 state->count = 0;
1378                 state->info->flags &= ~UIF_NORMAL_ACTIVE;
1379                 state->info->tty = NULL;
1380                 wake_up_interruptible(&state->info->open_wait);
1381                 wake_up_interruptible(&state->info->delta_msr_wait);
1382         }
1383         mutex_unlock(&state->mutex);
1384 }
1385
1386 /*
1387  * Copy across the serial console cflag setting into the termios settings
1388  * for the initial open of the port.  This allows continuity between the
1389  * kernel settings, and the settings init adopts when it opens the port
1390  * for the first time.
1391  */
1392 static void uart_update_termios(struct uart_state *state)
1393 {
1394         struct tty_struct *tty = state->info->tty;
1395         struct uart_port *port = state->port;
1396
1397         if (uart_console(port) && port->cons->cflag) {
1398                 tty->termios->c_cflag = port->cons->cflag;
1399                 port->cons->cflag = 0;
1400         }
1401
1402         /*
1403          * If the device failed to grab its irq resources,
1404          * or some other error occurred, don't try to talk
1405          * to the port hardware.
1406          */
1407         if (!(tty->flags & (1 << TTY_IO_ERROR))) {
1408                 /*
1409                  * Make termios settings take effect.
1410                  */
1411                 uart_change_speed(state, NULL);
1412
1413                 /*
1414                  * And finally enable the RTS and DTR signals.
1415                  */
1416                 if (tty->termios->c_cflag & CBAUD)
1417                         uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1418         }
1419 }
1420
1421 /*
1422  * Block the open until the port is ready.  We must be called with
1423  * the per-port semaphore held.
1424  */
1425 static int
1426 uart_block_til_ready(struct file *filp, struct uart_state *state)
1427 {
1428         DECLARE_WAITQUEUE(wait, current);
1429         struct uart_info *info = state->info;
1430         struct uart_port *port = state->port;
1431         unsigned int mctrl;
1432
1433         info->blocked_open++;
1434         state->count--;
1435
1436         add_wait_queue(&info->open_wait, &wait);
1437         while (1) {
1438                 set_current_state(TASK_INTERRUPTIBLE);
1439
1440                 /*
1441                  * If we have been hung up, tell userspace/restart open.
1442                  */
1443                 if (tty_hung_up_p(filp) || info->tty == NULL)
1444                         break;
1445
1446                 /*
1447                  * If the port has been closed, tell userspace/restart open.
1448                  */
1449                 if (!(info->flags & UIF_INITIALIZED))
1450                         break;
1451
1452                 /*
1453                  * If non-blocking mode is set, or CLOCAL mode is set,
1454                  * we don't want to wait for the modem status lines to
1455                  * indicate that the port is ready.
1456                  *
1457                  * Also, if the port is not enabled/configured, we want
1458                  * to allow the open to succeed here.  Note that we will
1459                  * have set TTY_IO_ERROR for a non-existant port.
1460                  */
1461                 if ((filp->f_flags & O_NONBLOCK) ||
1462                     (info->tty->termios->c_cflag & CLOCAL) ||
1463                     (info->tty->flags & (1 << TTY_IO_ERROR))) {
1464                         break;
1465                 }
1466
1467                 /*
1468                  * Set DTR to allow modem to know we're waiting.  Do
1469                  * not set RTS here - we want to make sure we catch
1470                  * the data from the modem.
1471                  */
1472                 if (info->tty->termios->c_cflag & CBAUD)
1473                         uart_set_mctrl(port, TIOCM_DTR);
1474
1475                 /*
1476                  * and wait for the carrier to indicate that the
1477                  * modem is ready for us.
1478                  */
1479                 spin_lock_irq(&port->lock);
1480                 port->ops->enable_ms(port);
1481                 mctrl = port->ops->get_mctrl(port);
1482                 spin_unlock_irq(&port->lock);
1483                 if (mctrl & TIOCM_CAR)
1484                         break;
1485
1486                 mutex_unlock(&state->mutex);
1487                 schedule();
1488                 mutex_lock(&state->mutex);
1489
1490                 if (signal_pending(current))
1491                         break;
1492         }
1493         set_current_state(TASK_RUNNING);
1494         remove_wait_queue(&info->open_wait, &wait);
1495
1496         state->count++;
1497         info->blocked_open--;
1498
1499         if (signal_pending(current))
1500                 return -ERESTARTSYS;
1501
1502         if (!info->tty || tty_hung_up_p(filp))
1503                 return -EAGAIN;
1504
1505         return 0;
1506 }
1507
1508 static struct uart_state *uart_get(struct uart_driver *drv, int line)
1509 {
1510         struct uart_state *state;
1511         int ret = 0;
1512
1513         state = drv->state + line;
1514         if (mutex_lock_interruptible(&state->mutex)) {
1515                 ret = -ERESTARTSYS;
1516                 goto err;
1517         }
1518
1519         state->count++;
1520         if (!state->port || state->port->flags & UPF_DEAD) {
1521                 ret = -ENXIO;
1522                 goto err_unlock;
1523         }
1524
1525         if (!state->info) {
1526                 state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);
1527                 if (state->info) {
1528                         init_waitqueue_head(&state->info->open_wait);
1529                         init_waitqueue_head(&state->info->delta_msr_wait);
1530
1531                         /*
1532                          * Link the info into the other structures.
1533                          */
1534                         state->port->info = state->info;
1535
1536                         tasklet_init(&state->info->tlet, uart_tasklet_action,
1537                                      (unsigned long)state);
1538                 } else {
1539                         ret = -ENOMEM;
1540                         goto err_unlock;
1541                 }
1542         }
1543         return state;
1544
1545  err_unlock:
1546         state->count--;
1547         mutex_unlock(&state->mutex);
1548  err:
1549         return ERR_PTR(ret);
1550 }
1551
1552 /*
1553  * In 2.4.5, calls to uart_open are serialised by the BKL in
1554  *   linux/fs/devices.c:chrdev_open()
1555  * Note that if this fails, then uart_close() _will_ be called.
1556  *
1557  * In time, we want to scrap the "opening nonpresent ports"
1558  * behaviour and implement an alternative way for setserial
1559  * to set base addresses/ports/types.  This will allow us to
1560  * get rid of a certain amount of extra tests.
1561  */
1562 static int uart_open(struct tty_struct *tty, struct file *filp)
1563 {
1564         struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
1565         struct uart_state *state;
1566         int retval, line = tty->index;
1567
1568         BUG_ON(!kernel_locked());
1569         pr_debug("uart_open(%d) called\n", line);
1570
1571         /*
1572          * tty->driver->num won't change, so we won't fail here with
1573          * tty->driver_data set to something non-NULL (and therefore
1574          * we won't get caught by uart_close()).
1575          */
1576         retval = -ENODEV;
1577         if (line >= tty->driver->num)
1578                 goto fail;
1579
1580         /*
1581          * We take the semaphore inside uart_get to guarantee that we won't
1582          * be re-entered while allocating the info structure, or while we
1583          * request any IRQs that the driver may need.  This also has the nice
1584          * side-effect that it delays the action of uart_hangup, so we can
1585          * guarantee that info->tty will always contain something reasonable.
1586          */
1587         state = uart_get(drv, line);
1588         if (IS_ERR(state)) {
1589                 retval = PTR_ERR(state);
1590                 goto fail;
1591         }
1592
1593         /*
1594          * Once we set tty->driver_data here, we are guaranteed that
1595          * uart_close() will decrement the driver module use count.
1596          * Any failures from here onwards should not touch the count.
1597          */
1598         tty->driver_data = state;
1599         tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1600         tty->alt_speed = 0;
1601         state->info->tty = tty;
1602
1603         /*
1604          * If the port is in the middle of closing, bail out now.
1605          */
1606         if (tty_hung_up_p(filp)) {
1607                 retval = -EAGAIN;
1608                 state->count--;
1609                 mutex_unlock(&state->mutex);
1610                 goto fail;
1611         }
1612
1613         /*
1614          * Make sure the device is in D0 state.
1615          */
1616         if (state->count == 1)
1617                 uart_change_pm(state, 0);
1618
1619         /*
1620          * Start up the serial port.
1621          */
1622         retval = uart_startup(state, 0);
1623
1624         /*
1625          * If we succeeded, wait until the port is ready.
1626          */
1627         if (retval == 0)
1628                 retval = uart_block_til_ready(filp, state);
1629         mutex_unlock(&state->mutex);
1630
1631         /*
1632          * If this is the first open to succeed, adjust things to suit.
1633          */
1634         if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) {
1635                 state->info->flags |= UIF_NORMAL_ACTIVE;
1636
1637                 uart_update_termios(state);
1638         }
1639
1640  fail:
1641         return retval;
1642 }
1643
1644 static const char *uart_type(struct uart_port *port)
1645 {
1646         const char *str = NULL;
1647
1648         if (port->ops->type)
1649                 str = port->ops->type(port);
1650
1651         if (!str)
1652                 str = "unknown";
1653
1654         return str;
1655 }
1656
1657 #ifdef CONFIG_PROC_FS
1658
1659 static int uart_line_info(char *buf, struct uart_driver *drv, int i)
1660 {
1661         struct uart_state *state = drv->state + i;
1662         int pm_state;
1663         struct uart_port *port = state->port;
1664         char stat_buf[32];
1665         unsigned int status;
1666         int mmio, ret;
1667
1668         if (!port)
1669                 return 0;
1670
1671         mmio = port->iotype >= UPIO_MEM;
1672         ret = sprintf(buf, "%d: uart:%s %s%08llX irq:%d",
1673                         port->line, uart_type(port),
1674                         mmio ? "mmio:0x" : "port:",
1675                         mmio ? (unsigned long long)port->mapbase
1676                              : (unsigned long long) port->iobase,
1677                         port->irq);
1678
1679         if (port->type == PORT_UNKNOWN) {
1680                 strcat(buf, "\n");
1681                 return ret + 1;
1682         }
1683
1684         if(capable(CAP_SYS_ADMIN))
1685         {
1686                 mutex_lock(&state->mutex);
1687                 pm_state = state->pm_state;
1688                 if (pm_state)
1689                         uart_change_pm(state, 0);
1690                 spin_lock_irq(&port->lock);
1691                 status = port->ops->get_mctrl(port);
1692                 spin_unlock_irq(&port->lock);
1693                 if (pm_state)
1694                         uart_change_pm(state, pm_state);
1695                 mutex_unlock(&state->mutex);
1696
1697                 ret += sprintf(buf + ret, " tx:%d rx:%d",
1698                                 port->icount.tx, port->icount.rx);
1699                 if (port->icount.frame)
1700                         ret += sprintf(buf + ret, " fe:%d",
1701                                 port->icount.frame);
1702                 if (port->icount.parity)
1703                         ret += sprintf(buf + ret, " pe:%d",
1704                                 port->icount.parity);
1705                 if (port->icount.brk)
1706                         ret += sprintf(buf + ret, " brk:%d",
1707                                 port->icount.brk);
1708                 if (port->icount.overrun)
1709                         ret += sprintf(buf + ret, " oe:%d",
1710                                 port->icount.overrun);
1711
1712 #define INFOBIT(bit,str) \
1713         if (port->mctrl & (bit)) \
1714                 strncat(stat_buf, (str), sizeof(stat_buf) - \
1715                         strlen(stat_buf) - 2)
1716 #define STATBIT(bit,str) \
1717         if (status & (bit)) \
1718                 strncat(stat_buf, (str), sizeof(stat_buf) - \
1719                        strlen(stat_buf) - 2)
1720
1721                 stat_buf[0] = '\0';
1722                 stat_buf[1] = '\0';
1723                 INFOBIT(TIOCM_RTS, "|RTS");
1724                 STATBIT(TIOCM_CTS, "|CTS");
1725                 INFOBIT(TIOCM_DTR, "|DTR");
1726                 STATBIT(TIOCM_DSR, "|DSR");
1727                 STATBIT(TIOCM_CAR, "|CD");
1728                 STATBIT(TIOCM_RNG, "|RI");
1729                 if (stat_buf[0])
1730                         stat_buf[0] = ' ';
1731                 strcat(stat_buf, "\n");
1732
1733                 ret += sprintf(buf + ret, stat_buf);
1734         } else {
1735                 strcat(buf, "\n");
1736                 ret++;
1737         }
1738 #undef STATBIT
1739 #undef INFOBIT
1740         return ret;
1741 }
1742
1743 static int uart_read_proc(char *page, char **start, off_t off,
1744                           int count, int *eof, void *data)
1745 {
1746         struct tty_driver *ttydrv = data;
1747         struct uart_driver *drv = ttydrv->driver_state;
1748         int i, len = 0, l;
1749         off_t begin = 0;
1750
1751         len += sprintf(page, "serinfo:1.0 driver%s%s revision:%s\n",
1752                         "", "", "");
1753         for (i = 0; i < drv->nr && len < PAGE_SIZE - 96; i++) {
1754                 l = uart_line_info(page + len, drv, i);
1755                 len += l;
1756                 if (len + begin > off + count)
1757                         goto done;
1758                 if (len + begin < off) {
1759                         begin += len;
1760                         len = 0;
1761                 }
1762         }
1763         *eof = 1;
1764  done:
1765         if (off >= len + begin)
1766                 return 0;
1767         *start = page + (off - begin);
1768         return (count < begin + len - off) ? count : (begin + len - off);
1769 }
1770 #endif
1771
1772 #ifdef CONFIG_SERIAL_CORE_CONSOLE
1773 /*
1774  *      uart_console_write - write a console message to a serial port
1775  *      @port: the port to write the message
1776  *      @s: array of characters
1777  *      @count: number of characters in string to write
1778  *      @write: function to write character to port
1779  */
1780 void uart_console_write(struct uart_port *port, const char *s,
1781                         unsigned int count,
1782                         void (*putchar)(struct uart_port *, int))
1783 {
1784         unsigned int i;
1785
1786         for (i = 0; i < count; i++, s++) {
1787                 if (*s == '\n')
1788                         putchar(port, '\r');
1789                 putchar(port, *s);
1790         }
1791 }
1792 EXPORT_SYMBOL_GPL(uart_console_write);
1793
1794 /*
1795  *      Check whether an invalid uart number has been specified, and
1796  *      if so, search for the first available port that does have
1797  *      console support.
1798  */
1799 struct uart_port * __init
1800 uart_get_console(struct uart_port *ports, int nr, struct console *co)
1801 {
1802         int idx = co->index;
1803
1804         if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
1805                                      ports[idx].membase == NULL))
1806                 for (idx = 0; idx < nr; idx++)
1807                         if (ports[idx].iobase != 0 ||
1808                             ports[idx].membase != NULL)
1809                                 break;
1810
1811         co->index = idx;
1812
1813         return ports + idx;
1814 }
1815
1816 /**
1817  *      uart_parse_options - Parse serial port baud/parity/bits/flow contro.
1818  *      @options: pointer to option string
1819  *      @baud: pointer to an 'int' variable for the baud rate.
1820  *      @parity: pointer to an 'int' variable for the parity.
1821  *      @bits: pointer to an 'int' variable for the number of data bits.
1822  *      @flow: pointer to an 'int' variable for the flow control character.
1823  *
1824  *      uart_parse_options decodes a string containing the serial console
1825  *      options.  The format of the string is <baud><parity><bits><flow>,
1826  *      eg: 115200n8r
1827  */
1828 void __init
1829 uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
1830 {
1831         char *s = options;
1832
1833         *baud = simple_strtoul(s, NULL, 10);
1834         while (*s >= '0' && *s <= '9')
1835                 s++;
1836         if (*s)
1837                 *parity = *s++;
1838         if (*s)
1839                 *bits = *s++ - '0';
1840         if (*s)
1841                 *flow = *s;
1842 }
1843
1844 struct baud_rates {
1845         unsigned int rate;
1846         unsigned int cflag;
1847 };
1848
1849 static const struct baud_rates baud_rates[] = {
1850         { 921600, B921600 },
1851         { 460800, B460800 },
1852         { 230400, B230400 },
1853         { 115200, B115200 },
1854         {  57600, B57600  },
1855         {  38400, B38400  },
1856         {  19200, B19200  },
1857         {   9600, B9600   },
1858         {   4800, B4800   },
1859         {   2400, B2400   },
1860         {   1200, B1200   },
1861         {      0, B38400  }
1862 };
1863
1864 /**
1865  *      uart_set_options - setup the serial console parameters
1866  *      @port: pointer to the serial ports uart_port structure
1867  *      @co: console pointer
1868  *      @baud: baud rate
1869  *      @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
1870  *      @bits: number of data bits
1871  *      @flow: flow control character - 'r' (rts)
1872  */
1873 int __init
1874 uart_set_options(struct uart_port *port, struct console *co,
1875                  int baud, int parity, int bits, int flow)
1876 {
1877         struct ktermios termios;
1878         static struct ktermios dummy;
1879         int i;
1880
1881         /*
1882          * Ensure that the serial console lock is initialised
1883          * early.
1884          */
1885         spin_lock_init(&port->lock);
1886         lockdep_set_class(&port->lock, &port_lock_key);
1887
1888         memset(&termios, 0, sizeof(struct ktermios));
1889
1890         termios.c_cflag = CREAD | HUPCL | CLOCAL;
1891
1892         /*
1893          * Construct a cflag setting.
1894          */
1895         for (i = 0; baud_rates[i].rate; i++)
1896                 if (baud_rates[i].rate <= baud)
1897                         break;
1898
1899         termios.c_cflag |= baud_rates[i].cflag;
1900
1901         if (bits == 7)
1902                 termios.c_cflag |= CS7;
1903         else
1904                 termios.c_cflag |= CS8;
1905
1906         switch (parity) {
1907         case 'o': case 'O':
1908                 termios.c_cflag |= PARODD;
1909                 /*fall through*/
1910         case 'e': case 'E':
1911                 termios.c_cflag |= PARENB;
1912                 break;
1913         }
1914
1915         if (flow == 'r')
1916                 termios.c_cflag |= CRTSCTS;
1917
1918         /*
1919          * some uarts on other side don't support no flow control.
1920          * So we set * DTR in host uart to make them happy
1921          */
1922         port->mctrl |= TIOCM_DTR;
1923
1924         port->ops->set_termios(port, &termios, &dummy);
1925         co->cflag = termios.c_cflag;
1926
1927         return 0;
1928 }
1929 #endif /* CONFIG_SERIAL_CORE_CONSOLE */
1930
1931 static void uart_change_pm(struct uart_state *state, int pm_state)
1932 {
1933         struct uart_port *port = state->port;
1934
1935         if (state->pm_state != pm_state) {
1936                 if (port->ops->pm)
1937                         port->ops->pm(port, pm_state, state->pm_state);
1938                 state->pm_state = pm_state;
1939         }
1940 }
1941
1942 struct uart_match {
1943         struct uart_port *port;
1944         struct uart_driver *driver;
1945 };
1946
1947 static int serial_match_port(struct device *dev, void *data)
1948 {
1949         struct uart_match *match = data;
1950         dev_t devt = MKDEV(match->driver->major, match->driver->minor) + match->port->line;
1951
1952         return dev->devt == devt; /* Actually, only one tty per port */
1953 }
1954
1955 int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
1956 {
1957         struct uart_state *state = drv->state + port->line;
1958         struct device *tty_dev;
1959         struct uart_match match = {port, drv};
1960
1961         mutex_lock(&state->mutex);
1962
1963         if (!console_suspend_enabled && uart_console(port)) {
1964                 /* we're going to avoid suspending serial console */
1965                 mutex_unlock(&state->mutex);
1966                 return 0;
1967         }
1968
1969         tty_dev = device_find_child(port->dev, &match, serial_match_port);
1970         if (device_may_wakeup(tty_dev)) {
1971                 enable_irq_wake(port->irq);
1972                 put_device(tty_dev);
1973                 mutex_unlock(&state->mutex);
1974                 return 0;
1975         }
1976         port->suspended = 1;
1977
1978         if (state->info && state->info->flags & UIF_INITIALIZED) {
1979                 const struct uart_ops *ops = port->ops;
1980
1981                 state->info->flags = (state->info->flags & ~UIF_INITIALIZED)
1982                                      | UIF_SUSPENDED;
1983
1984                 spin_lock_irq(&port->lock);
1985                 ops->stop_tx(port);
1986                 ops->set_mctrl(port, 0);
1987                 ops->stop_rx(port);
1988                 spin_unlock_irq(&port->lock);
1989
1990                 /*
1991                  * Wait for the transmitter to empty.
1992                  */
1993                 while (!ops->tx_empty(port)) {
1994                         msleep(10);
1995                 }
1996
1997                 ops->shutdown(port);
1998         }
1999
2000         /*
2001          * Disable the console device before suspending.
2002          */
2003         if (uart_console(port))
2004                 console_stop(port->cons);
2005
2006         uart_change_pm(state, 3);
2007
2008         mutex_unlock(&state->mutex);
2009
2010         return 0;
2011 }
2012
2013 int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
2014 {
2015         struct uart_state *state = drv->state + port->line;
2016
2017         mutex_lock(&state->mutex);
2018
2019         if (!console_suspend_enabled && uart_console(port)) {
2020                 /* no need to resume serial console, it wasn't suspended */
2021                 mutex_unlock(&state->mutex);
2022                 return 0;
2023         }
2024
2025         if (!port->suspended) {
2026                 disable_irq_wake(port->irq);
2027                 mutex_unlock(&state->mutex);
2028                 return 0;
2029         }
2030         port->suspended = 0;
2031
2032         uart_change_pm(state, 0);
2033
2034         /*
2035          * Re-enable the console device after suspending.
2036          */
2037         if (uart_console(port)) {
2038                 struct ktermios termios;
2039
2040                 /*
2041                  * First try to use the console cflag setting.
2042                  */
2043                 memset(&termios, 0, sizeof(struct ktermios));
2044                 termios.c_cflag = port->cons->cflag;
2045
2046                 /*
2047                  * If that's unset, use the tty termios setting.
2048                  */
2049                 if (state->info && state->info->tty && termios.c_cflag == 0)
2050                         termios = *state->info->tty->termios;
2051
2052                 port->ops->set_termios(port, &termios, NULL);
2053                 console_start(port->cons);
2054         }
2055
2056         if (state->info && state->info->flags & UIF_SUSPENDED) {
2057                 const struct uart_ops *ops = port->ops;
2058                 int ret;
2059
2060                 ops->set_mctrl(port, 0);
2061                 ret = ops->startup(port);
2062                 if (ret == 0) {
2063                         uart_change_speed(state, NULL);
2064                         spin_lock_irq(&port->lock);
2065                         ops->set_mctrl(port, port->mctrl);
2066                         ops->start_tx(port);
2067                         spin_unlock_irq(&port->lock);
2068                         state->info->flags |= UIF_INITIALIZED;
2069                 } else {
2070                         /*
2071                          * Failed to resume - maybe hardware went away?
2072                          * Clear the "initialized" flag so we won't try
2073                          * to call the low level drivers shutdown method.
2074                          */
2075                         uart_shutdown(state);
2076                 }
2077
2078                 state->info->flags &= ~UIF_SUSPENDED;
2079         }
2080
2081         mutex_unlock(&state->mutex);
2082
2083         return 0;
2084 }
2085
2086 static inline void
2087 uart_report_port(struct uart_driver *drv, struct uart_port *port)
2088 {
2089         char address[64];
2090
2091         switch (port->iotype) {
2092         case UPIO_PORT:
2093                 snprintf(address, sizeof(address),
2094                          "I/O 0x%x", port->iobase);
2095                 break;
2096         case UPIO_HUB6:
2097                 snprintf(address, sizeof(address),
2098                          "I/O 0x%x offset 0x%x", port->iobase, port->hub6);
2099                 break;
2100         case UPIO_MEM:
2101         case UPIO_MEM32:
2102         case UPIO_AU:
2103         case UPIO_TSI:
2104         case UPIO_DWAPB:
2105                 snprintf(address, sizeof(address),
2106                          "MMIO 0x%llx", (unsigned long long)port->mapbase);
2107                 break;
2108         default:
2109                 strlcpy(address, "*unknown*", sizeof(address));
2110                 break;
2111         }
2112
2113         printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
2114                port->dev ? port->dev->bus_id : "",
2115                port->dev ? ": " : "",
2116                drv->dev_name, port->line, address, port->irq, uart_type(port));
2117 }
2118
2119 static void
2120 uart_configure_port(struct uart_driver *drv, struct uart_state *state,
2121                     struct uart_port *port)
2122 {
2123         unsigned int flags;
2124
2125         /*
2126          * If there isn't a port here, don't do anything further.
2127          */
2128         if (!port->iobase && !port->mapbase && !port->membase)
2129                 return;
2130
2131         /*
2132          * Now do the auto configuration stuff.  Note that config_port
2133          * is expected to claim the resources and map the port for us.
2134          */
2135         flags = UART_CONFIG_TYPE;
2136         if (port->flags & UPF_AUTO_IRQ)
2137                 flags |= UART_CONFIG_IRQ;
2138         if (port->flags & UPF_BOOT_AUTOCONF) {
2139                 port->type = PORT_UNKNOWN;
2140                 port->ops->config_port(port, flags);
2141         }
2142
2143         if (port->type != PORT_UNKNOWN) {
2144                 unsigned long flags;
2145
2146                 uart_report_port(drv, port);
2147
2148                 /* Power up port for set_mctrl() */
2149                 uart_change_pm(state, 0);
2150
2151                 /*
2152                  * Ensure that the modem control lines are de-activated.
2153                  * We probably don't need a spinlock around this, but
2154                  */
2155                 spin_lock_irqsave(&port->lock, flags);
2156                 port->ops->set_mctrl(port, 0);
2157                 spin_unlock_irqrestore(&port->lock, flags);
2158
2159                 /*
2160                  * If this driver supports console, and it hasn't been
2161                  * successfully registered yet, try to re-register it.
2162                  * It may be that the port was not available.
2163                  */
2164                 if (port->cons && !(port->cons->flags & CON_ENABLED))
2165                         register_console(port->cons);
2166
2167                 /*
2168                  * Power down all ports by default, except the
2169                  * console if we have one.
2170                  */
2171                 if (!uart_console(port))
2172                         uart_change_pm(state, 3);
2173         }
2174 }
2175
2176 static const struct tty_operations uart_ops = {
2177         .open           = uart_open,
2178         .close          = uart_close,
2179         .write          = uart_write,
2180         .put_char       = uart_put_char,
2181         .flush_chars    = uart_flush_chars,
2182         .write_room     = uart_write_room,
2183         .chars_in_buffer= uart_chars_in_buffer,
2184         .flush_buffer   = uart_flush_buffer,
2185         .ioctl          = uart_ioctl,
2186         .throttle       = uart_throttle,
2187         .unthrottle     = uart_unthrottle,
2188         .send_xchar     = uart_send_xchar,
2189         .set_termios    = uart_set_termios,
2190         .stop           = uart_stop,
2191         .start          = uart_start,
2192         .hangup         = uart_hangup,
2193         .break_ctl      = uart_break_ctl,
2194         .wait_until_sent= uart_wait_until_sent,
2195 #ifdef CONFIG_PROC_FS
2196         .read_proc      = uart_read_proc,
2197 #endif
2198         .tiocmget       = uart_tiocmget,
2199         .tiocmset       = uart_tiocmset,
2200 };
2201
2202 /**
2203  *      uart_register_driver - register a driver with the uart core layer
2204  *      @drv: low level driver structure
2205  *
2206  *      Register a uart driver with the core driver.  We in turn register
2207  *      with the tty layer, and initialise the core driver per-port state.
2208  *
2209  *      We have a proc file in /proc/tty/driver which is named after the
2210  *      normal driver.
2211  *
2212  *      drv->port should be NULL, and the per-port structures should be
2213  *      registered using uart_add_one_port after this call has succeeded.
2214  */
2215 int uart_register_driver(struct uart_driver *drv)
2216 {
2217         struct tty_driver *normal = NULL;
2218         int i, retval;
2219
2220         BUG_ON(drv->state);
2221
2222         /*
2223          * Maybe we should be using a slab cache for this, especially if
2224          * we have a large number of ports to handle.
2225          */
2226         drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
2227         retval = -ENOMEM;
2228         if (!drv->state)
2229                 goto out;
2230
2231         normal  = alloc_tty_driver(drv->nr);
2232         if (!normal)
2233                 goto out;
2234
2235         drv->tty_driver = normal;
2236
2237         normal->owner           = drv->owner;
2238         normal->driver_name     = drv->driver_name;
2239         normal->name            = drv->dev_name;
2240         normal->major           = drv->major;
2241         normal->minor_start     = drv->minor;
2242         normal->type            = TTY_DRIVER_TYPE_SERIAL;
2243         normal->subtype         = SERIAL_TYPE_NORMAL;
2244         normal->init_termios    = tty_std_termios;
2245         normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2246         normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2247         normal->flags           = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2248         normal->driver_state    = drv;
2249         tty_set_operations(normal, &uart_ops);
2250
2251         /*
2252          * Initialise the UART state(s).
2253          */
2254         for (i = 0; i < drv->nr; i++) {
2255                 struct uart_state *state = drv->state + i;
2256
2257                 state->close_delay     = 500;   /* .5 seconds */
2258                 state->closing_wait    = 30000; /* 30 seconds */
2259
2260                 mutex_init(&state->mutex);
2261         }
2262
2263         retval = tty_register_driver(normal);
2264  out:
2265         if (retval < 0) {
2266                 put_tty_driver(normal);
2267                 kfree(drv->state);
2268         }
2269         return retval;
2270 }
2271
2272 /**
2273  *      uart_unregister_driver - remove a driver from the uart core layer
2274  *      @drv: low level driver structure
2275  *
2276  *      Remove all references to a driver from the core driver.  The low
2277  *      level driver must have removed all its ports via the
2278  *      uart_remove_one_port() if it registered them with uart_add_one_port().
2279  *      (ie, drv->port == NULL)
2280  */
2281 void uart_unregister_driver(struct uart_driver *drv)
2282 {
2283         struct tty_driver *p = drv->tty_driver;
2284         tty_unregister_driver(p);
2285         put_tty_driver(p);
2286         kfree(drv->state);
2287         drv->tty_driver = NULL;
2288 }
2289
2290 struct tty_driver *uart_console_device(struct console *co, int *index)
2291 {
2292         struct uart_driver *p = co->data;
2293         *index = co->index;
2294         return p->tty_driver;
2295 }
2296
2297 /**
2298  *      uart_add_one_port - attach a driver-defined port structure
2299  *      @drv: pointer to the uart low level driver structure for this port
2300  *      @port: uart port structure to use for this port.
2301  *
2302  *      This allows the driver to register its own uart_port structure
2303  *      with the core driver.  The main purpose is to allow the low
2304  *      level uart drivers to expand uart_port, rather than having yet
2305  *      more levels of structures.
2306  */
2307 int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
2308 {
2309         struct uart_state *state;
2310         int ret = 0;
2311         struct device *tty_dev;
2312
2313         BUG_ON(in_interrupt());
2314
2315         if (port->line >= drv->nr)
2316                 return -EINVAL;
2317
2318         state = drv->state + port->line;
2319
2320         mutex_lock(&port_mutex);
2321         mutex_lock(&state->mutex);
2322         if (state->port) {
2323                 ret = -EINVAL;
2324                 goto out;
2325         }
2326
2327         state->port = port;
2328         state->pm_state = -1;
2329
2330         port->cons = drv->cons;
2331         port->info = state->info;
2332
2333         /*
2334          * If this port is a console, then the spinlock is already
2335          * initialised.
2336          */
2337         if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
2338                 spin_lock_init(&port->lock);
2339                 lockdep_set_class(&port->lock, &port_lock_key);
2340         }
2341
2342         uart_configure_port(drv, state, port);
2343
2344         /*
2345          * Register the port whether it's detected or not.  This allows
2346          * setserial to be used to alter this ports parameters.
2347          */
2348         tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev);
2349         if (likely(!IS_ERR(tty_dev))) {
2350                 device_can_wakeup(tty_dev) = 1;
2351                 device_set_wakeup_enable(tty_dev, 0);
2352         } else
2353                 printk(KERN_ERR "Cannot register tty device on line %d\n",
2354                        port->line);
2355
2356         /*
2357          * Ensure UPF_DEAD is not set.
2358          */
2359         port->flags &= ~UPF_DEAD;
2360
2361  out:
2362         mutex_unlock(&state->mutex);
2363         mutex_unlock(&port_mutex);
2364
2365         return ret;
2366 }
2367
2368 /**
2369  *      uart_remove_one_port - detach a driver defined port structure
2370  *      @drv: pointer to the uart low level driver structure for this port
2371  *      @port: uart port structure for this port
2372  *
2373  *      This unhooks (and hangs up) the specified port structure from the
2374  *      core driver.  No further calls will be made to the low-level code
2375  *      for this port.
2376  */
2377 int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
2378 {
2379         struct uart_state *state = drv->state + port->line;
2380         struct uart_info *info;
2381
2382         BUG_ON(in_interrupt());
2383
2384         if (state->port != port)
2385                 printk(KERN_ALERT "Removing wrong port: %p != %p\n",
2386                         state->port, port);
2387
2388         mutex_lock(&port_mutex);
2389
2390         /*
2391          * Mark the port "dead" - this prevents any opens from
2392          * succeeding while we shut down the port.
2393          */
2394         mutex_lock(&state->mutex);
2395         port->flags |= UPF_DEAD;
2396         mutex_unlock(&state->mutex);
2397
2398         /*
2399          * Remove the devices from the tty layer
2400          */
2401         tty_unregister_device(drv->tty_driver, port->line);
2402
2403         info = state->info;
2404         if (info && info->tty)
2405                 tty_vhangup(info->tty);
2406
2407         /*
2408          * All users of this port should now be disconnected from
2409          * this driver, and the port shut down.  We should be the
2410          * only thread fiddling with this port from now on.
2411          */
2412         state->info = NULL;
2413
2414         /*
2415          * Free the port IO and memory resources, if any.
2416          */
2417         if (port->type != PORT_UNKNOWN)
2418                 port->ops->release_port(port);
2419
2420         /*
2421          * Indicate that there isn't a port here anymore.
2422          */
2423         port->type = PORT_UNKNOWN;
2424
2425         /*
2426          * Kill the tasklet, and free resources.
2427          */
2428         if (info) {
2429                 tasklet_kill(&info->tlet);
2430                 kfree(info);
2431         }
2432
2433         state->port = NULL;
2434         mutex_unlock(&port_mutex);
2435
2436         return 0;
2437 }
2438
2439 /*
2440  *      Are the two ports equivalent?
2441  */
2442 int uart_match_port(struct uart_port *port1, struct uart_port *port2)
2443 {
2444         if (port1->iotype != port2->iotype)
2445                 return 0;
2446
2447         switch (port1->iotype) {
2448         case UPIO_PORT:
2449                 return (port1->iobase == port2->iobase);
2450         case UPIO_HUB6:
2451                 return (port1->iobase == port2->iobase) &&
2452                        (port1->hub6   == port2->hub6);
2453         case UPIO_MEM:
2454         case UPIO_MEM32:
2455         case UPIO_AU:
2456         case UPIO_TSI:
2457         case UPIO_DWAPB:
2458                 return (port1->mapbase == port2->mapbase);
2459         }
2460         return 0;
2461 }
2462 EXPORT_SYMBOL(uart_match_port);
2463
2464 EXPORT_SYMBOL(uart_write_wakeup);
2465 EXPORT_SYMBOL(uart_register_driver);
2466 EXPORT_SYMBOL(uart_unregister_driver);
2467 EXPORT_SYMBOL(uart_suspend_port);
2468 EXPORT_SYMBOL(uart_resume_port);
2469 EXPORT_SYMBOL(uart_add_one_port);
2470 EXPORT_SYMBOL(uart_remove_one_port);
2471
2472 MODULE_DESCRIPTION("Serial driver core");
2473 MODULE_LICENSE("GPL");