drivers/serial/8250.c

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