1 /*- 2 * Copyright (c) 2018 Diane Bruce 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 /* 27 * Based on uart_dev_pl011.c 28 * Copyright (c) 2012 Semihalf. 29 * All rights reserved. 30 */ 31 /* 32 * The mini Uart has the following features: 33 * - 7 or 8 bit operation. 34 * - 1 start and 1 stop bit. 35 * - No parities. 36 * - Break generation. 37 * - 8 symbols deep FIFOs for receive and transmit. 38 * - SW controlled RTS, SW readable CTS. 39 * - Auto flow control with programmable FIFO level. 40 * - 16550 like registers. 41 * - Baudrate derived from system clock. 42 * This is a mini UART and it does NOT have the following capabilities: 43 * - Break detection 44 * - Framing errors detection. 45 * - Parity bit 46 * - Receive Time-out interrupt 47 * - DCD, DSR, DTR or RI signals. 48 * The implemented UART is not a 16650 compatible UART However as far 49 * as possible the first 8 control and status registers are laid out 50 * like a 16550 UART. All 16550 register bits which are not supported can 51 * be written but will be ignored and read back as 0. All control bits 52 * for simple UART receive/transmit operations are available. 53 */ 54 55 #include "opt_acpi.h" 56 #include "opt_platform.h" 57 58 #include <sys/cdefs.h> 59 __FBSDID("$FreeBSD$"); 60 61 #include <sys/param.h> 62 #include <sys/systm.h> 63 #include <sys/kernel.h> 64 #include <sys/bus.h> 65 66 #include <machine/bus.h> 67 #include <machine/machdep.h> 68 #include <machine/pcpu.h> 69 70 #include <dev/uart/uart.h> 71 #include <dev/uart/uart_cpu.h> 72 #ifdef FDT 73 #include <dev/uart/uart_cpu_fdt.h> 74 #include <dev/ofw/ofw_bus.h> 75 #endif 76 #include <dev/uart/uart_bus.h> 77 #include "uart_if.h" 78 79 /* BCM2835 Micro UART registers and masks*/ 80 #define AUX_MU_IO_REG 0x00 /* I/O register */ 81 82 /* 83 * According to errata bits 1 and 2 are swapped, 84 * Also bits 2 and 3 are required to enable interrupts. 85 */ 86 #define AUX_MU_IER_REG 0x01 87 #define IER_RXENABLE (1) 88 #define IER_TXENABLE (1<<1) 89 #define IER_REQUIRED (3<<2) 90 #define IER_MASK_ALL (IER_TXENABLE|IER_RXENABLE) 91 92 #define AUX_MU_IIR_REG 0x02 93 #define IIR_READY (1) 94 #define IIR_TXREADY (1<<1) 95 #define IIR_RXREADY (1<<2) 96 #define IIR_CLEAR (3<<1) 97 98 #define AUX_MU_LCR_REG 0x03 99 #define LCR_WLEN7 (0) 100 #define LCR_WLEN8 (3) 101 102 #define AUX_MU_MCR_REG 0x04 103 #define AUX_MCR_RTS (1<<1) 104 105 #define AUX_MU_LSR_REG 0x05 106 #define LSR_RXREADY (1) 107 #define LSR_OVRRUN (1<<1) 108 #define LSR_TXEMPTY (1<<5) 109 #define LSR_TXIDLE (1<<6) 110 111 #define AUX_MU_MSR_REG 0x06 112 #define MSR_CTS (1<<5) 113 114 #define AUX_MU_SCRATCH_REG 0x07 115 116 #define AUX_MU_CNTL_REG 0x08 117 #define CNTL_RXENAB (1) 118 #define CNTL_TXENAB (1<<1) 119 120 #define AUX_MU_STAT_REG 0x09 121 #define STAT_TX_SA (1<<1) 122 #define STAT_RX_SA (1) 123 124 #define AUX_MU_BAUD_REG 0x0a 125 126 /* 127 * FIXME: actual register size is SoC-dependent, we need to handle it 128 */ 129 #define __uart_getreg(bas, reg) \ 130 bus_space_read_4((bas)->bst, (bas)->bsh, uart_regofs(bas, reg)) 131 #define __uart_setreg(bas, reg, value) \ 132 bus_space_write_4((bas)->bst, (bas)->bsh, uart_regofs(bas, reg), value) 133 134 /* 135 * Low-level UART interface. 136 */ 137 static int uart_mu_probe(struct uart_bas *bas); 138 static void uart_mu_init(struct uart_bas *bas, int, int, int, int); 139 static void uart_mu_term(struct uart_bas *bas); 140 static void uart_mu_putc(struct uart_bas *bas, int); 141 static int uart_mu_rxready(struct uart_bas *bas); 142 static int uart_mu_getc(struct uart_bas *bas, struct mtx *); 143 144 static struct uart_ops uart_mu_ops = { 145 .probe = uart_mu_probe, 146 .init = uart_mu_init, 147 .term = uart_mu_term, 148 .putc = uart_mu_putc, 149 .rxready = uart_mu_rxready, 150 .getc = uart_mu_getc, 151 }; 152 153 static int 154 uart_mu_probe(struct uart_bas *bas) 155 { 156 157 return (0); 158 } 159 160 /* 161 * According to the docs, the cpu clock is locked to 250Mhz when 162 * the micro-uart is used 163 */ 164 #define CPU_CLOCK 250000000 165 166 static void 167 uart_mu_param(struct uart_bas *bas, int baudrate, int databits, int stopbits, 168 int parity) 169 { 170 uint32_t line; 171 uint32_t baud; 172 173 /* 174 * Zero all settings to make sure 175 * UART is disabled and not configured 176 */ 177 line = 0x0; 178 __uart_setreg(bas, AUX_MU_CNTL_REG, line); 179 180 /* As I know UART is disabled I can setup the line */ 181 switch (databits) { 182 case 7: 183 line |= LCR_WLEN7; 184 break; 185 case 6: 186 case 8: 187 default: 188 line |= LCR_WLEN8; 189 break; 190 } 191 192 __uart_setreg(bas, AUX_MU_LCR_REG, line); 193 194 /* See 2.2.1 BCM2835-ARM-Peripherals baudrate */ 195 if (baudrate != 0) { 196 baud = CPU_CLOCK / (8 * baudrate); 197 /* XXX 198 * baud = cpu_clock() / (8 * baudrate); 199 */ 200 __uart_setreg(bas, AUX_MU_BAUD_REG, ((uint32_t)(baud & 0xFFFF))); 201 } 202 203 /* re-enable UART */ 204 __uart_setreg(bas, AUX_MU_CNTL_REG, CNTL_RXENAB|CNTL_TXENAB); 205 } 206 207 static void 208 uart_mu_init(struct uart_bas *bas, int baudrate, int databits, int stopbits, 209 int parity) 210 { 211 212 /* Mask all interrupts */ 213 __uart_setreg(bas, AUX_MU_IER_REG, 0); 214 uart_mu_param(bas, baudrate, databits, stopbits, parity); 215 } 216 217 static void 218 uart_mu_term(struct uart_bas *bas) 219 { 220 } 221 222 static void 223 uart_mu_putc(struct uart_bas *bas, int c) 224 { 225 226 /* Wait when TX FIFO full. Push character otherwise. */ 227 while ((__uart_getreg(bas, AUX_MU_LSR_REG) & LSR_TXEMPTY) == 0) 228 ; 229 __uart_setreg(bas, AUX_MU_IO_REG, c & 0xff); 230 } 231 232 static int 233 uart_mu_rxready(struct uart_bas *bas) 234 { 235 236 return ((__uart_getreg(bas, AUX_MU_LSR_REG) & LSR_RXREADY) != 0); 237 } 238 239 static int 240 uart_mu_getc(struct uart_bas *bas, struct mtx *hwmtx) 241 { 242 int c; 243 244 while(!uart_mu_rxready(bas)) 245 ; 246 c = __uart_getreg(bas, AUX_MU_IO_REG) & 0xff; 247 return (c); 248 } 249 250 /* 251 * High-level UART interface. 252 */ 253 struct uart_mu_softc { 254 struct uart_softc bas; 255 uint16_t aux_ier; /* Interrupt mask */ 256 }; 257 258 static int uart_mu_bus_attach(struct uart_softc *); 259 static int uart_mu_bus_detach(struct uart_softc *); 260 static int uart_mu_bus_flush(struct uart_softc *, int); 261 static int uart_mu_bus_getsig(struct uart_softc *); 262 static int uart_mu_bus_ioctl(struct uart_softc *, int, intptr_t); 263 static int uart_mu_bus_ipend(struct uart_softc *); 264 static int uart_mu_bus_param(struct uart_softc *, int, int, int, int); 265 static int uart_mu_bus_probe(struct uart_softc *); 266 static int uart_mu_bus_receive(struct uart_softc *); 267 static int uart_mu_bus_setsig(struct uart_softc *, int); 268 static int uart_mu_bus_transmit(struct uart_softc *); 269 static void uart_mu_bus_grab(struct uart_softc *); 270 static void uart_mu_bus_ungrab(struct uart_softc *); 271 272 static kobj_method_t uart_mu_methods[] = { 273 KOBJMETHOD(uart_attach, uart_mu_bus_attach), 274 KOBJMETHOD(uart_detach, uart_mu_bus_detach), 275 KOBJMETHOD(uart_flush, uart_mu_bus_flush), 276 KOBJMETHOD(uart_getsig, uart_mu_bus_getsig), 277 KOBJMETHOD(uart_ioctl, uart_mu_bus_ioctl), 278 KOBJMETHOD(uart_ipend, uart_mu_bus_ipend), 279 KOBJMETHOD(uart_param, uart_mu_bus_param), 280 KOBJMETHOD(uart_probe, uart_mu_bus_probe), 281 KOBJMETHOD(uart_receive, uart_mu_bus_receive), 282 KOBJMETHOD(uart_setsig, uart_mu_bus_setsig), 283 KOBJMETHOD(uart_transmit, uart_mu_bus_transmit), 284 KOBJMETHOD(uart_grab, uart_mu_bus_grab), 285 KOBJMETHOD(uart_ungrab, uart_mu_bus_ungrab), 286 287 { 0, 0 } 288 }; 289 290 static struct uart_class uart_mu_class = { 291 "aux-uart", 292 uart_mu_methods, 293 sizeof(struct uart_mu_softc), 294 .uc_ops = &uart_mu_ops, 295 .uc_range = 0x48, 296 .uc_rclk = 0, 297 .uc_rshift = 2 298 }; 299 300 #ifdef FDT 301 static struct ofw_compat_data fdt_compat_data[] = { 302 {"brcm,bcm2835-aux-uart" , (uintptr_t)&uart_mu_class}, 303 {NULL, (uintptr_t)NULL}, 304 }; 305 UART_FDT_CLASS_AND_DEVICE(fdt_compat_data); 306 #endif 307 308 static int 309 uart_mu_bus_attach(struct uart_softc *sc) 310 { 311 struct uart_mu_softc *psc; 312 struct uart_bas *bas; 313 314 psc = (struct uart_mu_softc *)sc; 315 bas = &sc->sc_bas; 316 /* Clear interrupts */ 317 __uart_setreg(bas, AUX_MU_IIR_REG, IIR_CLEAR); 318 /* Enable interrupts */ 319 psc->aux_ier = (IER_RXENABLE|IER_TXENABLE|IER_REQUIRED); 320 __uart_setreg(bas, AUX_MU_IER_REG, psc->aux_ier); 321 sc->sc_txbusy = 0; 322 323 return (0); 324 } 325 326 static int 327 uart_mu_bus_detach(struct uart_softc *sc) 328 { 329 330 return (0); 331 } 332 333 static int 334 uart_mu_bus_flush(struct uart_softc *sc, int what) 335 { 336 337 return (0); 338 } 339 340 static int 341 uart_mu_bus_getsig(struct uart_softc *sc) 342 { 343 344 return (0); 345 } 346 347 static int 348 uart_mu_bus_ioctl(struct uart_softc *sc, int request, intptr_t data) 349 { 350 struct uart_bas *bas; 351 int error; 352 353 bas = &sc->sc_bas; 354 error = 0; 355 uart_lock(sc->sc_hwmtx); 356 switch (request) { 357 case UART_IOCTL_BREAK: 358 break; 359 case UART_IOCTL_BAUD: 360 *(int*)data = 115200; 361 break; 362 default: 363 error = EINVAL; 364 break; 365 } 366 uart_unlock(sc->sc_hwmtx); 367 368 return (error); 369 } 370 371 static int 372 uart_mu_bus_ipend(struct uart_softc *sc) 373 { 374 struct uart_mu_softc *psc; 375 struct uart_bas *bas; 376 uint32_t ints; 377 int ipend; 378 379 psc = (struct uart_mu_softc *)sc; 380 bas = &sc->sc_bas; 381 382 uart_lock(sc->sc_hwmtx); 383 ints = __uart_getreg(bas, AUX_MU_IIR_REG); 384 ipend = 0; 385 386 /* 387 * According to docs only one of IIR_RXREADY 388 * or IIR_TXREADY are valid eg. Only one or the other. 389 */ 390 if (ints & IIR_RXREADY) { 391 ipend |= SER_INT_RXREADY; 392 } else if (ints & IIR_TXREADY) { 393 if (__uart_getreg(bas, AUX_MU_LSR_REG) & LSR_TXIDLE) { 394 if (sc->sc_txbusy) 395 ipend |= SER_INT_TXIDLE; 396 397 /* Disable TX interrupt */ 398 __uart_setreg(bas, AUX_MU_IER_REG, 399 psc->aux_ier & ~IER_TXENABLE); 400 } 401 } 402 403 uart_unlock(sc->sc_hwmtx); 404 405 return (ipend); 406 } 407 408 static int 409 uart_mu_bus_param(struct uart_softc *sc, int baudrate, int databits, 410 int stopbits, int parity) 411 { 412 413 uart_lock(sc->sc_hwmtx); 414 uart_mu_param(&sc->sc_bas, baudrate, databits, stopbits, parity); 415 uart_unlock(sc->sc_hwmtx); 416 417 return (0); 418 } 419 420 static int 421 uart_mu_bus_probe(struct uart_softc *sc) 422 { 423 424 /* MU always has 8 byte deep fifo */ 425 sc->sc_rxfifosz = 8; 426 sc->sc_txfifosz = 8; 427 device_set_desc(sc->sc_dev, "BCM2835 Mini-UART"); 428 429 return (0); 430 } 431 432 static int 433 uart_mu_bus_receive(struct uart_softc *sc) 434 { 435 struct uart_mu_softc *psc; 436 struct uart_bas *bas; 437 uint32_t lsr, xc; 438 int rx; 439 440 bas = &sc->sc_bas; 441 uart_lock(sc->sc_hwmtx); 442 psc = (struct uart_mu_softc *)sc; 443 444 lsr = __uart_getreg(bas, AUX_MU_LSR_REG); 445 while (lsr & LSR_RXREADY) { 446 xc = __uart_getreg(bas, AUX_MU_IO_REG); 447 rx = xc & 0xff; 448 if (uart_rx_full(sc)) { 449 sc->sc_rxbuf[sc->sc_rxput] = UART_STAT_OVERRUN; 450 break; 451 } 452 uart_rx_put(sc, rx); 453 lsr = __uart_getreg(bas, AUX_MU_LSR_REG); 454 } 455 uart_unlock(sc->sc_hwmtx); 456 457 return (0); 458 } 459 460 static int 461 uart_mu_bus_setsig(struct uart_softc *sc, int sig) 462 { 463 464 return (0); 465 } 466 467 static int 468 uart_mu_bus_transmit(struct uart_softc *sc) 469 { 470 struct uart_mu_softc *psc; 471 struct uart_bas *bas; 472 int i; 473 474 psc = (struct uart_mu_softc *)sc; 475 bas = &sc->sc_bas; 476 uart_lock(sc->sc_hwmtx); 477 478 for (i = 0; i < sc->sc_txdatasz; i++) { 479 __uart_setreg(bas, AUX_MU_IO_REG, sc->sc_txbuf[i] & 0xff); 480 uart_barrier(bas); 481 } 482 483 /* Mark busy and enable TX interrupt */ 484 sc->sc_txbusy = 1; 485 __uart_setreg(bas, AUX_MU_IER_REG, psc->aux_ier); 486 487 uart_unlock(sc->sc_hwmtx); 488 489 return (0); 490 } 491 492 static void 493 uart_mu_bus_grab(struct uart_softc *sc) 494 { 495 struct uart_mu_softc *psc; 496 struct uart_bas *bas; 497 498 psc = (struct uart_mu_softc *)sc; 499 bas = &sc->sc_bas; 500 501 /* Disable interrupts on switch to polling */ 502 uart_lock(sc->sc_hwmtx); 503 __uart_setreg(bas, AUX_MU_IER_REG, psc->aux_ier &~IER_MASK_ALL); 504 uart_unlock(sc->sc_hwmtx); 505 } 506 507 static void 508 uart_mu_bus_ungrab(struct uart_softc *sc) 509 { 510 struct uart_mu_softc *psc; 511 struct uart_bas *bas; 512 513 psc = (struct uart_mu_softc *)sc; 514 bas = &sc->sc_bas; 515 516 /* Switch to using interrupts while not grabbed */ 517 uart_lock(sc->sc_hwmtx); 518 __uart_setreg(bas, AUX_MU_CNTL_REG, CNTL_RXENAB|CNTL_TXENAB); 519 __uart_setreg(bas, AUX_MU_IER_REG, psc->aux_ier); 520 uart_unlock(sc->sc_hwmtx); 521 } 522