drivers/tty/serial/8250.c

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