drivers/serial/8250.c

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