drivers/serial/8250.c

   1 /*
   2  *  linux/drivers/char/8250.c
   3  *
   4  *  Driver for 8250/16550-type serial ports
   5  *
   6  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   7  *
   8  *  Copyright (C) 2001 Russell King.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * A note about mapbase / membase
  16  *
  17  *  mapbase is the physical address of the IO port.
  18  *  membase is an 'ioremapped' cookie.
  19  */
  20
  21 #if defined(CONFIG_SERIAL_8250_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  22 #define SUPPORT_SYSRQ
  23 #endif
  24
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/ioport.h>
  28 #include <linux/init.h>
  29 #include <linux/console.h>
  30 #include <linux/sysrq.h>
  31 #include <linux/delay.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/tty.h>
  34 #include <linux/ratelimit.h>
  35 #include <linux/tty_flip.h>
  36 #include <linux/serial_reg.h>
  37 #include <linux/serial_core.h>
  38 #include <linux/serial.h>
  39 #include <linux/serial_8250.h>
  40 #include <linux/nmi.h>
  41 #include <linux/mutex.h>
  42 #include <linux/slab.h>
  43
  44 #include <asm/io.h>
  45 #include <asm/irq.h>
  46
  47 #include "8250.h"
  48
  49 #ifdef CONFIG_SPARC
  50 #include "suncore.h"
  51 #endif
  52
  53 /*
  54  * Configuration:
  55  *   share_irqs - whether we pass IRQF_SHARED to request_irq().  This option
  56  *                is unsafe when used on edge-triggered interrupts.
  57  */
  58 static unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
  59
  60 static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
  61
  62 static struct uart_driver serial8250_reg;
  63
  64 static int serial_index(struct uart_port *port)
  65 {
  66         return (serial8250_reg.minor - 64) + port->line;
  67 }
  68
  69 static unsigned int skip_txen_test; /* force skip of txen test at init time */
  70
  71 /*
  72  * Debugging.
  73  */
  74 #if 0
  75 #define DEBUG_AUTOCONF(fmt...)  printk(fmt)
  76 #else
  77 #define DEBUG_AUTOCONF(fmt...)  do { } while (0)
  78 #endif
  79
  80 #if 0
  81 #define DEBUG_INTR(fmt...)      printk(fmt)
  82 #else
  83 #define DEBUG_INTR(fmt...)      do { } while (0)
  84 #endif
  85
  86 #define PASS_LIMIT      256
  87
  88 #define BOTH_EMPTY      (UART_LSR_TEMT | UART_LSR_THRE)
  89
  90
  91 /*
  92  * We default to IRQ0 for the "no irq" hack.   Some
  93  * machine types want others as well - they're free
  94  * to redefine this in their header file.
  95  */
  96 #define is_real_interrupt(irq)  ((irq) != 0)
  97
  98 #ifdef CONFIG_SERIAL_8250_DETECT_IRQ
  99 #define CONFIG_SERIAL_DETECT_IRQ 1
 100 #endif
 101 #ifdef CONFIG_SERIAL_8250_MANY_PORTS
 102 #define CONFIG_SERIAL_MANY_PORTS 1
 103 #endif
 104
 105 /*
 106  * HUB6 is always on.  This will be removed once the header
 107  * files have been cleaned.
 108  */
 109 #define CONFIG_HUB6 1
 110
 111 #include <asm/serial.h>
 112 /*
 113  * SERIAL_PORT_DFNS tells us about built-in ports that have no
 114  * standard enumeration mechanism.   Platforms that can find all
 115  * serial ports via mechanisms like ACPI or PCI need not supply it.
 116  */
 117 #ifndef SERIAL_PORT_DFNS
 118 #define SERIAL_PORT_DFNS
 119 #endif
 120
 121 static const struct old_serial_port old_serial_port[] = {
 122         SERIAL_PORT_DFNS /* defined in asm/serial.h */
 123 };
 124
 125 #define UART_NR CONFIG_SERIAL_8250_NR_UARTS
 126
 127 #ifdef CONFIG_SERIAL_8250_RSA
 128
 129 #define PORT_RSA_MAX 4
 130 static unsigned long probe_rsa[PORT_RSA_MAX];
 131 static unsigned int probe_rsa_count;
 132 #endif /* CONFIG_SERIAL_8250_RSA  */
 133
 134 struct uart_8250_port {
 135         struct uart_port        port;
 136         struct timer_list       timer;          /* "no irq" timer */
 137         struct list_head        list;           /* ports on this IRQ */
 138         unsigned short          capabilities;   /* port capabilities */
 139         unsigned short          bugs;           /* port bugs */
 140         unsigned int            tx_loadsz;      /* transmit fifo load size */
 141         unsigned char           acr;
 142         unsigned char           ier;
 143         unsigned char           lcr;
 144         unsigned char           mcr;
 145         unsigned char           mcr_mask;       /* mask of user bits */
 146         unsigned char           mcr_force;      /* mask of forced bits */
 147         unsigned char           cur_iotype;     /* Running I/O type */
 148
 149         /*
 150          * Some bits in registers are cleared on a read, so they must
 151          * be saved whenever the register is read but the bits will not
 152          * be immediately processed.
 153          */
 154 #define LSR_SAVE_FLAGS UART_LSR_BRK_ERROR_BITS
 155         unsigned char           lsr_saved_flags;
 156 #define MSR_SAVE_FLAGS UART_MSR_ANY_DELTA
 157         unsigned char           msr_saved_flags;
 158 };
 159
 160 struct irq_info {
 161         struct                  hlist_node node;
 162         int                     irq;
 163         spinlock_t              lock;   /* Protects list not the hash */
 164         struct list_head        *head;
 165 };
 166
 167 #define NR_IRQ_HASH             32      /* Can be adjusted later */
 168 static struct hlist_head irq_lists[NR_IRQ_HASH];
 169 static DEFINE_MUTEX(hash_mutex);        /* Used to walk the hash */
 170
 171 /*
 172  * Here we define the default xmit fifo size used for each type of UART.
 173  */
 174 static const struct serial8250_config uart_config[] = {
 175         [PORT_UNKNOWN] = {
 176                 .name           = "unknown",
 177                 .fifo_size      = 1,
 178                 .tx_loadsz      = 1,
 179         },
 180         [PORT_8250] = {
 181                 .name           = "8250",
 182                 .fifo_size      = 1,
 183                 .tx_loadsz      = 1,
 184         },
 185         [PORT_16450] = {
 186                 .name           = "16450",
 187                 .fifo_size      = 1,
 188                 .tx_loadsz      = 1,
 189         },
 190         [PORT_16550] = {
 191                 .name           = "16550",
 192                 .fifo_size      = 1,
 193                 .tx_loadsz      = 1,
 194         },
 195         [PORT_16550A] = {
 196                 .name           = "16550A",
 197                 .fifo_size      = 16,
 198                 .tx_loadsz      = 16,
 199                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 200                 .flags          = UART_CAP_FIFO,
 201         },
 202         [PORT_CIRRUS] = {
 203                 .name           = "Cirrus",
 204                 .fifo_size      = 1,
 205                 .tx_loadsz      = 1,
 206         },
 207         [PORT_16650] = {
 208                 .name           = "ST16650",
 209                 .fifo_size      = 1,
 210                 .tx_loadsz      = 1,
 211                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 212         },
 213         [PORT_16650V2] = {
 214                 .name           = "ST16650V2",
 215                 .fifo_size      = 32,
 216                 .tx_loadsz      = 16,
 217                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 218                                   UART_FCR_T_TRIG_00,
 219                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 220         },
 221         [PORT_16750] = {
 222                 .name           = "TI16750",
 223                 .fifo_size      = 64,
 224                 .tx_loadsz      = 64,
 225                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
 226                                   UART_FCR7_64BYTE,
 227                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP | UART_CAP_AFE,
 228         },
 229         [PORT_STARTECH] = {
 230                 .name           = "Startech",
 231                 .fifo_size      = 1,
 232                 .tx_loadsz      = 1,
 233         },
 234         [PORT_16C950] = {
 235                 .name           = "16C950/954",
 236                 .fifo_size      = 128,
 237                 .tx_loadsz      = 128,
 238                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 239                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 240         },
 241         [PORT_16654] = {
 242                 .name           = "ST16654",
 243                 .fifo_size      = 64,
 244                 .tx_loadsz      = 32,
 245                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 246                                   UART_FCR_T_TRIG_10,
 247                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 248         },
 249         [PORT_16850] = {
 250                 .name           = "XR16850",
 251                 .fifo_size      = 128,
 252                 .tx_loadsz      = 128,
 253                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 254                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 255         },
 256         [PORT_RSA] = {
 257                 .name           = "RSA",
 258                 .fifo_size      = 2048,
 259                 .tx_loadsz      = 2048,
 260                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11,
 261                 .flags          = UART_CAP_FIFO,
 262         },
 263         [PORT_NS16550A] = {
 264                 .name           = "NS16550A",
 265                 .fifo_size      = 16,
 266                 .tx_loadsz      = 16,
 267                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 268                 .flags          = UART_CAP_FIFO | UART_NATSEMI,
 269         },
 270         [PORT_XSCALE] = {
 271                 .name           = "XScale",
 272                 .fifo_size      = 32,
 273                 .tx_loadsz      = 32,
 274                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 275                 .flags          = UART_CAP_FIFO | UART_CAP_UUE,
 276         },
 277         [PORT_RM9000] = {
 278                 .name           = "RM9000",
 279                 .fifo_size      = 16,
 280                 .tx_loadsz      = 16,
 281                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 282                 .flags          = UART_CAP_FIFO,
 283         },
 284         [PORT_OCTEON] = {
 285                 .name           = "OCTEON",
 286                 .fifo_size      = 64,
 287                 .tx_loadsz      = 64,
 288                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 289                 .flags          = UART_CAP_FIFO,
 290         },
 291         [PORT_AR7] = {
 292                 .name           = "AR7",
 293                 .fifo_size      = 16,
 294                 .tx_loadsz      = 16,
 295                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00,
 296                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 297         },
 298         [PORT_U6_16550A] = {
 299                 .name           = "U6_16550A",
 300                 .fifo_size      = 64,
 301                 .tx_loadsz      = 64,
 302                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 303                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 304         },
 305 };
 306
 307 #if defined(CONFIG_MIPS_ALCHEMY)
 308
 309 /* Au1x00 UART hardware has a weird register layout */
 310 static const u8 au_io_in_map[] = {
 311         [UART_RX]  = 0,
 312         [UART_IER] = 2,
 313         [UART_IIR] = 3,
 314         [UART_LCR] = 5,
 315         [UART_MCR] = 6,
 316         [UART_LSR] = 7,
 317         [UART_MSR] = 8,
 318 };
 319
 320 static const u8 au_io_out_map[] = {
 321         [UART_TX]  = 1,
 322         [UART_IER] = 2,
 323         [UART_FCR] = 4,
 324         [UART_LCR] = 5,
 325         [UART_MCR] = 6,
 326 };
 327
 328 /* sane hardware needs no mapping */
 329 static inline int map_8250_in_reg(struct uart_port *p, int offset)
 330 {
 331         if (p->iotype != UPIO_AU)
 332                 return offset;
 333         return au_io_in_map[offset];
 334 }
 335
 336 static inline int map_8250_out_reg(struct uart_port *p, int offset)
 337 {
 338         if (p->iotype != UPIO_AU)
 339                 return offset;
 340         return au_io_out_map[offset];
 341 }
 342
 343 #elif defined(CONFIG_SERIAL_8250_RM9K)
 344
 345 static const u8
 346         regmap_in[8] = {
 347                 [UART_RX]       = 0x00,
 348                 [UART_IER]      = 0x0c,
 349                 [UART_IIR]      = 0x14,
 350                 [UART_LCR]      = 0x1c,
 351                 [UART_MCR]      = 0x20,
 352                 [UART_LSR]      = 0x24,
 353                 [UART_MSR]      = 0x28,
 354                 [UART_SCR]      = 0x2c
 355         },
 356         regmap_out[8] = {
 357                 [UART_TX]       = 0x04,
 358                 [UART_IER]      = 0x0c,
 359                 [UART_FCR]      = 0x18,
 360                 [UART_LCR]      = 0x1c,
 361                 [UART_MCR]      = 0x20,
 362                 [UART_LSR]      = 0x24,
 363                 [UART_MSR]      = 0x28,
 364                 [UART_SCR]      = 0x2c
 365         };
 366
 367 static inline int map_8250_in_reg(struct uart_port *p, int offset)
 368 {
 369         if (p->iotype != UPIO_RM9000)
 370                 return offset;
 371         return regmap_in[offset];
 372 }
 373
 374 static inline int map_8250_out_reg(struct uart_port *p, int offset)
 375 {
 376         if (p->iotype != UPIO_RM9000)
 377                 return offset;
 378         return regmap_out[offset];
 379 }
 380
 381 #else
 382
 383 /* sane hardware needs no mapping */
 384 #define map_8250_in_reg(up, offset) (offset)
 385 #define map_8250_out_reg(up, offset) (offset)
 386
 387 #endif
 388
 389 static unsigned int hub6_serial_in(struct uart_port *p, int offset)
 390 {
 391         offset = map_8250_in_reg(p, offset) << p->regshift;
 392         outb(p->hub6 - 1 + offset, p->iobase);
 393         return inb(p->iobase + 1);
 394 }
 395
 396 static void hub6_serial_out(struct uart_port *p, int offset, int value)
 397 {
 398         offset = map_8250_out_reg(p, offset) << p->regshift;
 399         outb(p->hub6 - 1 + offset, p->iobase);
 400         outb(value, p->iobase + 1);
 401 }
 402
 403 static unsigned int mem_serial_in(struct uart_port *p, int offset)
 404 {
 405         offset = map_8250_in_reg(p, offset) << p->regshift;
 406         return readb(p->membase + offset);
 407 }
 408
 409 static void mem_serial_out(struct uart_port *p, int offset, int value)
 410 {
 411         offset = map_8250_out_reg(p, offset) << p->regshift;
 412         writeb(value, p->membase + offset);
 413 }
 414
 415 static void mem32_serial_out(struct uart_port *p, int offset, int value)
 416 {
 417         offset = map_8250_out_reg(p, offset) << p->regshift;
 418         writel(value, p->membase + offset);
 419 }
 420
 421 static unsigned int mem32_serial_in(struct uart_port *p, int offset)
 422 {
 423         offset = map_8250_in_reg(p, offset) << p->regshift;
 424         return readl(p->membase + offset);
 425 }
 426
 427 static unsigned int au_serial_in(struct uart_port *p, int offset)
 428 {
 429         offset = map_8250_in_reg(p, offset) << p->regshift;
 430         return __raw_readl(p->membase + offset);
 431 }
 432
 433 static void au_serial_out(struct uart_port *p, int offset, int value)
 434 {
 435         offset = map_8250_out_reg(p, offset) << p->regshift;
 436         __raw_writel(value, p->membase + offset);
 437 }
 438
 439 static unsigned int tsi_serial_in(struct uart_port *p, int offset)
 440 {
 441         unsigned int tmp;
 442         offset = map_8250_in_reg(p, offset) << p->regshift;
 443         if (offset == UART_IIR) {
 444                 tmp = readl(p->membase + (UART_IIR & ~3));
 445                 return (tmp >> 16) & 0xff; /* UART_IIR % 4 == 2 */
 446         } else
 447                 return readb(p->membase + offset);
 448 }
 449
 450 static void tsi_serial_out(struct uart_port *p, int offset, int value)
 451 {
 452         offset = map_8250_out_reg(p, offset) << p->regshift;
 453         if (!((offset == UART_IER) && (value & UART_IER_UUE)))
 454                 writeb(value, p->membase + offset);
 455 }
 456
 457 static void dwapb_serial_out(struct uart_port *p, int offset, int value)
 458 {
 459         int save_offset = offset;
 460         offset = map_8250_out_reg(p, offset) << p->regshift;
 461         /* Save the LCR value so it can be re-written when a
 462          * Busy Detect interrupt occurs. */
 463         if (save_offset == UART_LCR) {
 464                 struct uart_8250_port *up = (struct uart_8250_port *)p;
 465                 up->lcr = value;
 466         }
 467         writeb(value, p->membase + offset);
 468         /* Read the IER to ensure any interrupt is cleared before
 469          * returning from ISR. */
 470         if (save_offset == UART_TX || save_offset == UART_IER)
 471                 value = p->serial_in(p, UART_IER);
 472 }
 473
 474 static unsigned int io_serial_in(struct uart_port *p, int offset)
 475 {
 476         offset = map_8250_in_reg(p, offset) << p->regshift;
 477         return inb(p->iobase + offset);
 478 }
 479
 480 static void io_serial_out(struct uart_port *p, int offset, int value)
 481 {
 482         offset = map_8250_out_reg(p, offset) << p->regshift;
 483         outb(value, p->iobase + offset);
 484 }
 485
 486 static void set_io_from_upio(struct uart_port *p)
 487 {
 488         struct uart_8250_port *up = (struct uart_8250_port *)p;
 489         switch (p->iotype) {
 490         case UPIO_HUB6:
 491                 p->serial_in = hub6_serial_in;
 492                 p->serial_out = hub6_serial_out;
 493                 break;
 494
 495         case UPIO_MEM:
 496                 p->serial_in = mem_serial_in;
 497                 p->serial_out = mem_serial_out;
 498                 break;
 499
 500         case UPIO_RM9000:
 501         case UPIO_MEM32:
 502                 p->serial_in = mem32_serial_in;
 503                 p->serial_out = mem32_serial_out;
 504                 break;
 505
 506         case UPIO_AU:
 507                 p->serial_in = au_serial_in;
 508                 p->serial_out = au_serial_out;
 509                 break;
 510
 511         case UPIO_TSI:
 512                 p->serial_in = tsi_serial_in;
 513                 p->serial_out = tsi_serial_out;
 514                 break;
 515
 516         case UPIO_DWAPB:
 517                 p->serial_in = mem_serial_in;
 518                 p->serial_out = dwapb_serial_out;
 519                 break;
 520
 521         default:
 522                 p->serial_in = io_serial_in;
 523                 p->serial_out = io_serial_out;
 524                 break;
 525         }
 526         /* Remember loaded iotype */
 527         up->cur_iotype = p->iotype;
 528 }
 529
 530 static void
 531 serial_out_sync(struct uart_8250_port *up, int offset, int value)
 532 {
 533         struct uart_port *p = &up->port;
 534         switch (p->iotype) {
 535         case UPIO_MEM:
 536         case UPIO_MEM32:
 537         case UPIO_AU:
 538         case UPIO_DWAPB:
 539                 p->serial_out(p, offset, value);
 540                 p->serial_in(p, UART_LCR);      /* safe, no side-effects */
 541                 break;
 542         default:
 543                 p->serial_out(p, offset, value);
 544         }
 545 }
 546
 547 #define serial_in(up, offset)           \
 548         (up->port.serial_in(&(up)->port, (offset)))
 549 #define serial_out(up, offset, value)   \
 550         (up->port.serial_out(&(up)->port, (offset), (value)))
 551 /*
 552  * We used to support using pause I/O for certain machines.  We
 553  * haven't supported this for a while, but just in case it's badly
 554  * needed for certain old 386 machines, I've left these #define's
 555  * in....
 556  */
 557 #define serial_inp(up, offset)          serial_in(up, offset)
 558 #define serial_outp(up, offset, value)  serial_out(up, offset, value)
 559
 560 /* Uart divisor latch read */
 561 static inline int _serial_dl_read(struct uart_8250_port *up)
 562 {
 563         return serial_inp(up, UART_DLL) | serial_inp(up, UART_DLM) << 8;
 564 }
 565
 566 /* Uart divisor latch write */
 567 static inline void _serial_dl_write(struct uart_8250_port *up, int value)
 568 {
 569         serial_outp(up, UART_DLL, value & 0xff);
 570         serial_outp(up, UART_DLM, value >> 8 & 0xff);
 571 }
 572
 573 #if defined(CONFIG_MIPS_ALCHEMY)
 574 /* Au1x00 haven't got a standard divisor latch */
 575 static int serial_dl_read(struct uart_8250_port *up)
 576 {
 577         if (up->port.iotype == UPIO_AU)
 578                 return __raw_readl(up->port.membase + 0x28);
 579         else
 580                 return _serial_dl_read(up);
 581 }
 582
 583 static void serial_dl_write(struct uart_8250_port *up, int value)
 584 {
 585         if (up->port.iotype == UPIO_AU)
 586                 __raw_writel(value, up->port.membase + 0x28);
 587         else
 588                 _serial_dl_write(up, value);
 589 }
 590 #elif defined(CONFIG_SERIAL_8250_RM9K)
 591 static int serial_dl_read(struct uart_8250_port *up)
 592 {
 593         return  (up->port.iotype == UPIO_RM9000) ?
 594                 (((__raw_readl(up->port.membase + 0x10) << 8) |
 595                 (__raw_readl(up->port.membase + 0x08) & 0xff)) & 0xffff) :
 596                 _serial_dl_read(up);
 597 }
 598
 599 static void serial_dl_write(struct uart_8250_port *up, int value)
 600 {
 601         if (up->port.iotype == UPIO_RM9000) {
 602                 __raw_writel(value, up->port.membase + 0x08);
 603                 __raw_writel(value >> 8, up->port.membase + 0x10);
 604         } else {
 605                 _serial_dl_write(up, value);
 606         }
 607 }
 608 #else
 609 #define serial_dl_read(up) _serial_dl_read(up)
 610 #define serial_dl_write(up, value) _serial_dl_write(up, value)
 611 #endif
 612
 613 /*
 614  * For the 16C950
 615  */
 616 static void serial_icr_write(struct uart_8250_port *up, int offset, int value)
 617 {
 618         serial_out(up, UART_SCR, offset);
 619         serial_out(up, UART_ICR, value);
 620 }
 621
 622 static unsigned int serial_icr_read(struct uart_8250_port *up, int offset)
 623 {
 624         unsigned int value;
 625
 626         serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
 627         serial_out(up, UART_SCR, offset);
 628         value = serial_in(up, UART_ICR);
 629         serial_icr_write(up, UART_ACR, up->acr);
 630
 631         return value;
 632 }
 633
 634 /*
 635  * FIFO support.
 636  */
 637 static void serial8250_clear_fifos(struct uart_8250_port *p)
 638 {
 639         if (p->capabilities & UART_CAP_FIFO) {
 640                 serial_outp(p, UART_FCR, UART_FCR_ENABLE_FIFO);
 641                 serial_outp(p, UART_FCR, UART_FCR_ENABLE_FIFO |
 642                                UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 643                 serial_outp(p, UART_FCR, 0);
 644         }
 645 }
 646
 647 /*
 648  * IER sleep support.  UARTs which have EFRs need the "extended
 649  * capability" bit enabled.  Note that on XR16C850s, we need to
 650  * reset LCR to write to IER.
 651  */
 652 static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
 653 {
 654         if (p->capabilities & UART_CAP_SLEEP) {
 655                 if (p->capabilities & UART_CAP_EFR) {
 656                         serial_outp(p, UART_LCR, 0xBF);
 657                         serial_outp(p, UART_EFR, UART_EFR_ECB);
 658                         serial_outp(p, UART_LCR, 0);
 659                 }
 660                 serial_outp(p, UART_IER, sleep ? UART_IERX_SLEEP : 0);
 661                 if (p->capabilities & UART_CAP_EFR) {
 662                         serial_outp(p, UART_LCR, 0xBF);
 663                         serial_outp(p, UART_EFR, 0);
 664                         serial_outp(p, UART_LCR, 0);
 665                 }
 666         }
 667 }
 668
 669 #ifdef CONFIG_SERIAL_8250_RSA
 670 /*
 671  * Attempts to turn on the RSA FIFO.  Returns zero on failure.
 672  * We set the port uart clock rate if we succeed.
 673  */
 674 static int __enable_rsa(struct uart_8250_port *up)
 675 {
 676         unsigned char mode;
 677         int result;
 678
 679         mode = serial_inp(up, UART_RSA_MSR);
 680         result = mode & UART_RSA_MSR_FIFO;
 681
 682         if (!result) {
 683                 serial_outp(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
 684                 mode = serial_inp(up, UART_RSA_MSR);
 685                 result = mode & UART_RSA_MSR_FIFO;
 686         }
 687
 688         if (result)
 689                 up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
 690
 691         return result;
 692 }
 693
 694 static void enable_rsa(struct uart_8250_port *up)
 695 {
 696         if (up->port.type == PORT_RSA) {
 697                 if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
 698                         spin_lock_irq(&up->port.lock);
 699                         __enable_rsa(up);
 700                         spin_unlock_irq(&up->port.lock);
 701                 }
 702                 if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
 703                         serial_outp(up, UART_RSA_FRR, 0);
 704         }
 705 }
 706
 707 /*
 708  * Attempts to turn off the RSA FIFO.  Returns zero on failure.
 709  * It is unknown why interrupts were disabled in here.  However,
 710  * the caller is expected to preserve this behaviour by grabbing
 711  * the spinlock before calling this function.
 712  */
 713 static void disable_rsa(struct uart_8250_port *up)
 714 {
 715         unsigned char mode;
 716         int result;
 717
 718         if (up->port.type == PORT_RSA &&
 719             up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
 720                 spin_lock_irq(&up->port.lock);
 721
 722                 mode = serial_inp(up, UART_RSA_MSR);
 723                 result = !(mode & UART_RSA_MSR_FIFO);
 724
 725                 if (!result) {
 726                         serial_outp(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
 727                         mode = serial_inp(up, UART_RSA_MSR);
 728                         result = !(mode & UART_RSA_MSR_FIFO);
 729                 }
 730
 731                 if (result)
 732                         up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
 733                 spin_unlock_irq(&up->port.lock);
 734         }
 735 }
 736 #endif /* CONFIG_SERIAL_8250_RSA */
 737
 738 /*
 739  * This is a quickie test to see how big the FIFO is.
 740  * It doesn't work at all the time, more's the pity.
 741  */
 742 static int size_fifo(struct uart_8250_port *up)
 743 {
 744         unsigned char old_fcr, old_mcr, old_lcr;
 745         unsigned short old_dl;
 746         int count;
 747
 748         old_lcr = serial_inp(up, UART_LCR);
 749         serial_outp(up, UART_LCR, 0);
 750         old_fcr = serial_inp(up, UART_FCR);
 751         old_mcr = serial_inp(up, UART_MCR);
 752         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 753                     UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 754         serial_outp(up, UART_MCR, UART_MCR_LOOP);
 755         serial_outp(up, UART_LCR, UART_LCR_DLAB);
 756         old_dl = serial_dl_read(up);
 757         serial_dl_write(up, 0x0001);
 758         serial_outp(up, UART_LCR, 0x03);
 759         for (count = 0; count < 256; count++)
 760                 serial_outp(up, UART_TX, count);
 761         mdelay(20);/* FIXME - schedule_timeout */
 762         for (count = 0; (serial_inp(up, UART_LSR) & UART_LSR_DR) &&
 763              (count < 256); count++)
 764                 serial_inp(up, UART_RX);
 765         serial_outp(up, UART_FCR, old_fcr);
 766         serial_outp(up, UART_MCR, old_mcr);
 767         serial_outp(up, UART_LCR, UART_LCR_DLAB);
 768         serial_dl_write(up, old_dl);
 769         serial_outp(up, UART_LCR, old_lcr);
 770
 771         return count;
 772 }
 773
 774 /*
 775  * Read UART ID using the divisor method - set DLL and DLM to zero
 776  * and the revision will be in DLL and device type in DLM.  We
 777  * preserve the device state across this.
 778  */
 779 static unsigned int autoconfig_read_divisor_id(struct uart_8250_port *p)
 780 {
 781         unsigned char old_dll, old_dlm, old_lcr;
 782         unsigned int id;
 783
 784         old_lcr = serial_inp(p, UART_LCR);
 785         serial_outp(p, UART_LCR, UART_LCR_DLAB);
 786
 787         old_dll = serial_inp(p, UART_DLL);
 788         old_dlm = serial_inp(p, UART_DLM);
 789
 790         serial_outp(p, UART_DLL, 0);
 791         serial_outp(p, UART_DLM, 0);
 792
 793         id = serial_inp(p, UART_DLL) | serial_inp(p, UART_DLM) << 8;
 794
 795         serial_outp(p, UART_DLL, old_dll);
 796         serial_outp(p, UART_DLM, old_dlm);
 797         serial_outp(p, UART_LCR, old_lcr);
 798
 799         return id;
 800 }
 801
 802 /*
 803  * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's.
 804  * When this function is called we know it is at least a StarTech
 805  * 16650 V2, but it might be one of several StarTech UARTs, or one of
 806  * its clones.  (We treat the broken original StarTech 16650 V1 as a
 807  * 16550, and why not?  Startech doesn't seem to even acknowledge its
 808  * existence.)
 809  *
 810  * What evil have men's minds wrought...
 811  */
 812 static void autoconfig_has_efr(struct uart_8250_port *up)
 813 {
 814         unsigned int id1, id2, id3, rev;
 815
 816         /*
 817          * Everything with an EFR has SLEEP
 818          */
 819         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
 820
 821         /*
 822          * First we check to see if it's an Oxford Semiconductor UART.
 823          *
 824          * If we have to do this here because some non-National
 825          * Semiconductor clone chips lock up if you try writing to the
 826          * LSR register (which serial_icr_read does)
 827          */
 828
 829         /*
 830          * Check for Oxford Semiconductor 16C950.
 831          *
 832          * EFR [4] must be set else this test fails.
 833          *
 834          * This shouldn't be necessary, but Mike Hudson (Exoray@isys.ca)
 835          * claims that it's needed for 952 dual UART's (which are not
 836          * recommended for new designs).
 837          */
 838         up->acr = 0;
 839         serial_out(up, UART_LCR, 0xBF);
 840         serial_out(up, UART_EFR, UART_EFR_ECB);
 841         serial_out(up, UART_LCR, 0x00);
 842         id1 = serial_icr_read(up, UART_ID1);
 843         id2 = serial_icr_read(up, UART_ID2);
 844         id3 = serial_icr_read(up, UART_ID3);
 845         rev = serial_icr_read(up, UART_REV);
 846
 847         DEBUG_AUTOCONF("950id=%02x:%02x:%02x:%02x ", id1, id2, id3, rev);
 848
 849         if (id1 == 0x16 && id2 == 0xC9 &&
 850             (id3 == 0x50 || id3 == 0x52 || id3 == 0x54)) {
 851                 up->port.type = PORT_16C950;
 852
 853                 /*
 854                  * Enable work around for the Oxford Semiconductor 952 rev B
 855                  * chip which causes it to seriously miscalculate baud rates
 856                  * when DLL is 0.
 857                  */
 858                 if (id3 == 0x52 && rev == 0x01)
 859                         up->bugs |= UART_BUG_QUOT;
 860                 return;
 861         }
 862
 863         /*
 864          * We check for a XR16C850 by setting DLL and DLM to 0, and then
 865          * reading back DLL and DLM.  The chip type depends on the DLM
 866          * value read back:
 867          *  0x10 - XR16C850 and the DLL contains the chip revision.
 868          *  0x12 - XR16C2850.
 869          *  0x14 - XR16C854.
 870          */
 871         id1 = autoconfig_read_divisor_id(up);
 872         DEBUG_AUTOCONF("850id=%04x ", id1);
 873
 874         id2 = id1 >> 8;
 875         if (id2 == 0x10 || id2 == 0x12 || id2 == 0x14) {
 876                 up->port.type = PORT_16850;
 877                 return;
 878         }
 879
 880         /*
 881          * It wasn't an XR16C850.
 882          *
 883          * We distinguish between the '654 and the '650 by counting
 884          * how many bytes are in the FIFO.  I'm using this for now,
 885          * since that's the technique that was sent to me in the
 886          * serial driver update, but I'm not convinced this works.
 887          * I've had problems doing this in the past.  -TYT
 888          */
 889         if (size_fifo(up) == 64)
 890                 up->port.type = PORT_16654;
 891         else
 892                 up->port.type = PORT_16650V2;
 893 }
 894
 895 /*
 896  * We detected a chip without a FIFO.  Only two fall into
 897  * this category - the original 8250 and the 16450.  The
 898  * 16450 has a scratch register (accessible with LCR=0)
 899  */
 900 static void autoconfig_8250(struct uart_8250_port *up)
 901 {
 902         unsigned char scratch, status1, status2;
 903
 904         up->port.type = PORT_8250;
 905
 906         scratch = serial_in(up, UART_SCR);
 907         serial_outp(up, UART_SCR, 0xa5);
 908         status1 = serial_in(up, UART_SCR);
 909         serial_outp(up, UART_SCR, 0x5a);
 910         status2 = serial_in(up, UART_SCR);
 911         serial_outp(up, UART_SCR, scratch);
 912
 913         if (status1 == 0xa5 && status2 == 0x5a)
 914                 up->port.type = PORT_16450;
 915 }
 916
 917 static int broken_efr(struct uart_8250_port *up)
 918 {
 919         /*
 920          * Exar ST16C2550 "A2" devices incorrectly detect as
 921          * having an EFR, and report an ID of 0x0201.  See
 922          * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html
 923          */
 924         if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16)
 925                 return 1;
 926
 927         return 0;
 928 }
 929
 930 /*
 931  * We know that the chip has FIFOs.  Does it have an EFR?  The
 932  * EFR is located in the same register position as the IIR and
 933  * we know the top two bits of the IIR are currently set.  The
 934  * EFR should contain zero.  Try to read the EFR.
 935  */
 936 static void autoconfig_16550a(struct uart_8250_port *up)
 937 {
 938         unsigned char status1, status2;
 939         unsigned int iersave;
 940
 941         up->port.type = PORT_16550A;
 942         up->capabilities |= UART_CAP_FIFO;
 943
 944         /*
 945          * Check for presence of the EFR when DLAB is set.
 946          * Only ST16C650V1 UARTs pass this test.
 947          */
 948         serial_outp(up, UART_LCR, UART_LCR_DLAB);
 949         if (serial_in(up, UART_EFR) == 0) {
 950                 serial_outp(up, UART_EFR, 0xA8);
 951                 if (serial_in(up, UART_EFR) != 0) {
 952                         DEBUG_AUTOCONF("EFRv1 ");
 953                         up->port.type = PORT_16650;
 954                         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
 955                 } else {
 956                         DEBUG_AUTOCONF("Motorola 8xxx DUART ");
 957                 }
 958                 serial_outp(up, UART_EFR, 0);
 959                 return;
 960         }
 961
 962         /*
 963          * Maybe it requires 0xbf to be written to the LCR.
 964          * (other ST16C650V2 UARTs, TI16C752A, etc)
 965          */
 966         serial_outp(up, UART_LCR, 0xBF);
 967         if (serial_in(up, UART_EFR) == 0 && !broken_efr(up)) {
 968                 DEBUG_AUTOCONF("EFRv2 ");
 969                 autoconfig_has_efr(up);
 970                 return;
 971         }
 972
 973         /*
 974          * Check for a National Semiconductor SuperIO chip.
 975          * Attempt to switch to bank 2, read the value of the LOOP bit
 976          * from EXCR1. Switch back to bank 0, change it in MCR. Then
 977          * switch back to bank 2, read it from EXCR1 again and check
 978          * it's changed. If so, set baud_base in EXCR2 to 921600. -- dwmw2
 979          */
 980         serial_outp(up, UART_LCR, 0);
 981         status1 = serial_in(up, UART_MCR);
 982         serial_outp(up, UART_LCR, 0xE0);
 983         status2 = serial_in(up, 0x02); /* EXCR1 */
 984
 985         if (!((status2 ^ status1) & UART_MCR_LOOP)) {
 986                 serial_outp(up, UART_LCR, 0);
 987                 serial_outp(up, UART_MCR, status1 ^ UART_MCR_LOOP);
 988                 serial_outp(up, UART_LCR, 0xE0);
 989                 status2 = serial_in(up, 0x02); /* EXCR1 */
 990                 serial_outp(up, UART_LCR, 0);
 991                 serial_outp(up, UART_MCR, status1);
 992
 993                 if ((status2 ^ status1) & UART_MCR_LOOP) {
 994                         unsigned short quot;
 995
 996                         serial_outp(up, UART_LCR, 0xE0);
 997
 998                         quot = serial_dl_read(up);
 999                         quot <<= 3;
1000
1001                         status1 = serial_in(up, 0x04); /* EXCR2 */
1002                         status1 &= ~0xB0; /* Disable LOCK, mask out PRESL[01] */
1003                         status1 |= 0x10;  /* 1.625 divisor for baud_base --> 921600 */
1004                         serial_outp(up, 0x04, status1);
1005
1006                         serial_dl_write(up, quot);
1007
1008                         serial_outp(up, UART_LCR, 0);
1009
1010                         up->port.uartclk = 921600*16;
1011                         up->port.type = PORT_NS16550A;
1012                         up->capabilities |= UART_NATSEMI;
1013                         return;
1014                 }
1015         }
1016
1017         /*
1018          * No EFR.  Try to detect a TI16750, which only sets bit 5 of
1019          * the IIR when 64 byte FIFO mode is enabled when DLAB is set.
1020          * Try setting it with and without DLAB set.  Cheap clones
1021          * set bit 5 without DLAB set.
1022          */
1023         serial_outp(up, UART_LCR, 0);
1024         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
1025         status1 = serial_in(up, UART_IIR) >> 5;
1026         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1027         serial_outp(up, UART_LCR, UART_LCR_DLAB);
1028         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
1029         status2 = serial_in(up, UART_IIR) >> 5;
1030         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1031         serial_outp(up, UART_LCR, 0);
1032
1033         DEBUG_AUTOCONF("iir1=%d iir2=%d ", status1, status2);
1034
1035         if (status1 == 6 && status2 == 7) {
1036                 up->port.type = PORT_16750;
1037                 up->capabilities |= UART_CAP_AFE | UART_CAP_SLEEP;
1038                 return;
1039         }
1040
1041         /*
1042          * Try writing and reading the UART_IER_UUE bit (b6).
1043          * If it works, this is probably one of the Xscale platform's
1044          * internal UARTs.
1045          * We're going to explicitly set the UUE bit to 0 before
1046          * trying to write and read a 1 just to make sure it's not
1047          * already a 1 and maybe locked there before we even start start.
1048          */
1049         iersave = serial_in(up, UART_IER);
1050         serial_outp(up, UART_IER, iersave & ~UART_IER_UUE);
1051         if (!(serial_in(up, UART_IER) & UART_IER_UUE)) {
1052                 /*
1053                  * OK it's in a known zero state, try writing and reading
1054                  * without disturbing the current state of the other bits.
1055                  */
1056                 serial_outp(up, UART_IER, iersave | UART_IER_UUE);
1057                 if (serial_in(up, UART_IER) & UART_IER_UUE) {
1058                         /*
1059                          * It's an Xscale.
1060                          * We'll leave the UART_IER_UUE bit set to 1 (enabled).
1061                          */
1062                         DEBUG_AUTOCONF("Xscale ");
1063                         up->port.type = PORT_XSCALE;
1064                         up->capabilities |= UART_CAP_UUE;
1065                         return;
1066                 }
1067         } else {
1068                 /*
1069                  * If we got here we couldn't force the IER_UUE bit to 0.
1070                  * Log it and continue.
1071                  */
1072                 DEBUG_AUTOCONF("Couldn't force IER_UUE to 0 ");
1073         }
1074         serial_outp(up, UART_IER, iersave);
1075
1076         /*
1077          * We distinguish between 16550A and U6 16550A by counting
1078          * how many bytes are in the FIFO.
1079          */
1080         if (up->port.type == PORT_16550A && size_fifo(up) == 64) {
1081                 up->port.type = PORT_U6_16550A;
1082                 up->capabilities |= UART_CAP_AFE;
1083         }
1084 }
1085
1086 /*
1087  * This routine is called by rs_init() to initialize a specific serial
1088  * port.  It determines what type of UART chip this serial port is
1089  * using: 8250, 16450, 16550, 16550A.  The important question is
1090  * whether or not this UART is a 16550A or not, since this will
1091  * determine whether or not we can use its FIFO features or not.
1092  */
1093 static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
1094 {
1095         unsigned char status1, scratch, scratch2, scratch3;
1096         unsigned char save_lcr, save_mcr;
1097         unsigned long flags;
1098
1099         if (!up->port.iobase && !up->port.mapbase && !up->port.membase)
1100                 return;
1101
1102         DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04lx, 0x%p): ",
1103                        serial_index(&up->port), up->port.iobase, up->port.membase);
1104
1105         /*
1106          * We really do need global IRQs disabled here - we're going to
1107          * be frobbing the chips IRQ enable register to see if it exists.
1108          */
1109         spin_lock_irqsave(&up->port.lock, flags);
1110
1111         up->capabilities = 0;
1112         up->bugs = 0;
1113
1114         if (!(up->port.flags & UPF_BUGGY_UART)) {
1115                 /*
1116                  * Do a simple existence test first; if we fail this,
1117                  * there's no point trying anything else.
1118                  *
1119                  * 0x80 is used as a nonsense port to prevent against
1120                  * false positives due to ISA bus float.  The
1121                  * assumption is that 0x80 is a non-existent port;
1122                  * which should be safe since include/asm/io.h also
1123                  * makes this assumption.
1124                  *
1125                  * Note: this is safe as long as MCR bit 4 is clear
1126                  * and the device is in "PC" mode.
1127                  */
1128                 scratch = serial_inp(up, UART_IER);
1129                 serial_outp(up, UART_IER, 0);
1130 #ifdef __i386__
1131                 outb(0xff, 0x080);
1132 #endif
1133                 /*
1134                  * Mask out IER[7:4] bits for test as some UARTs (e.g. TL
1135                  * 16C754B) allow only to modify them if an EFR bit is set.
1136                  */
1137                 scratch2 = serial_inp(up, UART_IER) & 0x0f;
1138                 serial_outp(up, UART_IER, 0x0F);
1139 #ifdef __i386__
1140                 outb(0, 0x080);
1141 #endif
1142                 scratch3 = serial_inp(up, UART_IER) & 0x0f;
1143                 serial_outp(up, UART_IER, scratch);
1144                 if (scratch2 != 0 || scratch3 != 0x0F) {
1145                         /*
1146                          * We failed; there's nothing here
1147                          */
1148                         DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
1149                                        scratch2, scratch3);
1150                         goto out;
1151                 }
1152         }
1153
1154         save_mcr = serial_in(up, UART_MCR);
1155         save_lcr = serial_in(up, UART_LCR);
1156
1157         /*
1158          * Check to see if a UART is really there.  Certain broken
1159          * internal modems based on the Rockwell chipset fail this
1160          * test, because they apparently don't implement the loopback
1161          * test mode.  So this test is skipped on the COM 1 through
1162          * COM 4 ports.  This *should* be safe, since no board
1163          * manufacturer would be stupid enough to design a board
1164          * that conflicts with COM 1-4 --- we hope!
1165          */
1166         if (!(up->port.flags & UPF_SKIP_TEST)) {
1167                 serial_outp(up, UART_MCR, UART_MCR_LOOP | 0x0A);
1168                 status1 = serial_inp(up, UART_MSR) & 0xF0;
1169                 serial_outp(up, UART_MCR, save_mcr);
1170                 if (status1 != 0x90) {
1171                         DEBUG_AUTOCONF("LOOP test failed (%02x) ",
1172                                        status1);
1173                         goto out;
1174                 }
1175         }
1176
1177         /*
1178          * We're pretty sure there's a port here.  Lets find out what
1179          * type of port it is.  The IIR top two bits allows us to find
1180          * out if it's 8250 or 16450, 16550, 16550A or later.  This
1181          * determines what we test for next.
1182          *
1183          * We also initialise the EFR (if any) to zero for later.  The
1184          * EFR occupies the same register location as the FCR and IIR.
1185          */
1186         serial_outp(up, UART_LCR, 0xBF);
1187         serial_outp(up, UART_EFR, 0);
1188         serial_outp(up, UART_LCR, 0);
1189
1190         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1191         scratch = serial_in(up, UART_IIR) >> 6;
1192
1193         DEBUG_AUTOCONF("iir=%d ", scratch);
1194
1195         switch (scratch) {
1196         case 0:
1197                 autoconfig_8250(up);
1198                 break;
1199         case 1:
1200                 up->port.type = PORT_UNKNOWN;
1201                 break;
1202         case 2:
1203                 up->port.type = PORT_16550;
1204                 break;
1205         case 3:
1206                 autoconfig_16550a(up);
1207                 break;
1208         }
1209
1210 #ifdef CONFIG_SERIAL_8250_RSA
1211         /*
1212          * Only probe for RSA ports if we got the region.
1213          */
1214         if (up->port.type == PORT_16550A && probeflags & PROBE_RSA) {
1215                 int i;
1216
1217                 for (i = 0 ; i < probe_rsa_count; ++i) {
1218                         if (probe_rsa[i] == up->port.iobase &&
1219                             __enable_rsa(up)) {
1220                                 up->port.type = PORT_RSA;
1221                                 break;
1222                         }
1223                 }
1224         }
1225 #endif
1226
1227         serial_outp(up, UART_LCR, save_lcr);
1228
1229         if (up->capabilities != uart_config[up->port.type].flags) {
1230                 printk(KERN_WARNING
1231                        "ttyS%d: detected caps %08x should be %08x\n",
1232                        serial_index(&up->port), up->capabilities,
1233                        uart_config[up->port.type].flags);
1234         }
1235
1236         up->port.fifosize = uart_config[up->port.type].fifo_size;
1237         up->capabilities = uart_config[up->port.type].flags;
1238         up->tx_loadsz = uart_config[up->port.type].tx_loadsz;
1239
1240         if (up->port.type == PORT_UNKNOWN)
1241                 goto out;
1242
1243         /*
1244          * Reset the UART.
1245          */
1246 #ifdef CONFIG_SERIAL_8250_RSA
1247         if (up->port.type == PORT_RSA)
1248                 serial_outp(up, UART_RSA_FRR, 0);
1249 #endif
1250         serial_outp(up, UART_MCR, save_mcr);
1251         serial8250_clear_fifos(up);
1252         serial_in(up, UART_RX);
1253         if (up->capabilities & UART_CAP_UUE)
1254                 serial_outp(up, UART_IER, UART_IER_UUE);
1255         else
1256                 serial_outp(up, UART_IER, 0);
1257
1258  out:
1259         spin_unlock_irqrestore(&up->port.lock, flags);
1260         DEBUG_AUTOCONF("type=%s\n", uart_config[up->port.type].name);
1261 }
1262
1263 static void autoconfig_irq(struct uart_8250_port *up)
1264 {
1265         unsigned char save_mcr, save_ier;
1266         unsigned char save_ICP = 0;
1267         unsigned int ICP = 0;
1268         unsigned long irqs;
1269         int irq;
1270
1271         if (up->port.flags & UPF_FOURPORT) {
1272                 ICP = (up->port.iobase & 0xfe0) | 0x1f;
1273                 save_ICP = inb_p(ICP);
1274                 outb_p(0x80, ICP);
1275                 (void) inb_p(ICP);
1276         }
1277
1278         /* forget possible initially masked and pending IRQ */
1279         probe_irq_off(probe_irq_on());
1280         save_mcr = serial_inp(up, UART_MCR);
1281         save_ier = serial_inp(up, UART_IER);
1282         serial_outp(up, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2);
1283
1284         irqs = probe_irq_on();
1285         serial_outp(up, UART_MCR, 0);
1286         udelay(10);
1287         if (up->port.flags & UPF_FOURPORT) {
1288                 serial_outp(up, UART_MCR,
1289                             UART_MCR_DTR | UART_MCR_RTS);
1290         } else {
1291                 serial_outp(up, UART_MCR,
1292                             UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
1293         }
1294         serial_outp(up, UART_IER, 0x0f);        /* enable all intrs */
1295         (void)serial_inp(up, UART_LSR);
1296         (void)serial_inp(up, UART_RX);
1297         (void)serial_inp(up, UART_IIR);
1298         (void)serial_inp(up, UART_MSR);
1299         serial_outp(up, UART_TX, 0xFF);
1300         udelay(20);
1301         irq = probe_irq_off(irqs);
1302
1303         serial_outp(up, UART_MCR, save_mcr);
1304         serial_outp(up, UART_IER, save_ier);
1305
1306         if (up->port.flags & UPF_FOURPORT)
1307                 outb_p(save_ICP, ICP);
1308
1309         up->port.irq = (irq > 0) ? irq : 0;
1310 }
1311
1312 static inline void __stop_tx(struct uart_8250_port *p)
1313 {
1314         if (p->ier & UART_IER_THRI) {
1315                 p->ier &= ~UART_IER_THRI;
1316                 serial_out(p, UART_IER, p->ier);
1317         }
1318 }
1319
1320 static void serial8250_stop_tx(struct uart_port *port)
1321 {
1322         struct uart_8250_port *up = (struct uart_8250_port *)port;
1323
1324         __stop_tx(up);
1325
1326         /*
1327          * We really want to stop the transmitter from sending.
1328          */
1329         if (up->port.type == PORT_16C950) {
1330                 up->acr |= UART_ACR_TXDIS;
1331                 serial_icr_write(up, UART_ACR, up->acr);
1332         }
1333 }
1334
1335 static void transmit_chars(struct uart_8250_port *up);
1336
1337 static void serial8250_start_tx(struct uart_port *port)
1338 {
1339         struct uart_8250_port *up = (struct uart_8250_port *)port;
1340
1341         if (!(up->ier & UART_IER_THRI)) {
1342                 up->ier |= UART_IER_THRI;
1343                 serial_out(up, UART_IER, up->ier);
1344
1345                 if (up->bugs & UART_BUG_TXEN) {
1346                         unsigned char lsr;
1347                         lsr = serial_in(up, UART_LSR);
1348                         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1349                         if ((up->port.type == PORT_RM9000) ?
1350                                 (lsr & UART_LSR_THRE) :
1351                                 (lsr & UART_LSR_TEMT))
1352                                 transmit_chars(up);
1353                 }
1354         }
1355
1356         /*
1357          * Re-enable the transmitter if we disabled it.
1358          */
1359         if (up->port.type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
1360                 up->acr &= ~UART_ACR_TXDIS;
1361                 serial_icr_write(up, UART_ACR, up->acr);
1362         }
1363 }
1364
1365 static void serial8250_stop_rx(struct uart_port *port)
1366 {
1367         struct uart_8250_port *up = (struct uart_8250_port *)port;
1368
1369         up->ier &= ~UART_IER_RLSI;
1370         up->port.read_status_mask &= ~UART_LSR_DR;
1371         serial_out(up, UART_IER, up->ier);
1372 }
1373
1374 static void serial8250_enable_ms(struct uart_port *port)
1375 {
1376         struct uart_8250_port *up = (struct uart_8250_port *)port;
1377
1378         /* no MSR capabilities */
1379         if (up->bugs & UART_BUG_NOMSR)
1380                 return;
1381
1382         up->ier |= UART_IER_MSI;
1383         serial_out(up, UART_IER, up->ier);
1384 }
1385
1386 static void
1387 receive_chars(struct uart_8250_port *up, unsigned int *status)
1388 {
1389         struct tty_struct *tty = up->port.state->port.tty;
1390         unsigned char ch, lsr = *status;
1391         int max_count = 256;
1392         char flag;
1393
1394         do {
1395                 if (likely(lsr & UART_LSR_DR))
1396                         ch = serial_inp(up, UART_RX);
1397                 else
1398                         /*
1399                          * Intel 82571 has a Serial Over Lan device that will
1400                          * set UART_LSR_BI without setting UART_LSR_DR when
1401                          * it receives a break. To avoid reading from the
1402                          * receive buffer without UART_LSR_DR bit set, we
1403                          * just force the read character to be 0
1404                          */
1405                         ch = 0;
1406
1407                 flag = TTY_NORMAL;
1408                 up->port.icount.rx++;
1409
1410                 lsr |= up->lsr_saved_flags;
1411                 up->lsr_saved_flags = 0;
1412
1413                 if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
1414                         /*
1415                          * For statistics only
1416                          */
1417                         if (lsr & UART_LSR_BI) {
1418                                 lsr &= ~(UART_LSR_FE | UART_LSR_PE);
1419                                 up->port.icount.brk++;
1420                                 /*
1421                                  * We do the SysRQ and SAK checking
1422                                  * here because otherwise the break
1423                                  * may get masked by ignore_status_mask
1424                                  * or read_status_mask.
1425                                  */
1426                                 if (uart_handle_break(&up->port))
1427                                         goto ignore_char;
1428                         } else if (lsr & UART_LSR_PE)
1429                                 up->port.icount.parity++;
1430                         else if (lsr & UART_LSR_FE)
1431                                 up->port.icount.frame++;
1432                         if (lsr & UART_LSR_OE)
1433                                 up->port.icount.overrun++;
1434
1435                         /*
1436                          * Mask off conditions which should be ignored.
1437                          */
1438                         lsr &= up->port.read_status_mask;
1439
1440                         if (lsr & UART_LSR_BI) {
1441                                 DEBUG_INTR("handling break....");
1442                                 flag = TTY_BREAK;
1443                         } else if (lsr & UART_LSR_PE)
1444                                 flag = TTY_PARITY;
1445                         else if (lsr & UART_LSR_FE)
1446                                 flag = TTY_FRAME;
1447                 }
1448                 if (uart_handle_sysrq_char(&up->port, ch))
1449                         goto ignore_char;
1450
1451                 uart_insert_char(&up->port, lsr, UART_LSR_OE, ch, flag);
1452
1453 ignore_char:
1454                 lsr = serial_inp(up, UART_LSR);
1455         } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (max_count-- > 0));
1456         spin_unlock(&up->port.lock);
1457         tty_flip_buffer_push(tty);
1458         spin_lock(&up->port.lock);
1459         *status = lsr;
1460 }
1461
1462 static void transmit_chars(struct uart_8250_port *up)
1463 {
1464         struct circ_buf *xmit = &up->port.state->xmit;
1465         int count;
1466
1467         if (up->port.x_char) {
1468                 serial_outp(up, UART_TX, up->port.x_char);
1469                 up->port.icount.tx++;
1470                 up->port.x_char = 0;
1471                 return;
1472         }
1473         if (uart_tx_stopped(&up->port)) {
1474                 serial8250_stop_tx(&up->port);
1475                 return;
1476         }
1477         if (uart_circ_empty(xmit)) {
1478                 __stop_tx(up);
1479                 return;
1480         }
1481
1482         count = up->tx_loadsz;
1483         do {
1484                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
1485                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
1486                 up->port.icount.tx++;
1487                 if (uart_circ_empty(xmit))
1488                         break;
1489         } while (--count > 0);
1490
1491         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
1492                 uart_write_wakeup(&up->port);
1493
1494         DEBUG_INTR("THRE...");
1495
1496         if (uart_circ_empty(xmit))
1497                 __stop_tx(up);
1498 }
1499
1500 static unsigned int check_modem_status(struct uart_8250_port *up)
1501 {
1502         unsigned int status = serial_in(up, UART_MSR);
1503
1504         status |= up->msr_saved_flags;
1505         up->msr_saved_flags = 0;
1506         if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
1507             up->port.state != NULL) {
1508                 if (status & UART_MSR_TERI)
1509                         up->port.icount.rng++;
1510                 if (status & UART_MSR_DDSR)
1511                         up->port.icount.dsr++;
1512                 if (status & UART_MSR_DDCD)
1513                         uart_handle_dcd_change(&up->port, status & UART_MSR_DCD);
1514                 if (status & UART_MSR_DCTS)
1515                         uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
1516
1517                 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
1518         }
1519
1520         return status;
1521 }
1522
1523 /*
1524  * This handles the interrupt from one port.
1525  */
1526 static void serial8250_handle_port(struct uart_8250_port *up)
1527 {
1528         unsigned int status;
1529         unsigned long flags;
1530
1531         spin_lock_irqsave(&up->port.lock, flags);
1532
1533         status = serial_inp(up, UART_LSR);
1534
1535         DEBUG_INTR("status = %x...", status);
1536
1537         if (status & (UART_LSR_DR | UART_LSR_BI))
1538                 receive_chars(up, &status);
1539         check_modem_status(up);
1540         if (status & UART_LSR_THRE)
1541                 transmit_chars(up);
1542
1543         spin_unlock_irqrestore(&up->port.lock, flags);
1544 }
1545
1546 /*
1547  * This is the serial driver's interrupt routine.
1548  *
1549  * Arjan thinks the old way was overly complex, so it got simplified.
1550  * Alan disagrees, saying that need the complexity to handle the weird
1551  * nature of ISA shared interrupts.  (This is a special exception.)
1552  *
1553  * In order to handle ISA shared interrupts properly, we need to check
1554  * that all ports have been serviced, and therefore the ISA interrupt
1555  * line has been de-asserted.
1556  *
1557  * This means we need to loop through all ports. checking that they
1558  * don't have an interrupt pending.
1559  */
1560 static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
1561 {
1562         struct irq_info *i = dev_id;
1563         struct list_head *l, *end = NULL;
1564         int pass_counter = 0, handled = 0;
1565
1566         DEBUG_INTR("serial8250_interrupt(%d)...", irq);
1567
1568         spin_lock(&i->lock);
1569
1570         l = i->head;
1571         do {
1572                 struct uart_8250_port *up;
1573                 unsigned int iir;
1574
1575                 up = list_entry(l, struct uart_8250_port, list);
1576
1577                 iir = serial_in(up, UART_IIR);
1578                 if (!(iir & UART_IIR_NO_INT)) {
1579                         serial8250_handle_port(up);
1580
1581                         handled = 1;
1582
1583                         end = NULL;
1584                 } else if (up->port.iotype == UPIO_DWAPB &&
1585                           (iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
1586                         /* The DesignWare APB UART has an Busy Detect (0x07)
1587                          * interrupt meaning an LCR write attempt occured while the
1588                          * UART was busy. The interrupt must be cleared by reading
1589                          * the UART status register (USR) and the LCR re-written. */
1590                         unsigned int status;
1591                         status = *(volatile u32 *)up->port.private_data;
1592                         serial_out(up, UART_LCR, up->lcr);
1593
1594                         handled = 1;
1595
1596                         end = NULL;
1597                 } else if (end == NULL)
1598                         end = l;
1599
1600                 l = l->next;
1601
1602                 if (l == i->head && pass_counter++ > PASS_LIMIT) {
1603                         /* If we hit this, we're dead. */
1604                         printk_ratelimited(KERN_ERR
1605                                 "serial8250: too much work for irq%d\n", irq);
1606                         break;
1607                 }
1608         } while (l != end);
1609
1610         spin_unlock(&i->lock);
1611
1612         DEBUG_INTR("end.\n");
1613
1614         return IRQ_RETVAL(handled);
1615 }
1616
1617 /*
1618  * To support ISA shared interrupts, we need to have one interrupt
1619  * handler that ensures that the IRQ line has been deasserted
1620  * before returning.  Failing to do this will result in the IRQ
1621  * line being stuck active, and, since ISA irqs are edge triggered,
1622  * no more IRQs will be seen.
1623  */
1624 static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
1625 {
1626         spin_lock_irq(&i->lock);
1627
1628         if (!list_empty(i->head)) {
1629                 if (i->head == &up->list)
1630                         i->head = i->head->next;
1631                 list_del(&up->list);
1632         } else {
1633                 BUG_ON(i->head != &up->list);
1634                 i->head = NULL;
1635         }
1636         spin_unlock_irq(&i->lock);
1637         /* List empty so throw away the hash node */
1638         if (i->head == NULL) {
1639                 hlist_del(&i->node);
1640                 kfree(i);
1641         }
1642 }
1643
1644 static int serial_link_irq_chain(struct uart_8250_port *up)
1645 {
1646         struct hlist_head *h;
1647         struct hlist_node *n;
1648         struct irq_info *i;
1649         int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
1650
1651         mutex_lock(&hash_mutex);
1652
1653         h = &irq_lists[up->port.irq % NR_IRQ_HASH];
1654
1655         hlist_for_each(n, h) {
1656                 i = hlist_entry(n, struct irq_info, node);
1657                 if (i->irq == up->port.irq)
1658                         break;
1659         }
1660
1661         if (n == NULL) {
1662                 i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
1663                 if (i == NULL) {
1664                         mutex_unlock(&hash_mutex);
1665                         return -ENOMEM;
1666                 }
1667                 spin_lock_init(&i->lock);
1668                 i->irq = up->port.irq;
1669                 hlist_add_head(&i->node, h);
1670         }
1671         mutex_unlock(&hash_mutex);
1672
1673         spin_lock_irq(&i->lock);
1674
1675         if (i->head) {
1676                 list_add(&up->list, i->head);
1677                 spin_unlock_irq(&i->lock);
1678
1679                 ret = 0;
1680         } else {
1681                 INIT_LIST_HEAD(&up->list);
1682                 i->head = &up->list;
1683                 spin_unlock_irq(&i->lock);
1684                 irq_flags |= up->port.irqflags;
1685                 ret = request_irq(up->port.irq, serial8250_interrupt,
1686                                   irq_flags, "serial", i);
1687                 if (ret < 0)
1688                         serial_do_unlink(i, up);
1689         }
1690
1691         return ret;
1692 }
1693
1694 static void serial_unlink_irq_chain(struct uart_8250_port *up)
1695 {
1696         struct irq_info *i;
1697         struct hlist_node *n;
1698         struct hlist_head *h;
1699
1700         mutex_lock(&hash_mutex);
1701
1702         h = &irq_lists[up->port.irq % NR_IRQ_HASH];
1703
1704         hlist_for_each(n, h) {
1705                 i = hlist_entry(n, struct irq_info, node);
1706                 if (i->irq == up->port.irq)
1707                         break;
1708         }
1709
1710         BUG_ON(n == NULL);
1711         BUG_ON(i->head == NULL);
1712
1713         if (list_empty(i->head))
1714                 free_irq(up->port.irq, i);
1715
1716         serial_do_unlink(i, up);
1717         mutex_unlock(&hash_mutex);
1718 }
1719
1720 /*
1721  * This function is used to handle ports that do not have an
1722  * interrupt.  This doesn't work very well for 16450's, but gives
1723  * barely passable results for a 16550A.  (Although at the expense
1724  * of much CPU overhead).
1725  */
1726 static void serial8250_timeout(unsigned long data)
1727 {
1728         struct uart_8250_port *up = (struct uart_8250_port *)data;
1729         unsigned int iir;
1730
1731         iir = serial_in(up, UART_IIR);
1732         if (!(iir & UART_IIR_NO_INT))
1733                 serial8250_handle_port(up);
1734         mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
1735 }
1736
1737 static void serial8250_backup_timeout(unsigned long data)
1738 {
1739         struct uart_8250_port *up = (struct uart_8250_port *)data;
1740         unsigned int iir, ier = 0, lsr;
1741         unsigned long flags;
1742
1743         /*
1744          * Must disable interrupts or else we risk racing with the interrupt
1745          * based handler.
1746          */
1747         if (is_real_interrupt(up->port.irq)) {
1748                 ier = serial_in(up, UART_IER);
1749                 serial_out(up, UART_IER, 0);
1750         }
1751
1752         iir = serial_in(up, UART_IIR);
1753
1754         /*
1755          * This should be a safe test for anyone who doesn't trust the
1756          * IIR bits on their UART, but it's specifically designed for
1757          * the "Diva" UART used on the management processor on many HP
1758          * ia64 and parisc boxes.
1759          */
1760         spin_lock_irqsave(&up->port.lock, flags);
1761         lsr = serial_in(up, UART_LSR);
1762         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1763         spin_unlock_irqrestore(&up->port.lock, flags);
1764         if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
1765             (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
1766             (lsr & UART_LSR_THRE)) {
1767                 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
1768                 iir |= UART_IIR_THRI;
1769         }
1770
1771         if (!(iir & UART_IIR_NO_INT))
1772                 serial8250_handle_port(up);
1773
1774         if (is_real_interrupt(up->port.irq))
1775                 serial_out(up, UART_IER, ier);
1776
1777         /* Standard timer interval plus 0.2s to keep the port running */
1778         mod_timer(&up->timer,
1779                 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
1780 }
1781
1782 static unsigned int serial8250_tx_empty(struct uart_port *port)
1783 {
1784         struct uart_8250_port *up = (struct uart_8250_port *)port;
1785         unsigned long flags;
1786         unsigned int lsr;
1787
1788         spin_lock_irqsave(&up->port.lock, flags);
1789         lsr = serial_in(up, UART_LSR);
1790         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1791         spin_unlock_irqrestore(&up->port.lock, flags);
1792
1793         return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
1794 }
1795
1796 static unsigned int serial8250_get_mctrl(struct uart_port *port)
1797 {
1798         struct uart_8250_port *up = (struct uart_8250_port *)port;
1799         unsigned int status;
1800         unsigned int ret;
1801
1802         status = check_modem_status(up);
1803
1804         ret = 0;
1805         if (status & UART_MSR_DCD)
1806                 ret |= TIOCM_CAR;
1807         if (status & UART_MSR_RI)
1808                 ret |= TIOCM_RNG;
1809         if (status & UART_MSR_DSR)
1810                 ret |= TIOCM_DSR;
1811         if (status & UART_MSR_CTS)
1812                 ret |= TIOCM_CTS;
1813         return ret;
1814 }
1815
1816 static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
1817 {
1818         struct uart_8250_port *up = (struct uart_8250_port *)port;
1819         unsigned char mcr = 0;
1820
1821         if (mctrl & TIOCM_RTS)
1822                 mcr |= UART_MCR_RTS;
1823         if (mctrl & TIOCM_DTR)
1824                 mcr |= UART_MCR_DTR;
1825         if (mctrl & TIOCM_OUT1)
1826                 mcr |= UART_MCR_OUT1;
1827         if (mctrl & TIOCM_OUT2)
1828                 mcr |= UART_MCR_OUT2;
1829         if (mctrl & TIOCM_LOOP)
1830                 mcr |= UART_MCR_LOOP;
1831
1832         mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr;
1833
1834         serial_out(up, UART_MCR, mcr);
1835 }
1836
1837 static void serial8250_break_ctl(struct uart_port *port, int break_state)
1838 {
1839         struct uart_8250_port *up = (struct uart_8250_port *)port;
1840         unsigned long flags;
1841
1842         spin_lock_irqsave(&up->port.lock, flags);
1843         if (break_state == -1)
1844                 up->lcr |= UART_LCR_SBC;
1845         else
1846                 up->lcr &= ~UART_LCR_SBC;
1847         serial_out(up, UART_LCR, up->lcr);
1848         spin_unlock_irqrestore(&up->port.lock, flags);
1849 }
1850
1851 /*
1852  *      Wait for transmitter & holding register to empty
1853  */
1854 static void wait_for_xmitr(struct uart_8250_port *up, int bits)
1855 {
1856         unsigned int status, tmout = 10000;
1857
1858         /* Wait up to 10ms for the character(s) to be sent. */
1859         for (;;) {
1860                 status = serial_in(up, UART_LSR);
1861
1862                 up->lsr_saved_flags |= status & LSR_SAVE_FLAGS;
1863
1864                 if ((status & bits) == bits)
1865                         break;
1866                 if (--tmout == 0)
1867                         break;
1868                 udelay(1);
1869         }
1870
1871         /* Wait up to 1s for flow control if necessary */
1872         if (up->port.flags & UPF_CONS_FLOW) {
1873                 unsigned int tmout;
1874                 for (tmout = 1000000; tmout; tmout--) {
1875                         unsigned int msr = serial_in(up, UART_MSR);
1876                         up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
1877                         if (msr & UART_MSR_CTS)
1878                                 break;
1879                         udelay(1);
1880                         touch_nmi_watchdog();
1881                 }
1882         }
1883 }
1884
1885 #ifdef CONFIG_CONSOLE_POLL
1886 /*
1887  * Console polling routines for writing and reading from the uart while
1888  * in an interrupt or debug context.
1889  */
1890
1891 static int serial8250_get_poll_char(struct uart_port *port)
1892 {
1893         struct uart_8250_port *up = (struct uart_8250_port *)port;
1894         unsigned char lsr = serial_inp(up, UART_LSR);
1895
1896         if (!(lsr & UART_LSR_DR))
1897                 return NO_POLL_CHAR;
1898
1899         return serial_inp(up, UART_RX);
1900 }
1901
1902
1903 static void serial8250_put_poll_char(struct uart_port *port,
1904                          unsigned char c)
1905 {
1906         unsigned int ier;
1907         struct uart_8250_port *up = (struct uart_8250_port *)port;
1908
1909         /*
1910          *      First save the IER then disable the interrupts
1911          */
1912         ier = serial_in(up, UART_IER);
1913         if (up->capabilities & UART_CAP_UUE)
1914                 serial_out(up, UART_IER, UART_IER_UUE);
1915         else
1916                 serial_out(up, UART_IER, 0);
1917
1918         wait_for_xmitr(up, BOTH_EMPTY);
1919         /*
1920          *      Send the character out.
1921          *      If a LF, also do CR...
1922          */
1923         serial_out(up, UART_TX, c);
1924         if (c == 10) {
1925                 wait_for_xmitr(up, BOTH_EMPTY);
1926                 serial_out(up, UART_TX, 13);
1927         }
1928
1929         /*
1930          *      Finally, wait for transmitter to become empty
1931          *      and restore the IER
1932          */
1933         wait_for_xmitr(up, BOTH_EMPTY);
1934         serial_out(up, UART_IER, ier);
1935 }
1936
1937 #endif /* CONFIG_CONSOLE_POLL */
1938
1939 static int serial8250_startup(struct uart_port *port)
1940 {
1941         struct uart_8250_port *up = (struct uart_8250_port *)port;
1942         unsigned long flags;
1943         unsigned char lsr, iir;
1944         int retval;
1945
1946         up->capabilities = uart_config[up->port.type].flags;
1947         up->mcr = 0;
1948
1949         if (up->port.iotype != up->cur_iotype)
1950                 set_io_from_upio(port);
1951
1952         if (up->port.type == PORT_16C950) {
1953                 /* Wake up and initialize UART */
1954                 up->acr = 0;
1955                 serial_outp(up, UART_LCR, 0xBF);
1956                 serial_outp(up, UART_EFR, UART_EFR_ECB);
1957                 serial_outp(up, UART_IER, 0);
1958                 serial_outp(up, UART_LCR, 0);
1959                 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
1960                 serial_outp(up, UART_LCR, 0xBF);
1961                 serial_outp(up, UART_EFR, UART_EFR_ECB);
1962                 serial_outp(up, UART_LCR, 0);
1963         }
1964
1965 #ifdef CONFIG_SERIAL_8250_RSA
1966         /*
1967          * If this is an RSA port, see if we can kick it up to the
1968          * higher speed clock.
1969          */
1970         enable_rsa(up);
1971 #endif
1972
1973         /*
1974          * Clear the FIFO buffers and disable them.
1975          * (they will be reenabled in set_termios())
1976          */
1977         serial8250_clear_fifos(up);
1978
1979         /*
1980          * Clear the interrupt registers.
1981          */
1982         (void) serial_inp(up, UART_LSR);
1983         (void) serial_inp(up, UART_RX);
1984         (void) serial_inp(up, UART_IIR);
1985         (void) serial_inp(up, UART_MSR);
1986
1987         /*
1988          * At this point, there's no way the LSR could still be 0xff;
1989          * if it is, then bail out, because there's likely no UART
1990          * here.
1991          */
1992         if (!(up->port.flags & UPF_BUGGY_UART) &&
1993             (serial_inp(up, UART_LSR) == 0xff)) {
1994                 printk(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
1995                        serial_index(&up->port));
1996                 return -ENODEV;
1997         }
1998
1999         /*
2000          * For a XR16C850, we need to set the trigger levels
2001          */
2002         if (up->port.type == PORT_16850) {
2003                 unsigned char fctr;
2004
2005                 serial_outp(up, UART_LCR, 0xbf);
2006
2007                 fctr = serial_inp(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX);
2008                 serial_outp(up, UART_FCTR, fctr | UART_FCTR_TRGD | UART_FCTR_RX);
2009                 serial_outp(up, UART_TRG, UART_TRG_96);
2010                 serial_outp(up, UART_FCTR, fctr | UART_FCTR_TRGD | UART_FCTR_TX);
2011                 serial_outp(up, UART_TRG, UART_TRG_96);
2012
2013                 serial_outp(up, UART_LCR, 0);
2014         }
2015
2016         if (is_real_interrupt(up->port.irq)) {
2017                 unsigned char iir1;
2018                 /*
2019                  * Test for UARTs that do not reassert THRE when the
2020                  * transmitter is idle and the interrupt has already
2021                  * been cleared.  Real 16550s should always reassert
2022                  * this interrupt whenever the transmitter is idle and
2023                  * the interrupt is enabled.  Delays are necessary to
2024                  * allow register changes to become visible.
2025                  */
2026                 spin_lock_irqsave(&up->port.lock, flags);
2027                 if (up->port.irqflags & IRQF_SHARED)
2028                         disable_irq_nosync(up->port.irq);
2029
2030                 wait_for_xmitr(up, UART_LSR_THRE);
2031                 serial_out_sync(up, UART_IER, UART_IER_THRI);
2032                 udelay(1); /* allow THRE to set */
2033                 iir1 = serial_in(up, UART_IIR);
2034                 serial_out(up, UART_IER, 0);
2035                 serial_out_sync(up, UART_IER, UART_IER_THRI);
2036                 udelay(1); /* allow a working UART time to re-assert THRE */
2037                 iir = serial_in(up, UART_IIR);
2038                 serial_out(up, UART_IER, 0);
2039
2040                 if (up->port.irqflags & IRQF_SHARED)
2041                         enable_irq(up->port.irq);
2042                 spin_unlock_irqrestore(&up->port.lock, flags);
2043
2044                 /*
2045                  * If the interrupt is not reasserted, setup a timer to
2046                  * kick the UART on a regular basis.
2047                  */
2048                 if (!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) {
2049                         up->bugs |= UART_BUG_THRE;
2050                         pr_debug("ttyS%d - using backup timer\n",
2051                                  serial_index(port));
2052                 }
2053         }
2054
2055         /*
2056          * The above check will only give an accurate result the first time
2057          * the port is opened so this value needs to be preserved.
2058          */
2059         if (up->bugs & UART_BUG_THRE) {
2060                 up->timer.function = serial8250_backup_timeout;
2061                 up->timer.data = (unsigned long)up;
2062                 mod_timer(&up->timer, jiffies +
2063                         uart_poll_timeout(port) + HZ / 5);
2064         }
2065
2066         /*
2067          * If the "interrupt" for this port doesn't correspond with any
2068          * hardware interrupt, we use a timer-based system.  The original
2069          * driver used to do this with IRQ0.
2070          */
2071         if (!is_real_interrupt(up->port.irq)) {
2072                 up->timer.data = (unsigned long)up;
2073                 mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
2074         } else {
2075                 retval = serial_link_irq_chain(up);
2076                 if (retval)
2077                         return retval;
2078         }
2079
2080         /*
2081          * Now, initialize the UART
2082          */
2083         serial_outp(up, UART_LCR, UART_LCR_WLEN8);
2084
2085         spin_lock_irqsave(&up->port.lock, flags);
2086         if (up->port.flags & UPF_FOURPORT) {
2087                 if (!is_real_interrupt(up->port.irq))
2088                         up->port.mctrl |= TIOCM_OUT1;
2089         } else
2090                 /*
2091                  * Most PC uarts need OUT2 raised to enable interrupts.
2092                  */
2093                 if (is_real_interrupt(up->port.irq))
2094                         up->port.mctrl |= TIOCM_OUT2;
2095
2096         serial8250_set_mctrl(&up->port, up->port.mctrl);
2097
2098         /* Serial over Lan (SoL) hack:
2099            Intel 8257x Gigabit ethernet chips have a
2100            16550 emulation, to be used for Serial Over Lan.
2101            Those chips take a longer time than a normal
2102            serial device to signalize that a transmission
2103            data was queued. Due to that, the above test generally
2104            fails. One solution would be to delay the reading of
2105            iir. However, this is not reliable, since the timeout
2106            is variable. So, let's just don't test if we receive
2107            TX irq. This way, we'll never enable UART_BUG_TXEN.
2108          */
2109         if (skip_txen_test || up->port.flags & UPF_NO_TXEN_TEST)
2110                 goto dont_test_tx_en;
2111
2112         /*
2113          * Do a quick test to see if we receive an
2114          * interrupt when we enable the TX irq.
2115          */
2116         serial_outp(up, UART_IER, UART_IER_THRI);
2117         lsr = serial_in(up, UART_LSR);
2118         iir = serial_in(up, UART_IIR);
2119         serial_outp(up, UART_IER, 0);
2120
2121         if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) {
2122                 if (!(up->bugs & UART_BUG_TXEN)) {
2123                         up->bugs |= UART_BUG_TXEN;
2124                         pr_debug("ttyS%d - enabling bad tx status workarounds\n",
2125                                  serial_index(port));
2126                 }
2127         } else {
2128                 up->bugs &= ~UART_BUG_TXEN;
2129         }
2130
2131 dont_test_tx_en:
2132         spin_unlock_irqrestore(&up->port.lock, flags);
2133
2134         /*
2135          * Clear the interrupt registers again for luck, and clear the
2136          * saved flags to avoid getting false values from polling
2137          * routines or the previous session.
2138          */
2139         serial_inp(up, UART_LSR);
2140         serial_inp(up, UART_RX);
2141         serial_inp(up, UART_IIR);
2142         serial_inp(up, UART_MSR);
2143         up->lsr_saved_flags = 0;
2144         up->msr_saved_flags = 0;
2145
2146         /*
2147          * Finally, enable interrupts.  Note: Modem status interrupts
2148          * are set via set_termios(), which will be occurring imminently
2149          * anyway, so we don't enable them here.
2150          */
2151         up->ier = UART_IER_RLSI | UART_IER_RDI;
2152         serial_outp(up, UART_IER, up->ier);
2153
2154         if (up->port.flags & UPF_FOURPORT) {
2155                 unsigned int icp;
2156                 /*
2157                  * Enable interrupts on the AST Fourport board
2158                  */
2159                 icp = (up->port.iobase & 0xfe0) | 0x01f;
2160                 outb_p(0x80, icp);
2161                 (void) inb_p(icp);
2162         }
2163
2164         return 0;
2165 }
2166
2167 static void serial8250_shutdown(struct uart_port *port)
2168 {
2169         struct uart_8250_port *up = (struct uart_8250_port *)port;
2170         unsigned long flags;
2171
2172         /*
2173          * Disable interrupts from this port
2174          */
2175         up->ier = 0;
2176         serial_outp(up, UART_IER, 0);
2177
2178         spin_lock_irqsave(&up->port.lock, flags);
2179         if (up->port.flags & UPF_FOURPORT) {
2180                 /* reset interrupts on the AST Fourport board */
2181                 inb((up->port.iobase & 0xfe0) | 0x1f);
2182                 up->port.mctrl |= TIOCM_OUT1;
2183         } else
2184                 up->port.mctrl &= ~TIOCM_OUT2;
2185
2186         serial8250_set_mctrl(&up->port, up->port.mctrl);
2187         spin_unlock_irqrestore(&up->port.lock, flags);
2188
2189         /*
2190          * Disable break condition and FIFOs
2191          */
2192         serial_out(up, UART_LCR, serial_inp(up, UART_LCR) & ~UART_LCR_SBC);
2193         serial8250_clear_fifos(up);
2194
2195 #ifdef CONFIG_SERIAL_8250_RSA
2196         /*
2197          * Reset the RSA board back to 115kbps compat mode.
2198          */
2199         disable_rsa(up);
2200 #endif
2201
2202         /*
2203          * Read data port to reset things, and then unlink from
2204          * the IRQ chain.
2205          */
2206         (void) serial_in(up, UART_RX);
2207
2208         del_timer_sync(&up->timer);
2209         up->timer.function = serial8250_timeout;
2210         if (is_real_interrupt(up->port.irq))
2211                 serial_unlink_irq_chain(up);
2212 }
2213
2214 static unsigned int serial8250_get_divisor(struct uart_port *port, unsigned int baud)
2215 {
2216         unsigned int quot;
2217
2218         /*
2219          * Handle magic divisors for baud rates above baud_base on
2220          * SMSC SuperIO chips.
2221          */
2222         if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2223             baud == (port->uartclk/4))
2224                 quot = 0x8001;
2225         else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2226                  baud == (port->uartclk/8))
2227                 quot = 0x8002;
2228         else
2229                 quot = uart_get_divisor(port, baud);
2230
2231         return quot;
2232 }
2233
2234 void
2235 serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
2236                           struct ktermios *old)
2237 {
2238         struct uart_8250_port *up = (struct uart_8250_port *)port;
2239         unsigned char cval, fcr = 0;
2240         unsigned long flags;
2241         unsigned int baud, quot;
2242
2243         switch (termios->c_cflag & CSIZE) {
2244         case CS5:
2245                 cval = UART_LCR_WLEN5;
2246                 break;
2247         case CS6:
2248                 cval = UART_LCR_WLEN6;
2249                 break;
2250         case CS7:
2251                 cval = UART_LCR_WLEN7;
2252                 break;
2253         default:
2254         case CS8:
2255                 cval = UART_LCR_WLEN8;
2256                 break;
2257         }
2258
2259         if (termios->c_cflag & CSTOPB)
2260                 cval |= UART_LCR_STOP;
2261         if (termios->c_cflag & PARENB)
2262                 cval |= UART_LCR_PARITY;
2263         if (!(termios->c_cflag & PARODD))
2264                 cval |= UART_LCR_EPAR;
2265 #ifdef CMSPAR
2266         if (termios->c_cflag & CMSPAR)
2267                 cval |= UART_LCR_SPAR;
2268 #endif
2269
2270         /*
2271          * Ask the core to calculate the divisor for us.
2272          */
2273         baud = uart_get_baud_rate(port, termios, old,
2274                                   port->uartclk / 16 / 0xffff,
2275                                   port->uartclk / 16);
2276         quot = serial8250_get_divisor(port, baud);
2277
2278         /*
2279          * Oxford Semi 952 rev B workaround
2280          */
2281         if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0)
2282                 quot++;
2283
2284         if (up->capabilities & UART_CAP_FIFO && up->port.fifosize > 1) {
2285                 if (baud < 2400)
2286                         fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1;
2287                 else
2288                         fcr = uart_config[up->port.type].fcr;
2289         }
2290
2291         /*
2292          * MCR-based auto flow control.  When AFE is enabled, RTS will be
2293          * deasserted when the receive FIFO contains more characters than
2294          * the trigger, or the MCR RTS bit is cleared.  In the case where
2295          * the remote UART is not using CTS auto flow control, we must
2296          * have sufficient FIFO entries for the latency of the remote
2297          * UART to respond.  IOW, at least 32 bytes of FIFO.
2298          */
2299         if (up->capabilities & UART_CAP_AFE && up->port.fifosize >= 32) {
2300                 up->mcr &= ~UART_MCR_AFE;
2301                 if (termios->c_cflag & CRTSCTS)
2302                         up->mcr |= UART_MCR_AFE;
2303         }
2304
2305         /*
2306          * Ok, we're now changing the port state.  Do it with
2307          * interrupts disabled.
2308          */
2309         spin_lock_irqsave(&up->port.lock, flags);
2310
2311         /*
2312          * Update the per-port timeout.
2313          */
2314         uart_update_timeout(port, termios->c_cflag, baud);
2315
2316         up->port.read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
2317         if (termios->c_iflag & INPCK)
2318                 up->port.read_status_mask |= UART_LSR_FE | UART_LSR_PE;
2319         if (termios->c_iflag & (BRKINT | PARMRK))
2320                 up->port.read_status_mask |= UART_LSR_BI;
2321
2322         /*
2323          * Characteres to ignore
2324          */
2325         up->port.ignore_status_mask = 0;
2326         if (termios->c_iflag & IGNPAR)
2327                 up->port.ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
2328         if (termios->c_iflag & IGNBRK) {
2329                 up->port.ignore_status_mask |= UART_LSR_BI;
2330                 /*
2331                  * If we're ignoring parity and break indicators,
2332                  * ignore overruns too (for real raw support).
2333                  */
2334                 if (termios->c_iflag & IGNPAR)
2335                         up->port.ignore_status_mask |= UART_LSR_OE;
2336         }
2337
2338         /*
2339          * ignore all characters if CREAD is not set
2340          */
2341         if ((termios->c_cflag & CREAD) == 0)
2342                 up->port.ignore_status_mask |= UART_LSR_DR;
2343
2344         /*
2345          * CTS flow control flag and modem status interrupts
2346          */
2347         up->ier &= ~UART_IER_MSI;
2348         if (!(up->bugs & UART_BUG_NOMSR) &&
2349                         UART_ENABLE_MS(&up->port, termios->c_cflag))
2350                 up->ier |= UART_IER_MSI;
2351         if (up->capabilities & UART_CAP_UUE)
2352                 up->ier |= UART_IER_UUE | UART_IER_RTOIE;
2353
2354         serial_out(up, UART_IER, up->ier);
2355
2356         if (up->capabilities & UART_CAP_EFR) {
2357                 unsigned char efr = 0;
2358                 /*
2359                  * TI16C752/Startech hardware flow control.  FIXME:
2360                  * - TI16C752 requires control thresholds to be set.
2361                  * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled.
2362                  */
2363                 if (termios->c_cflag & CRTSCTS)
2364                         efr |= UART_EFR_CTS;
2365
2366                 serial_outp(up, UART_LCR, 0xBF);
2367                 serial_outp(up, UART_EFR, efr);
2368         }
2369
2370 #ifdef CONFIG_ARCH_OMAP
2371         /* Workaround to enable 115200 baud on OMAP1510 internal ports */
2372         if (cpu_is_omap1510() && is_omap_port(up)) {
2373                 if (baud == 115200) {
2374                         quot = 1;
2375                         serial_out(up, UART_OMAP_OSC_12M_SEL, 1);
2376                 } else
2377                         serial_out(up, UART_OMAP_OSC_12M_SEL, 0);
2378         }
2379 #endif
2380
2381         if (up->capabilities & UART_NATSEMI) {
2382                 /* Switch to bank 2 not bank 1, to avoid resetting EXCR2 */
2383                 serial_outp(up, UART_LCR, 0xe0);
2384         } else {
2385                 serial_outp(up, UART_LCR, cval | UART_LCR_DLAB);/* set DLAB */
2386         }
2387
2388         serial_dl_write(up, quot);
2389
2390         /*
2391          * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
2392          * is written without DLAB set, this mode will be disabled.
2393          */
2394         if (up->port.type == PORT_16750)
2395                 serial_outp(up, UART_FCR, fcr);
2396
2397         serial_outp(up, UART_LCR, cval);                /* reset DLAB */
2398         up->lcr = cval;                                 /* Save LCR */
2399         if (up->port.type != PORT_16750) {
2400                 if (fcr & UART_FCR_ENABLE_FIFO) {
2401                         /* emulated UARTs (Lucent Venus 167x) need two steps */
2402                         serial_outp(up, UART_FCR, UART_FCR_ENABLE_FIFO);
2403                 }
2404                 serial_outp(up, UART_FCR, fcr);         /* set fcr */
2405         }
2406         serial8250_set_mctrl(&up->port, up->port.mctrl);
2407         spin_unlock_irqrestore(&up->port.lock, flags);
2408         /* Don't rewrite B0 */
2409         if (tty_termios_baud_rate(termios))
2410                 tty_termios_encode_baud_rate(termios, baud, baud);
2411 }
2412 EXPORT_SYMBOL(serial8250_do_set_termios);
2413
2414 static void
2415 serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
2416                        struct ktermios *old)
2417 {
2418         if (port->set_termios)
2419                 port->set_termios(port, termios, old);
2420         else
2421                 serial8250_do_set_termios(port, termios, old);
2422 }
2423
2424 static void
2425 serial8250_set_ldisc(struct uart_port *port, int new)
2426 {
2427         if (new == N_PPS) {
2428                 port->flags |= UPF_HARDPPS_CD;
2429                 serial8250_enable_ms(port);
2430         } else
2431                 port->flags &= ~UPF_HARDPPS_CD;
2432 }
2433
2434
2435 void serial8250_do_pm(struct uart_port *port, unsigned int state,
2436                       unsigned int oldstate)
2437 {
2438         struct uart_8250_port *p = (struct uart_8250_port *)port;
2439
2440         serial8250_set_sleep(p, state != 0);
2441 }
2442 EXPORT_SYMBOL(serial8250_do_pm);
2443
2444 static void
2445 serial8250_pm(struct uart_port *port, unsigned int state,
2446               unsigned int oldstate)
2447 {
2448         if (port->pm)
2449                 port->pm(port, state, oldstate);
2450         else
2451                 serial8250_do_pm(port, state, oldstate);
2452 }
2453
2454 static unsigned int serial8250_port_size(struct uart_8250_port *pt)
2455 {
2456         if (pt->port.iotype == UPIO_AU)
2457                 return 0x1000;
2458 #ifdef CONFIG_ARCH_OMAP
2459         if (is_omap_port(pt))
2460                 return 0x16 << pt->port.regshift;
2461 #endif
2462         return 8 << pt->port.regshift;
2463 }
2464
2465 /*
2466  * Resource handling.
2467  */
2468 static int serial8250_request_std_resource(struct uart_8250_port *up)
2469 {
2470         unsigned int size = serial8250_port_size(up);
2471         int ret = 0;
2472
2473         switch (up->port.iotype) {
2474         case UPIO_AU:
2475         case UPIO_TSI:
2476         case UPIO_MEM32:
2477         case UPIO_MEM:
2478         case UPIO_DWAPB:
2479                 if (!up->port.mapbase)
2480                         break;
2481
2482                 if (!request_mem_region(up->port.mapbase, size, "serial")) {
2483                         ret = -EBUSY;
2484                         break;
2485                 }
2486
2487                 if (up->port.flags & UPF_IOREMAP) {
2488                         up->port.membase = ioremap_nocache(up->port.mapbase,
2489                                                                         size);
2490                         if (!up->port.membase) {
2491                                 release_mem_region(up->port.mapbase, size);
2492                                 ret = -ENOMEM;
2493                         }
2494                 }
2495                 break;
2496
2497         case UPIO_HUB6:
2498         case UPIO_PORT:
2499                 if (!request_region(up->port.iobase, size, "serial"))
2500                         ret = -EBUSY;
2501                 break;
2502         }
2503         return ret;
2504 }
2505
2506 static void serial8250_release_std_resource(struct uart_8250_port *up)
2507 {
2508         unsigned int size = serial8250_port_size(up);
2509
2510         switch (up->port.iotype) {
2511         case UPIO_AU:
2512         case UPIO_TSI:
2513         case UPIO_MEM32:
2514         case UPIO_MEM:
2515         case UPIO_DWAPB:
2516                 if (!up->port.mapbase)
2517                         break;
2518
2519                 if (up->port.flags & UPF_IOREMAP) {
2520                         iounmap(up->port.membase);
2521                         up->port.membase = NULL;
2522                 }
2523
2524                 release_mem_region(up->port.mapbase, size);
2525                 break;
2526
2527         case UPIO_HUB6:
2528         case UPIO_PORT:
2529                 release_region(up->port.iobase, size);
2530                 break;
2531         }
2532 }
2533
2534 static int serial8250_request_rsa_resource(struct uart_8250_port *up)
2535 {
2536         unsigned long start = UART_RSA_BASE << up->port.regshift;
2537         unsigned int size = 8 << up->port.regshift;
2538         int ret = -EINVAL;
2539
2540         switch (up->port.iotype) {
2541         case UPIO_HUB6:
2542         case UPIO_PORT:
2543                 start += up->port.iobase;
2544                 if (request_region(start, size, "serial-rsa"))
2545                         ret = 0;
2546                 else
2547                         ret = -EBUSY;
2548                 break;
2549         }
2550
2551         return ret;
2552 }
2553
2554 static void serial8250_release_rsa_resource(struct uart_8250_port *up)
2555 {
2556         unsigned long offset = UART_RSA_BASE << up->port.regshift;
2557         unsigned int size = 8 << up->port.regshift;
2558
2559         switch (up->port.iotype) {
2560         case UPIO_HUB6:
2561         case UPIO_PORT:
2562                 release_region(up->port.iobase + offset, size);
2563                 break;
2564         }
2565 }
2566
2567 static void serial8250_release_port(struct uart_port *port)
2568 {
2569         struct uart_8250_port *up = (struct uart_8250_port *)port;
2570
2571         serial8250_release_std_resource(up);
2572         if (up->port.type == PORT_RSA)
2573                 serial8250_release_rsa_resource(up);
2574 }
2575
2576 static int serial8250_request_port(struct uart_port *port)
2577 {
2578         struct uart_8250_port *up = (struct uart_8250_port *)port;
2579         int ret = 0;
2580
2581         ret = serial8250_request_std_resource(up);
2582         if (ret == 0 && up->port.type == PORT_RSA) {
2583                 ret = serial8250_request_rsa_resource(up);
2584                 if (ret < 0)
2585                         serial8250_release_std_resource(up);
2586         }
2587
2588         return ret;
2589 }
2590
2591 static void serial8250_config_port(struct uart_port *port, int flags)
2592 {
2593         struct uart_8250_port *up = (struct uart_8250_port *)port;
2594         int probeflags = PROBE_ANY;
2595         int ret;
2596
2597         /*
2598          * Find the region that we can probe for.  This in turn
2599          * tells us whether we can probe for the type of port.
2600          */
2601         ret = serial8250_request_std_resource(up);
2602         if (ret < 0)
2603                 return;
2604
2605         ret = serial8250_request_rsa_resource(up);
2606         if (ret < 0)
2607                 probeflags &= ~PROBE_RSA;
2608
2609         if (up->port.iotype != up->cur_iotype)
2610                 set_io_from_upio(port);
2611
2612         if (flags & UART_CONFIG_TYPE)
2613                 autoconfig(up, probeflags);
2614
2615         /* if access method is AU, it is a 16550 with a quirk */
2616         if (up->port.type == PORT_16550A && up->port.iotype == UPIO_AU)
2617                 up->bugs |= UART_BUG_NOMSR;
2618
2619         if (up->port.type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
2620                 autoconfig_irq(up);
2621
2622         if (up->port.type != PORT_RSA && probeflags & PROBE_RSA)
2623                 serial8250_release_rsa_resource(up);
2624         if (up->port.type == PORT_UNKNOWN)
2625                 serial8250_release_std_resource(up);
2626 }
2627
2628 static int
2629 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
2630 {
2631         if (ser->irq >= nr_irqs || ser->irq < 0 ||
2632             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
2633             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
2634             ser->type == PORT_STARTECH)
2635                 return -EINVAL;
2636         return 0;
2637 }
2638
2639 static const char *
2640 serial8250_type(struct uart_port *port)
2641 {
2642         int type = port->type;
2643
2644         if (type >= ARRAY_SIZE(uart_config))
2645                 type = 0;
2646         return uart_config[type].name;
2647 }
2648
2649 static struct uart_ops serial8250_pops = {
2650         .tx_empty       = serial8250_tx_empty,
2651         .set_mctrl      = serial8250_set_mctrl,
2652         .get_mctrl      = serial8250_get_mctrl,
2653         .stop_tx        = serial8250_stop_tx,
2654         .start_tx       = serial8250_start_tx,
2655         .stop_rx        = serial8250_stop_rx,
2656         .enable_ms      = serial8250_enable_ms,
2657         .break_ctl      = serial8250_break_ctl,
2658         .startup        = serial8250_startup,
2659         .shutdown       = serial8250_shutdown,
2660         .set_termios    = serial8250_set_termios,
2661         .set_ldisc      = serial8250_set_ldisc,
2662         .pm             = serial8250_pm,
2663         .type           = serial8250_type,
2664         .release_port   = serial8250_release_port,
2665         .request_port   = serial8250_request_port,
2666         .config_port    = serial8250_config_port,
2667         .verify_port    = serial8250_verify_port,
2668 #ifdef CONFIG_CONSOLE_POLL
2669         .poll_get_char = serial8250_get_poll_char,
2670         .poll_put_char = serial8250_put_poll_char,
2671 #endif
2672 };
2673
2674 static struct uart_8250_port serial8250_ports[UART_NR];
2675
2676 static void (*serial8250_isa_config)(int port, struct uart_port *up,
2677         unsigned short *capabilities);
2678
2679 void serial8250_set_isa_configurator(
2680         void (*v)(int port, struct uart_port *up, unsigned short *capabilities))
2681 {
2682         serial8250_isa_config = v;
2683 }
2684 EXPORT_SYMBOL(serial8250_set_isa_configurator);
2685
2686 static void __init serial8250_isa_init_ports(void)
2687 {
2688         struct uart_8250_port *up;
2689         static int first = 1;
2690         int i, irqflag = 0;
2691
2692         if (!first)
2693                 return;
2694         first = 0;
2695
2696         for (i = 0; i < nr_uarts; i++) {
2697                 struct uart_8250_port *up = &serial8250_ports[i];
2698
2699                 up->port.line = i;
2700                 spin_lock_init(&up->port.lock);
2701
2702                 init_timer(&up->timer);
2703                 up->timer.function = serial8250_timeout;
2704
2705                 /*
2706                  * ALPHA_KLUDGE_MCR needs to be killed.
2707                  */
2708                 up->mcr_mask = ~ALPHA_KLUDGE_MCR;
2709                 up->mcr_force = ALPHA_KLUDGE_MCR;
2710
2711                 up->port.ops = &serial8250_pops;
2712         }
2713
2714         if (share_irqs)
2715                 irqflag = IRQF_SHARED;
2716
2717         for (i = 0, up = serial8250_ports;
2718              i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
2719              i++, up++) {
2720                 up->port.iobase   = old_serial_port[i].port;
2721                 up->port.irq      = irq_canonicalize(old_serial_port[i].irq);
2722                 up->port.irqflags = old_serial_port[i].irqflags;
2723                 up->port.uartclk  = old_serial_port[i].baud_base * 16;
2724                 up->port.flags    = old_serial_port[i].flags;
2725                 up->port.hub6     = old_serial_port[i].hub6;
2726                 up->port.membase  = old_serial_port[i].iomem_base;
2727                 up->port.iotype   = old_serial_port[i].io_type;
2728                 up->port.regshift = old_serial_port[i].iomem_reg_shift;
2729                 set_io_from_upio(&up->port);
2730                 up->port.irqflags |= irqflag;
2731                 if (serial8250_isa_config != NULL)
2732                         serial8250_isa_config(i, &up->port, &up->capabilities);
2733
2734         }
2735 }
2736
2737 static void
2738 serial8250_init_fixed_type_port(struct uart_8250_port *up, unsigned int type)
2739 {
2740         up->port.type = type;
2741         up->port.fifosize = uart_config[type].fifo_size;
2742         up->capabilities = uart_config[type].flags;
2743         up->tx_loadsz = uart_config[type].tx_loadsz;
2744 }
2745
2746 static void __init
2747 serial8250_register_ports(struct uart_driver *drv, struct device *dev)
2748 {
2749         int i;
2750
2751         for (i = 0; i < nr_uarts; i++) {
2752                 struct uart_8250_port *up = &serial8250_ports[i];
2753                 up->cur_iotype = 0xFF;
2754         }
2755
2756         serial8250_isa_init_ports();
2757
2758         for (i = 0; i < nr_uarts; i++) {
2759                 struct uart_8250_port *up = &serial8250_ports[i];
2760
2761                 up->port.dev = dev;
2762
2763                 if (up->port.flags & UPF_FIXED_TYPE)
2764                         serial8250_init_fixed_type_port(up, up->port.type);
2765
2766                 uart_add_one_port(drv, &up->port);
2767         }
2768 }
2769
2770 #ifdef CONFIG_SERIAL_8250_CONSOLE
2771
2772 static void serial8250_console_putchar(struct uart_port *port, int ch)
2773 {
2774         struct uart_8250_port *up = (struct uart_8250_port *)port;
2775
2776         wait_for_xmitr(up, UART_LSR_THRE);
2777         serial_out(up, UART_TX, ch);
2778 }
2779
2780 /*
2781  *      Print a string to the serial port trying not to disturb
2782  *      any possible real use of the port...
2783  *
2784  *      The console_lock must be held when we get here.
2785  */
2786 static void
2787 serial8250_console_write(struct console *co, const char *s, unsigned int count)
2788 {
2789         struct uart_8250_port *up = &serial8250_ports[co->index];
2790         unsigned long flags;
2791         unsigned int ier;
2792         int locked = 1;
2793
2794         touch_nmi_watchdog();
2795
2796         local_irq_save(flags);
2797         if (up->port.sysrq) {
2798                 /* serial8250_handle_port() already took the lock */
2799                 locked = 0;
2800         } else if (oops_in_progress) {
2801                 locked = spin_trylock(&up->port.lock);
2802         } else
2803                 spin_lock(&up->port.lock);
2804
2805         /*
2806          *      First save the IER then disable the interrupts
2807          */
2808         ier = serial_in(up, UART_IER);
2809
2810         if (up->capabilities & UART_CAP_UUE)
2811                 serial_out(up, UART_IER, UART_IER_UUE);
2812         else
2813                 serial_out(up, UART_IER, 0);
2814
2815         uart_console_write(&up->port, s, count, serial8250_console_putchar);
2816
2817         /*
2818          *      Finally, wait for transmitter to become empty
2819          *      and restore the IER
2820          */
2821         wait_for_xmitr(up, BOTH_EMPTY);
2822         serial_out(up, UART_IER, ier);
2823
2824         /*
2825          *      The receive handling will happen properly because the
2826          *      receive ready bit will still be set; it is not cleared
2827          *      on read.  However, modem control will not, we must
2828          *      call it if we have saved something in the saved flags
2829          *      while processing with interrupts off.
2830          */
2831         if (up->msr_saved_flags)
2832                 check_modem_status(up);
2833
2834         if (locked)
2835                 spin_unlock(&up->port.lock);
2836         local_irq_restore(flags);
2837 }
2838
2839 static int __init serial8250_console_setup(struct console *co, char *options)
2840 {
2841         struct uart_port *port;
2842         int baud = 9600;
2843         int bits = 8;
2844         int parity = 'n';
2845         int flow = 'n';
2846
2847         /*
2848          * Check whether an invalid uart number has been specified, and
2849          * if so, search for the first available port that does have
2850          * console support.
2851          */
2852         if (co->index >= nr_uarts)
2853                 co->index = 0;
2854         port = &serial8250_ports[co->index].port;
2855         if (!port->iobase && !port->membase)
2856                 return -ENODEV;
2857
2858         if (options)
2859                 uart_parse_options(options, &baud, &parity, &bits, &flow);
2860
2861         return uart_set_options(port, co, baud, parity, bits, flow);
2862 }
2863
2864 static int serial8250_console_early_setup(void)
2865 {
2866         return serial8250_find_port_for_earlycon();
2867 }
2868
2869 static struct console serial8250_console = {
2870         .name           = "ttyS",
2871         .write          = serial8250_console_write,
2872         .device         = uart_console_device,
2873         .setup          = serial8250_console_setup,
2874         .early_setup    = serial8250_console_early_setup,
2875         .flags          = CON_PRINTBUFFER | CON_ANYTIME,
2876         .index          = -1,
2877         .data           = &serial8250_reg,
2878 };
2879
2880 static int __init serial8250_console_init(void)
2881 {
2882         if (nr_uarts > UART_NR)
2883                 nr_uarts = UART_NR;
2884
2885         serial8250_isa_init_ports();
2886         register_console(&serial8250_console);
2887         return 0;
2888 }
2889 console_initcall(serial8250_console_init);
2890
2891 int serial8250_find_port(struct uart_port *p)
2892 {
2893         int line;
2894         struct uart_port *port;
2895
2896         for (line = 0; line < nr_uarts; line++) {
2897                 port = &serial8250_ports[line].port;
2898                 if (uart_match_port(p, port))
2899                         return line;
2900         }
2901         return -ENODEV;
2902 }
2903
2904 #define SERIAL8250_CONSOLE      &serial8250_console
2905 #else
2906 #define SERIAL8250_CONSOLE      NULL
2907 #endif
2908
2909 static struct uart_driver serial8250_reg = {
2910         .owner                  = THIS_MODULE,
2911         .driver_name            = "serial",
2912         .dev_name               = "ttyS",
2913         .major                  = TTY_MAJOR,
2914         .minor                  = 64,
2915         .cons                   = SERIAL8250_CONSOLE,
2916 };
2917
2918 /*
2919  * early_serial_setup - early registration for 8250 ports
2920  *
2921  * Setup an 8250 port structure prior to console initialisation.  Use
2922  * after console initialisation will cause undefined behaviour.
2923  */
2924 int __init early_serial_setup(struct uart_port *port)
2925 {
2926         struct uart_port *p;
2927
2928         if (port->line >= ARRAY_SIZE(serial8250_ports))
2929                 return -ENODEV;
2930
2931         serial8250_isa_init_ports();
2932         p = &serial8250_ports[port->line].port;
2933         p->iobase       = port->iobase;
2934         p->membase      = port->membase;
2935         p->irq          = port->irq;
2936         p->irqflags     = port->irqflags;
2937         p->uartclk      = port->uartclk;
2938         p->fifosize     = port->fifosize;
2939         p->regshift     = port->regshift;
2940         p->iotype       = port->iotype;
2941         p->flags        = port->flags;
2942         p->mapbase      = port->mapbase;
2943         p->private_data = port->private_data;
2944         p->type         = port->type;
2945         p->line         = port->line;
2946
2947         set_io_from_upio(p);
2948         if (port->serial_in)
2949                 p->serial_in = port->serial_in;
2950         if (port->serial_out)
2951                 p->serial_out = port->serial_out;
2952
2953         return 0;
2954 }
2955
2956 /**
2957  *      serial8250_suspend_port - suspend one serial port
2958  *      @line:  serial line number
2959  *
2960  *      Suspend one serial port.
2961  */
2962 void serial8250_suspend_port(int line)
2963 {
2964         uart_suspend_port(&serial8250_reg, &serial8250_ports[line].port);
2965 }
2966
2967 /**
2968  *      serial8250_resume_port - resume one serial port
2969  *      @line:  serial line number
2970  *
2971  *      Resume one serial port.
2972  */
2973 void serial8250_resume_port(int line)
2974 {
2975         struct uart_8250_port *up = &serial8250_ports[line];
2976
2977         if (up->capabilities & UART_NATSEMI) {
2978                 unsigned char tmp;
2979
2980                 /* Ensure it's still in high speed mode */
2981                 serial_outp(up, UART_LCR, 0xE0);
2982
2983                 tmp = serial_in(up, 0x04); /* EXCR2 */
2984                 tmp &= ~0xB0; /* Disable LOCK, mask out PRESL[01] */
2985                 tmp |= 0x10;  /* 1.625 divisor for baud_base --> 921600 */
2986                 serial_outp(up, 0x04, tmp);
2987
2988                 serial_outp(up, UART_LCR, 0);
2989         }
2990         uart_resume_port(&serial8250_reg, &up->port);
2991 }
2992
2993 /*
2994  * Register a set of serial devices attached to a platform device.  The
2995  * list is terminated with a zero flags entry, which means we expect
2996  * all entries to have at least UPF_BOOT_AUTOCONF set.
2997  */
2998 static int __devinit serial8250_probe(struct platform_device *dev)
2999 {
3000         struct plat_serial8250_port *p = dev->dev.platform_data;
3001         struct uart_port port;
3002         int ret, i, irqflag = 0;
3003
3004         memset(&port, 0, sizeof(struct uart_port));
3005
3006         if (share_irqs)
3007                 irqflag = IRQF_SHARED;
3008
3009         for (i = 0; p && p->flags != 0; p++, i++) {
3010                 port.iobase             = p->iobase;
3011                 port.membase            = p->membase;
3012                 port.irq                = p->irq;
3013                 port.irqflags           = p->irqflags;
3014                 port.uartclk            = p->uartclk;
3015                 port.regshift           = p->regshift;
3016                 port.iotype             = p->iotype;
3017                 port.flags              = p->flags;
3018                 port.mapbase            = p->mapbase;
3019                 port.hub6               = p->hub6;
3020                 port.private_data       = p->private_data;
3021                 port.type               = p->type;
3022                 port.serial_in          = p->serial_in;
3023                 port.serial_out         = p->serial_out;
3024                 port.set_termios        = p->set_termios;
3025                 port.pm                 = p->pm;
3026                 port.dev                = &dev->dev;
3027                 port.irqflags           |= irqflag;
3028                 ret = serial8250_register_port(&port);
3029                 if (ret < 0) {
3030                         dev_err(&dev->dev, "unable to register port at index %d "
3031                                 "(IO%lx MEM%llx IRQ%d): %d\n", i,
3032                                 p->iobase, (unsigned long long)p->mapbase,
3033                                 p->irq, ret);
3034                 }
3035         }
3036         return 0;
3037 }
3038
3039 /*
3040  * Remove serial ports registered against a platform device.
3041  */
3042 static int __devexit serial8250_remove(struct platform_device *dev)
3043 {
3044         int i;
3045
3046         for (i = 0; i < nr_uarts; i++) {
3047                 struct uart_8250_port *up = &serial8250_ports[i];
3048
3049                 if (up->port.dev == &dev->dev)
3050                         serial8250_unregister_port(i);
3051         }
3052         return 0;
3053 }
3054
3055 static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
3056 {
3057         int i;
3058
3059         for (i = 0; i < UART_NR; i++) {
3060                 struct uart_8250_port *up = &serial8250_ports[i];
3061
3062                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
3063                         uart_suspend_port(&serial8250_reg, &up->port);
3064         }
3065
3066         return 0;
3067 }
3068
3069 static int serial8250_resume(struct platform_device *dev)
3070 {
3071         int i;
3072
3073         for (i = 0; i < UART_NR; i++) {
3074                 struct uart_8250_port *up = &serial8250_ports[i];
3075
3076                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
3077                         serial8250_resume_port(i);
3078         }
3079
3080         return 0;
3081 }
3082
3083 static struct platform_driver serial8250_isa_driver = {
3084         .probe          = serial8250_probe,
3085         .remove         = __devexit_p(serial8250_remove),
3086         .suspend        = serial8250_suspend,
3087         .resume         = serial8250_resume,
3088         .driver         = {
3089                 .name   = "serial8250",
3090                 .owner  = THIS_MODULE,
3091         },
3092 };
3093
3094 /*
3095  * This "device" covers _all_ ISA 8250-compatible serial devices listed
3096  * in the table in include/asm/serial.h
3097  */
3098 static struct platform_device *serial8250_isa_devs;
3099
3100 /*
3101  * serial8250_register_port and serial8250_unregister_port allows for
3102  * 16x50 serial ports to be configured at run-time, to support PCMCIA
3103  * modems and PCI multiport cards.
3104  */
3105 static DEFINE_MUTEX(serial_mutex);
3106
3107 static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port)
3108 {
3109         int i;
3110
3111         /*
3112          * First, find a port entry which matches.
3113          */
3114         for (i = 0; i < nr_uarts; i++)
3115                 if (uart_match_port(&serial8250_ports[i].port, port))
3116                         return &serial8250_ports[i];
3117
3118         /*
3119          * We didn't find a matching entry, so look for the first
3120          * free entry.  We look for one which hasn't been previously
3121          * used (indicated by zero iobase).
3122          */
3123         for (i = 0; i < nr_uarts; i++)
3124                 if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
3125                     serial8250_ports[i].port.iobase == 0)
3126                         return &serial8250_ports[i];
3127
3128         /*
3129          * That also failed.  Last resort is to find any entry which
3130          * doesn't have a real port associated with it.
3131          */
3132         for (i = 0; i < nr_uarts; i++)
3133                 if (serial8250_ports[i].port.type == PORT_UNKNOWN)
3134                         return &serial8250_ports[i];
3135
3136         return NULL;
3137 }
3138
3139 /**
3140  *      serial8250_register_port - register a serial port
3141  *      @port: serial port template
3142  *
3143  *      Configure the serial port specified by the request. If the
3144  *      port exists and is in use, it is hung up and unregistered
3145  *      first.
3146  *
3147  *      The port is then probed and if necessary the IRQ is autodetected
3148  *      If this fails an error is returned.
3149  *
3150  *      On success the port is ready to use and the line number is returned.
3151  */
3152 int serial8250_register_port(struct uart_port *port)
3153 {
3154         struct uart_8250_port *uart;
3155         int ret = -ENOSPC;
3156
3157         if (port->uartclk == 0)
3158                 return -EINVAL;
3159
3160         mutex_lock(&serial_mutex);
3161
3162         uart = serial8250_find_match_or_unused(port);
3163         if (uart) {
3164                 uart_remove_one_port(&serial8250_reg, &uart->port);
3165
3166                 uart->port.iobase       = port->iobase;
3167                 uart->port.membase      = port->membase;
3168                 uart->port.irq          = port->irq;
3169                 uart->port.irqflags     = port->irqflags;
3170                 uart->port.uartclk      = port->uartclk;
3171                 uart->port.fifosize     = port->fifosize;
3172                 uart->port.regshift     = port->regshift;
3173                 uart->port.iotype       = port->iotype;
3174                 uart->port.flags        = port->flags | UPF_BOOT_AUTOCONF;
3175                 uart->port.mapbase      = port->mapbase;
3176                 uart->port.private_data = port->private_data;
3177                 if (port->dev)
3178                         uart->port.dev = port->dev;
3179
3180                 if (port->flags & UPF_FIXED_TYPE)
3181                         serial8250_init_fixed_type_port(uart, port->type);
3182
3183                 set_io_from_upio(&uart->port);
3184                 /* Possibly override default I/O functions.  */
3185                 if (port->serial_in)
3186                         uart->port.serial_in = port->serial_in;
3187                 if (port->serial_out)
3188                         uart->port.serial_out = port->serial_out;
3189                 /*  Possibly override set_termios call */
3190                 if (port->set_termios)
3191                         uart->port.set_termios = port->set_termios;
3192                 if (port->pm)
3193                         uart->port.pm = port->pm;
3194
3195                 if (serial8250_isa_config != NULL)
3196                         serial8250_isa_config(0, &uart->port,
3197                                         &uart->capabilities);
3198
3199                 ret = uart_add_one_port(&serial8250_reg, &uart->port);
3200                 if (ret == 0)
3201                         ret = uart->port.line;
3202         }
3203         mutex_unlock(&serial_mutex);
3204
3205         return ret;
3206 }
3207 EXPORT_SYMBOL(serial8250_register_port);
3208
3209 /**
3210  *      serial8250_unregister_port - remove a 16x50 serial port at runtime
3211  *      @line: serial line number
3212  *
3213  *      Remove one serial port.  This may not be called from interrupt
3214  *      context.  We hand the port back to the our control.
3215  */
3216 void serial8250_unregister_port(int line)
3217 {
3218         struct uart_8250_port *uart = &serial8250_ports[line];
3219
3220         mutex_lock(&serial_mutex);
3221         uart_remove_one_port(&serial8250_reg, &uart->port);
3222         if (serial8250_isa_devs) {
3223                 uart->port.flags &= ~UPF_BOOT_AUTOCONF;
3224                 uart->port.type = PORT_UNKNOWN;
3225                 uart->port.dev = &serial8250_isa_devs->dev;
3226                 uart_add_one_port(&serial8250_reg, &uart->port);
3227         } else {
3228                 uart->port.dev = NULL;
3229         }
3230         mutex_unlock(&serial_mutex);
3231 }
3232 EXPORT_SYMBOL(serial8250_unregister_port);
3233
3234 static int __init serial8250_init(void)
3235 {
3236         int ret;
3237
3238         if (nr_uarts > UART_NR)
3239                 nr_uarts = UART_NR;
3240
3241         printk(KERN_INFO "Serial: 8250/16550 driver, "
3242                 "%d ports, IRQ sharing %sabled\n", nr_uarts,
3243                 share_irqs ? "en" : "dis");
3244
3245 #ifdef CONFIG_SPARC
3246         ret = sunserial_register_minors(&serial8250_reg, UART_NR);
3247 #else
3248         serial8250_reg.nr = UART_NR;
3249         ret = uart_register_driver(&serial8250_reg);
3250 #endif
3251         if (ret)
3252                 goto out;
3253
3254         serial8250_isa_devs = platform_device_alloc("serial8250",
3255                                                     PLAT8250_DEV_LEGACY);
3256         if (!serial8250_isa_devs) {
3257                 ret = -ENOMEM;
3258                 goto unreg_uart_drv;
3259         }
3260
3261         ret = platform_device_add(serial8250_isa_devs);
3262         if (ret)
3263                 goto put_dev;
3264
3265         serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
3266
3267         ret = platform_driver_register(&serial8250_isa_driver);
3268         if (ret == 0)
3269                 goto out;
3270
3271         platform_device_del(serial8250_isa_devs);
3272 put_dev:
3273         platform_device_put(serial8250_isa_devs);
3274 unreg_uart_drv:
3275 #ifdef CONFIG_SPARC
3276         sunserial_unregister_minors(&serial8250_reg, UART_NR);
3277 #else
3278         uart_unregister_driver(&serial8250_reg);
3279 #endif
3280 out:
3281         return ret;
3282 }
3283
3284 static void __exit serial8250_exit(void)
3285 {
3286         struct platform_device *isa_dev = serial8250_isa_devs;
3287
3288         /*
3289          * This tells serial8250_unregister_port() not to re-register
3290          * the ports (thereby making serial8250_isa_driver permanently
3291          * in use.)
3292          */
3293         serial8250_isa_devs = NULL;
3294
3295         platform_driver_unregister(&serial8250_isa_driver);
3296         platform_device_unregister(isa_dev);
3297
3298 #ifdef CONFIG_SPARC
3299         sunserial_unregister_minors(&serial8250_reg, UART_NR);
3300 #else
3301         uart_unregister_driver(&serial8250_reg);
3302 #endif
3303 }
3304
3305 module_init(serial8250_init);
3306 module_exit(serial8250_exit);
3307
3308 EXPORT_SYMBOL(serial8250_suspend_port);
3309 EXPORT_SYMBOL(serial8250_resume_port);
3310
3311 MODULE_LICENSE("GPL");
3312 MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
3313
3314 module_param(share_irqs, uint, 0644);
3315 MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices"
3316         " (unsafe)");
3317
3318 module_param(nr_uarts, uint, 0644);
3319 MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
3320
3321 module_param(skip_txen_test, uint, 0644);
3322 MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
3323
3324 #ifdef CONFIG_SERIAL_8250_RSA
3325 module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444);
3326 MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
3327 #endif
3328 MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);