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
1380         if (up->dma && !up->dma->tx_dma(up))
1381                 return;
1382
1383         if (!(up->ier & UART_IER_THRI)) {
1384                 up->ier |= UART_IER_THRI;
1385                 serial_port_out(port, UART_IER, up->ier);
1386
1387                 if (up->bugs & UART_BUG_TXEN) {
1388                         unsigned char lsr;
1389                         lsr = serial_in(up, UART_LSR);
1390                         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1391                         if (lsr & UART_LSR_THRE)
1392                                 serial8250_tx_chars(up);
1393                 }
1394         }
1395
1396         /*
1397          * Re-enable the transmitter if we disabled it.
1398          */
1399         if (port->type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
1400                 up->acr &= ~UART_ACR_TXDIS;
1401                 serial_icr_write(up, UART_ACR, up->acr);
1402         }
1403 }
1404
1405 static void serial8250_throttle(struct uart_port *port)
1406 {
1407         port->throttle(port);
1408 }
1409
1410 static void serial8250_unthrottle(struct uart_port *port)
1411 {
1412         port->unthrottle(port);
1413 }
1414
1415 static void serial8250_stop_rx(struct uart_port *port)
1416 {
1417         struct uart_8250_port *up = up_to_u8250p(port);
1418
1419         serial8250_rpm_get(up);
1420
1421         up->ier &= ~(UART_IER_RLSI | UART_IER_RDI);
1422         up->port.read_status_mask &= ~UART_LSR_DR;
1423         serial_port_out(port, UART_IER, up->ier);
1424
1425         serial8250_rpm_put(up);
1426 }
1427
1428 static void serial8250_disable_ms(struct uart_port *port)
1429 {
1430         struct uart_8250_port *up =
1431                 container_of(port, struct uart_8250_port, port);
1432
1433         /* no MSR capabilities */
1434         if (up->bugs & UART_BUG_NOMSR)
1435                 return;
1436
1437         up->ier &= ~UART_IER_MSI;
1438         serial_port_out(port, UART_IER, up->ier);
1439 }
1440
1441 static void serial8250_enable_ms(struct uart_port *port)
1442 {
1443         struct uart_8250_port *up = up_to_u8250p(port);
1444
1445         /* no MSR capabilities */
1446         if (up->bugs & UART_BUG_NOMSR)
1447                 return;
1448
1449         up->ier |= UART_IER_MSI;
1450
1451         serial8250_rpm_get(up);
1452         serial_port_out(port, UART_IER, up->ier);
1453         serial8250_rpm_put(up);
1454 }
1455
1456 /*
1457  * serial8250_rx_chars: processes according to the passed in LSR
1458  * value, and returns the remaining LSR bits not handled
1459  * by this Rx routine.
1460  */
1461 unsigned char
1462 serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
1463 {
1464         struct uart_port *port = &up->port;
1465         unsigned char ch;
1466         int max_count = 256;
1467         char flag;
1468
1469         do {
1470                 if (likely(lsr & UART_LSR_DR))
1471                         ch = serial_in(up, UART_RX);
1472                 else
1473                         /*
1474                          * Intel 82571 has a Serial Over Lan device that will
1475                          * set UART_LSR_BI without setting UART_LSR_DR when
1476                          * it receives a break. To avoid reading from the
1477                          * receive buffer without UART_LSR_DR bit set, we
1478                          * just force the read character to be 0
1479                          */
1480                         ch = 0;
1481
1482                 flag = TTY_NORMAL;
1483                 port->icount.rx++;
1484
1485                 lsr |= up->lsr_saved_flags;
1486                 up->lsr_saved_flags = 0;
1487
1488                 if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
1489                         if (lsr & UART_LSR_BI) {
1490                                 lsr &= ~(UART_LSR_FE | UART_LSR_PE);
1491                                 port->icount.brk++;
1492                                 /*
1493                                  * We do the SysRQ and SAK checking
1494                                  * here because otherwise the break
1495                                  * may get masked by ignore_status_mask
1496                                  * or read_status_mask.
1497                                  */
1498                                 if (uart_handle_break(port))
1499                                         goto ignore_char;
1500                         } else if (lsr & UART_LSR_PE)
1501                                 port->icount.parity++;
1502                         else if (lsr & UART_LSR_FE)
1503                                 port->icount.frame++;
1504                         if (lsr & UART_LSR_OE)
1505                                 port->icount.overrun++;
1506
1507                         /*
1508                          * Mask off conditions which should be ignored.
1509                          */
1510                         lsr &= port->read_status_mask;
1511
1512                         if (lsr & UART_LSR_BI) {
1513                                 DEBUG_INTR("handling break....");
1514                                 flag = TTY_BREAK;
1515                         } else if (lsr & UART_LSR_PE)
1516                                 flag = TTY_PARITY;
1517                         else if (lsr & UART_LSR_FE)
1518                                 flag = TTY_FRAME;
1519                 }
1520                 if (uart_handle_sysrq_char(port, ch))
1521                         goto ignore_char;
1522
1523                 uart_insert_char(port, lsr, UART_LSR_OE, ch, flag);
1524
1525 ignore_char:
1526                 lsr = serial_in(up, UART_LSR);
1527         } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (--max_count > 0));
1528         spin_unlock(&port->lock);
1529         tty_flip_buffer_push(&port->state->port);
1530         spin_lock(&port->lock);
1531         return lsr;
1532 }
1533 EXPORT_SYMBOL_GPL(serial8250_rx_chars);
1534
1535 void serial8250_tx_chars(struct uart_8250_port *up)
1536 {
1537         struct uart_port *port = &up->port;
1538         struct circ_buf *xmit = &port->state->xmit;
1539         int count;
1540
1541         if (port->x_char) {
1542                 serial_out(up, UART_TX, port->x_char);
1543                 port->icount.tx++;
1544                 port->x_char = 0;
1545                 return;
1546         }
1547         if (uart_tx_stopped(port)) {
1548                 serial8250_stop_tx(port);
1549                 return;
1550         }
1551         if (uart_circ_empty(xmit)) {
1552                 __stop_tx(up);
1553                 return;
1554         }
1555
1556         count = up->tx_loadsz;
1557         do {
1558                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
1559                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
1560                 port->icount.tx++;
1561                 if (uart_circ_empty(xmit))
1562                         break;
1563                 if (up->capabilities & UART_CAP_HFIFO) {
1564                         if ((serial_port_in(port, UART_LSR) & BOTH_EMPTY) !=
1565                             BOTH_EMPTY)
1566                                 break;
1567                 }
1568         } while (--count > 0);
1569
1570         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
1571                 uart_write_wakeup(port);
1572
1573         DEBUG_INTR("THRE...");
1574
1575         /*
1576          * With RPM enabled, we have to wait until the FIFO is empty before the
1577          * HW can go idle. So we get here once again with empty FIFO and disable
1578          * the interrupt and RPM in __stop_tx()
1579          */
1580         if (uart_circ_empty(xmit) && !(up->capabilities & UART_CAP_RPM))
1581                 __stop_tx(up);
1582 }
1583 EXPORT_SYMBOL_GPL(serial8250_tx_chars);
1584
1585 /* Caller holds uart port lock */
1586 unsigned int serial8250_modem_status(struct uart_8250_port *up)
1587 {
1588         struct uart_port *port = &up->port;
1589         unsigned int status = serial_in(up, UART_MSR);
1590
1591         status |= up->msr_saved_flags;
1592         up->msr_saved_flags = 0;
1593         if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
1594             port->state != NULL) {
1595                 if (status & UART_MSR_TERI)
1596                         port->icount.rng++;
1597                 if (status & UART_MSR_DDSR)
1598                         port->icount.dsr++;
1599                 if (status & UART_MSR_DDCD)
1600                         uart_handle_dcd_change(port, status & UART_MSR_DCD);
1601                 if (status & UART_MSR_DCTS)
1602                         uart_handle_cts_change(port, status & UART_MSR_CTS);
1603
1604                 wake_up_interruptible(&port->state->port.delta_msr_wait);
1605         }
1606
1607         return status;
1608 }
1609 EXPORT_SYMBOL_GPL(serial8250_modem_status);
1610
1611 /*
1612  * This handles the interrupt from one port.
1613  */
1614 int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
1615 {
1616         unsigned char status;
1617         unsigned long flags;
1618         struct uart_8250_port *up = up_to_u8250p(port);
1619         int dma_err = 0;
1620
1621         if (iir & UART_IIR_NO_INT)
1622                 return 0;
1623
1624         spin_lock_irqsave(&port->lock, flags);
1625
1626         status = serial_port_in(port, UART_LSR);
1627
1628         DEBUG_INTR("status = %x...", status);
1629
1630         if (status & (UART_LSR_DR | UART_LSR_BI)) {
1631                 if (up->dma)
1632                         dma_err = up->dma->rx_dma(up, iir);
1633
1634                 if (!up->dma || dma_err)
1635                         status = serial8250_rx_chars(up, status);
1636         }
1637         serial8250_modem_status(up);
1638         if ((!up->dma || (up->dma && up->dma->tx_err)) &&
1639             (status & UART_LSR_THRE))
1640                 serial8250_tx_chars(up);
1641
1642         spin_unlock_irqrestore(&port->lock, flags);
1643         return 1;
1644 }
1645 EXPORT_SYMBOL_GPL(serial8250_handle_irq);
1646
1647 static int serial8250_default_handle_irq(struct uart_port *port)
1648 {
1649         struct uart_8250_port *up = up_to_u8250p(port);
1650         unsigned int iir;
1651         int ret;
1652
1653         serial8250_rpm_get(up);
1654
1655         iir = serial_port_in(port, UART_IIR);
1656         ret = serial8250_handle_irq(port, iir);
1657
1658         serial8250_rpm_put(up);
1659         return ret;
1660 }
1661
1662 /*
1663  * These Exar UARTs have an extra interrupt indicator that could
1664  * fire for a few unimplemented interrupts.  One of which is a
1665  * wakeup event when coming out of sleep.  Put this here just
1666  * to be on the safe side that these interrupts don't go unhandled.
1667  */
1668 static int exar_handle_irq(struct uart_port *port)
1669 {
1670         unsigned char int0, int1, int2, int3;
1671         unsigned int iir = serial_port_in(port, UART_IIR);
1672         int ret;
1673
1674         ret = serial8250_handle_irq(port, iir);
1675
1676         if ((port->type == PORT_XR17V35X) ||
1677            (port->type == PORT_XR17D15X)) {
1678                 int0 = serial_port_in(port, 0x80);
1679                 int1 = serial_port_in(port, 0x81);
1680                 int2 = serial_port_in(port, 0x82);
1681                 int3 = serial_port_in(port, 0x83);
1682         }
1683
1684         return ret;
1685 }
1686
1687 /*
1688  * This is the serial driver's interrupt routine.
1689  *
1690  * Arjan thinks the old way was overly complex, so it got simplified.
1691  * Alan disagrees, saying that need the complexity to handle the weird
1692  * nature of ISA shared interrupts.  (This is a special exception.)
1693  *
1694  * In order to handle ISA shared interrupts properly, we need to check
1695  * that all ports have been serviced, and therefore the ISA interrupt
1696  * line has been de-asserted.
1697  *
1698  * This means we need to loop through all ports. checking that they
1699  * don't have an interrupt pending.
1700  */
1701 static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
1702 {
1703         struct irq_info *i = dev_id;
1704         struct list_head *l, *end = NULL;
1705         int pass_counter = 0, handled = 0;
1706
1707         DEBUG_INTR("serial8250_interrupt(%d)...", irq);
1708
1709         spin_lock(&i->lock);
1710
1711         l = i->head;
1712         do {
1713                 struct uart_8250_port *up;
1714                 struct uart_port *port;
1715
1716                 up = list_entry(l, struct uart_8250_port, list);
1717                 port = &up->port;
1718
1719                 if (port->handle_irq(port)) {
1720                         handled = 1;
1721                         end = NULL;
1722                 } else if (end == NULL)
1723                         end = l;
1724
1725                 l = l->next;
1726
1727                 if (l == i->head && pass_counter++ > PASS_LIMIT) {
1728                         /* If we hit this, we're dead. */
1729                         printk_ratelimited(KERN_ERR
1730                                 "serial8250: too much work for irq%d\n", irq);
1731                         break;
1732                 }
1733         } while (l != end);
1734
1735         spin_unlock(&i->lock);
1736
1737         DEBUG_INTR("end.\n");
1738
1739         return IRQ_RETVAL(handled);
1740 }
1741
1742 /*
1743  * To support ISA shared interrupts, we need to have one interrupt
1744  * handler that ensures that the IRQ line has been deasserted
1745  * before returning.  Failing to do this will result in the IRQ
1746  * line being stuck active, and, since ISA irqs are edge triggered,
1747  * no more IRQs will be seen.
1748  */
1749 static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
1750 {
1751         spin_lock_irq(&i->lock);
1752
1753         if (!list_empty(i->head)) {
1754                 if (i->head == &up->list)
1755                         i->head = i->head->next;
1756                 list_del(&up->list);
1757         } else {
1758                 BUG_ON(i->head != &up->list);
1759                 i->head = NULL;
1760         }
1761         spin_unlock_irq(&i->lock);
1762         /* List empty so throw away the hash node */
1763         if (i->head == NULL) {
1764                 hlist_del(&i->node);
1765                 kfree(i);
1766         }
1767 }
1768
1769 static int serial_link_irq_chain(struct uart_8250_port *up)
1770 {
1771         struct hlist_head *h;
1772         struct hlist_node *n;
1773         struct irq_info *i;
1774         int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
1775
1776         mutex_lock(&hash_mutex);
1777
1778         h = &irq_lists[up->port.irq % NR_IRQ_HASH];
1779
1780         hlist_for_each(n, h) {
1781                 i = hlist_entry(n, struct irq_info, node);
1782                 if (i->irq == up->port.irq)
1783                         break;
1784         }
1785
1786         if (n == NULL) {
1787                 i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
1788                 if (i == NULL) {
1789                         mutex_unlock(&hash_mutex);
1790                         return -ENOMEM;
1791                 }
1792                 spin_lock_init(&i->lock);
1793                 i->irq = up->port.irq;
1794                 hlist_add_head(&i->node, h);
1795         }
1796         mutex_unlock(&hash_mutex);
1797
1798         spin_lock_irq(&i->lock);
1799
1800         if (i->head) {
1801                 list_add(&up->list, i->head);
1802                 spin_unlock_irq(&i->lock);
1803
1804                 ret = 0;
1805         } else {
1806                 INIT_LIST_HEAD(&up->list);
1807                 i->head = &up->list;
1808                 spin_unlock_irq(&i->lock);
1809                 irq_flags |= up->port.irqflags;
1810                 ret = request_irq(up->port.irq, serial8250_interrupt,
1811                                   irq_flags, "serial", i);
1812                 if (ret < 0)
1813                         serial_do_unlink(i, up);
1814         }
1815
1816         return ret;
1817 }
1818
1819 static void serial_unlink_irq_chain(struct uart_8250_port *up)
1820 {
1821         /*
1822          * yes, some broken gcc emit "warning: 'i' may be used uninitialized"
1823          * but no, we are not going to take a patch that assigns NULL below.
1824          */
1825         struct irq_info *i;
1826         struct hlist_node *n;
1827         struct hlist_head *h;
1828
1829         mutex_lock(&hash_mutex);
1830
1831         h = &irq_lists[up->port.irq % NR_IRQ_HASH];
1832
1833         hlist_for_each(n, h) {
1834                 i = hlist_entry(n, struct irq_info, node);
1835                 if (i->irq == up->port.irq)
1836                         break;
1837         }
1838
1839         BUG_ON(n == NULL);
1840         BUG_ON(i->head == NULL);
1841
1842         if (list_empty(i->head))
1843                 free_irq(up->port.irq, i);
1844
1845         serial_do_unlink(i, up);
1846         mutex_unlock(&hash_mutex);
1847 }
1848
1849 /*
1850  * This function is used to handle ports that do not have an
1851  * interrupt.  This doesn't work very well for 16450's, but gives
1852  * barely passable results for a 16550A.  (Although at the expense
1853  * of much CPU overhead).
1854  */
1855 static void serial8250_timeout(unsigned long data)
1856 {
1857         struct uart_8250_port *up = (struct uart_8250_port *)data;
1858
1859         up->port.handle_irq(&up->port);
1860         mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
1861 }
1862
1863 static void serial8250_backup_timeout(unsigned long data)
1864 {
1865         struct uart_8250_port *up = (struct uart_8250_port *)data;
1866         unsigned int iir, ier = 0, lsr;
1867         unsigned long flags;
1868
1869         spin_lock_irqsave(&up->port.lock, flags);
1870
1871         /*
1872          * Must disable interrupts or else we risk racing with the interrupt
1873          * based handler.
1874          */
1875         if (up->port.irq) {
1876                 ier = serial_in(up, UART_IER);
1877                 serial_out(up, UART_IER, 0);
1878         }
1879
1880         iir = serial_in(up, UART_IIR);
1881
1882         /*
1883          * This should be a safe test for anyone who doesn't trust the
1884          * IIR bits on their UART, but it's specifically designed for
1885          * the "Diva" UART used on the management processor on many HP
1886          * ia64 and parisc boxes.
1887          */
1888         lsr = serial_in(up, UART_LSR);
1889         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1890         if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
1891             (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
1892             (lsr & UART_LSR_THRE)) {
1893                 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
1894                 iir |= UART_IIR_THRI;
1895         }
1896
1897         if (!(iir & UART_IIR_NO_INT))
1898                 serial8250_tx_chars(up);
1899
1900         if (up->port.irq)
1901                 serial_out(up, UART_IER, ier);
1902
1903         spin_unlock_irqrestore(&up->port.lock, flags);
1904
1905         /* Standard timer interval plus 0.2s to keep the port running */
1906         mod_timer(&up->timer,
1907                 jiffies + uart_poll_timeout(&up->port) + HZ / 5);
1908 }
1909
1910 static unsigned int serial8250_tx_empty(struct uart_port *port)
1911 {
1912         struct uart_8250_port *up = up_to_u8250p(port);
1913         unsigned long flags;
1914         unsigned int lsr;
1915
1916         serial8250_rpm_get(up);
1917
1918         spin_lock_irqsave(&port->lock, flags);
1919         lsr = serial_port_in(port, UART_LSR);
1920         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1921         spin_unlock_irqrestore(&port->lock, flags);
1922
1923         serial8250_rpm_put(up);
1924
1925         return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
1926 }
1927
1928 static unsigned int serial8250_get_mctrl(struct uart_port *port)
1929 {
1930         struct uart_8250_port *up = up_to_u8250p(port);
1931         unsigned int status;
1932         unsigned int ret;
1933
1934         serial8250_rpm_get(up);
1935         status = serial8250_modem_status(up);
1936         serial8250_rpm_put(up);
1937
1938         ret = 0;
1939         if (status & UART_MSR_DCD)
1940                 ret |= TIOCM_CAR;
1941         if (status & UART_MSR_RI)
1942                 ret |= TIOCM_RNG;
1943         if (status & UART_MSR_DSR)
1944                 ret |= TIOCM_DSR;
1945         if (status & UART_MSR_CTS)
1946                 ret |= TIOCM_CTS;
1947         return ret;
1948 }
1949
1950 void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl)
1951 {
1952         struct uart_8250_port *up = up_to_u8250p(port);
1953         unsigned char mcr = 0;
1954
1955         if (mctrl & TIOCM_RTS)
1956                 mcr |= UART_MCR_RTS;
1957         if (mctrl & TIOCM_DTR)
1958                 mcr |= UART_MCR_DTR;
1959         if (mctrl & TIOCM_OUT1)
1960                 mcr |= UART_MCR_OUT1;
1961         if (mctrl & TIOCM_OUT2)
1962                 mcr |= UART_MCR_OUT2;
1963         if (mctrl & TIOCM_LOOP)
1964                 mcr |= UART_MCR_LOOP;
1965
1966         mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr;
1967
1968         serial_port_out(port, UART_MCR, mcr);
1969 }
1970 EXPORT_SYMBOL_GPL(serial8250_do_set_mctrl);
1971
1972 static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
1973 {
1974         if (port->set_mctrl)
1975                 return port->set_mctrl(port, mctrl);
1976         return serial8250_do_set_mctrl(port, mctrl);
1977 }
1978
1979 static void serial8250_break_ctl(struct uart_port *port, int break_state)
1980 {
1981         struct uart_8250_port *up = up_to_u8250p(port);
1982         unsigned long flags;
1983
1984         serial8250_rpm_get(up);
1985         spin_lock_irqsave(&port->lock, flags);
1986         if (break_state == -1)
1987                 up->lcr |= UART_LCR_SBC;
1988         else
1989                 up->lcr &= ~UART_LCR_SBC;
1990         serial_port_out(port, UART_LCR, up->lcr);
1991         spin_unlock_irqrestore(&port->lock, flags);
1992         serial8250_rpm_put(up);
1993 }
1994
1995 /*
1996  *      Wait for transmitter & holding register to empty
1997  */
1998 static void wait_for_xmitr(struct uart_8250_port *up, int bits)
1999 {
2000         unsigned int status, tmout = 10000;
2001
2002         /* Wait up to 10ms for the character(s) to be sent. */
2003         for (;;) {
2004                 status = serial_in(up, UART_LSR);
2005
2006                 up->lsr_saved_flags |= status & LSR_SAVE_FLAGS;
2007
2008                 if ((status & bits) == bits)
2009                         break;
2010                 if (--tmout == 0)
2011                         break;
2012                 udelay(1);
2013         }
2014
2015         /* Wait up to 1s for flow control if necessary */
2016         if (up->port.flags & UPF_CONS_FLOW) {
2017                 unsigned int tmout;
2018                 for (tmout = 1000000; tmout; tmout--) {
2019                         unsigned int msr = serial_in(up, UART_MSR);
2020                         up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
2021                         if (msr & UART_MSR_CTS)
2022                                 break;
2023                         udelay(1);
2024                         touch_nmi_watchdog();
2025                 }
2026         }
2027 }
2028
2029 #ifdef CONFIG_CONSOLE_POLL
2030 /*
2031  * Console polling routines for writing and reading from the uart while
2032  * in an interrupt or debug context.
2033  */
2034
2035 static int serial8250_get_poll_char(struct uart_port *port)
2036 {
2037         struct uart_8250_port *up = up_to_u8250p(port);
2038         unsigned char lsr;
2039         int status;
2040
2041         serial8250_rpm_get(up);
2042
2043         lsr = serial_port_in(port, UART_LSR);
2044
2045         if (!(lsr & UART_LSR_DR)) {
2046                 status = NO_POLL_CHAR;
2047                 goto out;
2048         }
2049
2050         status = serial_port_in(port, UART_RX);
2051 out:
2052         serial8250_rpm_put(up);
2053         return status;
2054 }
2055
2056
2057 static void serial8250_put_poll_char(struct uart_port *port,
2058                          unsigned char c)
2059 {
2060         unsigned int ier;
2061         struct uart_8250_port *up = up_to_u8250p(port);
2062
2063         serial8250_rpm_get(up);
2064         /*
2065          *      First save the IER then disable the interrupts
2066          */
2067         ier = serial_port_in(port, UART_IER);
2068         if (up->capabilities & UART_CAP_UUE)
2069                 serial_port_out(port, UART_IER, UART_IER_UUE);
2070         else
2071                 serial_port_out(port, UART_IER, 0);
2072
2073         wait_for_xmitr(up, BOTH_EMPTY);
2074         /*
2075          *      Send the character out.
2076          */
2077         serial_port_out(port, UART_TX, c);
2078
2079         /*
2080          *      Finally, wait for transmitter to become empty
2081          *      and restore the IER
2082          */
2083         wait_for_xmitr(up, BOTH_EMPTY);
2084         serial_port_out(port, UART_IER, ier);
2085         serial8250_rpm_put(up);
2086 }
2087
2088 #endif /* CONFIG_CONSOLE_POLL */
2089
2090 int serial8250_do_startup(struct uart_port *port)
2091 {
2092         struct uart_8250_port *up = up_to_u8250p(port);
2093         unsigned long flags;
2094         unsigned char lsr, iir;
2095         int retval;
2096
2097         if (port->type == PORT_8250_CIR)
2098                 return -ENODEV;
2099
2100         if (!port->fifosize)
2101                 port->fifosize = uart_config[port->type].fifo_size;
2102         if (!up->tx_loadsz)
2103                 up->tx_loadsz = uart_config[port->type].tx_loadsz;
2104         if (!up->capabilities)
2105                 up->capabilities = uart_config[port->type].flags;
2106         up->mcr = 0;
2107
2108         if (port->iotype != up->cur_iotype)
2109                 set_io_from_upio(port);
2110
2111         serial8250_rpm_get(up);
2112         if (port->type == PORT_16C950) {
2113                 /* Wake up and initialize UART */
2114                 up->acr = 0;
2115                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
2116                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
2117                 serial_port_out(port, UART_IER, 0);
2118                 serial_port_out(port, UART_LCR, 0);
2119                 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
2120                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
2121                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
2122                 serial_port_out(port, UART_LCR, 0);
2123         }
2124
2125 #ifdef CONFIG_SERIAL_8250_RSA
2126         /*
2127          * If this is an RSA port, see if we can kick it up to the
2128          * higher speed clock.
2129          */
2130         enable_rsa(up);
2131 #endif
2132         /*
2133          * Clear the FIFO buffers and disable them.
2134          * (they will be reenabled in set_termios())
2135          */
2136         serial8250_clear_fifos(up);
2137
2138         /*
2139          * Clear the interrupt registers.
2140          */
2141         if (serial_port_in(port, UART_LSR) & UART_LSR_DR)
2142                 serial_port_in(port, UART_RX);
2143         serial_port_in(port, UART_IIR);
2144         serial_port_in(port, UART_MSR);
2145
2146         /*
2147          * At this point, there's no way the LSR could still be 0xff;
2148          * if it is, then bail out, because there's likely no UART
2149          * here.
2150          */
2151         if (!(port->flags & UPF_BUGGY_UART) &&
2152             (serial_port_in(port, UART_LSR) == 0xff)) {
2153                 printk_ratelimited(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
2154                                    serial_index(port));
2155                 retval = -ENODEV;
2156                 goto out;
2157         }
2158
2159         /*
2160          * For a XR16C850, we need to set the trigger levels
2161          */
2162         if (port->type == PORT_16850) {
2163                 unsigned char fctr;
2164
2165                 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
2166
2167                 fctr = serial_in(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX);
2168                 serial_port_out(port, UART_FCTR,
2169                                 fctr | UART_FCTR_TRGD | UART_FCTR_RX);
2170                 serial_port_out(port, UART_TRG, UART_TRG_96);
2171                 serial_port_out(port, UART_FCTR,
2172                                 fctr | UART_FCTR_TRGD | UART_FCTR_TX);
2173                 serial_port_out(port, UART_TRG, UART_TRG_96);
2174
2175                 serial_port_out(port, UART_LCR, 0);
2176         }
2177
2178         if (port->irq) {
2179                 unsigned char iir1;
2180                 /*
2181                  * Test for UARTs that do not reassert THRE when the
2182                  * transmitter is idle and the interrupt has already
2183                  * been cleared.  Real 16550s should always reassert
2184                  * this interrupt whenever the transmitter is idle and
2185                  * the interrupt is enabled.  Delays are necessary to
2186                  * allow register changes to become visible.
2187                  */
2188                 spin_lock_irqsave(&port->lock, flags);
2189                 if (up->port.irqflags & IRQF_SHARED)
2190                         disable_irq_nosync(port->irq);
2191
2192                 wait_for_xmitr(up, UART_LSR_THRE);
2193                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
2194                 udelay(1); /* allow THRE to set */
2195                 iir1 = serial_port_in(port, UART_IIR);
2196                 serial_port_out(port, UART_IER, 0);
2197                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
2198                 udelay(1); /* allow a working UART time to re-assert THRE */
2199                 iir = serial_port_in(port, UART_IIR);
2200                 serial_port_out(port, UART_IER, 0);
2201
2202                 if (port->irqflags & IRQF_SHARED)
2203                         enable_irq(port->irq);
2204                 spin_unlock_irqrestore(&port->lock, flags);
2205
2206                 /*
2207                  * If the interrupt is not reasserted, or we otherwise
2208                  * don't trust the iir, setup a timer to kick the UART
2209                  * on a regular basis.
2210                  */
2211                 if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) ||
2212                     up->port.flags & UPF_BUG_THRE) {
2213                         up->bugs |= UART_BUG_THRE;
2214                         pr_debug("ttyS%d - using backup timer\n",
2215                                  serial_index(port));
2216                 }
2217         }
2218
2219         /*
2220          * The above check will only give an accurate result the first time
2221          * the port is opened so this value needs to be preserved.
2222          */
2223         if (up->bugs & UART_BUG_THRE) {
2224                 up->timer.function = serial8250_backup_timeout;
2225                 up->timer.data = (unsigned long)up;
2226                 mod_timer(&up->timer, jiffies +
2227                         uart_poll_timeout(port) + HZ / 5);
2228         }
2229
2230         /*
2231          * If the "interrupt" for this port doesn't correspond with any
2232          * hardware interrupt, we use a timer-based system.  The original
2233          * driver used to do this with IRQ0.
2234          */
2235         if (!port->irq) {
2236                 up->timer.data = (unsigned long)up;
2237                 mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
2238         } else {
2239                 retval = serial_link_irq_chain(up);
2240                 if (retval)
2241                         goto out;
2242         }
2243
2244         /*
2245          * Now, initialize the UART
2246          */
2247         serial_port_out(port, UART_LCR, UART_LCR_WLEN8);
2248
2249         spin_lock_irqsave(&port->lock, flags);
2250         if (up->port.flags & UPF_FOURPORT) {
2251                 if (!up->port.irq)
2252                         up->port.mctrl |= TIOCM_OUT1;
2253         } else
2254                 /*
2255                  * Most PC uarts need OUT2 raised to enable interrupts.
2256                  */
2257                 if (port->irq)
2258                         up->port.mctrl |= TIOCM_OUT2;
2259
2260         serial8250_set_mctrl(port, port->mctrl);
2261
2262         /* Serial over Lan (SoL) hack:
2263            Intel 8257x Gigabit ethernet chips have a
2264            16550 emulation, to be used for Serial Over Lan.
2265            Those chips take a longer time than a normal
2266            serial device to signalize that a transmission
2267            data was queued. Due to that, the above test generally
2268            fails. One solution would be to delay the reading of
2269            iir. However, this is not reliable, since the timeout
2270            is variable. So, let's just don't test if we receive
2271            TX irq. This way, we'll never enable UART_BUG_TXEN.
2272          */
2273         if (skip_txen_test || up->port.flags & UPF_NO_TXEN_TEST)
2274                 goto dont_test_tx_en;
2275
2276         /*
2277          * Do a quick test to see if we receive an
2278          * interrupt when we enable the TX irq.
2279          */
2280         serial_port_out(port, UART_IER, UART_IER_THRI);
2281         lsr = serial_port_in(port, UART_LSR);
2282         iir = serial_port_in(port, UART_IIR);
2283         serial_port_out(port, UART_IER, 0);
2284
2285         if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) {
2286                 if (!(up->bugs & UART_BUG_TXEN)) {
2287                         up->bugs |= UART_BUG_TXEN;
2288                         pr_debug("ttyS%d - enabling bad tx status workarounds\n",
2289                                  serial_index(port));
2290                 }
2291         } else {
2292                 up->bugs &= ~UART_BUG_TXEN;
2293         }
2294
2295 dont_test_tx_en:
2296         spin_unlock_irqrestore(&port->lock, flags);
2297
2298         /*
2299          * Clear the interrupt registers again for luck, and clear the
2300          * saved flags to avoid getting false values from polling
2301          * routines or the previous session.
2302          */
2303         if (serial_port_in(port, UART_LSR) & UART_LSR_DR)
2304                 serial_port_in(port, UART_RX);
2305         serial_port_in(port, UART_IIR);
2306         serial_port_in(port, UART_MSR);
2307         up->lsr_saved_flags = 0;
2308         up->msr_saved_flags = 0;
2309
2310         /*
2311          * Request DMA channels for both RX and TX.
2312          */
2313         if (up->dma) {
2314                 retval = serial8250_request_dma(up);
2315                 if (retval) {
2316                         pr_warn_ratelimited("ttyS%d - failed to request DMA\n",
2317                                             serial_index(port));
2318                         up->dma = NULL;
2319                 }
2320         }
2321
2322         /*
2323          * Finally, enable interrupts.  Note: Modem status interrupts
2324          * are set via set_termios(), which will be occurring imminently
2325          * anyway, so we don't enable them here.
2326          */
2327         up->ier = UART_IER_RLSI | UART_IER_RDI;
2328         serial_port_out(port, UART_IER, up->ier);
2329
2330         if (port->flags & UPF_FOURPORT) {
2331                 unsigned int icp;
2332                 /*
2333                  * Enable interrupts on the AST Fourport board
2334                  */
2335                 icp = (port->iobase & 0xfe0) | 0x01f;
2336                 outb_p(0x80, icp);
2337                 inb_p(icp);
2338         }
2339         retval = 0;
2340 out:
2341         serial8250_rpm_put(up);
2342         return retval;
2343 }
2344 EXPORT_SYMBOL_GPL(serial8250_do_startup);
2345
2346 static int serial8250_startup(struct uart_port *port)
2347 {
2348         if (port->startup)
2349                 return port->startup(port);
2350         return serial8250_do_startup(port);
2351 }
2352
2353 void serial8250_do_shutdown(struct uart_port *port)
2354 {
2355         struct uart_8250_port *up = up_to_u8250p(port);
2356         unsigned long flags;
2357
2358         serial8250_rpm_get(up);
2359         /*
2360          * Disable interrupts from this port
2361          */
2362         up->ier = 0;
2363         serial_port_out(port, UART_IER, 0);
2364
2365         if (up->dma)
2366                 serial8250_release_dma(up);
2367
2368         spin_lock_irqsave(&port->lock, flags);
2369         if (port->flags & UPF_FOURPORT) {
2370                 /* reset interrupts on the AST Fourport board */
2371                 inb((port->iobase & 0xfe0) | 0x1f);
2372                 port->mctrl |= TIOCM_OUT1;
2373         } else
2374                 port->mctrl &= ~TIOCM_OUT2;
2375
2376         serial8250_set_mctrl(port, port->mctrl);
2377         spin_unlock_irqrestore(&port->lock, flags);
2378
2379         /*
2380          * Disable break condition and FIFOs
2381          */
2382         serial_port_out(port, UART_LCR,
2383                         serial_port_in(port, UART_LCR) & ~UART_LCR_SBC);
2384         serial8250_clear_fifos(up);
2385
2386 #ifdef CONFIG_SERIAL_8250_RSA
2387         /*
2388          * Reset the RSA board back to 115kbps compat mode.
2389          */
2390         disable_rsa(up);
2391 #endif
2392
2393         /*
2394          * Read data port to reset things, and then unlink from
2395          * the IRQ chain.
2396          */
2397         if (serial_port_in(port, UART_LSR) & UART_LSR_DR)
2398                 serial_port_in(port, UART_RX);
2399         serial8250_rpm_put(up);
2400
2401         del_timer_sync(&up->timer);
2402         up->timer.function = serial8250_timeout;
2403         if (port->irq)
2404                 serial_unlink_irq_chain(up);
2405 }
2406 EXPORT_SYMBOL_GPL(serial8250_do_shutdown);
2407
2408 static void serial8250_shutdown(struct uart_port *port)
2409 {
2410         if (port->shutdown)
2411                 port->shutdown(port);
2412         else
2413                 serial8250_do_shutdown(port);
2414 }
2415
2416 /*
2417  * XR17V35x UARTs have an extra fractional divisor register (DLD)
2418  * Calculate divisor with extra 4-bit fractional portion
2419  */
2420 static unsigned int xr17v35x_get_divisor(struct uart_8250_port *up,
2421                                          unsigned int baud,
2422                                          unsigned int *frac)
2423 {
2424         struct uart_port *port = &up->port;
2425         unsigned int quot_16;
2426
2427         quot_16 = DIV_ROUND_CLOSEST(port->uartclk, baud);
2428         *frac = quot_16 & 0x0f;
2429
2430         return quot_16 >> 4;
2431 }
2432
2433 static unsigned int serial8250_get_divisor(struct uart_8250_port *up,
2434                                            unsigned int baud,
2435                                            unsigned int *frac)
2436 {
2437         struct uart_port *port = &up->port;
2438         unsigned int quot;
2439
2440         /*
2441          * Handle magic divisors for baud rates above baud_base on
2442          * SMSC SuperIO chips.
2443          *
2444          */
2445         if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2446             baud == (port->uartclk/4))
2447                 quot = 0x8001;
2448         else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2449                  baud == (port->uartclk/8))
2450                 quot = 0x8002;
2451         else if (up->port.type == PORT_XR17V35X)
2452                 quot = xr17v35x_get_divisor(up, baud, frac);
2453         else
2454                 quot = uart_get_divisor(port, baud);
2455
2456         /*
2457          * Oxford Semi 952 rev B workaround
2458          */
2459         if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0)
2460                 quot++;
2461
2462         return quot;
2463 }
2464
2465 static unsigned char serial8250_compute_lcr(struct uart_8250_port *up,
2466                                             tcflag_t c_cflag)
2467 {
2468         unsigned char cval;
2469
2470         switch (c_cflag & CSIZE) {
2471         case CS5:
2472                 cval = UART_LCR_WLEN5;
2473                 break;
2474         case CS6:
2475                 cval = UART_LCR_WLEN6;
2476                 break;
2477         case CS7:
2478                 cval = UART_LCR_WLEN7;
2479                 break;
2480         default:
2481         case CS8:
2482                 cval = UART_LCR_WLEN8;
2483                 break;
2484         }
2485
2486         if (c_cflag & CSTOPB)
2487                 cval |= UART_LCR_STOP;
2488         if (c_cflag & PARENB) {
2489                 cval |= UART_LCR_PARITY;
2490                 if (up->bugs & UART_BUG_PARITY)
2491                         up->fifo_bug = true;
2492         }
2493         if (!(c_cflag & PARODD))
2494                 cval |= UART_LCR_EPAR;
2495 #ifdef CMSPAR
2496         if (c_cflag & CMSPAR)
2497                 cval |= UART_LCR_SPAR;
2498 #endif
2499
2500         return cval;
2501 }
2502
2503 static void serial8250_set_divisor(struct uart_port *port, unsigned int baud,
2504                             unsigned int quot, unsigned int quot_frac)
2505 {
2506         struct uart_8250_port *up = up_to_u8250p(port);
2507
2508         /* Workaround to enable 115200 baud on OMAP1510 internal ports */
2509         if (is_omap1510_8250(up)) {
2510                 if (baud == 115200) {
2511                         quot = 1;
2512                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 1);
2513                 } else
2514                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 0);
2515         }
2516
2517         /*
2518          * For NatSemi, switch to bank 2 not bank 1, to avoid resetting EXCR2,
2519          * otherwise just set DLAB
2520          */
2521         if (up->capabilities & UART_NATSEMI)
2522                 serial_port_out(port, UART_LCR, 0xe0);
2523         else
2524                 serial_port_out(port, UART_LCR, up->lcr | UART_LCR_DLAB);
2525
2526         serial_dl_write(up, quot);
2527
2528         /* XR17V35x UARTs have an extra fractional divisor register (DLD) */
2529         if (up->port.type == PORT_XR17V35X)
2530                 serial_port_out(port, 0x2, quot_frac);
2531 }
2532
2533 void
2534 serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
2535                           struct ktermios *old)
2536 {
2537         struct uart_8250_port *up = up_to_u8250p(port);
2538         unsigned char cval;
2539         unsigned long flags;
2540         unsigned int baud, quot, frac = 0;
2541
2542         cval = serial8250_compute_lcr(up, termios->c_cflag);
2543
2544         /*
2545          * Ask the core to calculate the divisor for us.
2546          */
2547         baud = uart_get_baud_rate(port, termios, old,
2548                                   port->uartclk / 16 / 0xffff,
2549                                   port->uartclk / 16);
2550         quot = serial8250_get_divisor(up, baud, &frac);
2551
2552         /*
2553          * Ok, we're now changing the port state.  Do it with
2554          * interrupts disabled.
2555          */
2556         serial8250_rpm_get(up);
2557         spin_lock_irqsave(&port->lock, flags);
2558
2559         up->lcr = cval;                                 /* Save computed LCR */
2560
2561         if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) {
2562                 /* NOTE: If fifo_bug is not set, a user can set RX_trigger. */
2563                 if ((baud < 2400 && !up->dma) || up->fifo_bug) {
2564                         up->fcr &= ~UART_FCR_TRIGGER_MASK;
2565                         up->fcr |= UART_FCR_TRIGGER_1;
2566                 }
2567         }
2568
2569         /*
2570          * MCR-based auto flow control.  When AFE is enabled, RTS will be
2571          * deasserted when the receive FIFO contains more characters than
2572          * the trigger, or the MCR RTS bit is cleared.  In the case where
2573          * the remote UART is not using CTS auto flow control, we must
2574          * have sufficient FIFO entries for the latency of the remote
2575          * UART to respond.  IOW, at least 32 bytes of FIFO.
2576          */
2577         if (up->capabilities & UART_CAP_AFE && port->fifosize >= 32) {
2578                 up->mcr &= ~UART_MCR_AFE;
2579                 if (termios->c_cflag & CRTSCTS)
2580                         up->mcr |= UART_MCR_AFE;
2581         }
2582
2583         /*
2584          * Update the per-port timeout.
2585          */
2586         uart_update_timeout(port, termios->c_cflag, baud);
2587
2588         port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
2589         if (termios->c_iflag & INPCK)
2590                 port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
2591         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
2592                 port->read_status_mask |= UART_LSR_BI;
2593
2594         /*
2595          * Characteres to ignore
2596          */
2597         port->ignore_status_mask = 0;
2598         if (termios->c_iflag & IGNPAR)
2599                 port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
2600         if (termios->c_iflag & IGNBRK) {
2601                 port->ignore_status_mask |= UART_LSR_BI;
2602                 /*
2603                  * If we're ignoring parity and break indicators,
2604                  * ignore overruns too (for real raw support).
2605                  */
2606                 if (termios->c_iflag & IGNPAR)
2607                         port->ignore_status_mask |= UART_LSR_OE;
2608         }
2609
2610         /*
2611          * ignore all characters if CREAD is not set
2612          */
2613         if ((termios->c_cflag & CREAD) == 0)
2614                 port->ignore_status_mask |= UART_LSR_DR;
2615
2616         /*
2617          * CTS flow control flag and modem status interrupts
2618          */
2619         up->ier &= ~UART_IER_MSI;
2620         if (!(up->bugs & UART_BUG_NOMSR) &&
2621                         UART_ENABLE_MS(&up->port, termios->c_cflag))
2622                 up->ier |= UART_IER_MSI;
2623         if (up->capabilities & UART_CAP_UUE)
2624                 up->ier |= UART_IER_UUE;
2625         if (up->capabilities & UART_CAP_RTOIE)
2626                 up->ier |= UART_IER_RTOIE;
2627
2628         serial_port_out(port, UART_IER, up->ier);
2629
2630         if (up->capabilities & UART_CAP_EFR) {
2631                 unsigned char efr = 0;
2632                 /*
2633                  * TI16C752/Startech hardware flow control.  FIXME:
2634                  * - TI16C752 requires control thresholds to be set.
2635                  * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled.
2636                  */
2637                 if (termios->c_cflag & CRTSCTS)
2638                         efr |= UART_EFR_CTS;
2639
2640                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
2641                 if (port->flags & UPF_EXAR_EFR)
2642                         serial_port_out(port, UART_XR_EFR, efr);
2643                 else
2644                         serial_port_out(port, UART_EFR, efr);
2645         }
2646
2647         serial8250_set_divisor(port, baud, quot, frac);
2648
2649         /*
2650          * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
2651          * is written without DLAB set, this mode will be disabled.
2652          */
2653         if (port->type == PORT_16750)
2654                 serial_port_out(port, UART_FCR, up->fcr);
2655
2656         serial_port_out(port, UART_LCR, up->lcr);       /* reset DLAB */
2657         if (port->type != PORT_16750) {
2658                 /* emulated UARTs (Lucent Venus 167x) need two steps */
2659                 if (up->fcr & UART_FCR_ENABLE_FIFO)
2660                         serial_port_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
2661                 serial_port_out(port, UART_FCR, up->fcr);       /* set fcr */
2662         }
2663         serial8250_set_mctrl(port, port->mctrl);
2664         spin_unlock_irqrestore(&port->lock, flags);
2665         serial8250_rpm_put(up);
2666
2667         /* Don't rewrite B0 */
2668         if (tty_termios_baud_rate(termios))
2669                 tty_termios_encode_baud_rate(termios, baud, baud);
2670 }
2671 EXPORT_SYMBOL(serial8250_do_set_termios);
2672
2673 static void
2674 serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
2675                        struct ktermios *old)
2676 {
2677         if (port->set_termios)
2678                 port->set_termios(port, termios, old);
2679         else
2680                 serial8250_do_set_termios(port, termios, old);
2681 }
2682
2683 static void
2684 serial8250_set_ldisc(struct uart_port *port, struct ktermios *termios)
2685 {
2686         if (termios->c_line == N_PPS) {
2687                 port->flags |= UPF_HARDPPS_CD;
2688                 spin_lock_irq(&port->lock);
2689                 serial8250_enable_ms(port);
2690                 spin_unlock_irq(&port->lock);
2691         } else {
2692                 port->flags &= ~UPF_HARDPPS_CD;
2693                 if (!UART_ENABLE_MS(port, termios->c_cflag)) {
2694                         spin_lock_irq(&port->lock);
2695                         serial8250_disable_ms(port);
2696                         spin_unlock_irq(&port->lock);
2697                 }
2698         }
2699 }
2700
2701
2702 void serial8250_do_pm(struct uart_port *port, unsigned int state,
2703                       unsigned int oldstate)
2704 {
2705         struct uart_8250_port *p = up_to_u8250p(port);
2706
2707         serial8250_set_sleep(p, state != 0);
2708 }
2709 EXPORT_SYMBOL(serial8250_do_pm);
2710
2711 static void
2712 serial8250_pm(struct uart_port *port, unsigned int state,
2713               unsigned int oldstate)
2714 {
2715         if (port->pm)
2716                 port->pm(port, state, oldstate);
2717         else
2718                 serial8250_do_pm(port, state, oldstate);
2719 }
2720
2721 static unsigned int serial8250_port_size(struct uart_8250_port *pt)
2722 {
2723         if (pt->port.iotype == UPIO_AU) {
2724                 if (pt->port.type == PORT_RT2880)
2725                         return 0x100;
2726                 return 0x1000;
2727         }
2728         if (is_omap1_8250(pt))
2729                 return 0x16 << pt->port.regshift;
2730
2731         return 8 << pt->port.regshift;
2732 }
2733
2734 /*
2735  * Resource handling.
2736  */
2737 static int serial8250_request_std_resource(struct uart_8250_port *up)
2738 {
2739         unsigned int size = serial8250_port_size(up);
2740         struct uart_port *port = &up->port;
2741         int ret = 0;
2742
2743         switch (port->iotype) {
2744         case UPIO_AU:
2745         case UPIO_TSI:
2746         case UPIO_MEM32:
2747         case UPIO_MEM:
2748                 if (!port->mapbase)
2749                         break;
2750
2751                 if (!request_mem_region(port->mapbase, size, "serial")) {
2752                         ret = -EBUSY;
2753                         break;
2754                 }
2755
2756                 if (port->flags & UPF_IOREMAP) {
2757                         port->membase = ioremap_nocache(port->mapbase, size);
2758                         if (!port->membase) {
2759                                 release_mem_region(port->mapbase, size);
2760                                 ret = -ENOMEM;
2761                         }
2762                 }
2763                 break;
2764
2765         case UPIO_HUB6:
2766         case UPIO_PORT:
2767                 if (!request_region(port->iobase, size, "serial"))
2768                         ret = -EBUSY;
2769                 break;
2770         }
2771         return ret;
2772 }
2773
2774 static void serial8250_release_std_resource(struct uart_8250_port *up)
2775 {
2776         unsigned int size = serial8250_port_size(up);
2777         struct uart_port *port = &up->port;
2778
2779         switch (port->iotype) {
2780         case UPIO_AU:
2781         case UPIO_TSI:
2782         case UPIO_MEM32:
2783         case UPIO_MEM:
2784                 if (!port->mapbase)
2785                         break;
2786
2787                 if (port->flags & UPF_IOREMAP) {
2788                         iounmap(port->membase);
2789                         port->membase = NULL;
2790                 }
2791
2792                 release_mem_region(port->mapbase, size);
2793                 break;
2794
2795         case UPIO_HUB6:
2796         case UPIO_PORT:
2797                 release_region(port->iobase, size);
2798                 break;
2799         }
2800 }
2801
2802 static int serial8250_request_rsa_resource(struct uart_8250_port *up)
2803 {
2804         unsigned long start = UART_RSA_BASE << up->port.regshift;
2805         unsigned int size = 8 << up->port.regshift;
2806         struct uart_port *port = &up->port;
2807         int ret = -EINVAL;
2808
2809         switch (port->iotype) {
2810         case UPIO_HUB6:
2811         case UPIO_PORT:
2812                 start += port->iobase;
2813                 if (request_region(start, size, "serial-rsa"))
2814                         ret = 0;
2815                 else
2816                         ret = -EBUSY;
2817                 break;
2818         }
2819
2820         return ret;
2821 }
2822
2823 static void serial8250_release_rsa_resource(struct uart_8250_port *up)
2824 {
2825         unsigned long offset = UART_RSA_BASE << up->port.regshift;
2826         unsigned int size = 8 << up->port.regshift;
2827         struct uart_port *port = &up->port;
2828
2829         switch (port->iotype) {
2830         case UPIO_HUB6:
2831         case UPIO_PORT:
2832                 release_region(port->iobase + offset, size);
2833                 break;
2834         }
2835 }
2836
2837 static void serial8250_release_port(struct uart_port *port)
2838 {
2839         struct uart_8250_port *up = up_to_u8250p(port);
2840
2841         serial8250_release_std_resource(up);
2842         if (port->type == PORT_RSA)
2843                 serial8250_release_rsa_resource(up);
2844 }
2845
2846 static int serial8250_request_port(struct uart_port *port)
2847 {
2848         struct uart_8250_port *up = up_to_u8250p(port);
2849         int ret;
2850
2851         if (port->type == PORT_8250_CIR)
2852                 return -ENODEV;
2853
2854         ret = serial8250_request_std_resource(up);
2855         if (ret == 0 && port->type == PORT_RSA) {
2856                 ret = serial8250_request_rsa_resource(up);
2857                 if (ret < 0)
2858                         serial8250_release_std_resource(up);
2859         }
2860
2861         return ret;
2862 }
2863
2864 static int fcr_get_rxtrig_bytes(struct uart_8250_port *up)
2865 {
2866         const struct serial8250_config *conf_type = &uart_config[up->port.type];
2867         unsigned char bytes;
2868
2869         bytes = conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(up->fcr)];
2870
2871         return bytes ? bytes : -EOPNOTSUPP;
2872 }
2873
2874 static int bytes_to_fcr_rxtrig(struct uart_8250_port *up, unsigned char bytes)
2875 {
2876         const struct serial8250_config *conf_type = &uart_config[up->port.type];
2877         int i;
2878
2879         if (!conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(UART_FCR_R_TRIG_00)])
2880                 return -EOPNOTSUPP;
2881
2882         for (i = 1; i < UART_FCR_R_TRIG_MAX_STATE; i++) {
2883                 if (bytes < conf_type->rxtrig_bytes[i])
2884                         /* Use the nearest lower value */
2885                         return (--i) << UART_FCR_R_TRIG_SHIFT;
2886         }
2887
2888         return UART_FCR_R_TRIG_11;
2889 }
2890
2891 static int do_get_rxtrig(struct tty_port *port)
2892 {
2893         struct uart_state *state = container_of(port, struct uart_state, port);
2894         struct uart_port *uport = state->uart_port;
2895         struct uart_8250_port *up =
2896                 container_of(uport, struct uart_8250_port, port);
2897
2898         if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1)
2899                 return -EINVAL;
2900
2901         return fcr_get_rxtrig_bytes(up);
2902 }
2903
2904 static int do_serial8250_get_rxtrig(struct tty_port *port)
2905 {
2906         int rxtrig_bytes;
2907
2908         mutex_lock(&port->mutex);
2909         rxtrig_bytes = do_get_rxtrig(port);
2910         mutex_unlock(&port->mutex);
2911
2912         return rxtrig_bytes;
2913 }
2914
2915 static ssize_t serial8250_get_attr_rx_trig_bytes(struct device *dev,
2916         struct device_attribute *attr, char *buf)
2917 {
2918         struct tty_port *port = dev_get_drvdata(dev);
2919         int rxtrig_bytes;
2920
2921         rxtrig_bytes = do_serial8250_get_rxtrig(port);
2922         if (rxtrig_bytes < 0)
2923                 return rxtrig_bytes;
2924
2925         return snprintf(buf, PAGE_SIZE, "%d\n", rxtrig_bytes);
2926 }
2927
2928 static int do_set_rxtrig(struct tty_port *port, unsigned char bytes)
2929 {
2930         struct uart_state *state = container_of(port, struct uart_state, port);
2931         struct uart_port *uport = state->uart_port;
2932         struct uart_8250_port *up =
2933                 container_of(uport, struct uart_8250_port, port);
2934         int rxtrig;
2935
2936         if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1 ||
2937             up->fifo_bug)
2938                 return -EINVAL;
2939
2940         rxtrig = bytes_to_fcr_rxtrig(up, bytes);
2941         if (rxtrig < 0)
2942                 return rxtrig;
2943
2944         serial8250_clear_fifos(up);
2945         up->fcr &= ~UART_FCR_TRIGGER_MASK;
2946         up->fcr |= (unsigned char)rxtrig;
2947         serial_out(up, UART_FCR, up->fcr);
2948         return 0;
2949 }
2950
2951 static int do_serial8250_set_rxtrig(struct tty_port *port, unsigned char bytes)
2952 {
2953         int ret;
2954
2955         mutex_lock(&port->mutex);
2956         ret = do_set_rxtrig(port, bytes);
2957         mutex_unlock(&port->mutex);
2958
2959         return ret;
2960 }
2961
2962 static ssize_t serial8250_set_attr_rx_trig_bytes(struct device *dev,
2963         struct device_attribute *attr, const char *buf, size_t count)
2964 {
2965         struct tty_port *port = dev_get_drvdata(dev);
2966         unsigned char bytes;
2967         int ret;
2968
2969         if (!count)
2970                 return -EINVAL;
2971
2972         ret = kstrtou8(buf, 10, &bytes);
2973         if (ret < 0)
2974                 return ret;
2975
2976         ret = do_serial8250_set_rxtrig(port, bytes);
2977         if (ret < 0)
2978                 return ret;
2979
2980         return count;
2981 }
2982
2983 static DEVICE_ATTR(rx_trig_bytes, S_IRUSR | S_IWUSR | S_IRGRP,
2984                    serial8250_get_attr_rx_trig_bytes,
2985                    serial8250_set_attr_rx_trig_bytes);
2986
2987 static struct attribute *serial8250_dev_attrs[] = {
2988         &dev_attr_rx_trig_bytes.attr,
2989         NULL,
2990         };
2991
2992 static struct attribute_group serial8250_dev_attr_group = {
2993         .attrs = serial8250_dev_attrs,
2994         };
2995
2996 static void register_dev_spec_attr_grp(struct uart_8250_port *up)
2997 {
2998         const struct serial8250_config *conf_type = &uart_config[up->port.type];
2999
3000         if (conf_type->rxtrig_bytes[0])
3001                 up->port.attr_group = &serial8250_dev_attr_group;
3002 }
3003
3004 static void serial8250_config_port(struct uart_port *port, int flags)
3005 {
3006         struct uart_8250_port *up = up_to_u8250p(port);
3007         int probeflags = PROBE_ANY;
3008         int ret;
3009
3010         if (port->type == PORT_8250_CIR)
3011                 return;
3012
3013         /*
3014          * Find the region that we can probe for.  This in turn
3015          * tells us whether we can probe for the type of port.
3016          */
3017         ret = serial8250_request_std_resource(up);
3018         if (ret < 0)
3019                 return;
3020
3021         ret = serial8250_request_rsa_resource(up);
3022         if (ret < 0)
3023                 probeflags &= ~PROBE_RSA;
3024
3025         if (port->iotype != up->cur_iotype)
3026                 set_io_from_upio(port);
3027
3028         if (flags & UART_CONFIG_TYPE)
3029                 autoconfig(up, probeflags);
3030
3031         /* if access method is AU, it is a 16550 with a quirk */
3032         if (port->type == PORT_16550A && port->iotype == UPIO_AU)
3033                 up->bugs |= UART_BUG_NOMSR;
3034
3035         /* HW bugs may trigger IRQ while IIR == NO_INT */
3036         if (port->type == PORT_TEGRA)
3037                 up->bugs |= UART_BUG_NOMSR;
3038
3039         if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
3040                 autoconfig_irq(up);
3041
3042         if (port->type != PORT_RSA && probeflags & PROBE_RSA)
3043                 serial8250_release_rsa_resource(up);
3044         if (port->type == PORT_UNKNOWN)
3045                 serial8250_release_std_resource(up);
3046
3047         /* Fixme: probably not the best place for this */
3048         if ((port->type == PORT_XR17V35X) ||
3049            (port->type == PORT_XR17D15X))
3050                 port->handle_irq = exar_handle_irq;
3051
3052         register_dev_spec_attr_grp(up);
3053         up->fcr = uart_config[up->port.type].fcr;
3054 }
3055
3056 static int
3057 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
3058 {
3059         if (ser->irq >= nr_irqs || ser->irq < 0 ||
3060             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
3061             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
3062             ser->type == PORT_STARTECH)
3063                 return -EINVAL;
3064         return 0;
3065 }
3066
3067 static const char *
3068 serial8250_type(struct uart_port *port)
3069 {
3070         int type = port->type;
3071
3072         if (type >= ARRAY_SIZE(uart_config))
3073                 type = 0;
3074         return uart_config[type].name;
3075 }
3076
3077 static struct uart_ops serial8250_pops = {
3078         .tx_empty       = serial8250_tx_empty,
3079         .set_mctrl      = serial8250_set_mctrl,
3080         .get_mctrl      = serial8250_get_mctrl,
3081         .stop_tx        = serial8250_stop_tx,
3082         .start_tx       = serial8250_start_tx,
3083         .throttle       = serial8250_throttle,
3084         .unthrottle     = serial8250_unthrottle,
3085         .stop_rx        = serial8250_stop_rx,
3086         .enable_ms      = serial8250_enable_ms,
3087         .break_ctl      = serial8250_break_ctl,
3088         .startup        = serial8250_startup,
3089         .shutdown       = serial8250_shutdown,
3090         .set_termios    = serial8250_set_termios,
3091         .set_ldisc      = serial8250_set_ldisc,
3092         .pm             = serial8250_pm,
3093         .type           = serial8250_type,
3094         .release_port   = serial8250_release_port,
3095         .request_port   = serial8250_request_port,
3096         .config_port    = serial8250_config_port,
3097         .verify_port    = serial8250_verify_port,
3098 #ifdef CONFIG_CONSOLE_POLL
3099         .poll_get_char = serial8250_get_poll_char,
3100         .poll_put_char = serial8250_put_poll_char,
3101 #endif
3102 };
3103
3104 static struct uart_8250_port serial8250_ports[UART_NR];
3105
3106 /**
3107  * serial8250_get_port - retrieve struct uart_8250_port
3108  * @line: serial line number
3109  *
3110  * This function retrieves struct uart_8250_port for the specific line.
3111  * This struct *must* *not* be used to perform a 8250 or serial core operation
3112  * which is not accessible otherwise. Its only purpose is to make the struct
3113  * accessible to the runtime-pm callbacks for context suspend/restore.
3114  * The lock assumption made here is none because runtime-pm suspend/resume
3115  * callbacks should not be invoked if there is any operation performed on the
3116  * port.
3117  */
3118 struct uart_8250_port *serial8250_get_port(int line)
3119 {
3120         return &serial8250_ports[line];
3121 }
3122 EXPORT_SYMBOL_GPL(serial8250_get_port);
3123
3124 static void (*serial8250_isa_config)(int port, struct uart_port *up,
3125         unsigned short *capabilities);
3126
3127 void serial8250_set_isa_configurator(
3128         void (*v)(int port, struct uart_port *up, unsigned short *capabilities))
3129 {
3130         serial8250_isa_config = v;
3131 }
3132 EXPORT_SYMBOL(serial8250_set_isa_configurator);
3133
3134 static void __init serial8250_isa_init_ports(void)
3135 {
3136         struct uart_8250_port *up;
3137         static int first = 1;
3138         int i, irqflag = 0;
3139
3140         if (!first)
3141                 return;
3142         first = 0;
3143
3144         if (nr_uarts > UART_NR)
3145                 nr_uarts = UART_NR;
3146
3147         for (i = 0; i < nr_uarts; i++) {
3148                 struct uart_8250_port *up = &serial8250_ports[i];
3149                 struct uart_port *port = &up->port;
3150
3151                 port->line = i;
3152                 spin_lock_init(&port->lock);
3153
3154                 init_timer(&up->timer);
3155                 up->timer.function = serial8250_timeout;
3156                 up->cur_iotype = 0xFF;
3157
3158                 /*
3159                  * ALPHA_KLUDGE_MCR needs to be killed.
3160                  */
3161                 up->mcr_mask = ~ALPHA_KLUDGE_MCR;
3162                 up->mcr_force = ALPHA_KLUDGE_MCR;
3163
3164                 port->ops = &serial8250_pops;
3165         }
3166
3167         if (share_irqs)
3168                 irqflag = IRQF_SHARED;
3169
3170         for (i = 0, up = serial8250_ports;
3171              i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
3172              i++, up++) {
3173                 struct uart_port *port = &up->port;
3174
3175                 port->iobase   = old_serial_port[i].port;
3176                 port->irq      = irq_canonicalize(old_serial_port[i].irq);
3177                 port->irqflags = old_serial_port[i].irqflags;
3178                 port->uartclk  = old_serial_port[i].baud_base * 16;
3179                 port->flags    = old_serial_port[i].flags;
3180                 port->hub6     = old_serial_port[i].hub6;
3181                 port->membase  = old_serial_port[i].iomem_base;
3182                 port->iotype   = old_serial_port[i].io_type;
3183                 port->regshift = old_serial_port[i].iomem_reg_shift;
3184                 set_io_from_upio(port);
3185                 port->irqflags |= irqflag;
3186                 if (serial8250_isa_config != NULL)
3187                         serial8250_isa_config(i, &up->port, &up->capabilities);
3188
3189         }
3190 }
3191
3192 static void
3193 serial8250_init_fixed_type_port(struct uart_8250_port *up, unsigned int type)
3194 {
3195         up->port.type = type;
3196         if (!up->port.fifosize)
3197                 up->port.fifosize = uart_config[type].fifo_size;
3198         if (!up->tx_loadsz)
3199                 up->tx_loadsz = uart_config[type].tx_loadsz;
3200         if (!up->capabilities)
3201                 up->capabilities = uart_config[type].flags;
3202 }
3203
3204 static void __init
3205 serial8250_register_ports(struct uart_driver *drv, struct device *dev)
3206 {
3207         int i;
3208
3209         for (i = 0; i < nr_uarts; i++) {
3210                 struct uart_8250_port *up = &serial8250_ports[i];
3211
3212                 if (up->port.dev)
3213                         continue;
3214
3215                 up->port.dev = dev;
3216
3217                 if (up->port.flags & UPF_FIXED_TYPE)
3218                         serial8250_init_fixed_type_port(up, up->port.type);
3219
3220                 uart_add_one_port(drv, &up->port);
3221         }
3222 }
3223
3224 #ifdef CONFIG_SERIAL_8250_CONSOLE
3225
3226 static void serial8250_console_putchar(struct uart_port *port, int ch)
3227 {
3228         struct uart_8250_port *up = up_to_u8250p(port);
3229
3230         wait_for_xmitr(up, UART_LSR_THRE);
3231         serial_port_out(port, UART_TX, ch);
3232 }
3233
3234 /*
3235  *      Print a string to the serial port trying not to disturb
3236  *      any possible real use of the port...
3237  *
3238  *      The console_lock must be held when we get here.
3239  */
3240 static void
3241 serial8250_console_write(struct console *co, const char *s, unsigned int count)
3242 {
3243         struct uart_8250_port *up = &serial8250_ports[co->index];
3244         struct uart_port *port = &up->port;
3245         unsigned long flags;
3246         unsigned int ier;
3247         int locked = 1;
3248
3249         touch_nmi_watchdog();
3250
3251         serial8250_rpm_get(up);
3252
3253         if (port->sysrq)
3254                 locked = 0;
3255         else if (oops_in_progress)
3256                 locked = spin_trylock_irqsave(&port->lock, flags);
3257         else
3258                 spin_lock_irqsave(&port->lock, flags);
3259
3260         /*
3261          *      First save the IER then disable the interrupts
3262          */
3263         ier = serial_port_in(port, UART_IER);
3264
3265         if (up->capabilities & UART_CAP_UUE)
3266                 serial_port_out(port, UART_IER, UART_IER_UUE);
3267         else
3268                 serial_port_out(port, UART_IER, 0);
3269
3270         /* check scratch reg to see if port powered off during system sleep */
3271         if (up->canary && (up->canary != serial_port_in(port, UART_SCR))) {
3272                 struct ktermios termios;
3273                 unsigned int baud, quot, frac = 0;
3274
3275                 termios.c_cflag = port->cons->cflag;
3276                 if (port->state->port.tty && termios.c_cflag == 0)
3277                         termios.c_cflag = port->state->port.tty->termios.c_cflag;
3278
3279                 baud = uart_get_baud_rate(port, &termios, NULL,
3280                                           port->uartclk / 16 / 0xffff,
3281                                           port->uartclk / 16);
3282                 quot = serial8250_get_divisor(up, baud, &frac);
3283
3284                 serial8250_set_divisor(port, baud, quot, frac);
3285                 serial_port_out(port, UART_LCR, up->lcr);
3286                 serial_port_out(port, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
3287
3288                 up->canary = 0;
3289         }
3290
3291         uart_console_write(port, s, count, serial8250_console_putchar);
3292
3293         /*
3294          *      Finally, wait for transmitter to become empty
3295          *      and restore the IER
3296          */
3297         wait_for_xmitr(up, BOTH_EMPTY);
3298         serial_port_out(port, UART_IER, ier);
3299
3300         /*
3301          *      The receive handling will happen properly because the
3302          *      receive ready bit will still be set; it is not cleared
3303          *      on read.  However, modem control will not, we must
3304          *      call it if we have saved something in the saved flags
3305          *      while processing with interrupts off.
3306          */
3307         if (up->msr_saved_flags)
3308                 serial8250_modem_status(up);
3309
3310         if (locked)
3311                 spin_unlock_irqrestore(&port->lock, flags);
3312         serial8250_rpm_put(up);
3313 }
3314
3315 static int serial8250_console_setup(struct console *co, char *options)
3316 {
3317         struct uart_port *port;
3318         int baud = 9600;
3319         int bits = 8;
3320         int parity = 'n';
3321         int flow = 'n';
3322
3323         /*
3324          * Check whether an invalid uart number has been specified, and
3325          * if so, search for the first available port that does have
3326          * console support.
3327          */
3328         if (co->index >= nr_uarts)
3329                 co->index = 0;
3330         port = &serial8250_ports[co->index].port;
3331         if (!port->iobase && !port->membase)
3332                 return -ENODEV;
3333
3334         if (options)
3335                 uart_parse_options(options, &baud, &parity, &bits, &flow);
3336
3337         return uart_set_options(port, co, baud, parity, bits, flow);
3338 }
3339
3340 static int serial8250_console_early_setup(void)
3341 {
3342         return serial8250_find_port_for_earlycon();
3343 }
3344
3345 static struct console serial8250_console = {
3346         .name           = "ttyS",
3347         .write          = serial8250_console_write,
3348         .device         = uart_console_device,
3349         .setup          = serial8250_console_setup,
3350         .early_setup    = serial8250_console_early_setup,
3351         .flags          = CON_PRINTBUFFER | CON_ANYTIME,
3352         .index          = -1,
3353         .data           = &serial8250_reg,
3354 };
3355
3356 static int __init serial8250_console_init(void)
3357 {
3358         serial8250_isa_init_ports();
3359         register_console(&serial8250_console);
3360         return 0;
3361 }
3362 console_initcall(serial8250_console_init);
3363
3364 int serial8250_find_port(struct uart_port *p)
3365 {
3366         int line;
3367         struct uart_port *port;
3368
3369         for (line = 0; line < nr_uarts; line++) {
3370                 port = &serial8250_ports[line].port;
3371                 if (uart_match_port(p, port))
3372                         return line;
3373         }
3374         return -ENODEV;
3375 }
3376
3377 #define SERIAL8250_CONSOLE      &serial8250_console
3378 #else
3379 #define SERIAL8250_CONSOLE      NULL
3380 #endif
3381
3382 static struct uart_driver serial8250_reg = {
3383         .owner                  = THIS_MODULE,
3384         .driver_name            = "serial",
3385         .dev_name               = "ttyS",
3386         .major                  = TTY_MAJOR,
3387         .minor                  = 64,
3388         .cons                   = SERIAL8250_CONSOLE,
3389 };
3390
3391 /*
3392  * early_serial_setup - early registration for 8250 ports
3393  *
3394  * Setup an 8250 port structure prior to console initialisation.  Use
3395  * after console initialisation will cause undefined behaviour.
3396  */
3397 int __init early_serial_setup(struct uart_port *port)
3398 {
3399         struct uart_port *p;
3400
3401         if (port->line >= ARRAY_SIZE(serial8250_ports))
3402                 return -ENODEV;
3403
3404         serial8250_isa_init_ports();
3405         p = &serial8250_ports[port->line].port;
3406         p->iobase       = port->iobase;
3407         p->membase      = port->membase;
3408         p->irq          = port->irq;
3409         p->irqflags     = port->irqflags;
3410         p->uartclk      = port->uartclk;
3411         p->fifosize     = port->fifosize;
3412         p->regshift     = port->regshift;
3413         p->iotype       = port->iotype;
3414         p->flags        = port->flags;
3415         p->mapbase      = port->mapbase;
3416         p->private_data = port->private_data;
3417         p->type         = port->type;
3418         p->line         = port->line;
3419
3420         set_io_from_upio(p);
3421         if (port->serial_in)
3422                 p->serial_in = port->serial_in;
3423         if (port->serial_out)
3424                 p->serial_out = port->serial_out;
3425         if (port->handle_irq)
3426                 p->handle_irq = port->handle_irq;
3427         else
3428                 p->handle_irq = serial8250_default_handle_irq;
3429
3430         return 0;
3431 }
3432
3433 /**
3434  *      serial8250_suspend_port - suspend one serial port
3435  *      @line:  serial line number
3436  *
3437  *      Suspend one serial port.
3438  */
3439 void serial8250_suspend_port(int line)
3440 {
3441         struct uart_8250_port *up = &serial8250_ports[line];
3442         struct uart_port *port = &up->port;
3443
3444         if (!console_suspend_enabled && uart_console(port) &&
3445             port->type != PORT_8250) {
3446                 unsigned char canary = 0xa5;
3447                 serial_out(up, UART_SCR, canary);
3448                 up->canary = canary;
3449         }
3450
3451         uart_suspend_port(&serial8250_reg, port);
3452 }
3453
3454 /**
3455  *      serial8250_resume_port - resume one serial port
3456  *      @line:  serial line number
3457  *
3458  *      Resume one serial port.
3459  */
3460 void serial8250_resume_port(int line)
3461 {
3462         struct uart_8250_port *up = &serial8250_ports[line];
3463         struct uart_port *port = &up->port;
3464
3465         up->canary = 0;
3466
3467         if (up->capabilities & UART_NATSEMI) {
3468                 /* Ensure it's still in high speed mode */
3469                 serial_port_out(port, UART_LCR, 0xE0);
3470
3471                 ns16550a_goto_highspeed(up);
3472
3473                 serial_port_out(port, UART_LCR, 0);
3474                 port->uartclk = 921600*16;
3475         }
3476         uart_resume_port(&serial8250_reg, port);
3477 }
3478
3479 /*
3480  * Register a set of serial devices attached to a platform device.  The
3481  * list is terminated with a zero flags entry, which means we expect
3482  * all entries to have at least UPF_BOOT_AUTOCONF set.
3483  */
3484 static int serial8250_probe(struct platform_device *dev)
3485 {
3486         struct plat_serial8250_port *p = dev_get_platdata(&dev->dev);
3487         struct uart_8250_port uart;
3488         int ret, i, irqflag = 0;
3489
3490         memset(&uart, 0, sizeof(uart));
3491
3492         if (share_irqs)
3493                 irqflag = IRQF_SHARED;
3494
3495         for (i = 0; p && p->flags != 0; p++, i++) {
3496                 uart.port.iobase        = p->iobase;
3497                 uart.port.membase       = p->membase;
3498                 uart.port.irq           = p->irq;
3499                 uart.port.irqflags      = p->irqflags;
3500                 uart.port.uartclk       = p->uartclk;
3501                 uart.port.regshift      = p->regshift;
3502                 uart.port.iotype        = p->iotype;
3503                 uart.port.flags         = p->flags;
3504                 uart.port.mapbase       = p->mapbase;
3505                 uart.port.hub6          = p->hub6;
3506                 uart.port.private_data  = p->private_data;
3507                 uart.port.type          = p->type;
3508                 uart.port.serial_in     = p->serial_in;
3509                 uart.port.serial_out    = p->serial_out;
3510                 uart.port.handle_irq    = p->handle_irq;
3511                 uart.port.handle_break  = p->handle_break;
3512                 uart.port.set_termios   = p->set_termios;
3513                 uart.port.pm            = p->pm;
3514                 uart.port.dev           = &dev->dev;
3515                 uart.port.irqflags      |= irqflag;
3516                 ret = serial8250_register_8250_port(&uart);
3517                 if (ret < 0) {
3518                         dev_err(&dev->dev, "unable to register port at index %d "
3519                                 "(IO%lx MEM%llx IRQ%d): %d\n", i,
3520                                 p->iobase, (unsigned long long)p->mapbase,
3521                                 p->irq, ret);
3522                 }
3523         }
3524         return 0;
3525 }
3526
3527 /*
3528  * Remove serial ports registered against a platform device.
3529  */
3530 static int serial8250_remove(struct platform_device *dev)
3531 {
3532         int i;
3533
3534         for (i = 0; i < nr_uarts; i++) {
3535                 struct uart_8250_port *up = &serial8250_ports[i];
3536
3537                 if (up->port.dev == &dev->dev)
3538                         serial8250_unregister_port(i);
3539         }
3540         return 0;
3541 }
3542
3543 static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
3544 {
3545         int i;
3546
3547         for (i = 0; i < UART_NR; i++) {
3548                 struct uart_8250_port *up = &serial8250_ports[i];
3549
3550                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
3551                         uart_suspend_port(&serial8250_reg, &up->port);
3552         }
3553
3554         return 0;
3555 }
3556
3557 static int serial8250_resume(struct platform_device *dev)
3558 {
3559         int i;
3560
3561         for (i = 0; i < UART_NR; i++) {
3562                 struct uart_8250_port *up = &serial8250_ports[i];
3563
3564                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
3565                         serial8250_resume_port(i);
3566         }
3567
3568         return 0;
3569 }
3570
3571 static struct platform_driver serial8250_isa_driver = {
3572         .probe          = serial8250_probe,
3573         .remove         = serial8250_remove,
3574         .suspend        = serial8250_suspend,
3575         .resume         = serial8250_resume,
3576         .driver         = {
3577                 .name   = "serial8250",
3578         },
3579 };
3580
3581 /*
3582  * This "device" covers _all_ ISA 8250-compatible serial devices listed
3583  * in the table in include/asm/serial.h
3584  */
3585 static struct platform_device *serial8250_isa_devs;
3586
3587 /*
3588  * serial8250_register_8250_port and serial8250_unregister_port allows for
3589  * 16x50 serial ports to be configured at run-time, to support PCMCIA
3590  * modems and PCI multiport cards.
3591  */
3592 static DEFINE_MUTEX(serial_mutex);
3593
3594 static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port)
3595 {
3596         int i;
3597
3598         /*
3599          * First, find a port entry which matches.
3600          */
3601         for (i = 0; i < nr_uarts; i++)
3602                 if (uart_match_port(&serial8250_ports[i].port, port))
3603                         return &serial8250_ports[i];
3604
3605         /* try line number first if still available */
3606         i = port->line;
3607         if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN &&
3608                         serial8250_ports[i].port.iobase == 0)
3609                 return &serial8250_ports[i];
3610         /*
3611          * We didn't find a matching entry, so look for the first
3612          * free entry.  We look for one which hasn't been previously
3613          * used (indicated by zero iobase).
3614          */
3615         for (i = 0; i < nr_uarts; i++)
3616                 if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
3617                     serial8250_ports[i].port.iobase == 0)
3618                         return &serial8250_ports[i];
3619
3620         /*
3621          * That also failed.  Last resort is to find any entry which
3622          * doesn't have a real port associated with it.
3623          */
3624         for (i = 0; i < nr_uarts; i++)
3625                 if (serial8250_ports[i].port.type == PORT_UNKNOWN)
3626                         return &serial8250_ports[i];
3627
3628         return NULL;
3629 }
3630
3631 /**
3632  *      serial8250_register_8250_port - register a serial port
3633  *      @up: serial port template
3634  *
3635  *      Configure the serial port specified by the request. If the
3636  *      port exists and is in use, it is hung up and unregistered
3637  *      first.
3638  *
3639  *      The port is then probed and if necessary the IRQ is autodetected
3640  *      If this fails an error is returned.
3641  *
3642  *      On success the port is ready to use and the line number is returned.
3643  */
3644 int serial8250_register_8250_port(struct uart_8250_port *up)
3645 {
3646         struct uart_8250_port *uart;
3647         int ret = -ENOSPC;
3648
3649         if (up->port.uartclk == 0)
3650                 return -EINVAL;
3651
3652         mutex_lock(&serial_mutex);
3653
3654         uart = serial8250_find_match_or_unused(&up->port);
3655         if (uart && uart->port.type != PORT_8250_CIR) {
3656                 if (uart->port.dev)
3657                         uart_remove_one_port(&serial8250_reg, &uart->port);
3658
3659                 uart->port.iobase       = up->port.iobase;
3660                 uart->port.membase      = up->port.membase;
3661                 uart->port.irq          = up->port.irq;
3662                 uart->port.irqflags     = up->port.irqflags;
3663                 uart->port.uartclk      = up->port.uartclk;
3664                 uart->port.fifosize     = up->port.fifosize;
3665                 uart->port.regshift     = up->port.regshift;
3666                 uart->port.iotype       = up->port.iotype;
3667                 uart->port.flags        = up->port.flags | UPF_BOOT_AUTOCONF;
3668                 uart->bugs              = up->bugs;
3669                 uart->port.mapbase      = up->port.mapbase;
3670                 uart->port.private_data = up->port.private_data;
3671                 uart->port.fifosize     = up->port.fifosize;
3672                 uart->tx_loadsz         = up->tx_loadsz;
3673                 uart->capabilities      = up->capabilities;
3674                 uart->port.throttle     = up->port.throttle;
3675                 uart->port.unthrottle   = up->port.unthrottle;
3676                 uart->port.rs485_config = up->port.rs485_config;
3677                 uart->port.rs485        = up->port.rs485;
3678
3679                 /* Take tx_loadsz from fifosize if it wasn't set separately */
3680                 if (uart->port.fifosize && !uart->tx_loadsz)
3681                         uart->tx_loadsz = uart->port.fifosize;
3682
3683                 if (up->port.dev)
3684                         uart->port.dev = up->port.dev;
3685
3686                 if (up->port.flags & UPF_FIXED_TYPE)
3687                         serial8250_init_fixed_type_port(uart, up->port.type);
3688
3689                 set_io_from_upio(&uart->port);
3690                 /* Possibly override default I/O functions.  */
3691                 if (up->port.serial_in)
3692                         uart->port.serial_in = up->port.serial_in;
3693                 if (up->port.serial_out)
3694                         uart->port.serial_out = up->port.serial_out;
3695                 if (up->port.handle_irq)
3696                         uart->port.handle_irq = up->port.handle_irq;
3697                 /*  Possibly override set_termios call */
3698                 if (up->port.set_termios)
3699                         uart->port.set_termios = up->port.set_termios;
3700                 if (up->port.set_mctrl)
3701                         uart->port.set_mctrl = up->port.set_mctrl;
3702                 if (up->port.startup)
3703                         uart->port.startup = up->port.startup;
3704                 if (up->port.shutdown)
3705                         uart->port.shutdown = up->port.shutdown;
3706                 if (up->port.pm)
3707                         uart->port.pm = up->port.pm;
3708                 if (up->port.handle_break)
3709                         uart->port.handle_break = up->port.handle_break;
3710                 if (up->dl_read)
3711                         uart->dl_read = up->dl_read;
3712                 if (up->dl_write)
3713                         uart->dl_write = up->dl_write;
3714                 if (up->dma) {
3715                         uart->dma = up->dma;
3716                         if (!uart->dma->tx_dma)
3717                                 uart->dma->tx_dma = serial8250_tx_dma;
3718                         if (!uart->dma->rx_dma)
3719                                 uart->dma->rx_dma = serial8250_rx_dma;
3720                 }
3721
3722                 if (serial8250_isa_config != NULL)
3723                         serial8250_isa_config(0, &uart->port,
3724                                         &uart->capabilities);
3725
3726                 ret = uart_add_one_port(&serial8250_reg, &uart->port);
3727                 if (ret == 0)
3728                         ret = uart->port.line;
3729         }
3730         mutex_unlock(&serial_mutex);
3731
3732         return ret;
3733 }
3734 EXPORT_SYMBOL(serial8250_register_8250_port);
3735
3736 /**
3737  *      serial8250_unregister_port - remove a 16x50 serial port at runtime
3738  *      @line: serial line number
3739  *
3740  *      Remove one serial port.  This may not be called from interrupt
3741  *      context.  We hand the port back to the our control.
3742  */
3743 void serial8250_unregister_port(int line)
3744 {
3745         struct uart_8250_port *uart = &serial8250_ports[line];
3746
3747         mutex_lock(&serial_mutex);
3748         uart_remove_one_port(&serial8250_reg, &uart->port);
3749         if (serial8250_isa_devs) {
3750                 uart->port.flags &= ~UPF_BOOT_AUTOCONF;
3751                 uart->port.type = PORT_UNKNOWN;
3752                 uart->port.dev = &serial8250_isa_devs->dev;
3753                 uart->capabilities = uart_config[uart->port.type].flags;
3754                 uart_add_one_port(&serial8250_reg, &uart->port);
3755         } else {
3756                 uart->port.dev = NULL;
3757         }
3758         mutex_unlock(&serial_mutex);
3759 }
3760 EXPORT_SYMBOL(serial8250_unregister_port);
3761
3762 static int __init serial8250_init(void)
3763 {
3764         int ret;
3765
3766         serial8250_isa_init_ports();
3767
3768         printk(KERN_INFO "Serial: 8250/16550 driver, "
3769                 "%d ports, IRQ sharing %sabled\n", nr_uarts,
3770                 share_irqs ? "en" : "dis");
3771
3772 #ifdef CONFIG_SPARC
3773         ret = sunserial_register_minors(&serial8250_reg, UART_NR);
3774 #else
3775         serial8250_reg.nr = UART_NR;
3776         ret = uart_register_driver(&serial8250_reg);
3777 #endif
3778         if (ret)
3779                 goto out;
3780
3781         ret = serial8250_pnp_init();
3782         if (ret)
3783                 goto unreg_uart_drv;
3784
3785         serial8250_isa_devs = platform_device_alloc("serial8250",
3786                                                     PLAT8250_DEV_LEGACY);
3787         if (!serial8250_isa_devs) {
3788                 ret = -ENOMEM;
3789                 goto unreg_pnp;
3790         }
3791
3792         ret = platform_device_add(serial8250_isa_devs);
3793         if (ret)
3794                 goto put_dev;
3795
3796         serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
3797
3798         ret = platform_driver_register(&serial8250_isa_driver);
3799         if (ret == 0)
3800                 goto out;
3801
3802         platform_device_del(serial8250_isa_devs);
3803 put_dev:
3804         platform_device_put(serial8250_isa_devs);
3805 unreg_pnp:
3806         serial8250_pnp_exit();
3807 unreg_uart_drv:
3808 #ifdef CONFIG_SPARC
3809         sunserial_unregister_minors(&serial8250_reg, UART_NR);
3810 #else
3811         uart_unregister_driver(&serial8250_reg);
3812 #endif
3813 out:
3814         return ret;
3815 }
3816
3817 static void __exit serial8250_exit(void)
3818 {
3819         struct platform_device *isa_dev = serial8250_isa_devs;
3820
3821         /*
3822          * This tells serial8250_unregister_port() not to re-register
3823          * the ports (thereby making serial8250_isa_driver permanently
3824          * in use.)
3825          */
3826         serial8250_isa_devs = NULL;
3827
3828         platform_driver_unregister(&serial8250_isa_driver);
3829         platform_device_unregister(isa_dev);
3830
3831         serial8250_pnp_exit();
3832
3833 #ifdef CONFIG_SPARC
3834         sunserial_unregister_minors(&serial8250_reg, UART_NR);
3835 #else
3836         uart_unregister_driver(&serial8250_reg);
3837 #endif
3838 }
3839
3840 module_init(serial8250_init);
3841 module_exit(serial8250_exit);
3842
3843 EXPORT_SYMBOL(serial8250_suspend_port);
3844 EXPORT_SYMBOL(serial8250_resume_port);
3845
3846 MODULE_LICENSE("GPL");
3847 MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
3848
3849 module_param(share_irqs, uint, 0644);
3850 MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices"
3851         " (unsafe)");
3852
3853 module_param(nr_uarts, uint, 0644);
3854 MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
3855
3856 module_param(skip_txen_test, uint, 0644);
3857 MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
3858
3859 #ifdef CONFIG_SERIAL_8250_RSA
3860 module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444);
3861 MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
3862 #endif
3863 MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
3864
3865 #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
3866 #ifndef MODULE
3867 /* This module was renamed to 8250_core in 3.7.  Keep the old "8250" name
3868  * working as well for the module options so we don't break people.  We
3869  * need to keep the names identical and the convenient macros will happily
3870  * refuse to let us do that by failing the build with redefinition errors
3871  * of global variables.  So we stick them inside a dummy function to avoid
3872  * those conflicts.  The options still get parsed, and the redefined
3873  * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive.
3874  *
3875  * This is hacky.  I'm sorry.
3876  */
3877 static void __used s8250_options(void)
3878 {
3879 #undef MODULE_PARAM_PREFIX
3880 #define MODULE_PARAM_PREFIX "8250_core."
3881
3882         module_param_cb(share_irqs, &param_ops_uint, &share_irqs, 0644);
3883         module_param_cb(nr_uarts, &param_ops_uint, &nr_uarts, 0644);
3884         module_param_cb(skip_txen_test, &param_ops_uint, &skip_txen_test, 0644);
3885 #ifdef CONFIG_SERIAL_8250_RSA
3886         __module_param_call(MODULE_PARAM_PREFIX, probe_rsa,
3887                 &param_array_ops, .arr = &__param_arr_probe_rsa,
3888                 0444, -1, 0);
3889 #endif
3890 }
3891 #else
3892 MODULE_ALIAS("8250_core");
3893 #endif
3894 #endif