drivers/tty/serial/8250/8250_core.c

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