sys/dev/uart/uart_dev_lpc.c

   1 /*-
   2  * Copyright (c) 2003 Marcel Moolenaar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/bus.h>
  33 #include <sys/conf.h>
  34 #include <machine/bus.h>
  35
  36 #include <dev/uart/uart.h>
  37 #include <dev/uart/uart_cpu.h>
  38 #include <dev/uart/uart_cpu_fdt.h>
  39 #include <dev/uart/uart_bus.h>
  40
  41 #include <dev/ic/ns16550.h>
  42 #include <arm/lpc/lpcreg.h>
  43
  44 #include "uart_if.h"
  45
  46 #define DEFAULT_RCLK            (13 * 1000 * 1000)
  47
  48 static bus_space_handle_t bsh_clkpwr;
  49
  50 #define lpc_ns8250_get_clkreg(_bas, _reg)       \
  51     bus_space_read_4((_bas)->bst, bsh_clkpwr, (_reg))
  52 #define lpc_ns8250_set_clkreg(_bas, _reg, _val) \
  53     bus_space_write_4((_bas)->bst, bsh_clkpwr, (_reg), (_val))
  54
  55 /*
  56  * Clear pending interrupts. THRE is cleared by reading IIR. Data
  57  * that may have been received gets lost here.
  58  */
  59 static void
  60 lpc_ns8250_clrint(struct uart_bas *bas)
  61 {
  62         uint8_t iir, lsr;
  63
  64         iir = uart_getreg(bas, REG_IIR);
  65         while ((iir & IIR_NOPEND) == 0) {
  66                 iir &= IIR_IMASK;
  67                 if (iir == IIR_RLS) {
  68                         lsr = uart_getreg(bas, REG_LSR);
  69                         if (lsr & (LSR_BI|LSR_FE|LSR_PE))
  70                                 (void)uart_getreg(bas, REG_DATA);
  71                 } else if (iir == IIR_RXRDY || iir == IIR_RXTOUT)
  72                         (void)uart_getreg(bas, REG_DATA);
  73                 else if (iir == IIR_MLSC)
  74                         (void)uart_getreg(bas, REG_MSR);
  75                 uart_barrier(bas);
  76                 iir = uart_getreg(bas, REG_IIR);
  77         }
  78 }
  79
  80 static int
  81 lpc_ns8250_delay(struct uart_bas *bas)
  82 {
  83         uint32_t uclk;
  84         int x, y;
  85
  86         uclk = lpc_ns8250_get_clkreg(bas, LPC_CLKPWR_UART_U5CLK);
  87
  88         x = (uclk >> 8) & 0xff;
  89         y = uclk & 0xff;
  90
  91         return (16000000 / (bas->rclk * x / y));
  92 }
  93
  94 static void
  95 lpc_ns8250_divisor(int rclk, int baudrate, int *x, int *y)
  96 {
  97
  98         switch (baudrate) {
  99         case 2400:
 100                 *x = 1;
 101                 *y = 255;
 102                 return;
 103         case 4800:
 104                 *x = 1;
 105                 *y = 169;
 106                 return;
 107         case 9600:
 108                 *x = 3;
 109                 *y = 254;
 110                 return;
 111         case 19200:
 112                 *x = 3;
 113                 *y = 127;
 114                 return;
 115         case 38400:
 116                 *x = 6;
 117                 *y = 127;
 118                 return;
 119         case 57600:
 120                 *x = 9;
 121                 *y = 127;
 122                 return;
 123         default:
 124         case 115200:
 125                 *x = 19;
 126                 *y = 134;
 127                 return;
 128         case 230400:
 129                 *x = 19;
 130                 *y = 67;
 131                 return;
 132         case 460800:
 133                 *x = 38;
 134                 *y = 67;
 135                 return;
 136         }
 137 }
 138
 139 static int
 140 lpc_ns8250_drain(struct uart_bas *bas, int what)
 141 {
 142         int delay, limit;
 143
 144         delay = lpc_ns8250_delay(bas);
 145
 146         if (what & UART_DRAIN_TRANSMITTER) {
 147                 /*
 148                  * Pick an arbitrary high limit to avoid getting stuck in
 149                  * an infinite loop when the hardware is broken. Make the
 150                  * limit high enough to handle large FIFOs.
 151                  */
 152                 limit = 10*1024;
 153                 while ((uart_getreg(bas, REG_LSR) & LSR_TEMT) == 0 && --limit)
 154                         DELAY(delay);
 155                 if (limit == 0) {
 156                         /* printf("lpc_ns8250: transmitter appears stuck... "); */
 157                         return (EIO);
 158                 }
 159         }
 160
 161         if (what & UART_DRAIN_RECEIVER) {
 162                 /*
 163                  * Pick an arbitrary high limit to avoid getting stuck in
 164                  * an infinite loop when the hardware is broken. Make the
 165                  * limit high enough to handle large FIFOs and integrated
 166                  * UARTs. The HP rx2600 for example has 3 UARTs on the
 167                  * management board that tend to get a lot of data send
 168                  * to it when the UART is first activated.
 169                  */
 170                 limit=10*4096;
 171                 while ((uart_getreg(bas, REG_LSR) & LSR_RXRDY) && --limit) {
 172                         (void)uart_getreg(bas, REG_DATA);
 173                         uart_barrier(bas);
 174                         DELAY(delay << 2);
 175                 }
 176                 if (limit == 0) {
 177                         /* printf("lpc_ns8250: receiver appears broken... "); */
 178                         return (EIO);
 179                 }
 180         }
 181
 182         return (0);
 183 }
 184
 185 /*
 186  * We can only flush UARTs with FIFOs. UARTs without FIFOs should be
 187  * drained. WARNING: this function clobbers the FIFO setting!
 188  */
 189 static void
 190 lpc_ns8250_flush(struct uart_bas *bas, int what)
 191 {
 192         uint8_t fcr;
 193
 194         fcr = FCR_ENABLE;
 195         if (what & UART_FLUSH_TRANSMITTER)
 196                 fcr |= FCR_XMT_RST;
 197         if (what & UART_FLUSH_RECEIVER)
 198                 fcr |= FCR_RCV_RST;
 199         uart_setreg(bas, REG_FCR, fcr);
 200         uart_barrier(bas);
 201 }
 202
 203 static int
 204 lpc_ns8250_param(struct uart_bas *bas, int baudrate, int databits, int stopbits,
 205     int parity)
 206 {
 207         int xdiv, ydiv;
 208         uint8_t lcr;
 209
 210         lcr = 0;
 211         if (databits >= 8)
 212                 lcr |= LCR_8BITS;
 213         else if (databits == 7)
 214                 lcr |= LCR_7BITS;
 215         else if (databits == 6)
 216                 lcr |= LCR_6BITS;
 217         else
 218                 lcr |= LCR_5BITS;
 219         if (stopbits > 1)
 220                 lcr |= LCR_STOPB;
 221         lcr |= parity << 3;
 222
 223         /* Set baudrate. */
 224         if (baudrate > 0) {
 225                 uart_setreg(bas, REG_LCR, lcr | LCR_DLAB);
 226                 uart_barrier(bas);
 227                 uart_setreg(bas, REG_DLL, 0x00);
 228                 uart_setreg(bas, REG_DLH, 0x00);
 229                 uart_barrier(bas);
 230
 231                 lpc_ns8250_divisor(bas->rclk, baudrate, &xdiv, &ydiv);
 232                 lpc_ns8250_set_clkreg(bas,
 233                     LPC_CLKPWR_UART_U5CLK,
 234                     LPC_CLKPWR_UART_UCLK_X(xdiv) |
 235                     LPC_CLKPWR_UART_UCLK_Y(ydiv));
 236         }
 237
 238         /* Set LCR and clear DLAB. */
 239         uart_setreg(bas, REG_LCR, lcr);
 240         uart_barrier(bas);
 241         return (0);
 242 }
 243
 244 /*
 245  * Low-level UART interface.
 246  */
 247 static int lpc_ns8250_probe(struct uart_bas *bas);
 248 static void lpc_ns8250_init(struct uart_bas *bas, int, int, int, int);
 249 static void lpc_ns8250_term(struct uart_bas *bas);
 250 static void lpc_ns8250_putc(struct uart_bas *bas, int);
 251 static int lpc_ns8250_rxready(struct uart_bas *bas);
 252 static int lpc_ns8250_getc(struct uart_bas *bas, struct mtx *);
 253
 254 static struct uart_ops uart_lpc_ns8250_ops = {
 255         .probe = lpc_ns8250_probe,
 256         .init = lpc_ns8250_init,
 257         .term = lpc_ns8250_term,
 258         .putc = lpc_ns8250_putc,
 259         .rxready = lpc_ns8250_rxready,
 260         .getc = lpc_ns8250_getc,
 261 };
 262
 263 static int
 264 lpc_ns8250_probe(struct uart_bas *bas)
 265 {
 266 #if 0
 267         u_char val;
 268
 269         /* Check known 0 bits that don't depend on DLAB. */
 270         val = uart_getreg(bas, REG_IIR);
 271         if (val & 0x30)
 272                 return (ENXIO);
 273         /*
 274          * Bit 6 of the MCR (= 0x40) appears to be 1 for the Sun1699
 275          * chip, but otherwise doesn't seem to have a function. In
 276          * other words, uart(4) works regardless. Ignore that bit so
 277          * the probe succeeds.
 278          */
 279         val = uart_getreg(bas, REG_MCR);
 280         if (val & 0xa0)
 281                 return (ENXIO);
 282 #endif
 283         return (0);
 284 }
 285
 286 static void
 287 lpc_ns8250_init(struct uart_bas *bas, int baudrate, int databits, int stopbits,
 288     int parity)
 289 {
 290         u_char  ier;
 291         u_long  clkmode;
 292
 293         /* Enable UART clock */
 294         bus_space_map(bas->bst, LPC_CLKPWR_PHYS_BASE, LPC_CLKPWR_SIZE, 0,
 295             &bsh_clkpwr);
 296         clkmode = lpc_ns8250_get_clkreg(bas, LPC_UART_CLKMODE);
 297         lpc_ns8250_set_clkreg(bas, LPC_UART_CLKMODE, clkmode |
 298             LPC_UART_CLKMODE_UART5(1));
 299
 300 #if 0
 301         /* Work around H/W bug */
 302         uart_setreg(bas, REG_DATA, 0x00);
 303 #endif
 304         if (bas->rclk == 0)
 305                 bas->rclk = DEFAULT_RCLK;
 306         lpc_ns8250_param(bas, baudrate, databits, stopbits, parity);
 307
 308         /* Disable all interrupt sources. */
 309         /*
 310          * We use 0xe0 instead of 0xf0 as the mask because the XScale PXA
 311          * UARTs split the receive time-out interrupt bit out separately as
 312          * 0x10.  This gets handled by ier_mask and ier_rxbits below.
 313          */
 314         ier = uart_getreg(bas, REG_IER) & 0xe0;
 315         uart_setreg(bas, REG_IER, ier);
 316         uart_barrier(bas);
 317
 318         /* Disable the FIFO (if present). */
 319         uart_setreg(bas, REG_FCR, 0);
 320         uart_barrier(bas);
 321
 322         /* Set RTS & DTR. */
 323         uart_setreg(bas, REG_MCR, MCR_IE | MCR_RTS | MCR_DTR);
 324         uart_barrier(bas);
 325
 326         lpc_ns8250_clrint(bas);
 327 }
 328
 329 static void
 330 lpc_ns8250_term(struct uart_bas *bas)
 331 {
 332
 333         /* Clear RTS & DTR. */
 334         uart_setreg(bas, REG_MCR, MCR_IE);
 335         uart_barrier(bas);
 336 }
 337
 338 static void
 339 lpc_ns8250_putc(struct uart_bas *bas, int c)
 340 {
 341         int limit;
 342
 343         limit = 250000;
 344         while ((uart_getreg(bas, REG_LSR) & LSR_THRE) == 0 && --limit)
 345                 DELAY(4);
 346         uart_setreg(bas, REG_DATA, c);
 347         uart_barrier(bas);
 348         limit = 250000;
 349         while ((uart_getreg(bas, REG_LSR) & LSR_TEMT) == 0 && --limit)
 350                 DELAY(4);
 351 }
 352
 353 static int
 354 lpc_ns8250_rxready(struct uart_bas *bas)
 355 {
 356
 357         return ((uart_getreg(bas, REG_LSR) & LSR_RXRDY) != 0 ? 1 : 0);
 358 }
 359
 360 static int
 361 lpc_ns8250_getc(struct uart_bas *bas, struct mtx *hwmtx)
 362 {
 363         int c;
 364
 365         uart_lock(hwmtx);
 366
 367         while ((uart_getreg(bas, REG_LSR) & LSR_RXRDY) == 0) {
 368                 uart_unlock(hwmtx);
 369                 DELAY(4);
 370                 uart_lock(hwmtx);
 371         }
 372
 373         c = uart_getreg(bas, REG_DATA);
 374
 375         uart_unlock(hwmtx);
 376
 377         return (c);
 378 }
 379
 380 /*
 381  * High-level UART interface.
 382  */
 383 struct lpc_ns8250_softc {
 384         struct uart_softc base;
 385         uint8_t         fcr;
 386         uint8_t         ier;
 387         uint8_t         mcr;
 388
 389         uint8_t         ier_mask;
 390         uint8_t         ier_rxbits;
 391 };
 392
 393 static int lpc_ns8250_bus_attach(struct uart_softc *);
 394 static int lpc_ns8250_bus_detach(struct uart_softc *);
 395 static int lpc_ns8250_bus_flush(struct uart_softc *, int);
 396 static int lpc_ns8250_bus_getsig(struct uart_softc *);
 397 static int lpc_ns8250_bus_ioctl(struct uart_softc *, int, intptr_t);
 398 static int lpc_ns8250_bus_ipend(struct uart_softc *);
 399 static int lpc_ns8250_bus_param(struct uart_softc *, int, int, int, int);
 400 static int lpc_ns8250_bus_probe(struct uart_softc *);
 401 static int lpc_ns8250_bus_receive(struct uart_softc *);
 402 static int lpc_ns8250_bus_setsig(struct uart_softc *, int);
 403 static int lpc_ns8250_bus_transmit(struct uart_softc *);
 404 static void lpc_ns8250_bus_grab(struct uart_softc *);
 405 static void lpc_ns8250_bus_ungrab(struct uart_softc *);
 406
 407 static kobj_method_t lpc_ns8250_methods[] = {
 408         KOBJMETHOD(uart_attach,         lpc_ns8250_bus_attach),
 409         KOBJMETHOD(uart_detach,         lpc_ns8250_bus_detach),
 410         KOBJMETHOD(uart_flush,          lpc_ns8250_bus_flush),
 411         KOBJMETHOD(uart_getsig,         lpc_ns8250_bus_getsig),
 412         KOBJMETHOD(uart_ioctl,          lpc_ns8250_bus_ioctl),
 413         KOBJMETHOD(uart_ipend,          lpc_ns8250_bus_ipend),
 414         KOBJMETHOD(uart_param,          lpc_ns8250_bus_param),
 415         KOBJMETHOD(uart_probe,          lpc_ns8250_bus_probe),
 416         KOBJMETHOD(uart_receive,        lpc_ns8250_bus_receive),
 417         KOBJMETHOD(uart_setsig,         lpc_ns8250_bus_setsig),
 418         KOBJMETHOD(uart_transmit,       lpc_ns8250_bus_transmit),
 419         KOBJMETHOD(uart_grab,           lpc_ns8250_bus_grab),
 420         KOBJMETHOD(uart_ungrab,         lpc_ns8250_bus_ungrab),
 421         { 0, 0 }
 422 };
 423
 424 static struct uart_class uart_lpc_class = {
 425         "lpc_ns8250",
 426         lpc_ns8250_methods,
 427         sizeof(struct lpc_ns8250_softc),
 428         .uc_ops = &uart_lpc_ns8250_ops,
 429         .uc_range = 8,
 430         .uc_rclk = DEFAULT_RCLK,
 431         .uc_rshift = 0
 432 };
 433
 434 static struct ofw_compat_data compat_data[] = {
 435         {"lpc,uart",            (uintptr_t)&uart_lpc_class},
 436         {NULL,                  (uintptr_t)NULL},
 437 };
 438 UART_FDT_CLASS_AND_DEVICE(compat_data);
 439
 440 #define SIGCHG(c, i, s, d)                              \
 441         if (c) {                                        \
 442                 i |= (i & s) ? s : s | d;               \
 443         } else {                                        \
 444                 i = (i & s) ? (i & ~s) | d : i;         \
 445         }
 446
 447 static int
 448 lpc_ns8250_bus_attach(struct uart_softc *sc)
 449 {
 450         struct lpc_ns8250_softc *lpc_ns8250 = (struct lpc_ns8250_softc*)sc;
 451         struct uart_bas *bas;
 452         unsigned int ivar;
 453
 454         bas = &sc->sc_bas;
 455
 456         lpc_ns8250->mcr = uart_getreg(bas, REG_MCR);
 457         lpc_ns8250->fcr = FCR_ENABLE | FCR_DMA;
 458         if (!resource_int_value("uart", device_get_unit(sc->sc_dev), "flags",
 459             &ivar)) {
 460                 if (UART_FLAGS_FCR_RX_LOW(ivar))
 461                         lpc_ns8250->fcr |= FCR_RX_LOW;
 462                 else if (UART_FLAGS_FCR_RX_MEDL(ivar))
 463                         lpc_ns8250->fcr |= FCR_RX_MEDL;
 464                 else if (UART_FLAGS_FCR_RX_HIGH(ivar))
 465                         lpc_ns8250->fcr |= FCR_RX_HIGH;
 466                 else
 467                         lpc_ns8250->fcr |= FCR_RX_MEDH;
 468         } else
 469                 lpc_ns8250->fcr |= FCR_RX_HIGH;
 470
 471         /* Get IER mask */
 472         ivar = 0xf0;
 473         resource_int_value("uart", device_get_unit(sc->sc_dev), "ier_mask",
 474             &ivar);
 475         lpc_ns8250->ier_mask = (uint8_t)(ivar & 0xff);
 476
 477         /* Get IER RX interrupt bits */
 478         ivar = IER_EMSC | IER_ERLS | IER_ERXRDY;
 479         resource_int_value("uart", device_get_unit(sc->sc_dev), "ier_rxbits",
 480             &ivar);
 481         lpc_ns8250->ier_rxbits = (uint8_t)(ivar & 0xff);
 482
 483         uart_setreg(bas, REG_FCR, lpc_ns8250->fcr);
 484         uart_barrier(bas);
 485         lpc_ns8250_bus_flush(sc, UART_FLUSH_RECEIVER|UART_FLUSH_TRANSMITTER);
 486
 487         if (lpc_ns8250->mcr & MCR_DTR)
 488                 sc->sc_hwsig |= SER_DTR;
 489         if (lpc_ns8250->mcr & MCR_RTS)
 490                 sc->sc_hwsig |= SER_RTS;
 491         lpc_ns8250_bus_getsig(sc);
 492
 493         lpc_ns8250_clrint(bas);
 494         lpc_ns8250->ier = uart_getreg(bas, REG_IER) & lpc_ns8250->ier_mask;
 495         lpc_ns8250->ier |= lpc_ns8250->ier_rxbits;
 496         uart_setreg(bas, REG_IER, lpc_ns8250->ier);
 497         uart_barrier(bas);
 498
 499         return (0);
 500 }
 501
 502 static int
 503 lpc_ns8250_bus_detach(struct uart_softc *sc)
 504 {
 505         struct lpc_ns8250_softc *lpc_ns8250;
 506         struct uart_bas *bas;
 507         u_char ier;
 508
 509         lpc_ns8250 = (struct lpc_ns8250_softc *)sc;
 510         bas = &sc->sc_bas;
 511         ier = uart_getreg(bas, REG_IER) & lpc_ns8250->ier_mask;
 512         uart_setreg(bas, REG_IER, ier);
 513         uart_barrier(bas);
 514         lpc_ns8250_clrint(bas);
 515         return (0);
 516 }
 517
 518 static int
 519 lpc_ns8250_bus_flush(struct uart_softc *sc, int what)
 520 {
 521         struct lpc_ns8250_softc *lpc_ns8250 = (struct lpc_ns8250_softc*)sc;
 522         struct uart_bas *bas;
 523         int error;
 524
 525         bas = &sc->sc_bas;
 526         uart_lock(sc->sc_hwmtx);
 527         if (sc->sc_rxfifosz > 1) {
 528                 lpc_ns8250_flush(bas, what);
 529                 uart_setreg(bas, REG_FCR, lpc_ns8250->fcr);
 530                 uart_barrier(bas);
 531                 error = 0;
 532         } else
 533                 error = lpc_ns8250_drain(bas, what);
 534         uart_unlock(sc->sc_hwmtx);
 535         return (error);
 536 }
 537
 538 static int
 539 lpc_ns8250_bus_getsig(struct uart_softc *sc)
 540 {
 541         uint32_t new, old, sig;
 542         uint8_t msr;
 543
 544         do {
 545                 old = sc->sc_hwsig;
 546                 sig = old;
 547                 uart_lock(sc->sc_hwmtx);
 548                 msr = uart_getreg(&sc->sc_bas, REG_MSR);
 549                 uart_unlock(sc->sc_hwmtx);
 550                 SIGCHG(msr & MSR_DSR, sig, SER_DSR, SER_DDSR);
 551                 SIGCHG(msr & MSR_CTS, sig, SER_CTS, SER_DCTS);
 552                 SIGCHG(msr & MSR_DCD, sig, SER_DCD, SER_DDCD);
 553                 SIGCHG(msr & MSR_RI,  sig, SER_RI,  SER_DRI);
 554                 new = sig & ~SER_MASK_DELTA;
 555         } while (!atomic_cmpset_32(&sc->sc_hwsig, old, new));
 556         return (sig);
 557 }
 558
 559 static int
 560 lpc_ns8250_bus_ioctl(struct uart_softc *sc, int request, intptr_t data)
 561 {
 562         struct uart_bas *bas;
 563         int baudrate, divisor, error;
 564         uint8_t efr, lcr;
 565
 566         bas = &sc->sc_bas;
 567         error = 0;
 568         uart_lock(sc->sc_hwmtx);
 569         switch (request) {
 570         case UART_IOCTL_BREAK:
 571                 lcr = uart_getreg(bas, REG_LCR);
 572                 if (data)
 573                         lcr |= LCR_SBREAK;
 574                 else
 575                         lcr &= ~LCR_SBREAK;
 576                 uart_setreg(bas, REG_LCR, lcr);
 577                 uart_barrier(bas);
 578                 break;
 579         case UART_IOCTL_IFLOW:
 580                 lcr = uart_getreg(bas, REG_LCR);
 581                 uart_barrier(bas);
 582                 uart_setreg(bas, REG_LCR, 0xbf);
 583                 uart_barrier(bas);
 584                 efr = uart_getreg(bas, REG_EFR);
 585                 if (data)
 586                         efr |= EFR_RTS;
 587                 else
 588                         efr &= ~EFR_RTS;
 589                 uart_setreg(bas, REG_EFR, efr);
 590                 uart_barrier(bas);
 591                 uart_setreg(bas, REG_LCR, lcr);
 592                 uart_barrier(bas);
 593                 break;
 594         case UART_IOCTL_OFLOW:
 595                 lcr = uart_getreg(bas, REG_LCR);
 596                 uart_barrier(bas);
 597                 uart_setreg(bas, REG_LCR, 0xbf);
 598                 uart_barrier(bas);
 599                 efr = uart_getreg(bas, REG_EFR);
 600                 if (data)
 601                         efr |= EFR_CTS;
 602                 else
 603                         efr &= ~EFR_CTS;
 604                 uart_setreg(bas, REG_EFR, efr);
 605                 uart_barrier(bas);
 606                 uart_setreg(bas, REG_LCR, lcr);
 607                 uart_barrier(bas);
 608                 break;
 609         case UART_IOCTL_BAUD:
 610                 lcr = uart_getreg(bas, REG_LCR);
 611                 uart_setreg(bas, REG_LCR, lcr | LCR_DLAB);
 612                 uart_barrier(bas);
 613                 divisor = uart_getreg(bas, REG_DLL) |
 614                     (uart_getreg(bas, REG_DLH) << 8);
 615                 uart_barrier(bas);
 616                 uart_setreg(bas, REG_LCR, lcr);
 617                 uart_barrier(bas);
 618                 baudrate = (divisor > 0) ? bas->rclk / divisor / 16 : 0;
 619                 if (baudrate > 0)
 620                         *(int*)data = baudrate;
 621                 else
 622                         error = ENXIO;
 623                 break;
 624         default:
 625                 error = EINVAL;
 626                 break;
 627         }
 628         uart_unlock(sc->sc_hwmtx);
 629         return (error);
 630 }
 631
 632 static int
 633 lpc_ns8250_bus_ipend(struct uart_softc *sc)
 634 {
 635         struct uart_bas *bas;
 636         struct lpc_ns8250_softc *lpc_ns8250;
 637         int ipend;
 638         uint8_t iir, lsr;
 639
 640         lpc_ns8250 = (struct lpc_ns8250_softc *)sc;
 641         bas = &sc->sc_bas;
 642         uart_lock(sc->sc_hwmtx);
 643         iir = uart_getreg(bas, REG_IIR);
 644         if (iir & IIR_NOPEND) {
 645                 uart_unlock(sc->sc_hwmtx);
 646                 return (0);
 647         }
 648         ipend = 0;
 649         if (iir & IIR_RXRDY) {
 650                 lsr = uart_getreg(bas, REG_LSR);
 651                 if (lsr & LSR_OE)
 652                         ipend |= SER_INT_OVERRUN;
 653                 if (lsr & LSR_BI)
 654                         ipend |= SER_INT_BREAK;
 655                 if (lsr & LSR_RXRDY)
 656                         ipend |= SER_INT_RXREADY;
 657         } else {
 658                 if (iir & IIR_TXRDY) {
 659                         ipend |= SER_INT_TXIDLE;
 660                         uart_setreg(bas, REG_IER, lpc_ns8250->ier);
 661                         uart_barrier(bas);
 662                 } else
 663                         ipend |= SER_INT_SIGCHG;
 664         }
 665         if (ipend == 0)
 666                 lpc_ns8250_clrint(bas);
 667         uart_unlock(sc->sc_hwmtx);
 668         return (ipend);
 669 }
 670
 671 static int
 672 lpc_ns8250_bus_param(struct uart_softc *sc, int baudrate, int databits,
 673     int stopbits, int parity)
 674 {
 675         struct uart_bas *bas;
 676         int error;
 677
 678         bas = &sc->sc_bas;
 679         uart_lock(sc->sc_hwmtx);
 680         error = lpc_ns8250_param(bas, baudrate, databits, stopbits, parity);
 681         uart_unlock(sc->sc_hwmtx);
 682         return (error);
 683 }
 684
 685 static int
 686 lpc_ns8250_bus_probe(struct uart_softc *sc)
 687 {
 688         struct lpc_ns8250_softc *lpc_ns8250;
 689         struct uart_bas *bas;
 690         int count, delay, error, limit;
 691         uint8_t lsr, mcr, ier;
 692
 693         lpc_ns8250 = (struct lpc_ns8250_softc *)sc;
 694         bas = &sc->sc_bas;
 695
 696         error = lpc_ns8250_probe(bas);
 697         if (error)
 698                 return (error);
 699
 700         mcr = MCR_IE;
 701         if (sc->sc_sysdev == NULL) {
 702                 /* By using lpc_ns8250_init() we also set DTR and RTS. */
 703                 lpc_ns8250_init(bas, 115200, 8, 1, UART_PARITY_NONE);
 704         } else
 705                 mcr |= MCR_DTR | MCR_RTS;
 706
 707         error = lpc_ns8250_drain(bas, UART_DRAIN_TRANSMITTER);
 708         if (error)
 709                 return (error);
 710
 711         /*
 712          * Set loopback mode. This avoids having garbage on the wire and
 713          * also allows us send and receive data. We set DTR and RTS to
 714          * avoid the possibility that automatic flow-control prevents
 715          * any data from being sent.
 716          */
 717         uart_setreg(bas, REG_MCR, MCR_LOOPBACK | MCR_IE | MCR_DTR | MCR_RTS);
 718         uart_barrier(bas);
 719
 720         /*
 721          * Enable FIFOs. And check that the UART has them. If not, we're
 722          * done. Since this is the first time we enable the FIFOs, we reset
 723          * them.
 724          */
 725         uart_setreg(bas, REG_FCR, FCR_ENABLE);
 726         uart_barrier(bas);
 727         if (!(uart_getreg(bas, REG_IIR) & IIR_FIFO_MASK)) {
 728                 /*
 729                  * NS16450 or INS8250. We don't bother to differentiate
 730                  * between them. They're too old to be interesting.
 731                  */
 732                 uart_setreg(bas, REG_MCR, mcr);
 733                 uart_barrier(bas);
 734                 sc->sc_rxfifosz = sc->sc_txfifosz = 1;
 735                 device_set_desc(sc->sc_dev, "8250 or 16450 or compatible");
 736                 return (0);
 737         }
 738
 739         uart_setreg(bas, REG_FCR, FCR_ENABLE | FCR_XMT_RST | FCR_RCV_RST);
 740         uart_barrier(bas);
 741
 742         count = 0;
 743         delay = lpc_ns8250_delay(bas);
 744
 745         /* We have FIFOs. Drain the transmitter and receiver. */
 746         error = lpc_ns8250_drain(bas, UART_DRAIN_RECEIVER|UART_DRAIN_TRANSMITTER);
 747         if (error) {
 748                 uart_setreg(bas, REG_MCR, mcr);
 749                 uart_setreg(bas, REG_FCR, 0);
 750                 uart_barrier(bas);
 751                 goto done;
 752         }
 753
 754         /*
 755          * We should have a sufficiently clean "pipe" to determine the
 756          * size of the FIFOs. We send as much characters as is reasonable
 757          * and wait for the overflow bit in the LSR register to be
 758          * asserted, counting the characters as we send them. Based on
 759          * that count we know the FIFO size.
 760          */
 761         do {
 762                 uart_setreg(bas, REG_DATA, 0);
 763                 uart_barrier(bas);
 764                 count++;
 765
 766                 limit = 30;
 767                 lsr = 0;
 768                 /*
 769                  * LSR bits are cleared upon read, so we must accumulate
 770                  * them to be able to test LSR_OE below.
 771                  */
 772                 while (((lsr |= uart_getreg(bas, REG_LSR)) & LSR_TEMT) == 0 &&
 773                     --limit)
 774                         DELAY(delay);
 775                 if (limit == 0) {
 776                         ier = uart_getreg(bas, REG_IER) & lpc_ns8250->ier_mask;
 777                         uart_setreg(bas, REG_IER, ier);
 778                         uart_setreg(bas, REG_MCR, mcr);
 779                         uart_setreg(bas, REG_FCR, 0);
 780                         uart_barrier(bas);
 781                         count = 0;
 782                         goto done;
 783                 }
 784         } while ((lsr & LSR_OE) == 0 && count < 130);
 785         count--;
 786
 787         uart_setreg(bas, REG_MCR, mcr);
 788
 789         /* Reset FIFOs. */
 790         lpc_ns8250_flush(bas, UART_FLUSH_RECEIVER|UART_FLUSH_TRANSMITTER);
 791
 792 done:
 793         sc->sc_rxfifosz = 64;
 794         device_set_desc(sc->sc_dev, "LPC32x0 UART with FIFOs");
 795
 796         /*
 797          * Force the Tx FIFO size to 16 bytes for now. We don't program the
 798          * Tx trigger. Also, we assume that all data has been sent when the
 799          * interrupt happens.
 800          */
 801         sc->sc_txfifosz = 16;
 802
 803 #if 0
 804         /*
 805          * XXX there are some issues related to hardware flow control and
 806          * it's likely that uart(4) is the cause. This basically needs more
 807          * investigation, but we avoid using for hardware flow control
 808          * until then.
 809          */
 810         /* 16650s or higher have automatic flow control. */
 811         if (sc->sc_rxfifosz > 16) {
 812                 sc->sc_hwiflow = 1;
 813                 sc->sc_hwoflow = 1;
 814         }
 815 #endif
 816         return (0);
 817 }
 818
 819 static int
 820 lpc_ns8250_bus_receive(struct uart_softc *sc)
 821 {
 822         struct uart_bas *bas;
 823         int xc;
 824         uint8_t lsr;
 825
 826         bas = &sc->sc_bas;
 827         uart_lock(sc->sc_hwmtx);
 828         lsr = uart_getreg(bas, REG_LSR);
 829         while (lsr & LSR_RXRDY) {
 830                 if (uart_rx_full(sc)) {
 831                         sc->sc_rxbuf[sc->sc_rxput] = UART_STAT_OVERRUN;
 832                         break;
 833                 }
 834                 xc = uart_getreg(bas, REG_DATA);
 835                 if (lsr & LSR_FE)
 836                         xc |= UART_STAT_FRAMERR;
 837                 if (lsr & LSR_PE)
 838                         xc |= UART_STAT_PARERR;
 839                 uart_rx_put(sc, xc);
 840                 lsr = uart_getreg(bas, REG_LSR);
 841         }
 842         /* Discard everything left in the Rx FIFO. */
 843         while (lsr & LSR_RXRDY) {
 844                 (void)uart_getreg(bas, REG_DATA);
 845                 uart_barrier(bas);
 846                 lsr = uart_getreg(bas, REG_LSR);
 847         }
 848         uart_unlock(sc->sc_hwmtx);
 849         return (0);
 850 }
 851
 852 static int
 853 lpc_ns8250_bus_setsig(struct uart_softc *sc, int sig)
 854 {
 855         struct lpc_ns8250_softc *lpc_ns8250 = (struct lpc_ns8250_softc*)sc;
 856         struct uart_bas *bas;
 857         uint32_t new, old;
 858
 859         bas = &sc->sc_bas;
 860         do {
 861                 old = sc->sc_hwsig;
 862                 new = old;
 863                 if (sig & SER_DDTR) {
 864                         SIGCHG(sig & SER_DTR, new, SER_DTR,
 865                             SER_DDTR);
 866                 }
 867                 if (sig & SER_DRTS) {
 868                         SIGCHG(sig & SER_RTS, new, SER_RTS,
 869                             SER_DRTS);
 870                 }
 871         } while (!atomic_cmpset_32(&sc->sc_hwsig, old, new));
 872         uart_lock(sc->sc_hwmtx);
 873         lpc_ns8250->mcr &= ~(MCR_DTR|MCR_RTS);
 874         if (new & SER_DTR)
 875                 lpc_ns8250->mcr |= MCR_DTR;
 876         if (new & SER_RTS)
 877                 lpc_ns8250->mcr |= MCR_RTS;
 878         uart_setreg(bas, REG_MCR, lpc_ns8250->mcr);
 879         uart_barrier(bas);
 880         uart_unlock(sc->sc_hwmtx);
 881         return (0);
 882 }
 883
 884 static int
 885 lpc_ns8250_bus_transmit(struct uart_softc *sc)
 886 {
 887         struct lpc_ns8250_softc *lpc_ns8250 = (struct lpc_ns8250_softc*)sc;
 888         struct uart_bas *bas;
 889         int i;
 890
 891         bas = &sc->sc_bas;
 892         uart_lock(sc->sc_hwmtx);
 893         while ((uart_getreg(bas, REG_LSR) & LSR_THRE) == 0)
 894                 ;
 895         for (i = 0; i < sc->sc_txdatasz; i++) {
 896                 uart_setreg(bas, REG_DATA, sc->sc_txbuf[i]);
 897                 uart_barrier(bas);
 898         }
 899         uart_setreg(bas, REG_IER, lpc_ns8250->ier | IER_ETXRDY);
 900         uart_barrier(bas);
 901         sc->sc_txbusy = 1;
 902         uart_unlock(sc->sc_hwmtx);
 903         return (0);
 904 }
 905
 906 void
 907 lpc_ns8250_bus_grab(struct uart_softc *sc)
 908 {
 909         struct uart_bas *bas = &sc->sc_bas;
 910
 911         /*
 912          * turn off all interrupts to enter polling mode. Leave the
 913          * saved mask alone. We'll restore whatever it was in ungrab.
 914          * All pending interrupt signals are reset when IER is set to 0.
 915          */
 916         uart_lock(sc->sc_hwmtx);
 917         uart_setreg(bas, REG_IER, 0);
 918         uart_barrier(bas);
 919         uart_unlock(sc->sc_hwmtx);
 920 }
 921
 922 void
 923 lpc_ns8250_bus_ungrab(struct uart_softc *sc)
 924 {
 925         struct lpc_ns8250_softc *lpc_ns8250 = (struct lpc_ns8250_softc*)sc;
 926         struct uart_bas *bas = &sc->sc_bas;
 927
 928         /*
 929          * Restore previous interrupt mask
 930          */
 931         uart_lock(sc->sc_hwmtx);
 932         uart_setreg(bas, REG_IER, lpc_ns8250->ier);
 933         uart_barrier(bas);
 934         uart_unlock(sc->sc_hwmtx);
 935 }