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