1 /*- 2 * Copyright (c) 2017 Semihalf. 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 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/bus.h> 32 #include <sys/conf.h> 33 #include <sys/kernel.h> 34 #include <sys/sysctl.h> 35 #include <sys/systm.h> 36 37 #include <machine/bus.h> 38 39 #include <dev/ofw/ofw_bus_subr.h> 40 #include <dev/uart/uart.h> 41 #include <dev/uart/uart_bus.h> 42 #include <dev/uart/uart_cpu.h> 43 #include <dev/uart/uart_cpu_fdt.h> 44 45 #include "uart_if.h" 46 47 #define UART_RBR 0x00 /* Receiver Buffer */ 48 #define RBR_BRK_DET (1 << 15) /* Break Detect */ 49 #define RBR_FRM_ERR_DET (1 << 14) /* Frame Error Detect */ 50 #define RBR_PAR_ERR_DET (1 << 13) /* Parity Error Detect */ 51 #define RBR_OVR_ERR_DET (1 << 12) /* Overrun Error */ 52 53 #define UART_TSH 0x04 /* Transmitter Holding Register */ 54 55 #define UART_CTRL 0x08 /* Control Register */ 56 #define CTRL_SOFT_RST (1 << 31) /* Soft Reset */ 57 #define CTRL_TX_FIFO_RST (1 << 15) /* TX FIFO Reset */ 58 #define CTRL_RX_FIFO_RST (1 << 14) /* RX FIFO Reset */ 59 #define CTRL_ST_MIRR_EN (1 << 13) /* Status Mirror Enable */ 60 #define CTRL_LPBK_EN (1 << 12) /* Loopback Mode Enable */ 61 #define CTRL_SND_BRK_SEQ (1 << 11) /* Send Break Sequence */ 62 #define CTRL_PAR_EN (1 << 10) /* Parity Enable */ 63 #define CTRL_TWO_STOP (1 << 9) /* Two Stop Bits */ 64 #define CTRL_TX_HALF_INT (1 << 8) /* TX Half-Full Interrupt Enable */ 65 #define CTRL_RX_HALF_INT (1 << 7) /* RX Half-Full Interrupt Enable */ 66 #define CTRL_TX_EMPT_INT (1 << 6) /* TX Empty Interrupt Enable */ 67 #define CTRL_TX_RDY_INT (1 << 5) /* TX Ready Interrupt Enable */ 68 #define CTRL_RX_RDY_INT (1 << 4) /* RX Ready Interrupt Enable */ 69 #define CTRL_BRK_DET_INT (1 << 3) /* Break Detect Interrupt Enable */ 70 #define CTRL_FRM_ERR_INT (1 << 2) /* Frame Error Interrupt Enable */ 71 #define CTRL_PAR_ERR_INT (1 << 1) /* Parity Error Interrupt Enable */ 72 #define CTRL_OVR_ERR_INT (1 << 0) /* Overrun Error Interrupt Enable */ 73 #define CTRL_INTR_MASK 0x1ff 74 #define CTRL_TX_IDLE_INT CTRL_TX_RDY_INT 75 #define CTRL_IPEND_MASK (CTRL_OVR_ERR_INT | CTRL_BRK_DET_INT | \ 76 CTRL_RX_RDY_INT) 77 78 #define UART_STAT 0x0c /* Status Register */ 79 #define STAT_TX_FIFO_EMPT (1 << 13) /* TX FIFO Empty */ 80 #define STAT_RX_FIFO_EMPT (1 << 12) /* RX FIFO Empty */ 81 #define STAT_TX_FIFO_FULL (1 << 11) /* TX FIFO Full */ 82 #define STAT_TX_FIFO_HALF (1 << 10) /* TX FIFO Half Full */ 83 #define STAT_RX_TOGL (1 << 9) /* RX Toogled */ 84 #define STAT_RX_FIFO_FULL (1 << 8) /* RX FIFO Full */ 85 #define STAT_RX_FIFO_HALF (1 << 7) /* RX FIFO Half Full */ 86 #define STAT_TX_EMPT (1 << 6) /* TX Empty */ 87 #define STAT_TX_RDY (1 << 5) /* TX Ready */ 88 #define STAT_RX_RDY (1 << 4) /* RX Ready */ 89 #define STAT_BRK_DET (1 << 3) /* Break Detect */ 90 #define STAT_FRM_ERR (1 << 2) /* Frame Error */ 91 #define STAT_PAR_ERR (1 << 1) /* Parity Error */ 92 #define STAT_OVR_ERR (1 << 0) /* Overrun Error */ 93 #define STAT_TX_IDLE STAT_TX_RDY 94 #define STAT_TRANS_MASK (STAT_OVR_ERR | STAT_BRK_DET | STAT_RX_RDY) 95 96 #define UART_CCR 0x10 /* Clock Control Register */ 97 #define CCR_BAUDRATE_DIV 0x3ff /* Baud Rate Divisor */ 98 99 #define DEFAULT_RCLK 25804800 100 #define ONE_FRAME_TIME 87 101 102 #define stat_ipend_trans(i) ( \ 103 (i & STAT_OVR_ERR) << 16 | \ 104 (i & STAT_BRK_DET) << 14 | \ 105 (i & STAT_RX_RDY) << 14) 106 107 /* 108 * For debugging purposes 109 */ 110 #if 0 111 #ifdef EARLY_PRINTF 112 #if defined(SOCDEV_PA) && defined(SOCDEV_VA) 113 #define UART_REG_OFFSET 0x12000 114 static void 115 uart_mvebu_early_putc(int c) 116 { 117 volatile uint32_t *tsh; 118 volatile uint32_t *stat; 119 120 tsh = (uint32_t *)(SOCDEV_VA + UART_REG_OFFSET + UART_TSH); 121 stat = (uint32_t *)(SOCDEV_VA + UART_REG_OFFSET + UART_STAT); 122 123 while(!(*stat & STAT_TX_RDY)) 124 ; 125 126 *tsh = c & 0xff; 127 } 128 129 early_putc_t *early_putc = uart_mvebu_early_putc; 130 #endif 131 #endif 132 #endif 133 134 /* 135 * Low-level UART interface. 136 */ 137 static int uart_mvebu_probe(struct uart_bas *); 138 static void uart_mvebu_init(struct uart_bas *, int, int, int, int); 139 static void uart_mvebu_putc(struct uart_bas *, int); 140 static int uart_mvebu_rxready(struct uart_bas *); 141 static int uart_mvebu_getc(struct uart_bas *, struct mtx *); 142 143 static struct uart_ops uart_mvebu_ops = { 144 .probe = uart_mvebu_probe, 145 .init = uart_mvebu_init, 146 .term = NULL, 147 .putc = uart_mvebu_putc, 148 .rxready = uart_mvebu_rxready, 149 .getc = uart_mvebu_getc, 150 }; 151 152 static int 153 uart_mvebu_probe(struct uart_bas *bas) 154 { 155 156 return (0); 157 } 158 159 static int 160 uart_mvebu_divisor(int rclk, int baudrate) 161 { 162 int divisor; 163 164 if (baudrate == 0) 165 return (0); 166 167 divisor = (rclk >> 4) / baudrate; 168 if (divisor <= 1 || divisor >= 1024) 169 return (0); 170 171 return (divisor); 172 } 173 174 static int 175 uart_mvebu_param(struct uart_bas *bas, int baudrate, int databits, int stopbits, 176 int parity) 177 { 178 uint32_t ctrl = 0; 179 uint32_t ccr; 180 int divisor, ret = 0; 181 182 /* Reset UART */ 183 ctrl = uart_getreg(bas, UART_CTRL); 184 uart_setreg(bas, UART_CTRL, ctrl | CTRL_TX_FIFO_RST | CTRL_RX_FIFO_RST | 185 CTRL_LPBK_EN); 186 uart_barrier(bas); 187 188 switch (stopbits) { 189 case 2: 190 ctrl |= CTRL_TWO_STOP; 191 break; 192 case 1: 193 default: 194 ctrl &=~ CTRL_TWO_STOP; 195 } 196 197 switch (parity) { 198 case 3: /* Even parity bit */ 199 ctrl |= CTRL_PAR_EN; 200 break; 201 default: 202 ctrl &=~ CTRL_PAR_EN; 203 } 204 205 /* Set baudrate. */ 206 if (baudrate > 0) { 207 divisor = uart_mvebu_divisor(bas->rclk, baudrate); 208 if (divisor == 0) { 209 ret = EINVAL; 210 } else { 211 ccr = uart_getreg(bas, UART_CCR); 212 ccr &=~CCR_BAUDRATE_DIV; 213 214 uart_setreg(bas, UART_CCR, ccr | divisor); 215 uart_barrier(bas); 216 } 217 } 218 219 /* Set mirroring of status bits */ 220 ctrl |= CTRL_ST_MIRR_EN; 221 222 uart_setreg(bas, UART_CTRL, ctrl); 223 uart_barrier(bas); 224 225 return (ret); 226 } 227 228 static void 229 uart_mvebu_init(struct uart_bas *bas, int baudrate, int databits, int stopbits, 230 int parity) 231 { 232 /* Set default frequency */ 233 bas->rclk = DEFAULT_RCLK; 234 235 /* Mask interrupts */ 236 uart_setreg(bas, UART_CTRL, uart_getreg(bas, UART_CTRL) & 237 ~CTRL_INTR_MASK); 238 uart_barrier(bas); 239 240 uart_mvebu_param(bas, baudrate, databits, stopbits, parity); 241 } 242 243 static void 244 uart_mvebu_putc(struct uart_bas *bas, int c) 245 { 246 while (uart_getreg(bas, UART_STAT) & STAT_TX_FIFO_FULL) 247 ; 248 uart_setreg(bas, UART_TSH, c & 0xff); 249 } 250 251 static int 252 uart_mvebu_rxready(struct uart_bas *bas) 253 { 254 if (uart_getreg(bas, UART_STAT) & STAT_RX_RDY) 255 return 1; 256 return 0; 257 } 258 259 static int 260 uart_mvebu_getc(struct uart_bas *bas, struct mtx *hwmtx) 261 { 262 int c; 263 264 uart_lock(hwmtx); 265 while (!(uart_getreg(bas, UART_STAT) & STAT_RX_RDY)) 266 ; 267 268 c = uart_getreg(bas, UART_RBR) & 0xff; 269 uart_unlock(hwmtx); 270 271 return c; 272 } 273 274 /* 275 * UART driver methods implementation. 276 */ 277 struct uart_mvebu_softc { 278 struct uart_softc base; 279 uint16_t intrm; 280 }; 281 282 static int uart_mvebu_bus_attach(struct uart_softc *); 283 static int uart_mvebu_bus_detach(struct uart_softc *); 284 static int uart_mvebu_bus_flush(struct uart_softc *, int); 285 static int uart_mvebu_bus_getsig(struct uart_softc *); 286 static int uart_mvebu_bus_ioctl(struct uart_softc *, int, intptr_t); 287 static int uart_mvebu_bus_ipend(struct uart_softc *); 288 static int uart_mvebu_bus_param(struct uart_softc *, int, int, int, int); 289 static int uart_mvebu_bus_probe(struct uart_softc *); 290 static int uart_mvebu_bus_receive(struct uart_softc *); 291 static int uart_mvebu_bus_setsig(struct uart_softc *, int); 292 static int uart_mvebu_bus_transmit(struct uart_softc *); 293 static void uart_mvebu_bus_grab(struct uart_softc *); 294 static void uart_mvebu_bus_ungrab(struct uart_softc *); 295 296 static kobj_method_t uart_mvebu_methods[] = { 297 KOBJMETHOD(uart_attach, uart_mvebu_bus_attach), 298 KOBJMETHOD(uart_detach, uart_mvebu_bus_detach), 299 KOBJMETHOD(uart_flush, uart_mvebu_bus_flush), 300 KOBJMETHOD(uart_getsig, uart_mvebu_bus_getsig), 301 KOBJMETHOD(uart_ioctl, uart_mvebu_bus_ioctl), 302 KOBJMETHOD(uart_ipend, uart_mvebu_bus_ipend), 303 KOBJMETHOD(uart_param, uart_mvebu_bus_param), 304 KOBJMETHOD(uart_probe, uart_mvebu_bus_probe), 305 KOBJMETHOD(uart_receive, uart_mvebu_bus_receive), 306 KOBJMETHOD(uart_setsig, uart_mvebu_bus_setsig), 307 KOBJMETHOD(uart_transmit, uart_mvebu_bus_transmit), 308 KOBJMETHOD(uart_grab, uart_mvebu_bus_grab), 309 KOBJMETHOD(uart_ungrab, uart_mvebu_bus_ungrab), 310 { 0, 0 } 311 }; 312 313 struct uart_class uart_mvebu_class = { 314 "mvebu-uart", 315 uart_mvebu_methods, 316 sizeof(struct uart_mvebu_softc), 317 .uc_ops = &uart_mvebu_ops, 318 .uc_range = 0x14, 319 .uc_rclk = DEFAULT_RCLK, 320 .uc_rshift = 0, 321 .uc_riowidth = 4 322 }; 323 324 static struct ofw_compat_data compat_data[] = { 325 {"marvell,armada-3700-uart", (uintptr_t)&uart_mvebu_class}, 326 {NULL, (uintptr_t)NULL}, 327 }; 328 UART_FDT_CLASS_AND_DEVICE(compat_data); 329 330 static int 331 uart_mvebu_bus_attach(struct uart_softc *sc) 332 { 333 struct uart_bas *bas; 334 int ctrl; 335 336 bas = &sc->sc_bas; 337 uart_lock(sc->sc_hwmtx); 338 339 ctrl = uart_getreg(bas, UART_CTRL); 340 341 /* Enable interrupts */ 342 ctrl &=~ CTRL_INTR_MASK; 343 ctrl |= CTRL_IPEND_MASK; 344 345 /* Set interrupts */ 346 uart_setreg(bas, UART_CTRL, ctrl); 347 uart_barrier(bas); 348 349 uart_unlock(sc->sc_hwmtx); 350 351 return (0); 352 } 353 354 static int 355 uart_mvebu_bus_detach(struct uart_softc *sc) 356 { 357 358 return (0); 359 } 360 361 static int 362 uart_mvebu_bus_flush(struct uart_softc *sc, int what) 363 { 364 struct uart_bas *bas; 365 int ctrl, ret = 0; 366 367 bas = &sc->sc_bas; 368 uart_lock(sc->sc_hwmtx); 369 ctrl = uart_getreg(bas, UART_CTRL); 370 371 switch (what) { 372 case UART_FLUSH_RECEIVER: 373 uart_setreg(bas, UART_CTRL, ctrl | CTRL_RX_FIFO_RST); 374 uart_barrier(bas); 375 break; 376 377 case UART_FLUSH_TRANSMITTER: 378 uart_setreg(bas, UART_CTRL, ctrl | CTRL_TX_FIFO_RST); 379 uart_barrier(bas); 380 break; 381 382 default: 383 ret = EINVAL; 384 break; 385 } 386 387 /* Back to normal operation */ 388 if (!ret) { 389 uart_setreg(bas, UART_CTRL, ctrl); 390 uart_barrier(bas); 391 } 392 393 uart_unlock(sc->sc_hwmtx); 394 return (ret); 395 } 396 397 static int 398 uart_mvebu_bus_getsig(struct uart_softc *sc) 399 { 400 401 return (0); 402 } 403 404 static int 405 uart_mvebu_bus_ioctl(struct uart_softc *sc, int request, intptr_t data) 406 { 407 struct uart_bas *bas; 408 int ctrl, ret = 0; 409 int divisor, baudrate; 410 411 bas = &sc->sc_bas; 412 uart_lock(sc->sc_hwmtx); 413 switch (request) { 414 case UART_IOCTL_BREAK: 415 ctrl = uart_getreg(bas, UART_CTRL); 416 if (data) 417 ctrl |= CTRL_SND_BRK_SEQ; 418 else 419 ctrl &=~ CTRL_SND_BRK_SEQ; 420 uart_setreg(bas, UART_CTRL, ctrl); 421 uart_barrier(bas); 422 break; 423 424 case UART_IOCTL_BAUD: 425 divisor = uart_getreg(bas, UART_CCR) & CCR_BAUDRATE_DIV; 426 baudrate = bas->rclk/(divisor * 16); 427 *(int *)data = baudrate; 428 break; 429 430 default: 431 ret = ENOTTY; 432 break; 433 } 434 uart_unlock(sc->sc_hwmtx); 435 436 return (ret); 437 } 438 439 static int 440 uart_mvebu_bus_ipend(struct uart_softc *sc) 441 { 442 struct uart_bas *bas; 443 int ipend, ctrl, ret = 0; 444 445 bas = &sc->sc_bas; 446 uart_lock(sc->sc_hwmtx); 447 ipend = uart_getreg(bas, UART_STAT); 448 ctrl = uart_getreg(bas, UART_CTRL); 449 450 if (((ipend & STAT_TX_IDLE) == STAT_TX_IDLE) && 451 (ctrl & CTRL_TX_IDLE_INT) == CTRL_TX_IDLE_INT) { 452 /* Disable TX IDLE Interrupt generation */ 453 uart_setreg(bas, UART_CTRL, ctrl & ~CTRL_TX_IDLE_INT); 454 uart_barrier(bas); 455 456 /* SER_INT_TXIDLE means empty TX FIFO. Wait until it cleans */ 457 while(!(uart_getreg(bas, UART_STAT) & STAT_TX_FIFO_EMPT)) 458 DELAY(ONE_FRAME_TIME/2); 459 460 ret |= SER_INT_TXIDLE; 461 } 462 463 ret |= stat_ipend_trans(ipend & STAT_TRANS_MASK); 464 465 uart_unlock(sc->sc_hwmtx); 466 467 return (ret); 468 } 469 470 static int 471 uart_mvebu_bus_param(struct uart_softc *sc, int baudrate, int databits, 472 int stopbits, int parity) 473 { 474 int ret; 475 476 uart_lock(sc->sc_hwmtx); 477 ret = uart_mvebu_param(&sc->sc_bas, baudrate, databits, stopbits, parity); 478 uart_unlock(sc->sc_hwmtx); 479 480 return (ret); 481 } 482 483 static int 484 uart_mvebu_bus_probe(struct uart_softc *sc) 485 { 486 if (!ofw_bus_status_okay(sc->sc_dev)) 487 return (ENXIO); 488 489 if (!ofw_bus_search_compatible(sc->sc_dev, compat_data)->ocd_data) 490 return (ENXIO); 491 492 device_set_desc(sc->sc_dev, "Marvell Armada 3700 UART"); 493 494 sc->sc_txfifosz = 32; 495 sc->sc_rxfifosz = 64; 496 sc->sc_hwiflow = 0; 497 sc->sc_hwoflow = 0; 498 499 return (0); 500 } 501 502 int 503 uart_mvebu_bus_receive(struct uart_softc *sc) 504 { 505 struct uart_bas *bas; 506 uint32_t xc; 507 int rx, er; 508 509 bas = &sc->sc_bas; 510 uart_lock(sc->sc_hwmtx); 511 512 while (!(uart_getreg(bas, UART_STAT) & STAT_RX_FIFO_EMPT)) { 513 if (uart_rx_full(sc)) { 514 sc->sc_rxbuf[sc->sc_rxput] = UART_STAT_OVERRUN; 515 break; 516 } 517 518 xc = uart_getreg(bas, UART_RBR); 519 rx = xc & 0xff; 520 er = xc & 0xf000; 521 /* 522 * Formula which translates marvell error bits 523 * Only valid when CTRL_ST_MIRR_EN is set 524 */ 525 er = (er & RBR_BRK_DET) >> 7 | 526 (er & RBR_FRM_ERR_DET) >> 5 | 527 (er & RBR_PAR_ERR_DET) >> 2 | 528 (er & RBR_OVR_ERR_DET) >> 2; 529 530 uart_rx_put(sc, rx | er); 531 uart_barrier(bas); 532 } 533 /* 534 * uart_if.m says that receive interrupt 535 * should be cleared, so we need to reset 536 * RX FIFO 537 */ 538 539 if (!(uart_getreg(bas, UART_STAT) & STAT_RX_FIFO_EMPT)) { 540 uart_mvebu_bus_flush(sc, UART_FLUSH_RECEIVER); 541 } 542 543 uart_unlock(sc->sc_hwmtx); 544 return (0); 545 } 546 547 static int 548 uart_mvebu_bus_setsig(struct uart_softc *sc, int sig) 549 { 550 /* Not supported by hardware */ 551 return (0); 552 } 553 554 int 555 uart_mvebu_bus_transmit(struct uart_softc *sc) 556 { 557 struct uart_bas *bas; 558 int i, ctrl; 559 560 bas = &sc->sc_bas; 561 uart_lock(sc->sc_hwmtx); 562 563 /* Turn off all interrupts during send */ 564 ctrl = uart_getreg(bas, UART_CTRL); 565 uart_setreg(bas, UART_CTRL, ctrl & ~CTRL_INTR_MASK); 566 uart_barrier(bas); 567 568 for (i = 0; i < sc->sc_txdatasz; i++) { 569 uart_setreg(bas, UART_TSH, sc->sc_txbuf[i] & 0xff); 570 uart_barrier(bas); 571 } 572 573 /* 574 * Make sure that interrupt is generated 575 * when FIFO can get more data. 576 */ 577 uart_setreg(bas, UART_CTRL, ctrl | CTRL_TX_IDLE_INT); 578 uart_barrier(bas); 579 580 /* Mark busy */ 581 sc->sc_txbusy = 1; 582 583 uart_unlock(sc->sc_hwmtx); 584 return (0); 585 } 586 587 static void 588 uart_mvebu_bus_grab(struct uart_softc *sc) 589 { 590 struct uart_mvebu_softc *msc = (struct uart_mvebu_softc *)sc; 591 struct uart_bas *bas = &sc->sc_bas; 592 uint32_t ctrl; 593 594 /* Mask all interrupts */ 595 uart_lock(sc->sc_hwmtx); 596 ctrl = uart_getreg(bas, UART_CTRL); 597 msc->intrm = ctrl & CTRL_INTR_MASK; 598 uart_setreg(bas, UART_CTRL, ctrl & ~CTRL_INTR_MASK); 599 uart_barrier(bas); 600 uart_unlock(sc->sc_hwmtx); 601 } 602 603 static void 604 uart_mvebu_bus_ungrab(struct uart_softc *sc) 605 { 606 struct uart_mvebu_softc *msc = (struct uart_mvebu_softc *)sc; 607 struct uart_bas *bas = &sc->sc_bas; 608 uint32_t ctrl; 609 610 /* Restore interrupts */ 611 uart_lock(sc->sc_hwmtx); 612 ctrl = uart_getreg(bas, UART_CTRL) & ~CTRL_INTR_MASK; 613 uart_setreg(bas, UART_CTRL, ctrl | msc->intrm); 614 uart_barrier(bas); 615 uart_unlock(sc->sc_hwmtx); 616 } 617