kernel/drivers/tty/serial/8250/8250_port.c

   1 /*
   2  *  Base port operations for 8250/16550-type serial ports
   3  *
   4  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   5  *  Split from 8250_core.c, Copyright (C) 2001 Russell King.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * A note about mapbase / membase
  13  *
  14  *  mapbase is the physical address of the IO port.
  15  *  membase is an 'ioremapped' cookie.
  16  */
  17
  18 #if defined(CONFIG_SERIAL_8250_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  19 #define SUPPORT_SYSRQ
  20 #endif
  21
  22 #include <linux/module.h>
  23 #include <linux/moduleparam.h>
  24 #include <linux/ioport.h>
  25 #include <linux/init.h>
  26 #include <linux/console.h>
  27 #include <linux/sysrq.h>
  28 #include <linux/delay.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/tty.h>
  31 #include <linux/ratelimit.h>
  32 #include <linux/tty_flip.h>
  33 #include <linux/serial.h>
  34 #include <linux/serial_8250.h>
  35 #include <linux/nmi.h>
  36 #include <linux/mutex.h>
  37 #include <linux/slab.h>
  38 #include <linux/kdb.h>
  39 #include <linux/uaccess.h>
  40 #include <linux/pm_runtime.h>
  41
  42 #include <asm/io.h>
  43 #include <asm/irq.h>
  44
  45 #include "8250.h"
  46
  47 /*
  48  * Debugging.
  49  */
  50 #if 0
  51 #define DEBUG_AUTOCONF(fmt...)  printk(fmt)
  52 #else
  53 #define DEBUG_AUTOCONF(fmt...)  do { } while (0)
  54 #endif
  55
  56 #define BOTH_EMPTY      (UART_LSR_TEMT | UART_LSR_THRE)
  57
  58 /*
  59  * Here we define the default xmit fifo size used for each type of UART.
  60  */
  61 static const struct serial8250_config uart_config[] = {
  62         [PORT_UNKNOWN] = {
  63                 .name           = "unknown",
  64                 .fifo_size      = 1,
  65                 .tx_loadsz      = 1,
  66         },
  67         [PORT_8250] = {
  68                 .name           = "8250",
  69                 .fifo_size      = 1,
  70                 .tx_loadsz      = 1,
  71         },
  72         [PORT_16450] = {
  73                 .name           = "16450",
  74                 .fifo_size      = 1,
  75                 .tx_loadsz      = 1,
  76         },
  77         [PORT_16550] = {
  78                 .name           = "16550",
  79                 .fifo_size      = 1,
  80                 .tx_loadsz      = 1,
  81         },
  82         [PORT_16550A] = {
  83                 .name           = "16550A",
  84                 .fifo_size      = 16,
  85                 .tx_loadsz      = 16,
  86                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
  87                 .rxtrig_bytes   = {1, 4, 8, 14},
  88                 .flags          = UART_CAP_FIFO,
  89         },
  90         [PORT_CIRRUS] = {
  91                 .name           = "Cirrus",
  92                 .fifo_size      = 1,
  93                 .tx_loadsz      = 1,
  94         },
  95         [PORT_16650] = {
  96                 .name           = "ST16650",
  97                 .fifo_size      = 1,
  98                 .tx_loadsz      = 1,
  99                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 100         },
 101         [PORT_16650V2] = {
 102                 .name           = "ST16650V2",
 103                 .fifo_size      = 32,
 104                 .tx_loadsz      = 16,
 105                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 106                                   UART_FCR_T_TRIG_00,
 107                 .rxtrig_bytes   = {8, 16, 24, 28},
 108                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 109         },
 110         [PORT_16750] = {
 111                 .name           = "TI16750",
 112                 .fifo_size      = 64,
 113                 .tx_loadsz      = 64,
 114                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
 115                                   UART_FCR7_64BYTE,
 116                 .rxtrig_bytes   = {1, 16, 32, 56},
 117                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP | UART_CAP_AFE,
 118         },
 119         [PORT_STARTECH] = {
 120                 .name           = "Startech",
 121                 .fifo_size      = 1,
 122                 .tx_loadsz      = 1,
 123         },
 124         [PORT_16C950] = {
 125                 .name           = "16C950/954",
 126                 .fifo_size      = 128,
 127                 .tx_loadsz      = 128,
 128                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 129                 /* UART_CAP_EFR breaks billionon CF bluetooth card. */
 130                 .flags          = UART_CAP_FIFO | UART_CAP_SLEEP,
 131         },
 132         [PORT_16654] = {
 133                 .name           = "ST16654",
 134                 .fifo_size      = 64,
 135                 .tx_loadsz      = 32,
 136                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 137                                   UART_FCR_T_TRIG_10,
 138                 .rxtrig_bytes   = {8, 16, 56, 60},
 139                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 140         },
 141         [PORT_16850] = {
 142                 .name           = "XR16850",
 143                 .fifo_size      = 128,
 144                 .tx_loadsz      = 128,
 145                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 146                 .flags          = UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 147         },
 148         [PORT_RSA] = {
 149                 .name           = "RSA",
 150                 .fifo_size      = 2048,
 151                 .tx_loadsz      = 2048,
 152                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11,
 153                 .flags          = UART_CAP_FIFO,
 154         },
 155         [PORT_NS16550A] = {
 156                 .name           = "NS16550A",
 157                 .fifo_size      = 16,
 158                 .tx_loadsz      = 16,
 159                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 160                 .flags          = UART_CAP_FIFO | UART_NATSEMI,
 161         },
 162         [PORT_XSCALE] = {
 163                 .name           = "XScale",
 164                 .fifo_size      = 32,
 165                 .tx_loadsz      = 32,
 166                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 167                 .flags          = UART_CAP_FIFO | UART_CAP_UUE | UART_CAP_RTOIE,
 168         },
 169         [PORT_OCTEON] = {
 170                 .name           = "OCTEON",
 171                 .fifo_size      = 64,
 172                 .tx_loadsz      = 64,
 173                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 174                 .flags          = UART_CAP_FIFO,
 175         },
 176         [PORT_AR7] = {
 177                 .name           = "AR7",
 178                 .fifo_size      = 16,
 179                 .tx_loadsz      = 16,
 180                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00,
 181                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 182         },
 183         [PORT_U6_16550A] = {
 184                 .name           = "U6_16550A",
 185                 .fifo_size      = 64,
 186                 .tx_loadsz      = 64,
 187                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 188                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 189         },
 190         [PORT_TEGRA] = {
 191                 .name           = "Tegra",
 192                 .fifo_size      = 32,
 193                 .tx_loadsz      = 8,
 194                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 195                                   UART_FCR_T_TRIG_01,
 196                 .rxtrig_bytes   = {1, 4, 8, 14},
 197                 .flags          = UART_CAP_FIFO | UART_CAP_RTOIE,
 198         },
 199         [PORT_XR17D15X] = {
 200                 .name           = "XR17D15X",
 201                 .fifo_size      = 64,
 202                 .tx_loadsz      = 64,
 203                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 204                 .flags          = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
 205                                   UART_CAP_SLEEP,
 206         },
 207         [PORT_XR17V35X] = {
 208                 .name           = "XR17V35X",
 209                 .fifo_size      = 256,
 210                 .tx_loadsz      = 256,
 211                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11 |
 212                                   UART_FCR_T_TRIG_11,
 213                 .flags          = UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
 214                                   UART_CAP_SLEEP,
 215         },
 216         [PORT_LPC3220] = {
 217                 .name           = "LPC3220",
 218                 .fifo_size      = 64,
 219                 .tx_loadsz      = 32,
 220                 .fcr            = UART_FCR_DMA_SELECT | UART_FCR_ENABLE_FIFO |
 221                                   UART_FCR_R_TRIG_00 | UART_FCR_T_TRIG_00,
 222                 .flags          = UART_CAP_FIFO,
 223         },
 224         [PORT_BRCM_TRUMANAGE] = {
 225                 .name           = "TruManage",
 226                 .fifo_size      = 1,
 227                 .tx_loadsz      = 1024,
 228                 .flags          = UART_CAP_HFIFO,
 229         },
 230         [PORT_8250_CIR] = {
 231                 .name           = "CIR port"
 232         },
 233         [PORT_ALTR_16550_F32] = {
 234                 .name           = "Altera 16550 FIFO32",
 235                 .fifo_size      = 32,
 236                 .tx_loadsz      = 32,
 237                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 238                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 239         },
 240         [PORT_ALTR_16550_F64] = {
 241                 .name           = "Altera 16550 FIFO64",
 242                 .fifo_size      = 64,
 243                 .tx_loadsz      = 64,
 244                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 245                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 246         },
 247         [PORT_ALTR_16550_F128] = {
 248                 .name           = "Altera 16550 FIFO128",
 249                 .fifo_size      = 128,
 250                 .tx_loadsz      = 128,
 251                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 252                 .flags          = UART_CAP_FIFO | UART_CAP_AFE,
 253         },
 254 /* tx_loadsz is set to 63-bytes instead of 64-bytes to implement
 255 workaround of errata A-008006 which states that tx_loadsz should  be
 256 configured less than Maximum supported fifo bytes */
 257         [PORT_16550A_FSL64] = {
 258                 .name           = "16550A_FSL64",
 259                 .fifo_size      = 64,
 260                 .tx_loadsz      = 63,
 261                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
 262                                   UART_FCR7_64BYTE,
 263                 .flags          = UART_CAP_FIFO,
 264         },
 265         [PORT_RT2880] = {
 266                 .name           = "Palmchip BK-3103",
 267                 .fifo_size      = 16,
 268                 .tx_loadsz      = 16,
 269                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 270                 .rxtrig_bytes   = {1, 4, 8, 14},
 271                 .flags          = UART_CAP_FIFO,
 272         },
 273 };
 274
 275 /* Uart divisor latch read */
 276 static int default_serial_dl_read(struct uart_8250_port *up)
 277 {
 278         return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8;
 279 }
 280
 281 /* Uart divisor latch write */
 282 static void default_serial_dl_write(struct uart_8250_port *up, int value)
 283 {
 284         serial_out(up, UART_DLL, value & 0xff);
 285         serial_out(up, UART_DLM, value >> 8 & 0xff);
 286 }
 287
 288 #ifdef CONFIG_SERIAL_8250_RT288X
 289
 290 /* Au1x00/RT288x UART hardware has a weird register layout */
 291 static const s8 au_io_in_map[8] = {
 292          0,     /* UART_RX  */
 293          2,     /* UART_IER */
 294          3,     /* UART_IIR */
 295          5,     /* UART_LCR */
 296          6,     /* UART_MCR */
 297          7,     /* UART_LSR */
 298          8,     /* UART_MSR */
 299         -1,     /* UART_SCR (unmapped) */
 300 };
 301
 302 static const s8 au_io_out_map[8] = {
 303          1,     /* UART_TX  */
 304          2,     /* UART_IER */
 305          4,     /* UART_FCR */
 306          5,     /* UART_LCR */
 307          6,     /* UART_MCR */
 308         -1,     /* UART_LSR (unmapped) */
 309         -1,     /* UART_MSR (unmapped) */
 310         -1,     /* UART_SCR (unmapped) */
 311 };
 312
 313 static unsigned int au_serial_in(struct uart_port *p, int offset)
 314 {
 315         if (offset >= ARRAY_SIZE(au_io_in_map))
 316                 return UINT_MAX;
 317         offset = au_io_in_map[offset];
 318         if (offset < 0)
 319                 return UINT_MAX;
 320         return __raw_readl(p->membase + (offset << p->regshift));
 321 }
 322
 323 static void au_serial_out(struct uart_port *p, int offset, int value)
 324 {
 325         if (offset >= ARRAY_SIZE(au_io_out_map))
 326                 return;
 327         offset = au_io_out_map[offset];
 328         if (offset < 0)
 329                 return;
 330         __raw_writel(value, p->membase + (offset << p->regshift));
 331 }
 332
 333 /* Au1x00 haven't got a standard divisor latch */
 334 static int au_serial_dl_read(struct uart_8250_port *up)
 335 {
 336         return __raw_readl(up->port.membase + 0x28);
 337 }
 338
 339 static void au_serial_dl_write(struct uart_8250_port *up, int value)
 340 {
 341         __raw_writel(value, up->port.membase + 0x28);
 342 }
 343
 344 #endif
 345
 346 static unsigned int hub6_serial_in(struct uart_port *p, int offset)
 347 {
 348         offset = offset << p->regshift;
 349         outb(p->hub6 - 1 + offset, p->iobase);
 350         return inb(p->iobase + 1);
 351 }
 352
 353 static void hub6_serial_out(struct uart_port *p, int offset, int value)
 354 {
 355         offset = offset << p->regshift;
 356         outb(p->hub6 - 1 + offset, p->iobase);
 357         outb(value, p->iobase + 1);
 358 }
 359
 360 static unsigned int mem_serial_in(struct uart_port *p, int offset)
 361 {
 362         offset = offset << p->regshift;
 363         return readb(p->membase + offset);
 364 }
 365
 366 static void mem_serial_out(struct uart_port *p, int offset, int value)
 367 {
 368         offset = offset << p->regshift;
 369         writeb(value, p->membase + offset);
 370 }
 371
 372 static void mem32_serial_out(struct uart_port *p, int offset, int value)
 373 {
 374         offset = offset << p->regshift;
 375         writel(value, p->membase + offset);
 376 }
 377
 378 static unsigned int mem32_serial_in(struct uart_port *p, int offset)
 379 {
 380         offset = offset << p->regshift;
 381         return readl(p->membase + offset);
 382 }
 383
 384 static void mem32be_serial_out(struct uart_port *p, int offset, int value)
 385 {
 386         offset = offset << p->regshift;
 387         iowrite32be(value, p->membase + offset);
 388 }
 389
 390 static unsigned int mem32be_serial_in(struct uart_port *p, int offset)
 391 {
 392         offset = offset << p->regshift;
 393         return ioread32be(p->membase + offset);
 394 }
 395
 396 static unsigned int io_serial_in(struct uart_port *p, int offset)
 397 {
 398         offset = offset << p->regshift;
 399         return inb(p->iobase + offset);
 400 }
 401
 402 static void io_serial_out(struct uart_port *p, int offset, int value)
 403 {
 404         offset = offset << p->regshift;
 405         outb(value, p->iobase + offset);
 406 }
 407
 408 static int serial8250_default_handle_irq(struct uart_port *port);
 409 static int exar_handle_irq(struct uart_port *port);
 410
 411 static void set_io_from_upio(struct uart_port *p)
 412 {
 413         struct uart_8250_port *up = up_to_u8250p(p);
 414
 415         up->dl_read = default_serial_dl_read;
 416         up->dl_write = default_serial_dl_write;
 417
 418         switch (p->iotype) {
 419         case UPIO_HUB6:
 420                 p->serial_in = hub6_serial_in;
 421                 p->serial_out = hub6_serial_out;
 422                 break;
 423
 424         case UPIO_MEM:
 425                 p->serial_in = mem_serial_in;
 426                 p->serial_out = mem_serial_out;
 427                 break;
 428
 429         case UPIO_MEM32:
 430                 p->serial_in = mem32_serial_in;
 431                 p->serial_out = mem32_serial_out;
 432                 break;
 433
 434         case UPIO_MEM32BE:
 435                 p->serial_in = mem32be_serial_in;
 436                 p->serial_out = mem32be_serial_out;
 437                 break;
 438
 439 #ifdef CONFIG_SERIAL_8250_RT288X
 440         case UPIO_AU:
 441                 p->serial_in = au_serial_in;
 442                 p->serial_out = au_serial_out;
 443                 up->dl_read = au_serial_dl_read;
 444                 up->dl_write = au_serial_dl_write;
 445                 break;
 446 #endif
 447
 448         default:
 449                 p->serial_in = io_serial_in;
 450                 p->serial_out = io_serial_out;
 451                 break;
 452         }
 453         /* Remember loaded iotype */
 454         up->cur_iotype = p->iotype;
 455         p->handle_irq = serial8250_default_handle_irq;
 456 }
 457
 458 static void
 459 serial_port_out_sync(struct uart_port *p, int offset, int value)
 460 {
 461         switch (p->iotype) {
 462         case UPIO_MEM:
 463         case UPIO_MEM32:
 464         case UPIO_MEM32BE:
 465         case UPIO_AU:
 466                 p->serial_out(p, offset, value);
 467                 p->serial_in(p, UART_LCR);      /* safe, no side-effects */
 468                 break;
 469         default:
 470                 p->serial_out(p, offset, value);
 471         }
 472 }
 473
 474 /*
 475  * For the 16C950
 476  */
 477 static void serial_icr_write(struct uart_8250_port *up, int offset, int value)
 478 {
 479         serial_out(up, UART_SCR, offset);
 480         serial_out(up, UART_ICR, value);
 481 }
 482
 483 static unsigned int serial_icr_read(struct uart_8250_port *up, int offset)
 484 {
 485         unsigned int value;
 486
 487         serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
 488         serial_out(up, UART_SCR, offset);
 489         value = serial_in(up, UART_ICR);
 490         serial_icr_write(up, UART_ACR, up->acr);
 491
 492         return value;
 493 }
 494
 495 /*
 496  * FIFO support.
 497  */
 498 static void serial8250_clear_fifos(struct uart_8250_port *p)
 499 {
 500         if (p->capabilities & UART_CAP_FIFO) {
 501                 serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO);
 502                 serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO |
 503                                UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 504                 serial_out(p, UART_FCR, 0);
 505         }
 506 }
 507
 508 void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p)
 509 {
 510         serial8250_clear_fifos(p);
 511         serial_out(p, UART_FCR, p->fcr);
 512 }
 513 EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos);
 514
 515 void serial8250_rpm_get(struct uart_8250_port *p)
 516 {
 517         if (!(p->capabilities & UART_CAP_RPM))
 518                 return;
 519         pm_runtime_get_sync(p->port.dev);
 520 }
 521 EXPORT_SYMBOL_GPL(serial8250_rpm_get);
 522
 523 void serial8250_rpm_put(struct uart_8250_port *p)
 524 {
 525         if (!(p->capabilities & UART_CAP_RPM))
 526                 return;
 527         pm_runtime_mark_last_busy(p->port.dev);
 528         pm_runtime_put_autosuspend(p->port.dev);
 529 }
 530 EXPORT_SYMBOL_GPL(serial8250_rpm_put);
 531
 532 /*
 533  * These two wrappers ensure that enable_runtime_pm_tx() can be called more than
 534  * once and disable_runtime_pm_tx() will still disable RPM because the fifo is
 535  * empty and the HW can idle again.
 536  */
 537 static void serial8250_rpm_get_tx(struct uart_8250_port *p)
 538 {
 539         unsigned char rpm_active;
 540
 541         if (!(p->capabilities & UART_CAP_RPM))
 542                 return;
 543
 544         rpm_active = xchg(&p->rpm_tx_active, 1);
 545         if (rpm_active)
 546                 return;
 547         pm_runtime_get_sync(p->port.dev);
 548 }
 549
 550 static void serial8250_rpm_put_tx(struct uart_8250_port *p)
 551 {
 552         unsigned char rpm_active;
 553
 554         if (!(p->capabilities & UART_CAP_RPM))
 555                 return;
 556
 557         rpm_active = xchg(&p->rpm_tx_active, 0);
 558         if (!rpm_active)
 559                 return;
 560         pm_runtime_mark_last_busy(p->port.dev);
 561         pm_runtime_put_autosuspend(p->port.dev);
 562 }
 563
 564 /*
 565  * IER sleep support.  UARTs which have EFRs need the "extended
 566  * capability" bit enabled.  Note that on XR16C850s, we need to
 567  * reset LCR to write to IER.
 568  */
 569 static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
 570 {
 571         unsigned char lcr = 0, efr = 0;
 572         /*
 573          * Exar UARTs have a SLEEP register that enables or disables
 574          * each UART to enter sleep mode separately.  On the XR17V35x the
 575          * register is accessible to each UART at the UART_EXAR_SLEEP
 576          * offset but the UART channel may only write to the corresponding
 577          * bit.
 578          */
 579         serial8250_rpm_get(p);
 580         if ((p->port.type == PORT_XR17V35X) ||
 581            (p->port.type == PORT_XR17D15X)) {
 582                 serial_out(p, UART_EXAR_SLEEP, sleep ? 0xff : 0);
 583                 goto out;
 584         }
 585
 586         if (p->capabilities & UART_CAP_SLEEP) {
 587                 if (p->capabilities & UART_CAP_EFR) {
 588                         lcr = serial_in(p, UART_LCR);
 589                         efr = serial_in(p, UART_EFR);
 590                         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
 591                         serial_out(p, UART_EFR, UART_EFR_ECB);
 592                         serial_out(p, UART_LCR, 0);
 593                 }
 594                 serial_out(p, UART_IER, sleep ? UART_IERX_SLEEP : 0);
 595                 if (p->capabilities & UART_CAP_EFR) {
 596                         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
 597                         serial_out(p, UART_EFR, efr);
 598                         serial_out(p, UART_LCR, lcr);
 599                 }
 600         }
 601 out:
 602         serial8250_rpm_put(p);
 603 }
 604
 605 #ifdef CONFIG_SERIAL_8250_RSA
 606 /*
 607  * Attempts to turn on the RSA FIFO.  Returns zero on failure.
 608  * We set the port uart clock rate if we succeed.
 609  */
 610 static int __enable_rsa(struct uart_8250_port *up)
 611 {
 612         unsigned char mode;
 613         int result;
 614
 615         mode = serial_in(up, UART_RSA_MSR);
 616         result = mode & UART_RSA_MSR_FIFO;
 617
 618         if (!result) {
 619                 serial_out(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
 620                 mode = serial_in(up, UART_RSA_MSR);
 621                 result = mode & UART_RSA_MSR_FIFO;
 622         }
 623
 624         if (result)
 625                 up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
 626
 627         return result;
 628 }
 629
 630 static void enable_rsa(struct uart_8250_port *up)
 631 {
 632         if (up->port.type == PORT_RSA) {
 633                 if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
 634                         spin_lock_irq(&up->port.lock);
 635                         __enable_rsa(up);
 636                         spin_unlock_irq(&up->port.lock);
 637                 }
 638                 if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
 639                         serial_out(up, UART_RSA_FRR, 0);
 640         }
 641 }
 642
 643 /*
 644  * Attempts to turn off the RSA FIFO.  Returns zero on failure.
 645  * It is unknown why interrupts were disabled in here.  However,
 646  * the caller is expected to preserve this behaviour by grabbing
 647  * the spinlock before calling this function.
 648  */
 649 static void disable_rsa(struct uart_8250_port *up)
 650 {
 651         unsigned char mode;
 652         int result;
 653
 654         if (up->port.type == PORT_RSA &&
 655             up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
 656                 spin_lock_irq(&up->port.lock);
 657
 658                 mode = serial_in(up, UART_RSA_MSR);
 659                 result = !(mode & UART_RSA_MSR_FIFO);
 660
 661                 if (!result) {
 662                         serial_out(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
 663                         mode = serial_in(up, UART_RSA_MSR);
 664                         result = !(mode & UART_RSA_MSR_FIFO);
 665                 }
 666
 667                 if (result)
 668                         up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
 669                 spin_unlock_irq(&up->port.lock);
 670         }
 671 }
 672 #endif /* CONFIG_SERIAL_8250_RSA */
 673
 674 /*
 675  * This is a quickie test to see how big the FIFO is.
 676  * It doesn't work at all the time, more's the pity.
 677  */
 678 static int size_fifo(struct uart_8250_port *up)
 679 {
 680         unsigned char old_fcr, old_mcr, old_lcr;
 681         unsigned short old_dl;
 682         int count;
 683
 684         old_lcr = serial_in(up, UART_LCR);
 685         serial_out(up, UART_LCR, 0);
 686         old_fcr = serial_in(up, UART_FCR);
 687         old_mcr = serial_in(up, UART_MCR);
 688         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 689                     UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 690         serial_out(up, UART_MCR, UART_MCR_LOOP);
 691         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 692         old_dl = serial_dl_read(up);
 693         serial_dl_write(up, 0x0001);
 694         serial_out(up, UART_LCR, 0x03);
 695         for (count = 0; count < 256; count++)
 696                 serial_out(up, UART_TX, count);
 697         mdelay(20);/* FIXME - schedule_timeout */
 698         for (count = 0; (serial_in(up, UART_LSR) & UART_LSR_DR) &&
 699              (count < 256); count++)
 700                 serial_in(up, UART_RX);
 701         serial_out(up, UART_FCR, old_fcr);
 702         serial_out(up, UART_MCR, old_mcr);
 703         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 704         serial_dl_write(up, old_dl);
 705         serial_out(up, UART_LCR, old_lcr);
 706
 707         return count;
 708 }
 709
 710 /*
 711  * Read UART ID using the divisor method - set DLL and DLM to zero
 712  * and the revision will be in DLL and device type in DLM.  We
 713  * preserve the device state across this.
 714  */
 715 static unsigned int autoconfig_read_divisor_id(struct uart_8250_port *p)
 716 {
 717         unsigned char old_dll, old_dlm, old_lcr;
 718         unsigned int id;
 719
 720         old_lcr = serial_in(p, UART_LCR);
 721         serial_out(p, UART_LCR, UART_LCR_CONF_MODE_A);
 722
 723         old_dll = serial_in(p, UART_DLL);
 724         old_dlm = serial_in(p, UART_DLM);
 725
 726         serial_out(p, UART_DLL, 0);
 727         serial_out(p, UART_DLM, 0);
 728
 729         id = serial_in(p, UART_DLL) | serial_in(p, UART_DLM) << 8;
 730
 731         serial_out(p, UART_DLL, old_dll);
 732         serial_out(p, UART_DLM, old_dlm);
 733         serial_out(p, UART_LCR, old_lcr);
 734
 735         return id;
 736 }
 737
 738 /*
 739  * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's.
 740  * When this function is called we know it is at least a StarTech
 741  * 16650 V2, but it might be one of several StarTech UARTs, or one of
 742  * its clones.  (We treat the broken original StarTech 16650 V1 as a
 743  * 16550, and why not?  Startech doesn't seem to even acknowledge its
 744  * existence.)
 745  *
 746  * What evil have men's minds wrought...
 747  */
 748 static void autoconfig_has_efr(struct uart_8250_port *up)
 749 {
 750         unsigned int id1, id2, id3, rev;
 751
 752         /*
 753          * Everything with an EFR has SLEEP
 754          */
 755         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
 756
 757         /*
 758          * First we check to see if it's an Oxford Semiconductor UART.
 759          *
 760          * If we have to do this here because some non-National
 761          * Semiconductor clone chips lock up if you try writing to the
 762          * LSR register (which serial_icr_read does)
 763          */
 764
 765         /*
 766          * Check for Oxford Semiconductor 16C950.
 767          *
 768          * EFR [4] must be set else this test fails.
 769          *
 770          * This shouldn't be necessary, but Mike Hudson (Exoray@isys.ca)
 771          * claims that it's needed for 952 dual UART's (which are not
 772          * recommended for new designs).
 773          */
 774         up->acr = 0;
 775         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 776         serial_out(up, UART_EFR, UART_EFR_ECB);
 777         serial_out(up, UART_LCR, 0x00);
 778         id1 = serial_icr_read(up, UART_ID1);
 779         id2 = serial_icr_read(up, UART_ID2);
 780         id3 = serial_icr_read(up, UART_ID3);
 781         rev = serial_icr_read(up, UART_REV);
 782
 783         DEBUG_AUTOCONF("950id=%02x:%02x:%02x:%02x ", id1, id2, id3, rev);
 784
 785         if (id1 == 0x16 && id2 == 0xC9 &&
 786             (id3 == 0x50 || id3 == 0x52 || id3 == 0x54)) {
 787                 up->port.type = PORT_16C950;
 788
 789                 /*
 790                  * Enable work around for the Oxford Semiconductor 952 rev B
 791                  * chip which causes it to seriously miscalculate baud rates
 792                  * when DLL is 0.
 793                  */
 794                 if (id3 == 0x52 && rev == 0x01)
 795                         up->bugs |= UART_BUG_QUOT;
 796                 return;
 797         }
 798
 799         /*
 800          * We check for a XR16C850 by setting DLL and DLM to 0, and then
 801          * reading back DLL and DLM.  The chip type depends on the DLM
 802          * value read back:
 803          *  0x10 - XR16C850 and the DLL contains the chip revision.
 804          *  0x12 - XR16C2850.
 805          *  0x14 - XR16C854.
 806          */
 807         id1 = autoconfig_read_divisor_id(up);
 808         DEBUG_AUTOCONF("850id=%04x ", id1);
 809
 810         id2 = id1 >> 8;
 811         if (id2 == 0x10 || id2 == 0x12 || id2 == 0x14) {
 812                 up->port.type = PORT_16850;
 813                 return;
 814         }
 815
 816         /*
 817          * It wasn't an XR16C850.
 818          *
 819          * We distinguish between the '654 and the '650 by counting
 820          * how many bytes are in the FIFO.  I'm using this for now,
 821          * since that's the technique that was sent to me in the
 822          * serial driver update, but I'm not convinced this works.
 823          * I've had problems doing this in the past.  -TYT
 824          */
 825         if (size_fifo(up) == 64)
 826                 up->port.type = PORT_16654;
 827         else
 828                 up->port.type = PORT_16650V2;
 829 }
 830
 831 /*
 832  * We detected a chip without a FIFO.  Only two fall into
 833  * this category - the original 8250 and the 16450.  The
 834  * 16450 has a scratch register (accessible with LCR=0)
 835  */
 836 static void autoconfig_8250(struct uart_8250_port *up)
 837 {
 838         unsigned char scratch, status1, status2;
 839
 840         up->port.type = PORT_8250;
 841
 842         scratch = serial_in(up, UART_SCR);
 843         serial_out(up, UART_SCR, 0xa5);
 844         status1 = serial_in(up, UART_SCR);
 845         serial_out(up, UART_SCR, 0x5a);
 846         status2 = serial_in(up, UART_SCR);
 847         serial_out(up, UART_SCR, scratch);
 848
 849         if (status1 == 0xa5 && status2 == 0x5a)
 850                 up->port.type = PORT_16450;
 851 }
 852
 853 static int broken_efr(struct uart_8250_port *up)
 854 {
 855         /*
 856          * Exar ST16C2550 "A2" devices incorrectly detect as
 857          * having an EFR, and report an ID of 0x0201.  See
 858          * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html
 859          */
 860         if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16)
 861                 return 1;
 862
 863         return 0;
 864 }
 865
 866 /*
 867  * We know that the chip has FIFOs.  Does it have an EFR?  The
 868  * EFR is located in the same register position as the IIR and
 869  * we know the top two bits of the IIR are currently set.  The
 870  * EFR should contain zero.  Try to read the EFR.
 871  */
 872 static void autoconfig_16550a(struct uart_8250_port *up)
 873 {
 874         unsigned char status1, status2;
 875         unsigned int iersave;
 876
 877         up->port.type = PORT_16550A;
 878         up->capabilities |= UART_CAP_FIFO;
 879
 880         /*
 881          * XR17V35x UARTs have an extra divisor register, DLD
 882          * that gets enabled with when DLAB is set which will
 883          * cause the device to incorrectly match and assign
 884          * port type to PORT_16650.  The EFR for this UART is
 885          * found at offset 0x09. Instead check the Deice ID (DVID)
 886          * register for a 2, 4 or 8 port UART.
 887          */
 888         if (up->port.flags & UPF_EXAR_EFR) {
 889                 status1 = serial_in(up, UART_EXAR_DVID);
 890                 if (status1 == 0x82 || status1 == 0x84 || status1 == 0x88) {
 891                         DEBUG_AUTOCONF("Exar XR17V35x ");
 892                         up->port.type = PORT_XR17V35X;
 893                         up->capabilities |= UART_CAP_AFE | UART_CAP_EFR |
 894                                                 UART_CAP_SLEEP;
 895
 896                         return;
 897                 }
 898
 899         }
 900
 901         /*
 902          * Check for presence of the EFR when DLAB is set.
 903          * Only ST16C650V1 UARTs pass this test.
 904          */
 905         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 906         if (serial_in(up, UART_EFR) == 0) {
 907                 serial_out(up, UART_EFR, 0xA8);
 908                 if (serial_in(up, UART_EFR) != 0) {
 909                         DEBUG_AUTOCONF("EFRv1 ");
 910                         up->port.type = PORT_16650;
 911                         up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
 912                 } else {
 913                         serial_out(up, UART_LCR, 0);
 914                         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 915                                    UART_FCR7_64BYTE);
 916                         status1 = serial_in(up, UART_IIR) >> 5;
 917                         serial_out(up, UART_FCR, 0);
 918                         serial_out(up, UART_LCR, 0);
 919
 920                         if (status1 == 7)
 921                                 up->port.type = PORT_16550A_FSL64;
 922                         else
 923                                 DEBUG_AUTOCONF("Motorola 8xxx DUART ");
 924                 }
 925                 serial_out(up, UART_EFR, 0);
 926                 return;
 927         }
 928
 929         /*
 930          * Maybe it requires 0xbf to be written to the LCR.
 931          * (other ST16C650V2 UARTs, TI16C752A, etc)
 932          */
 933         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 934         if (serial_in(up, UART_EFR) == 0 && !broken_efr(up)) {
 935                 DEBUG_AUTOCONF("EFRv2 ");
 936                 autoconfig_has_efr(up);
 937                 return;
 938         }
 939
 940         /*
 941          * Check for a National Semiconductor SuperIO chip.
 942          * Attempt to switch to bank 2, read the value of the LOOP bit
 943          * from EXCR1. Switch back to bank 0, change it in MCR. Then
 944          * switch back to bank 2, read it from EXCR1 again and check
 945          * it's changed. If so, set baud_base in EXCR2 to 921600. -- dwmw2
 946          */
 947         serial_out(up, UART_LCR, 0);
 948         status1 = serial_in(up, UART_MCR);
 949         serial_out(up, UART_LCR, 0xE0);
 950         status2 = serial_in(up, 0x02); /* EXCR1 */
 951
 952         if (!((status2 ^ status1) & UART_MCR_LOOP)) {
 953                 serial_out(up, UART_LCR, 0);
 954                 serial_out(up, UART_MCR, status1 ^ UART_MCR_LOOP);
 955                 serial_out(up, UART_LCR, 0xE0);
 956                 status2 = serial_in(up, 0x02); /* EXCR1 */
 957                 serial_out(up, UART_LCR, 0);
 958                 serial_out(up, UART_MCR, status1);
 959
 960                 if ((status2 ^ status1) & UART_MCR_LOOP) {
 961                         unsigned short quot;
 962
 963                         serial_out(up, UART_LCR, 0xE0);
 964
 965                         quot = serial_dl_read(up);
 966                         quot <<= 3;
 967
 968                         if (ns16550a_goto_highspeed(up))
 969                                 serial_dl_write(up, quot);
 970
 971                         serial_out(up, UART_LCR, 0);
 972
 973                         up->port.uartclk = 921600*16;
 974                         up->port.type = PORT_NS16550A;
 975                         up->capabilities |= UART_NATSEMI;
 976                         return;
 977                 }
 978         }
 979
 980         /*
 981          * No EFR.  Try to detect a TI16750, which only sets bit 5 of
 982          * the IIR when 64 byte FIFO mode is enabled when DLAB is set.
 983          * Try setting it with and without DLAB set.  Cheap clones
 984          * set bit 5 without DLAB set.
 985          */
 986         serial_out(up, UART_LCR, 0);
 987         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
 988         status1 = serial_in(up, UART_IIR) >> 5;
 989         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 990         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 991         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
 992         status2 = serial_in(up, UART_IIR) >> 5;
 993         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 994         serial_out(up, UART_LCR, 0);
 995
 996         DEBUG_AUTOCONF("iir1=%d iir2=%d ", status1, status2);
 997
 998         if (status1 == 6 && status2 == 7) {
 999                 up->port.type = PORT_16750;
1000                 up->capabilities |= UART_CAP_AFE | UART_CAP_SLEEP;
1001                 return;
1002         }
1003
1004         /*
1005          * Try writing and reading the UART_IER_UUE bit (b6).
1006          * If it works, this is probably one of the Xscale platform's
1007          * internal UARTs.
1008          * We're going to explicitly set the UUE bit to 0 before
1009          * trying to write and read a 1 just to make sure it's not
1010          * already a 1 and maybe locked there before we even start start.
1011          */
1012         iersave = serial_in(up, UART_IER);
1013         serial_out(up, UART_IER, iersave & ~UART_IER_UUE);
1014         if (!(serial_in(up, UART_IER) & UART_IER_UUE)) {
1015                 /*
1016                  * OK it's in a known zero state, try writing and reading
1017                  * without disturbing the current state of the other bits.
1018                  */
1019                 serial_out(up, UART_IER, iersave | UART_IER_UUE);
1020                 if (serial_in(up, UART_IER) & UART_IER_UUE) {
1021                         /*
1022                          * It's an Xscale.
1023                          * We'll leave the UART_IER_UUE bit set to 1 (enabled).
1024                          */
1025                         DEBUG_AUTOCONF("Xscale ");
1026                         up->port.type = PORT_XSCALE;
1027                         up->capabilities |= UART_CAP_UUE | UART_CAP_RTOIE;
1028                         return;
1029                 }
1030         } else {
1031                 /*
1032                  * If we got here we couldn't force the IER_UUE bit to 0.
1033                  * Log it and continue.
1034                  */
1035                 DEBUG_AUTOCONF("Couldn't force IER_UUE to 0 ");
1036         }
1037         serial_out(up, UART_IER, iersave);
1038
1039         /*
1040          * Exar uarts have EFR in a weird location
1041          */
1042         if (up->port.flags & UPF_EXAR_EFR) {
1043                 DEBUG_AUTOCONF("Exar XR17D15x ");
1044                 up->port.type = PORT_XR17D15X;
1045                 up->capabilities |= UART_CAP_AFE | UART_CAP_EFR |
1046                                     UART_CAP_SLEEP;
1047
1048                 return;
1049         }
1050
1051         /*
1052          * We distinguish between 16550A and U6 16550A by counting
1053          * how many bytes are in the FIFO.
1054          */
1055         if (up->port.type == PORT_16550A && size_fifo(up) == 64) {
1056                 up->port.type = PORT_U6_16550A;
1057                 up->capabilities |= UART_CAP_AFE;
1058         }
1059 }
1060
1061 /*
1062  * This routine is called by rs_init() to initialize a specific serial
1063  * port.  It determines what type of UART chip this serial port is
1064  * using: 8250, 16450, 16550, 16550A.  The important question is
1065  * whether or not this UART is a 16550A or not, since this will
1066  * determine whether or not we can use its FIFO features or not.
1067  */
1068 static void autoconfig(struct uart_8250_port *up)
1069 {
1070         unsigned char status1, scratch, scratch2, scratch3;
1071         unsigned char save_lcr, save_mcr;
1072         struct uart_port *port = &up->port;
1073         unsigned long flags;
1074         unsigned int old_capabilities;
1075
1076         if (!port->iobase && !port->mapbase && !port->membase)
1077                 return;
1078
1079         DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04lx, 0x%p): ",
1080                        serial_index(port), port->iobase, port->membase);
1081
1082         /*
1083          * We really do need global IRQs disabled here - we're going to
1084          * be frobbing the chips IRQ enable register to see if it exists.
1085          */
1086         spin_lock_irqsave(&port->lock, flags);
1087
1088         up->capabilities = 0;
1089         up->bugs = 0;
1090
1091         if (!(port->flags & UPF_BUGGY_UART)) {
1092                 /*
1093                  * Do a simple existence test first; if we fail this,
1094                  * there's no point trying anything else.
1095                  *
1096                  * 0x80 is used as a nonsense port to prevent against
1097                  * false positives due to ISA bus float.  The
1098                  * assumption is that 0x80 is a non-existent port;
1099                  * which should be safe since include/asm/io.h also
1100                  * makes this assumption.
1101                  *
1102                  * Note: this is safe as long as MCR bit 4 is clear
1103                  * and the device is in "PC" mode.
1104                  */
1105                 scratch = serial_in(up, UART_IER);
1106                 serial_out(up, UART_IER, 0);
1107 #ifdef __i386__
1108                 outb(0xff, 0x080);
1109 #endif
1110                 /*
1111                  * Mask out IER[7:4] bits for test as some UARTs (e.g. TL
1112                  * 16C754B) allow only to modify them if an EFR bit is set.
1113                  */
1114                 scratch2 = serial_in(up, UART_IER) & 0x0f;
1115                 serial_out(up, UART_IER, 0x0F);
1116 #ifdef __i386__
1117                 outb(0, 0x080);
1118 #endif
1119                 scratch3 = serial_in(up, UART_IER) & 0x0f;
1120                 serial_out(up, UART_IER, scratch);
1121                 if (scratch2 != 0 || scratch3 != 0x0F) {
1122                         /*
1123                          * We failed; there's nothing here
1124                          */
1125                         spin_unlock_irqrestore(&port->lock, flags);
1126                         DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
1127                                        scratch2, scratch3);
1128                         goto out;
1129                 }
1130         }
1131
1132         save_mcr = serial_in(up, UART_MCR);
1133         save_lcr = serial_in(up, UART_LCR);
1134
1135         /*
1136          * Check to see if a UART is really there.  Certain broken
1137          * internal modems based on the Rockwell chipset fail this
1138          * test, because they apparently don't implement the loopback
1139          * test mode.  So this test is skipped on the COM 1 through
1140          * COM 4 ports.  This *should* be safe, since no board
1141          * manufacturer would be stupid enough to design a board
1142          * that conflicts with COM 1-4 --- we hope!
1143          */
1144         if (!(port->flags & UPF_SKIP_TEST)) {
1145                 serial_out(up, UART_MCR, UART_MCR_LOOP | 0x0A);
1146                 status1 = serial_in(up, UART_MSR) & 0xF0;
1147                 serial_out(up, UART_MCR, save_mcr);
1148                 if (status1 != 0x90) {
1149                         spin_unlock_irqrestore(&port->lock, flags);
1150                         DEBUG_AUTOCONF("LOOP test failed (%02x) ",
1151                                        status1);
1152                         goto out;
1153                 }
1154         }
1155
1156         /*
1157          * We're pretty sure there's a port here.  Lets find out what
1158          * type of port it is.  The IIR top two bits allows us to find
1159          * out if it's 8250 or 16450, 16550, 16550A or later.  This
1160          * determines what we test for next.
1161          *
1162          * We also initialise the EFR (if any) to zero for later.  The
1163          * EFR occupies the same register location as the FCR and IIR.
1164          */
1165         serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1166         serial_out(up, UART_EFR, 0);
1167         serial_out(up, UART_LCR, 0);
1168
1169         serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
1170         scratch = serial_in(up, UART_IIR) >> 6;
1171
1172         switch (scratch) {
1173         case 0:
1174                 autoconfig_8250(up);
1175                 break;
1176         case 1:
1177                 port->type = PORT_UNKNOWN;
1178                 break;
1179         case 2:
1180                 port->type = PORT_16550;
1181                 break;
1182         case 3:
1183                 autoconfig_16550a(up);
1184                 break;
1185         }
1186
1187 #ifdef CONFIG_SERIAL_8250_RSA
1188         /*
1189          * Only probe for RSA ports if we got the region.
1190          */
1191         if (port->type == PORT_16550A && up->probe & UART_PROBE_RSA &&
1192             __enable_rsa(up))
1193                 port->type = PORT_RSA;
1194 #endif
1195
1196         serial_out(up, UART_LCR, save_lcr);
1197
1198         port->fifosize = uart_config[up->port.type].fifo_size;
1199         old_capabilities = up->capabilities;
1200         up->capabilities = uart_config[port->type].flags;
1201         up->tx_loadsz = uart_config[port->type].tx_loadsz;
1202
1203         if (port->type == PORT_UNKNOWN)
1204                 goto out_lock;
1205
1206         /*
1207          * Reset the UART.
1208          */
1209 #ifdef CONFIG_SERIAL_8250_RSA
1210         if (port->type == PORT_RSA)
1211                 serial_out(up, UART_RSA_FRR, 0);
1212 #endif
1213         serial_out(up, UART_MCR, save_mcr);
1214         serial8250_clear_fifos(up);
1215         serial_in(up, UART_RX);
1216         if (up->capabilities & UART_CAP_UUE)
1217                 serial_out(up, UART_IER, UART_IER_UUE);
1218         else
1219                 serial_out(up, UART_IER, 0);
1220
1221 out_lock:
1222         spin_unlock_irqrestore(&port->lock, flags);
1223         if (up->capabilities != old_capabilities) {
1224                 printk(KERN_WARNING
1225                        "ttyS%d: detected caps %08x should be %08x\n",
1226                        serial_index(port), old_capabilities,
1227                        up->capabilities);
1228         }
1229 out:
1230         DEBUG_AUTOCONF("iir=%d ", scratch);
1231         DEBUG_AUTOCONF("type=%s\n", uart_config[port->type].name);
1232 }
1233
1234 static void autoconfig_irq(struct uart_8250_port *up)
1235 {
1236         struct uart_port *port = &up->port;
1237         unsigned char save_mcr, save_ier;
1238         unsigned char save_ICP = 0;
1239         unsigned int ICP = 0;
1240         unsigned long irqs;
1241         int irq;
1242
1243         if (port->flags & UPF_FOURPORT) {
1244                 ICP = (port->iobase & 0xfe0) | 0x1f;
1245                 save_ICP = inb_p(ICP);
1246                 outb_p(0x80, ICP);
1247                 inb_p(ICP);
1248         }
1249
1250         if (uart_console(port))
1251                 console_lock();
1252
1253         /* forget possible initially masked and pending IRQ */
1254         probe_irq_off(probe_irq_on());
1255         save_mcr = serial_in(up, UART_MCR);
1256         save_ier = serial_in(up, UART_IER);
1257         serial_out(up, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2);
1258
1259         irqs = probe_irq_on();
1260         serial_out(up, UART_MCR, 0);
1261         udelay(10);
1262         if (port->flags & UPF_FOURPORT) {
1263                 serial_out(up, UART_MCR,
1264                             UART_MCR_DTR | UART_MCR_RTS);
1265         } else {
1266                 serial_out(up, UART_MCR,
1267                             UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
1268         }
1269         serial_out(up, UART_IER, 0x0f); /* enable all intrs */
1270         serial_in(up, UART_LSR);
1271         serial_in(up, UART_RX);
1272         serial_in(up, UART_IIR);
1273         serial_in(up, UART_MSR);
1274         serial_out(up, UART_TX, 0xFF);
1275         udelay(20);
1276         irq = probe_irq_off(irqs);
1277
1278         serial_out(up, UART_MCR, save_mcr);
1279         serial_out(up, UART_IER, save_ier);
1280
1281         if (port->flags & UPF_FOURPORT)
1282                 outb_p(save_ICP, ICP);
1283
1284         if (uart_console(port))
1285                 console_unlock();
1286
1287         port->irq = (irq > 0) ? irq : 0;
1288 }
1289
1290 static inline void __stop_tx(struct uart_8250_port *p)
1291 {
1292         if (p->ier & UART_IER_THRI) {
1293                 p->ier &= ~UART_IER_THRI;
1294                 serial_out(p, UART_IER, p->ier);
1295                 serial8250_rpm_put_tx(p);
1296         }
1297 }
1298
1299 static void serial8250_stop_tx(struct uart_port *port)
1300 {
1301         struct uart_8250_port *up = up_to_u8250p(port);
1302
1303         serial8250_rpm_get(up);
1304         __stop_tx(up);
1305
1306         /*
1307          * We really want to stop the transmitter from sending.
1308          */
1309         if (port->type == PORT_16C950) {
1310                 up->acr |= UART_ACR_TXDIS;
1311                 serial_icr_write(up, UART_ACR, up->acr);
1312         }
1313         serial8250_rpm_put(up);
1314 }
1315
1316 static void serial8250_start_tx(struct uart_port *port)
1317 {
1318         struct uart_8250_port *up = up_to_u8250p(port);
1319
1320         serial8250_rpm_get_tx(up);
1321
1322         if (up->dma && !up->dma->tx_dma(up))
1323                 return;
1324
1325         if (!(up->ier & UART_IER_THRI)) {
1326                 up->ier |= UART_IER_THRI;
1327                 serial_port_out(port, UART_IER, up->ier);
1328
1329                 if (up->bugs & UART_BUG_TXEN) {
1330                         unsigned char lsr;
1331                         lsr = serial_in(up, UART_LSR);
1332                         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1333                         if (lsr & UART_LSR_THRE)
1334                                 serial8250_tx_chars(up);
1335                 }
1336         }
1337
1338         /*
1339          * Re-enable the transmitter if we disabled it.
1340          */
1341         if (port->type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
1342                 up->acr &= ~UART_ACR_TXDIS;
1343                 serial_icr_write(up, UART_ACR, up->acr);
1344         }
1345 }
1346
1347 static void serial8250_throttle(struct uart_port *port)
1348 {
1349         port->throttle(port);
1350 }
1351
1352 static void serial8250_unthrottle(struct uart_port *port)
1353 {
1354         port->unthrottle(port);
1355 }
1356
1357 static void serial8250_stop_rx(struct uart_port *port)
1358 {
1359         struct uart_8250_port *up = up_to_u8250p(port);
1360
1361         serial8250_rpm_get(up);
1362
1363         up->ier &= ~(UART_IER_RLSI | UART_IER_RDI);
1364         up->port.read_status_mask &= ~UART_LSR_DR;
1365         serial_port_out(port, UART_IER, up->ier);
1366
1367         serial8250_rpm_put(up);
1368 }
1369
1370 static void serial8250_disable_ms(struct uart_port *port)
1371 {
1372         struct uart_8250_port *up =
1373                 container_of(port, struct uart_8250_port, port);
1374
1375         /* no MSR capabilities */
1376         if (up->bugs & UART_BUG_NOMSR)
1377                 return;
1378
1379         up->ier &= ~UART_IER_MSI;
1380         serial_port_out(port, UART_IER, up->ier);
1381 }
1382
1383 static void serial8250_enable_ms(struct uart_port *port)
1384 {
1385         struct uart_8250_port *up = up_to_u8250p(port);
1386
1387         /* no MSR capabilities */
1388         if (up->bugs & UART_BUG_NOMSR)
1389                 return;
1390
1391         up->ier |= UART_IER_MSI;
1392
1393         serial8250_rpm_get(up);
1394         serial_port_out(port, UART_IER, up->ier);
1395         serial8250_rpm_put(up);
1396 }
1397
1398 /*
1399  * serial8250_rx_chars: processes according to the passed in LSR
1400  * value, and returns the remaining LSR bits not handled
1401  * by this Rx routine.
1402  */
1403 unsigned char
1404 serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
1405 {
1406         struct uart_port *port = &up->port;
1407         unsigned char ch;
1408         int max_count = 256;
1409         char flag;
1410
1411         do {
1412                 if (likely(lsr & UART_LSR_DR))
1413                         ch = serial_in(up, UART_RX);
1414                 else
1415                         /*
1416                          * Intel 82571 has a Serial Over Lan device that will
1417                          * set UART_LSR_BI without setting UART_LSR_DR when
1418                          * it receives a break. To avoid reading from the
1419                          * receive buffer without UART_LSR_DR bit set, we
1420                          * just force the read character to be 0
1421                          */
1422                         ch = 0;
1423
1424                 flag = TTY_NORMAL;
1425                 port->icount.rx++;
1426
1427                 lsr |= up->lsr_saved_flags;
1428                 up->lsr_saved_flags = 0;
1429
1430                 if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
1431                         if (lsr & UART_LSR_BI) {
1432                                 lsr &= ~(UART_LSR_FE | UART_LSR_PE);
1433                                 port->icount.brk++;
1434                                 /*
1435                                  * We do the SysRQ and SAK checking
1436                                  * here because otherwise the break
1437                                  * may get masked by ignore_status_mask
1438                                  * or read_status_mask.
1439                                  */
1440                                 if (uart_handle_break(port))
1441                                         goto ignore_char;
1442                         } else if (lsr & UART_LSR_PE)
1443                                 port->icount.parity++;
1444                         else if (lsr & UART_LSR_FE)
1445                                 port->icount.frame++;
1446                         if (lsr & UART_LSR_OE)
1447                                 port->icount.overrun++;
1448
1449                         /*
1450                          * Mask off conditions which should be ignored.
1451                          */
1452                         lsr &= port->read_status_mask;
1453
1454                         if (lsr & UART_LSR_BI) {
1455                                 DEBUG_INTR("handling break....");
1456                                 flag = TTY_BREAK;
1457                         } else if (lsr & UART_LSR_PE)
1458                                 flag = TTY_PARITY;
1459                         else if (lsr & UART_LSR_FE)
1460                                 flag = TTY_FRAME;
1461                 }
1462                 if (uart_handle_sysrq_char(port, ch))
1463                         goto ignore_char;
1464
1465                 uart_insert_char(port, lsr, UART_LSR_OE, ch, flag);
1466
1467 ignore_char:
1468                 lsr = serial_in(up, UART_LSR);
1469         } while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (--max_count > 0));
1470         spin_unlock(&port->lock);
1471         tty_flip_buffer_push(&port->state->port);
1472         spin_lock(&port->lock);
1473         return lsr;
1474 }
1475 EXPORT_SYMBOL_GPL(serial8250_rx_chars);
1476
1477 void serial8250_tx_chars(struct uart_8250_port *up)
1478 {
1479         struct uart_port *port = &up->port;
1480         struct circ_buf *xmit = &port->state->xmit;
1481         int count;
1482
1483         if (port->x_char) {
1484                 serial_out(up, UART_TX, port->x_char);
1485                 port->icount.tx++;
1486                 port->x_char = 0;
1487                 return;
1488         }
1489         if (uart_tx_stopped(port)) {
1490                 serial8250_stop_tx(port);
1491                 return;
1492         }
1493         if (uart_circ_empty(xmit)) {
1494                 __stop_tx(up);
1495                 return;
1496         }
1497
1498         count = up->tx_loadsz;
1499         do {
1500                 serial_out(up, UART_TX, xmit->buf[xmit->tail]);
1501                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
1502                 port->icount.tx++;
1503                 if (uart_circ_empty(xmit))
1504                         break;
1505                 if (up->capabilities & UART_CAP_HFIFO) {
1506                         if ((serial_port_in(port, UART_LSR) & BOTH_EMPTY) !=
1507                             BOTH_EMPTY)
1508                                 break;
1509                 }
1510         } while (--count > 0);
1511
1512         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
1513                 uart_write_wakeup(port);
1514
1515         DEBUG_INTR("THRE...");
1516
1517         /*
1518          * With RPM enabled, we have to wait until the FIFO is empty before the
1519          * HW can go idle. So we get here once again with empty FIFO and disable
1520          * the interrupt and RPM in __stop_tx()
1521          */
1522         if (uart_circ_empty(xmit) && !(up->capabilities & UART_CAP_RPM))
1523                 __stop_tx(up);
1524 }
1525 EXPORT_SYMBOL_GPL(serial8250_tx_chars);
1526
1527 /* Caller holds uart port lock */
1528 unsigned int serial8250_modem_status(struct uart_8250_port *up)
1529 {
1530         struct uart_port *port = &up->port;
1531         unsigned int status = serial_in(up, UART_MSR);
1532
1533         status |= up->msr_saved_flags;
1534         up->msr_saved_flags = 0;
1535         if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
1536             port->state != NULL) {
1537                 if (status & UART_MSR_TERI)
1538                         port->icount.rng++;
1539                 if (status & UART_MSR_DDSR)
1540                         port->icount.dsr++;
1541                 if (status & UART_MSR_DDCD)
1542                         uart_handle_dcd_change(port, status & UART_MSR_DCD);
1543                 if (status & UART_MSR_DCTS)
1544                         uart_handle_cts_change(port, status & UART_MSR_CTS);
1545
1546                 wake_up_interruptible(&port->state->port.delta_msr_wait);
1547         }
1548
1549         return status;
1550 }
1551 EXPORT_SYMBOL_GPL(serial8250_modem_status);
1552
1553 /*
1554  * This handles the interrupt from one port.
1555  */
1556 int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
1557 {
1558         unsigned char status;
1559         unsigned long flags;
1560         struct uart_8250_port *up = up_to_u8250p(port);
1561         int dma_err = 0;
1562
1563         if (iir & UART_IIR_NO_INT)
1564                 return 0;
1565
1566         spin_lock_irqsave(&port->lock, flags);
1567
1568         status = serial_port_in(port, UART_LSR);
1569
1570         DEBUG_INTR("status = %x...", status);
1571
1572         if (status & (UART_LSR_DR | UART_LSR_BI)) {
1573                 if (up->dma)
1574                         dma_err = up->dma->rx_dma(up, iir);
1575
1576                 if (!up->dma || dma_err)
1577                         status = serial8250_rx_chars(up, status);
1578         }
1579         serial8250_modem_status(up);
1580         if ((!up->dma || (up->dma && up->dma->tx_err)) &&
1581             (status & UART_LSR_THRE))
1582                 serial8250_tx_chars(up);
1583
1584         spin_unlock_irqrestore(&port->lock, flags);
1585         return 1;
1586 }
1587 EXPORT_SYMBOL_GPL(serial8250_handle_irq);
1588
1589 static int serial8250_default_handle_irq(struct uart_port *port)
1590 {
1591         struct uart_8250_port *up = up_to_u8250p(port);
1592         unsigned int iir;
1593         int ret;
1594
1595         serial8250_rpm_get(up);
1596
1597         iir = serial_port_in(port, UART_IIR);
1598         ret = serial8250_handle_irq(port, iir);
1599
1600         serial8250_rpm_put(up);
1601         return ret;
1602 }
1603
1604 /*
1605  * These Exar UARTs have an extra interrupt indicator that could
1606  * fire for a few unimplemented interrupts.  One of which is a
1607  * wakeup event when coming out of sleep.  Put this here just
1608  * to be on the safe side that these interrupts don't go unhandled.
1609  */
1610 static int exar_handle_irq(struct uart_port *port)
1611 {
1612         unsigned char int0, int1, int2, int3;
1613         unsigned int iir = serial_port_in(port, UART_IIR);
1614         int ret;
1615
1616         ret = serial8250_handle_irq(port, iir);
1617
1618         if ((port->type == PORT_XR17V35X) ||
1619            (port->type == PORT_XR17D15X)) {
1620                 int0 = serial_port_in(port, 0x80);
1621                 int1 = serial_port_in(port, 0x81);
1622                 int2 = serial_port_in(port, 0x82);
1623                 int3 = serial_port_in(port, 0x83);
1624         }
1625
1626         return ret;
1627 }
1628
1629 static unsigned int serial8250_tx_empty(struct uart_port *port)
1630 {
1631         struct uart_8250_port *up = up_to_u8250p(port);
1632         unsigned long flags;
1633         unsigned int lsr;
1634
1635         serial8250_rpm_get(up);
1636
1637         spin_lock_irqsave(&port->lock, flags);
1638         lsr = serial_port_in(port, UART_LSR);
1639         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1640         spin_unlock_irqrestore(&port->lock, flags);
1641
1642         serial8250_rpm_put(up);
1643
1644         return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
1645 }
1646
1647 static unsigned int serial8250_get_mctrl(struct uart_port *port)
1648 {
1649         struct uart_8250_port *up = up_to_u8250p(port);
1650         unsigned int status;
1651         unsigned int ret;
1652
1653         serial8250_rpm_get(up);
1654         status = serial8250_modem_status(up);
1655         serial8250_rpm_put(up);
1656
1657         ret = 0;
1658         if (status & UART_MSR_DCD)
1659                 ret |= TIOCM_CAR;
1660         if (status & UART_MSR_RI)
1661                 ret |= TIOCM_RNG;
1662         if (status & UART_MSR_DSR)
1663                 ret |= TIOCM_DSR;
1664         if (status & UART_MSR_CTS)
1665                 ret |= TIOCM_CTS;
1666         return ret;
1667 }
1668
1669 void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl)
1670 {
1671         struct uart_8250_port *up = up_to_u8250p(port);
1672         unsigned char mcr = 0;
1673
1674         if (mctrl & TIOCM_RTS)
1675                 mcr |= UART_MCR_RTS;
1676         if (mctrl & TIOCM_DTR)
1677                 mcr |= UART_MCR_DTR;
1678         if (mctrl & TIOCM_OUT1)
1679                 mcr |= UART_MCR_OUT1;
1680         if (mctrl & TIOCM_OUT2)
1681                 mcr |= UART_MCR_OUT2;
1682         if (mctrl & TIOCM_LOOP)
1683                 mcr |= UART_MCR_LOOP;
1684
1685         mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr;
1686
1687         serial_port_out(port, UART_MCR, mcr);
1688 }
1689 EXPORT_SYMBOL_GPL(serial8250_do_set_mctrl);
1690
1691 static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
1692 {
1693         if (port->set_mctrl)
1694                 port->set_mctrl(port, mctrl);
1695         else
1696                 serial8250_do_set_mctrl(port, mctrl);
1697 }
1698
1699 static void serial8250_break_ctl(struct uart_port *port, int break_state)
1700 {
1701         struct uart_8250_port *up = up_to_u8250p(port);
1702         unsigned long flags;
1703
1704         serial8250_rpm_get(up);
1705         spin_lock_irqsave(&port->lock, flags);
1706         if (break_state == -1)
1707                 up->lcr |= UART_LCR_SBC;
1708         else
1709                 up->lcr &= ~UART_LCR_SBC;
1710         serial_port_out(port, UART_LCR, up->lcr);
1711         spin_unlock_irqrestore(&port->lock, flags);
1712         serial8250_rpm_put(up);
1713 }
1714
1715 /*
1716  *      Wait for transmitter & holding register to empty
1717  */
1718 static void wait_for_xmitr(struct uart_8250_port *up, int bits)
1719 {
1720         unsigned int status, tmout = 10000;
1721
1722         /* Wait up to 10ms for the character(s) to be sent. */
1723         for (;;) {
1724                 status = serial_in(up, UART_LSR);
1725
1726                 up->lsr_saved_flags |= status & LSR_SAVE_FLAGS;
1727
1728                 if ((status & bits) == bits)
1729                         break;
1730                 if (--tmout == 0)
1731                         break;
1732                 udelay(1);
1733         }
1734
1735         /* Wait up to 1s for flow control if necessary */
1736         if (up->port.flags & UPF_CONS_FLOW) {
1737                 unsigned int tmout;
1738                 for (tmout = 1000000; tmout; tmout--) {
1739                         unsigned int msr = serial_in(up, UART_MSR);
1740                         up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
1741                         if (msr & UART_MSR_CTS)
1742                                 break;
1743                         udelay(1);
1744                         touch_nmi_watchdog();
1745                 }
1746         }
1747 }
1748
1749 #ifdef CONFIG_CONSOLE_POLL
1750 /*
1751  * Console polling routines for writing and reading from the uart while
1752  * in an interrupt or debug context.
1753  */
1754
1755 static int serial8250_get_poll_char(struct uart_port *port)
1756 {
1757         struct uart_8250_port *up = up_to_u8250p(port);
1758         unsigned char lsr;
1759         int status;
1760
1761         serial8250_rpm_get(up);
1762
1763         lsr = serial_port_in(port, UART_LSR);
1764
1765         if (!(lsr & UART_LSR_DR)) {
1766                 status = NO_POLL_CHAR;
1767                 goto out;
1768         }
1769
1770         status = serial_port_in(port, UART_RX);
1771 out:
1772         serial8250_rpm_put(up);
1773         return status;
1774 }
1775
1776
1777 static void serial8250_put_poll_char(struct uart_port *port,
1778                          unsigned char c)
1779 {
1780         unsigned int ier;
1781         struct uart_8250_port *up = up_to_u8250p(port);
1782
1783         serial8250_rpm_get(up);
1784         /*
1785          *      First save the IER then disable the interrupts
1786          */
1787         ier = serial_port_in(port, UART_IER);
1788         if (up->capabilities & UART_CAP_UUE)
1789                 serial_port_out(port, UART_IER, UART_IER_UUE);
1790         else
1791                 serial_port_out(port, UART_IER, 0);
1792
1793         wait_for_xmitr(up, BOTH_EMPTY);
1794         /*
1795          *      Send the character out.
1796          */
1797         serial_port_out(port, UART_TX, c);
1798
1799         /*
1800          *      Finally, wait for transmitter to become empty
1801          *      and restore the IER
1802          */
1803         wait_for_xmitr(up, BOTH_EMPTY);
1804         serial_port_out(port, UART_IER, ier);
1805         serial8250_rpm_put(up);
1806 }
1807
1808 #endif /* CONFIG_CONSOLE_POLL */
1809
1810 int serial8250_do_startup(struct uart_port *port)
1811 {
1812         struct uart_8250_port *up = up_to_u8250p(port);
1813         unsigned long flags;
1814         unsigned char lsr, iir;
1815         int retval;
1816
1817         if (!port->fifosize)
1818                 port->fifosize = uart_config[port->type].fifo_size;
1819         if (!up->tx_loadsz)
1820                 up->tx_loadsz = uart_config[port->type].tx_loadsz;
1821         if (!up->capabilities)
1822                 up->capabilities = uart_config[port->type].flags;
1823         up->mcr = 0;
1824
1825         if (port->iotype != up->cur_iotype)
1826                 set_io_from_upio(port);
1827
1828         serial8250_rpm_get(up);
1829         if (port->type == PORT_16C950) {
1830                 /* Wake up and initialize UART */
1831                 up->acr = 0;
1832                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
1833                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
1834                 serial_port_out(port, UART_IER, 0);
1835                 serial_port_out(port, UART_LCR, 0);
1836                 serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
1837                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
1838                 serial_port_out(port, UART_EFR, UART_EFR_ECB);
1839                 serial_port_out(port, UART_LCR, 0);
1840         }
1841
1842 #ifdef CONFIG_SERIAL_8250_RSA
1843         /*
1844          * If this is an RSA port, see if we can kick it up to the
1845          * higher speed clock.
1846          */
1847         enable_rsa(up);
1848 #endif
1849
1850         if (port->type == PORT_XR17V35X) {
1851                 /*
1852                  * First enable access to IER [7:5], ISR [5:4], FCR [5:4],
1853                  * MCR [7:5] and MSR [7:0]
1854                  */
1855                 serial_port_out(port, UART_XR_EFR, UART_EFR_ECB);
1856
1857                 /*
1858                  * Make sure all interrups are masked until initialization is
1859                  * complete and the FIFOs are cleared
1860                  */
1861                 serial_port_out(port, UART_IER, 0);
1862         }
1863
1864         /*
1865          * Clear the FIFO buffers and disable them.
1866          * (they will be reenabled in set_termios())
1867          */
1868         serial8250_clear_fifos(up);
1869
1870         /*
1871          * Clear the interrupt registers.
1872          */
1873         serial_port_in(port, UART_LSR);
1874         serial_port_in(port, UART_RX);
1875         serial_port_in(port, UART_IIR);
1876         serial_port_in(port, UART_MSR);
1877
1878         /*
1879          * At this point, there's no way the LSR could still be 0xff;
1880          * if it is, then bail out, because there's likely no UART
1881          * here.
1882          */
1883         if (!(port->flags & UPF_BUGGY_UART) &&
1884             (serial_port_in(port, UART_LSR) == 0xff)) {
1885                 printk_ratelimited(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
1886                                    serial_index(port));
1887                 retval = -ENODEV;
1888                 goto out;
1889         }
1890
1891         /*
1892          * For a XR16C850, we need to set the trigger levels
1893          */
1894         if (port->type == PORT_16850) {
1895                 unsigned char fctr;
1896
1897                 serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
1898
1899                 fctr = serial_in(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX);
1900                 serial_port_out(port, UART_FCTR,
1901                                 fctr | UART_FCTR_TRGD | UART_FCTR_RX);
1902                 serial_port_out(port, UART_TRG, UART_TRG_96);
1903                 serial_port_out(port, UART_FCTR,
1904                                 fctr | UART_FCTR_TRGD | UART_FCTR_TX);
1905                 serial_port_out(port, UART_TRG, UART_TRG_96);
1906
1907                 serial_port_out(port, UART_LCR, 0);
1908         }
1909
1910         if (port->irq) {
1911                 unsigned char iir1;
1912                 /*
1913                  * Test for UARTs that do not reassert THRE when the
1914                  * transmitter is idle and the interrupt has already
1915                  * been cleared.  Real 16550s should always reassert
1916                  * this interrupt whenever the transmitter is idle and
1917                  * the interrupt is enabled.  Delays are necessary to
1918                  * allow register changes to become visible.
1919                  */
1920                 spin_lock_irqsave(&port->lock, flags);
1921                 if (up->port.irqflags & IRQF_SHARED)
1922                         disable_irq_nosync(port->irq);
1923
1924                 wait_for_xmitr(up, UART_LSR_THRE);
1925                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
1926                 udelay(1); /* allow THRE to set */
1927                 iir1 = serial_port_in(port, UART_IIR);
1928                 serial_port_out(port, UART_IER, 0);
1929                 serial_port_out_sync(port, UART_IER, UART_IER_THRI);
1930                 udelay(1); /* allow a working UART time to re-assert THRE */
1931                 iir = serial_port_in(port, UART_IIR);
1932                 serial_port_out(port, UART_IER, 0);
1933
1934                 if (port->irqflags & IRQF_SHARED)
1935                         enable_irq(port->irq);
1936                 spin_unlock_irqrestore(&port->lock, flags);
1937
1938                 /*
1939                  * If the interrupt is not reasserted, or we otherwise
1940                  * don't trust the iir, setup a timer to kick the UART
1941                  * on a regular basis.
1942                  */
1943                 if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) ||
1944                     up->port.flags & UPF_BUG_THRE) {
1945                         up->bugs |= UART_BUG_THRE;
1946                 }
1947         }
1948
1949         retval = up->ops->setup_irq(up);
1950         if (retval)
1951                 goto out;
1952
1953         /*
1954          * Now, initialize the UART
1955          */
1956         serial_port_out(port, UART_LCR, UART_LCR_WLEN8);
1957
1958         spin_lock_irqsave(&port->lock, flags);
1959         if (up->port.flags & UPF_FOURPORT) {
1960                 if (!up->port.irq)
1961                         up->port.mctrl |= TIOCM_OUT1;
1962         } else
1963                 /*
1964                  * Most PC uarts need OUT2 raised to enable interrupts.
1965                  */
1966                 if (port->irq)
1967                         up->port.mctrl |= TIOCM_OUT2;
1968
1969         serial8250_set_mctrl(port, port->mctrl);
1970
1971         /* Serial over Lan (SoL) hack:
1972            Intel 8257x Gigabit ethernet chips have a
1973            16550 emulation, to be used for Serial Over Lan.
1974            Those chips take a longer time than a normal
1975            serial device to signalize that a transmission
1976            data was queued. Due to that, the above test generally
1977            fails. One solution would be to delay the reading of
1978            iir. However, this is not reliable, since the timeout
1979            is variable. So, let's just don't test if we receive
1980            TX irq. This way, we'll never enable UART_BUG_TXEN.
1981          */
1982         if (up->port.flags & UPF_NO_TXEN_TEST)
1983                 goto dont_test_tx_en;
1984
1985         /*
1986          * Do a quick test to see if we receive an
1987          * interrupt when we enable the TX irq.
1988          */
1989         serial_port_out(port, UART_IER, UART_IER_THRI);
1990         lsr = serial_port_in(port, UART_LSR);
1991         iir = serial_port_in(port, UART_IIR);
1992         serial_port_out(port, UART_IER, 0);
1993
1994         if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) {
1995                 if (!(up->bugs & UART_BUG_TXEN)) {
1996                         up->bugs |= UART_BUG_TXEN;
1997                         pr_debug("ttyS%d - enabling bad tx status workarounds\n",
1998                                  serial_index(port));
1999                 }
2000         } else {
2001                 up->bugs &= ~UART_BUG_TXEN;
2002         }
2003
2004 dont_test_tx_en:
2005         spin_unlock_irqrestore(&port->lock, flags);
2006
2007         /*
2008          * Clear the interrupt registers again for luck, and clear the
2009          * saved flags to avoid getting false values from polling
2010          * routines or the previous session.
2011          */
2012         serial_port_in(port, UART_LSR);
2013         serial_port_in(port, UART_RX);
2014         serial_port_in(port, UART_IIR);
2015         serial_port_in(port, UART_MSR);
2016         up->lsr_saved_flags = 0;
2017         up->msr_saved_flags = 0;
2018
2019         /*
2020          * Request DMA channels for both RX and TX.
2021          */
2022         if (up->dma) {
2023                 retval = serial8250_request_dma(up);
2024                 if (retval) {
2025                         pr_warn_ratelimited("ttyS%d - failed to request DMA\n",
2026                                             serial_index(port));
2027                         up->dma = NULL;
2028                 }
2029         }
2030
2031         /*
2032          * Set the IER shadow for rx interrupts but defer actual interrupt
2033          * enable until after the FIFOs are enabled; otherwise, an already-
2034          * active sender can swamp the interrupt handler with "too much work".
2035          */
2036         up->ier = UART_IER_RLSI | UART_IER_RDI;
2037
2038         if (port->flags & UPF_FOURPORT) {
2039                 unsigned int icp;
2040                 /*
2041                  * Enable interrupts on the AST Fourport board
2042                  */
2043                 icp = (port->iobase & 0xfe0) | 0x01f;
2044                 outb_p(0x80, icp);
2045                 inb_p(icp);
2046         }
2047         retval = 0;
2048 out:
2049         serial8250_rpm_put(up);
2050         return retval;
2051 }
2052 EXPORT_SYMBOL_GPL(serial8250_do_startup);
2053
2054 static int serial8250_startup(struct uart_port *port)
2055 {
2056         if (port->startup)
2057                 return port->startup(port);
2058         return serial8250_do_startup(port);
2059 }
2060
2061 void serial8250_do_shutdown(struct uart_port *port)
2062 {
2063         struct uart_8250_port *up = up_to_u8250p(port);
2064         unsigned long flags;
2065
2066         serial8250_rpm_get(up);
2067         /*
2068          * Disable interrupts from this port
2069          */
2070         up->ier = 0;
2071         serial_port_out(port, UART_IER, 0);
2072
2073         if (up->dma)
2074                 serial8250_release_dma(up);
2075
2076         spin_lock_irqsave(&port->lock, flags);
2077         if (port->flags & UPF_FOURPORT) {
2078                 /* reset interrupts on the AST Fourport board */
2079                 inb((port->iobase & 0xfe0) | 0x1f);
2080                 port->mctrl |= TIOCM_OUT1;
2081         } else
2082                 port->mctrl &= ~TIOCM_OUT2;
2083
2084         serial8250_set_mctrl(port, port->mctrl);
2085         spin_unlock_irqrestore(&port->lock, flags);
2086
2087         /*
2088          * Disable break condition and FIFOs
2089          */
2090         serial_port_out(port, UART_LCR,
2091                         serial_port_in(port, UART_LCR) & ~UART_LCR_SBC);
2092         serial8250_clear_fifos(up);
2093
2094 #ifdef CONFIG_SERIAL_8250_RSA
2095         /*
2096          * Reset the RSA board back to 115kbps compat mode.
2097          */
2098         disable_rsa(up);
2099 #endif
2100
2101         /*
2102          * Read data port to reset things, and then unlink from
2103          * the IRQ chain.
2104          */
2105         serial_port_in(port, UART_RX);
2106         serial8250_rpm_put(up);
2107
2108         up->ops->release_irq(up);
2109 }
2110 EXPORT_SYMBOL_GPL(serial8250_do_shutdown);
2111
2112 static void serial8250_shutdown(struct uart_port *port)
2113 {
2114         if (port->shutdown)
2115                 port->shutdown(port);
2116         else
2117                 serial8250_do_shutdown(port);
2118 }
2119
2120 /*
2121  * XR17V35x UARTs have an extra fractional divisor register (DLD)
2122  * Calculate divisor with extra 4-bit fractional portion
2123  */
2124 static unsigned int xr17v35x_get_divisor(struct uart_8250_port *up,
2125                                          unsigned int baud,
2126                                          unsigned int *frac)
2127 {
2128         struct uart_port *port = &up->port;
2129         unsigned int quot_16;
2130
2131         quot_16 = DIV_ROUND_CLOSEST(port->uartclk, baud);
2132         *frac = quot_16 & 0x0f;
2133
2134         return quot_16 >> 4;
2135 }
2136
2137 static unsigned int serial8250_get_divisor(struct uart_8250_port *up,
2138                                            unsigned int baud,
2139                                            unsigned int *frac)
2140 {
2141         struct uart_port *port = &up->port;
2142         unsigned int quot;
2143
2144         /*
2145          * Handle magic divisors for baud rates above baud_base on
2146          * SMSC SuperIO chips.
2147          *
2148          */
2149         if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2150             baud == (port->uartclk/4))
2151                 quot = 0x8001;
2152         else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
2153                  baud == (port->uartclk/8))
2154                 quot = 0x8002;
2155         else if (up->port.type == PORT_XR17V35X)
2156                 quot = xr17v35x_get_divisor(up, baud, frac);
2157         else
2158                 quot = uart_get_divisor(port, baud);
2159
2160         /*
2161          * Oxford Semi 952 rev B workaround
2162          */
2163         if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0)
2164                 quot++;
2165
2166         return quot;
2167 }
2168
2169 static unsigned char serial8250_compute_lcr(struct uart_8250_port *up,
2170                                             tcflag_t c_cflag)
2171 {
2172         unsigned char cval;
2173
2174         switch (c_cflag & CSIZE) {
2175         case CS5:
2176                 cval = UART_LCR_WLEN5;
2177                 break;
2178         case CS6:
2179                 cval = UART_LCR_WLEN6;
2180                 break;
2181         case CS7:
2182                 cval = UART_LCR_WLEN7;
2183                 break;
2184         default:
2185         case CS8:
2186                 cval = UART_LCR_WLEN8;
2187                 break;
2188         }
2189
2190         if (c_cflag & CSTOPB)
2191                 cval |= UART_LCR_STOP;
2192         if (c_cflag & PARENB) {
2193                 cval |= UART_LCR_PARITY;
2194                 if (up->bugs & UART_BUG_PARITY)
2195                         up->fifo_bug = true;
2196         }
2197         if (!(c_cflag & PARODD))
2198                 cval |= UART_LCR_EPAR;
2199 #ifdef CMSPAR
2200         if (c_cflag & CMSPAR)
2201                 cval |= UART_LCR_SPAR;
2202 #endif
2203
2204         return cval;
2205 }
2206
2207 static void serial8250_set_divisor(struct uart_port *port, unsigned int baud,
2208                             unsigned int quot, unsigned int quot_frac)
2209 {
2210         struct uart_8250_port *up = up_to_u8250p(port);
2211
2212         /* Workaround to enable 115200 baud on OMAP1510 internal ports */
2213         if (is_omap1510_8250(up)) {
2214                 if (baud == 115200) {
2215                         quot = 1;
2216                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 1);
2217                 } else
2218                         serial_port_out(port, UART_OMAP_OSC_12M_SEL, 0);
2219         }
2220
2221         /*
2222          * For NatSemi, switch to bank 2 not bank 1, to avoid resetting EXCR2,
2223          * otherwise just set DLAB
2224          */
2225         if (up->capabilities & UART_NATSEMI)
2226                 serial_port_out(port, UART_LCR, 0xe0);
2227         else
2228                 serial_port_out(port, UART_LCR, up->lcr | UART_LCR_DLAB);
2229
2230         serial_dl_write(up, quot);
2231
2232         /* XR17V35x UARTs have an extra fractional divisor register (DLD) */
2233         if (up->port.type == PORT_XR17V35X)
2234                 serial_port_out(port, 0x2, quot_frac);
2235 }
2236
2237 static unsigned int
2238 serial8250_get_baud_rate(struct uart_port *port, struct ktermios *termios,
2239                          struct ktermios *old)
2240 {
2241         unsigned int tolerance = port->uartclk / 100;
2242
2243         /*
2244          * Ask the core to calculate the divisor for us.
2245          * Allow 1% tolerance at the upper limit so uart clks marginally
2246          * slower than nominal still match standard baud rates without
2247          * causing transmission errors.
2248          */
2249         return uart_get_baud_rate(port, termios, old,
2250                                   port->uartclk / 16 / 0xffff,
2251                                   (port->uartclk + tolerance) / 16);
2252 }
2253
2254 void
2255 serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
2256                           struct ktermios *old)
2257 {
2258         struct uart_8250_port *up = up_to_u8250p(port);
2259         unsigned char cval;
2260         unsigned long flags;
2261         unsigned int baud, quot, frac = 0;
2262
2263         cval = serial8250_compute_lcr(up, termios->c_cflag);
2264
2265         baud = serial8250_get_baud_rate(port, termios, old);
2266         quot = serial8250_get_divisor(up, baud, &frac);
2267
2268         /*
2269          * Ok, we're now changing the port state.  Do it with
2270          * interrupts disabled.
2271          */
2272         serial8250_rpm_get(up);
2273         spin_lock_irqsave(&port->lock, flags);
2274
2275         up->lcr = cval;                                 /* Save computed LCR */
2276
2277         if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) {
2278                 /* NOTE: If fifo_bug is not set, a user can set RX_trigger. */
2279                 if ((baud < 2400 && !up->dma) || up->fifo_bug) {
2280                         up->fcr &= ~UART_FCR_TRIGGER_MASK;
2281                         up->fcr |= UART_FCR_TRIGGER_1;
2282                 }
2283         }
2284
2285         /*
2286          * MCR-based auto flow control.  When AFE is enabled, RTS will be
2287          * deasserted when the receive FIFO contains more characters than
2288          * the trigger, or the MCR RTS bit is cleared.  In the case where
2289          * the remote UART is not using CTS auto flow control, we must
2290          * have sufficient FIFO entries for the latency of the remote
2291          * UART to respond.  IOW, at least 32 bytes of FIFO.
2292          */
2293         if (up->capabilities & UART_CAP_AFE && port->fifosize >= 32) {
2294                 up->mcr &= ~UART_MCR_AFE;
2295                 if (termios->c_cflag & CRTSCTS)
2296                         up->mcr |= UART_MCR_AFE;
2297         }
2298
2299         /*
2300          * Update the per-port timeout.
2301          */
2302         uart_update_timeout(port, termios->c_cflag, baud);
2303
2304         port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
2305         if (termios->c_iflag & INPCK)
2306                 port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
2307         if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
2308                 port->read_status_mask |= UART_LSR_BI;
2309
2310         /*
2311          * Characteres to ignore
2312          */
2313         port->ignore_status_mask = 0;
2314         if (termios->c_iflag & IGNPAR)
2315                 port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
2316         if (termios->c_iflag & IGNBRK) {
2317                 port->ignore_status_mask |= UART_LSR_BI;
2318                 /*
2319                  * If we're ignoring parity and break indicators,
2320                  * ignore overruns too (for real raw support).
2321                  */
2322                 if (termios->c_iflag & IGNPAR)
2323                         port->ignore_status_mask |= UART_LSR_OE;
2324         }
2325
2326         /*
2327          * ignore all characters if CREAD is not set
2328          */
2329         if ((termios->c_cflag & CREAD) == 0)
2330                 port->ignore_status_mask |= UART_LSR_DR;
2331
2332         /*
2333          * CTS flow control flag and modem status interrupts
2334          */
2335         up->ier &= ~UART_IER_MSI;
2336         if (!(up->bugs & UART_BUG_NOMSR) &&
2337                         UART_ENABLE_MS(&up->port, termios->c_cflag))
2338                 up->ier |= UART_IER_MSI;
2339         if (up->capabilities & UART_CAP_UUE)
2340                 up->ier |= UART_IER_UUE;
2341         if (up->capabilities & UART_CAP_RTOIE)
2342                 up->ier |= UART_IER_RTOIE;
2343
2344         serial_port_out(port, UART_IER, up->ier);
2345
2346         if (up->capabilities & UART_CAP_EFR) {
2347                 unsigned char efr = 0;
2348                 /*
2349                  * TI16C752/Startech hardware flow control.  FIXME:
2350                  * - TI16C752 requires control thresholds to be set.
2351                  * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled.
2352                  */
2353                 if (termios->c_cflag & CRTSCTS)
2354                         efr |= UART_EFR_CTS;
2355
2356                 serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
2357                 if (port->flags & UPF_EXAR_EFR)
2358                         serial_port_out(port, UART_XR_EFR, efr);
2359                 else
2360                         serial_port_out(port, UART_EFR, efr);
2361         }
2362
2363         serial8250_set_divisor(port, baud, quot, frac);
2364
2365         /*
2366          * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
2367          * is written without DLAB set, this mode will be disabled.
2368          */
2369         if (port->type == PORT_16750)
2370                 serial_port_out(port, UART_FCR, up->fcr);
2371
2372         serial_port_out(port, UART_LCR, up->lcr);       /* reset DLAB */
2373         if (port->type != PORT_16750) {
2374                 /* emulated UARTs (Lucent Venus 167x) need two steps */
2375                 if (up->fcr & UART_FCR_ENABLE_FIFO)
2376                         serial_port_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
2377                 serial_port_out(port, UART_FCR, up->fcr);       /* set fcr */
2378         }
2379         serial8250_set_mctrl(port, port->mctrl);
2380         spin_unlock_irqrestore(&port->lock, flags);
2381         serial8250_rpm_put(up);
2382
2383         /* Don't rewrite B0 */
2384         if (tty_termios_baud_rate(termios))
2385                 tty_termios_encode_baud_rate(termios, baud, baud);
2386 }
2387 EXPORT_SYMBOL(serial8250_do_set_termios);
2388
2389 static void
2390 serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
2391                        struct ktermios *old)
2392 {
2393         if (port->set_termios)
2394                 port->set_termios(port, termios, old);
2395         else
2396                 serial8250_do_set_termios(port, termios, old);
2397 }
2398
2399 static void
2400 serial8250_set_ldisc(struct uart_port *port, struct ktermios *termios)
2401 {
2402         if (termios->c_line == N_PPS) {
2403                 port->flags |= UPF_HARDPPS_CD;
2404                 spin_lock_irq(&port->lock);
2405                 serial8250_enable_ms(port);
2406                 spin_unlock_irq(&port->lock);
2407         } else {
2408                 port->flags &= ~UPF_HARDPPS_CD;
2409                 if (!UART_ENABLE_MS(port, termios->c_cflag)) {
2410                         spin_lock_irq(&port->lock);
2411                         serial8250_disable_ms(port);
2412                         spin_unlock_irq(&port->lock);
2413                 }
2414         }
2415 }
2416
2417
2418 void serial8250_do_pm(struct uart_port *port, unsigned int state,
2419                       unsigned int oldstate)
2420 {
2421         struct uart_8250_port *p = up_to_u8250p(port);
2422
2423         serial8250_set_sleep(p, state != 0);
2424 }
2425 EXPORT_SYMBOL(serial8250_do_pm);
2426
2427 static void
2428 serial8250_pm(struct uart_port *port, unsigned int state,
2429               unsigned int oldstate)
2430 {
2431         if (port->pm)
2432                 port->pm(port, state, oldstate);
2433         else
2434                 serial8250_do_pm(port, state, oldstate);
2435 }
2436
2437 static unsigned int serial8250_port_size(struct uart_8250_port *pt)
2438 {
2439         if (pt->port.mapsize)
2440                 return pt->port.mapsize;
2441         if (pt->port.iotype == UPIO_AU) {
2442                 if (pt->port.type == PORT_RT2880)
2443                         return 0x100;
2444                 return 0x1000;
2445         }
2446         if (is_omap1_8250(pt))
2447                 return 0x16 << pt->port.regshift;
2448
2449         return 8 << pt->port.regshift;
2450 }
2451
2452 /*
2453  * Resource handling.
2454  */
2455 static int serial8250_request_std_resource(struct uart_8250_port *up)
2456 {
2457         unsigned int size = serial8250_port_size(up);
2458         struct uart_port *port = &up->port;
2459         int ret = 0;
2460
2461         switch (port->iotype) {
2462         case UPIO_AU:
2463         case UPIO_TSI:
2464         case UPIO_MEM32:
2465         case UPIO_MEM32BE:
2466         case UPIO_MEM:
2467                 if (!port->mapbase)
2468                         break;
2469
2470                 if (!request_mem_region(port->mapbase, size, "serial")) {
2471                         ret = -EBUSY;
2472                         break;
2473                 }
2474
2475                 if (port->flags & UPF_IOREMAP) {
2476                         port->membase = ioremap_nocache(port->mapbase, size);
2477                         if (!port->membase) {
2478                                 release_mem_region(port->mapbase, size);
2479                                 ret = -ENOMEM;
2480                         }
2481                 }
2482                 break;
2483
2484         case UPIO_HUB6:
2485         case UPIO_PORT:
2486                 if (!request_region(port->iobase, size, "serial"))
2487                         ret = -EBUSY;
2488                 break;
2489         }
2490         return ret;
2491 }
2492
2493 static void serial8250_release_std_resource(struct uart_8250_port *up)
2494 {
2495         unsigned int size = serial8250_port_size(up);
2496         struct uart_port *port = &up->port;
2497
2498         switch (port->iotype) {
2499         case UPIO_AU:
2500         case UPIO_TSI:
2501         case UPIO_MEM32:
2502         case UPIO_MEM32BE:
2503         case UPIO_MEM:
2504                 if (!port->mapbase)
2505                         break;
2506
2507                 if (port->flags & UPF_IOREMAP) {
2508                         iounmap(port->membase);
2509                         port->membase = NULL;
2510                 }
2511
2512                 release_mem_region(port->mapbase, size);
2513                 break;
2514
2515         case UPIO_HUB6:
2516         case UPIO_PORT:
2517                 release_region(port->iobase, size);
2518                 break;
2519         }
2520 }
2521
2522 static void serial8250_release_port(struct uart_port *port)
2523 {
2524         struct uart_8250_port *up = up_to_u8250p(port);
2525
2526         serial8250_release_std_resource(up);
2527 }
2528
2529 static int serial8250_request_port(struct uart_port *port)
2530 {
2531         struct uart_8250_port *up = up_to_u8250p(port);
2532
2533         return serial8250_request_std_resource(up);
2534 }
2535
2536 static int fcr_get_rxtrig_bytes(struct uart_8250_port *up)
2537 {
2538         const struct serial8250_config *conf_type = &uart_config[up->port.type];
2539         unsigned char bytes;
2540
2541         bytes = conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(up->fcr)];
2542
2543         return bytes ? bytes : -EOPNOTSUPP;
2544 }
2545
2546 static int bytes_to_fcr_rxtrig(struct uart_8250_port *up, unsigned char bytes)
2547 {
2548         const struct serial8250_config *conf_type = &uart_config[up->port.type];
2549         int i;
2550
2551         if (!conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(UART_FCR_R_TRIG_00)])
2552                 return -EOPNOTSUPP;
2553
2554         for (i = 1; i < UART_FCR_R_TRIG_MAX_STATE; i++) {
2555                 if (bytes < conf_type->rxtrig_bytes[i])
2556                         /* Use the nearest lower value */
2557                         return (--i) << UART_FCR_R_TRIG_SHIFT;
2558         }
2559
2560         return UART_FCR_R_TRIG_11;
2561 }
2562
2563 static int do_get_rxtrig(struct tty_port *port)
2564 {
2565         struct uart_state *state = container_of(port, struct uart_state, port);
2566         struct uart_port *uport = state->uart_port;
2567         struct uart_8250_port *up =
2568                 container_of(uport, struct uart_8250_port, port);
2569
2570         if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1)
2571                 return -EINVAL;
2572
2573         return fcr_get_rxtrig_bytes(up);
2574 }
2575
2576 static int do_serial8250_get_rxtrig(struct tty_port *port)
2577 {
2578         int rxtrig_bytes;
2579
2580         mutex_lock(&port->mutex);
2581         rxtrig_bytes = do_get_rxtrig(port);
2582         mutex_unlock(&port->mutex);
2583
2584         return rxtrig_bytes;
2585 }
2586
2587 static ssize_t serial8250_get_attr_rx_trig_bytes(struct device *dev,
2588         struct device_attribute *attr, char *buf)
2589 {
2590         struct tty_port *port = dev_get_drvdata(dev);
2591         int rxtrig_bytes;
2592
2593         rxtrig_bytes = do_serial8250_get_rxtrig(port);
2594         if (rxtrig_bytes < 0)
2595                 return rxtrig_bytes;
2596
2597         return snprintf(buf, PAGE_SIZE, "%d\n", rxtrig_bytes);
2598 }
2599
2600 static int do_set_rxtrig(struct tty_port *port, unsigned char bytes)
2601 {
2602         struct uart_state *state = container_of(port, struct uart_state, port);
2603         struct uart_port *uport = state->uart_port;
2604         struct uart_8250_port *up =
2605                 container_of(uport, struct uart_8250_port, port);
2606         int rxtrig;
2607
2608         if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1 ||
2609             up->fifo_bug)
2610                 return -EINVAL;
2611
2612         rxtrig = bytes_to_fcr_rxtrig(up, bytes);
2613         if (rxtrig < 0)
2614                 return rxtrig;
2615
2616         serial8250_clear_fifos(up);
2617         up->fcr &= ~UART_FCR_TRIGGER_MASK;
2618         up->fcr |= (unsigned char)rxtrig;
2619         serial_out(up, UART_FCR, up->fcr);
2620         return 0;
2621 }
2622
2623 static int do_serial8250_set_rxtrig(struct tty_port *port, unsigned char bytes)
2624 {
2625         int ret;
2626
2627         mutex_lock(&port->mutex);
2628         ret = do_set_rxtrig(port, bytes);
2629         mutex_unlock(&port->mutex);
2630
2631         return ret;
2632 }
2633
2634 static ssize_t serial8250_set_attr_rx_trig_bytes(struct device *dev,
2635         struct device_attribute *attr, const char *buf, size_t count)
2636 {
2637         struct tty_port *port = dev_get_drvdata(dev);
2638         unsigned char bytes;
2639         int ret;
2640
2641         if (!count)
2642                 return -EINVAL;
2643
2644         ret = kstrtou8(buf, 10, &bytes);
2645         if (ret < 0)
2646                 return ret;
2647
2648         ret = do_serial8250_set_rxtrig(port, bytes);
2649         if (ret < 0)
2650                 return ret;
2651
2652         return count;
2653 }
2654
2655 static DEVICE_ATTR(rx_trig_bytes, S_IRUSR | S_IWUSR | S_IRGRP,
2656                    serial8250_get_attr_rx_trig_bytes,
2657                    serial8250_set_attr_rx_trig_bytes);
2658
2659 static struct attribute *serial8250_dev_attrs[] = {
2660         &dev_attr_rx_trig_bytes.attr,
2661         NULL,
2662         };
2663
2664 static struct attribute_group serial8250_dev_attr_group = {
2665         .attrs = serial8250_dev_attrs,
2666         };
2667
2668 static void register_dev_spec_attr_grp(struct uart_8250_port *up)
2669 {
2670         const struct serial8250_config *conf_type = &uart_config[up->port.type];
2671
2672         if (conf_type->rxtrig_bytes[0])
2673                 up->port.attr_group = &serial8250_dev_attr_group;
2674 }
2675
2676 static void serial8250_config_port(struct uart_port *port, int flags)
2677 {
2678         struct uart_8250_port *up = up_to_u8250p(port);
2679         int ret;
2680
2681         /*
2682          * Find the region that we can probe for.  This in turn
2683          * tells us whether we can probe for the type of port.
2684          */
2685         ret = serial8250_request_std_resource(up);
2686         if (ret < 0)
2687                 return;
2688
2689         if (port->iotype != up->cur_iotype)
2690                 set_io_from_upio(port);
2691
2692         if (flags & UART_CONFIG_TYPE)
2693                 autoconfig(up);
2694
2695         /* if access method is AU, it is a 16550 with a quirk */
2696         if (port->type == PORT_16550A && port->iotype == UPIO_AU)
2697                 up->bugs |= UART_BUG_NOMSR;
2698
2699         /* HW bugs may trigger IRQ while IIR == NO_INT */
2700         if (port->type == PORT_TEGRA)
2701                 up->bugs |= UART_BUG_NOMSR;
2702
2703         if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
2704                 autoconfig_irq(up);
2705
2706         if (port->type == PORT_UNKNOWN)
2707                 serial8250_release_std_resource(up);
2708
2709         /* Fixme: probably not the best place for this */
2710         if ((port->type == PORT_XR17V35X) ||
2711            (port->type == PORT_XR17D15X))
2712                 port->handle_irq = exar_handle_irq;
2713
2714         register_dev_spec_attr_grp(up);
2715         up->fcr = uart_config[up->port.type].fcr;
2716 }
2717
2718 static int
2719 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
2720 {
2721         if (ser->irq >= nr_irqs || ser->irq < 0 ||
2722             ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
2723             ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
2724             ser->type == PORT_STARTECH)
2725                 return -EINVAL;
2726         return 0;
2727 }
2728
2729 static const char *
2730 serial8250_type(struct uart_port *port)
2731 {
2732         int type = port->type;
2733
2734         if (type >= ARRAY_SIZE(uart_config))
2735                 type = 0;
2736         return uart_config[type].name;
2737 }
2738
2739 static const struct uart_ops serial8250_pops = {
2740         .tx_empty       = serial8250_tx_empty,
2741         .set_mctrl      = serial8250_set_mctrl,
2742         .get_mctrl      = serial8250_get_mctrl,
2743         .stop_tx        = serial8250_stop_tx,
2744         .start_tx       = serial8250_start_tx,
2745         .throttle       = serial8250_throttle,
2746         .unthrottle     = serial8250_unthrottle,
2747         .stop_rx        = serial8250_stop_rx,
2748         .enable_ms      = serial8250_enable_ms,
2749         .break_ctl      = serial8250_break_ctl,
2750         .startup        = serial8250_startup,
2751         .shutdown       = serial8250_shutdown,
2752         .set_termios    = serial8250_set_termios,
2753         .set_ldisc      = serial8250_set_ldisc,
2754         .pm             = serial8250_pm,
2755         .type           = serial8250_type,
2756         .release_port   = serial8250_release_port,
2757         .request_port   = serial8250_request_port,
2758         .config_port    = serial8250_config_port,
2759         .verify_port    = serial8250_verify_port,
2760 #ifdef CONFIG_CONSOLE_POLL
2761         .poll_get_char = serial8250_get_poll_char,
2762         .poll_put_char = serial8250_put_poll_char,
2763 #endif
2764 };
2765
2766 void serial8250_init_port(struct uart_8250_port *up)
2767 {
2768         struct uart_port *port = &up->port;
2769
2770         spin_lock_init(&port->lock);
2771         port->ops = &serial8250_pops;
2772
2773         up->cur_iotype = 0xFF;
2774 }
2775 EXPORT_SYMBOL_GPL(serial8250_init_port);
2776
2777 void serial8250_set_defaults(struct uart_8250_port *up)
2778 {
2779         struct uart_port *port = &up->port;
2780
2781         if (up->port.flags & UPF_FIXED_TYPE) {
2782                 unsigned int type = up->port.type;
2783
2784                 if (!up->port.fifosize)
2785                         up->port.fifosize = uart_config[type].fifo_size;
2786                 if (!up->tx_loadsz)
2787                         up->tx_loadsz = uart_config[type].tx_loadsz;
2788                 if (!up->capabilities)
2789                         up->capabilities = uart_config[type].flags;
2790         }
2791
2792         set_io_from_upio(port);
2793
2794         /* default dma handlers */
2795         if (up->dma) {
2796                 if (!up->dma->tx_dma)
2797                         up->dma->tx_dma = serial8250_tx_dma;
2798                 if (!up->dma->rx_dma)
2799                         up->dma->rx_dma = serial8250_rx_dma;
2800         }
2801 }
2802 EXPORT_SYMBOL_GPL(serial8250_set_defaults);
2803
2804 #ifdef CONFIG_SERIAL_8250_CONSOLE
2805
2806 static void serial8250_console_putchar(struct uart_port *port, int ch)
2807 {
2808         struct uart_8250_port *up = up_to_u8250p(port);
2809
2810         wait_for_xmitr(up, UART_LSR_THRE);
2811         serial_port_out(port, UART_TX, ch);
2812 }
2813
2814 /*
2815  *      Restore serial console when h/w power-off detected
2816  */
2817 static void serial8250_console_restore(struct uart_8250_port *up)
2818 {
2819         struct uart_port *port = &up->port;
2820         struct ktermios termios;
2821         unsigned int baud, quot, frac = 0;
2822
2823         termios.c_cflag = port->cons->cflag;
2824         if (port->state->port.tty && termios.c_cflag == 0)
2825                 termios.c_cflag = port->state->port.tty->termios.c_cflag;
2826
2827         baud = serial8250_get_baud_rate(port, &termios, NULL);
2828         quot = serial8250_get_divisor(up, baud, &frac);
2829
2830         serial8250_set_divisor(port, baud, quot, frac);
2831         serial_port_out(port, UART_LCR, up->lcr);
2832         serial_port_out(port, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
2833 }
2834
2835 /*
2836  *      Print a string to the serial port trying not to disturb
2837  *      any possible real use of the port...
2838  *
2839  *      The console_lock must be held when we get here.
2840  */
2841 void serial8250_console_write(struct uart_8250_port *up, const char *s,
2842                               unsigned int count)
2843 {
2844         struct uart_port *port = &up->port;
2845         unsigned long flags;
2846         unsigned int ier;
2847         int locked = 1;
2848
2849         touch_nmi_watchdog();
2850
2851         serial8250_rpm_get(up);
2852
2853         if (port->sysrq)
2854                 locked = 0;
2855         else if (oops_in_progress || in_kdb_printk())
2856                 locked = spin_trylock_irqsave(&port->lock, flags);
2857         else
2858                 spin_lock_irqsave(&port->lock, flags);
2859
2860         /*
2861          *      First save the IER then disable the interrupts
2862          */
2863         ier = serial_port_in(port, UART_IER);
2864
2865         if (up->capabilities & UART_CAP_UUE)
2866                 serial_port_out(port, UART_IER, UART_IER_UUE);
2867         else
2868                 serial_port_out(port, UART_IER, 0);
2869
2870         /* check scratch reg to see if port powered off during system sleep */
2871         if (up->canary && (up->canary != serial_port_in(port, UART_SCR))) {
2872                 serial8250_console_restore(up);
2873                 up->canary = 0;
2874         }
2875
2876         uart_console_write(port, s, count, serial8250_console_putchar);
2877
2878         /*
2879          *      Finally, wait for transmitter to become empty
2880          *      and restore the IER
2881          */
2882         wait_for_xmitr(up, BOTH_EMPTY);
2883         serial_port_out(port, UART_IER, ier);
2884
2885         /*
2886          *      The receive handling will happen properly because the
2887          *      receive ready bit will still be set; it is not cleared
2888          *      on read.  However, modem control will not, we must
2889          *      call it if we have saved something in the saved flags
2890          *      while processing with interrupts off.
2891          */
2892         if (up->msr_saved_flags)
2893                 serial8250_modem_status(up);
2894
2895         if (locked)
2896                 spin_unlock_irqrestore(&port->lock, flags);
2897         serial8250_rpm_put(up);
2898 }
2899
2900 static unsigned int probe_baud(struct uart_port *port)
2901 {
2902         unsigned char lcr, dll, dlm;
2903         unsigned int quot;
2904
2905         lcr = serial_port_in(port, UART_LCR);
2906         serial_port_out(port, UART_LCR, lcr | UART_LCR_DLAB);
2907         dll = serial_port_in(port, UART_DLL);
2908         dlm = serial_port_in(port, UART_DLM);
2909         serial_port_out(port, UART_LCR, lcr);
2910
2911         quot = (dlm << 8) | dll;
2912         return (port->uartclk / 16) / quot;
2913 }
2914
2915 int serial8250_console_setup(struct uart_port *port, char *options, bool probe)
2916 {
2917         int baud = 9600;
2918         int bits = 8;
2919         int parity = 'n';
2920         int flow = 'n';
2921
2922         if (!port->iobase && !port->membase)
2923                 return -ENODEV;
2924
2925         if (options)
2926                 uart_parse_options(options, &baud, &parity, &bits, &flow);
2927         else if (probe)
2928                 baud = probe_baud(port);
2929
2930         return uart_set_options(port, port->cons, baud, parity, bits, flow);
2931 }
2932
2933 #endif /* CONFIG_SERIAL_8250_CONSOLE */
2934
2935 MODULE_LICENSE("GPL");