sys/arm/nvidia/tegra_uart.c

   1 /*-
   2  * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org>
   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
  31 /*
  32  * UART driver for Tegra SoCs.
  33  */
  34 #include "opt_platform.h"
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/bus.h>
  39 #include <sys/conf.h>
  40 #include <sys/kernel.h>
  41 #include <sys/module.h>
  42 #include <sys/sysctl.h>
  43 #include <machine/bus.h>
  44
  45 #include <dev/extres/clk/clk.h>
  46 #include <dev/extres/hwreset/hwreset.h>
  47 #include <dev/fdt/fdt_common.h>
  48 #include <dev/ofw/ofw_bus.h>
  49 #include <dev/ofw/ofw_bus_subr.h>
  50 #include <dev/uart/uart.h>
  51 #include <dev/uart/uart_cpu.h>
  52 #include <dev/uart/uart_cpu_fdt.h>
  53 #include <dev/uart/uart_bus.h>
  54 #include <dev/uart/uart_dev_ns8250.h>
  55 #include <dev/ic/ns16550.h>
  56
  57 #include "uart_if.h"
  58
  59 /*
  60  * High-level UART interface.
  61  */
  62 struct tegra_softc {
  63         struct ns8250_softc     ns8250_base;
  64         clk_t                   clk;
  65         hwreset_t               reset;
  66 };
  67
  68 /*
  69  * UART class interface.
  70  */
  71 static int
  72 tegra_uart_attach(struct uart_softc *sc)
  73 {
  74         int rv;
  75         struct ns8250_softc *ns8250 = (struct ns8250_softc*)sc;
  76         struct uart_bas *bas = &sc->sc_bas;
  77
  78         rv = ns8250_bus_attach(sc);
  79         if (rv != 0)
  80                 return (rv);
  81
  82         ns8250->ier_rxbits = 0x1d;
  83         ns8250->ier_mask = 0xc0;
  84         ns8250->ier = uart_getreg(bas, REG_IER) & ns8250->ier_mask;
  85         ns8250->ier |= ns8250->ier_rxbits;
  86         uart_setreg(bas, REG_IER, ns8250->ier);
  87         uart_barrier(bas);
  88         return (0);
  89 }
  90
  91 static void
  92 tegra_uart_grab(struct uart_softc *sc)
  93 {
  94         struct uart_bas *bas = &sc->sc_bas;
  95         struct ns8250_softc *ns8250 = (struct ns8250_softc*)sc;
  96         u_char ier;
  97
  98         /*
  99          * turn off all interrupts to enter polling mode. Leave the
 100          * saved mask alone. We'll restore whatever it was in ungrab.
 101          * All pending interrupt signals are reset when IER is set to 0.
 102          */
 103         uart_lock(sc->sc_hwmtx);
 104         ier = uart_getreg(bas, REG_IER);
 105         uart_setreg(bas, REG_IER, ier & ns8250->ier_mask);
 106         uart_setreg(bas, REG_FCR, 0);
 107         uart_barrier(bas);
 108         uart_unlock(sc->sc_hwmtx);
 109 }
 110
 111 static void
 112 tegra_uart_ungrab(struct uart_softc *sc)
 113 {
 114         struct ns8250_softc *ns8250 = (struct ns8250_softc*)sc;
 115         struct uart_bas *bas = &sc->sc_bas;
 116
 117         /*
 118          * Restore previous interrupt mask
 119          */
 120         uart_lock(sc->sc_hwmtx);
 121         uart_setreg(bas, REG_FCR, ns8250->fcr);
 122         uart_setreg(bas, REG_IER, ns8250->ier);
 123         uart_barrier(bas);
 124         uart_unlock(sc->sc_hwmtx);
 125 }
 126
 127 static kobj_method_t tegra_methods[] = {
 128         KOBJMETHOD(uart_probe,          ns8250_bus_probe),
 129         KOBJMETHOD(uart_attach,         tegra_uart_attach),
 130         KOBJMETHOD(uart_detach,         ns8250_bus_detach),
 131         KOBJMETHOD(uart_flush,          ns8250_bus_flush),
 132         KOBJMETHOD(uart_getsig,         ns8250_bus_getsig),
 133         KOBJMETHOD(uart_ioctl,          ns8250_bus_ioctl),
 134         KOBJMETHOD(uart_ipend,          ns8250_bus_ipend),
 135         KOBJMETHOD(uart_param,          ns8250_bus_param),
 136         KOBJMETHOD(uart_receive,        ns8250_bus_receive),
 137         KOBJMETHOD(uart_setsig,         ns8250_bus_setsig),
 138         KOBJMETHOD(uart_transmit,       ns8250_bus_transmit),
 139         KOBJMETHOD(uart_grab,           tegra_uart_grab),
 140         KOBJMETHOD(uart_ungrab,         tegra_uart_ungrab),
 141         KOBJMETHOD_END
 142 };
 143
 144 static struct uart_class tegra_uart_class = {
 145         "tegra class",
 146         tegra_methods,
 147         sizeof(struct tegra_softc),
 148         .uc_ops = &uart_ns8250_ops,
 149         .uc_range = 8,
 150         .uc_rclk = 0,
 151 };
 152
 153 /* Compatible devices. */
 154 static struct ofw_compat_data compat_data[] = {
 155         {"nvidia,tegra124-uart", (uintptr_t)&tegra_uart_class},
 156         {NULL,                  (uintptr_t)NULL},
 157 };
 158
 159 UART_FDT_CLASS(compat_data);
 160
 161 /*
 162  * UART Driver interface.
 163  */
 164 static int
 165 uart_fdt_get_shift1(phandle_t node)
 166 {
 167         pcell_t shift;
 168
 169         if ((OF_getencprop(node, "reg-shift", &shift, sizeof(shift))) <= 0)
 170                 shift = 2;
 171         return ((int)shift);
 172 }
 173
 174 static int
 175 tegra_uart_probe(device_t dev)
 176 {
 177         struct tegra_softc *sc;
 178         phandle_t node;
 179         uint64_t freq;
 180         int shift;
 181         int rv;
 182         const struct ofw_compat_data *cd;
 183
 184         sc = device_get_softc(dev);
 185         if (!ofw_bus_status_okay(dev))
 186                 return (ENXIO);
 187         cd = ofw_bus_search_compatible(dev, compat_data);
 188         if (cd->ocd_data == 0)
 189                 return (ENXIO);
 190         sc->ns8250_base.base.sc_class = (struct uart_class *)cd->ocd_data;
 191
 192         rv = hwreset_get_by_ofw_name(dev, "serial", &sc->reset);
 193         if (rv != 0) {
 194                 device_printf(dev, "Cannot get 'serial' reset\n");
 195                 return (ENXIO);
 196         }
 197         rv = hwreset_deassert(sc->reset);
 198         if (rv != 0) {
 199                 device_printf(dev, "Cannot unreset 'serial' reset\n");
 200                 return (ENXIO);
 201         }
 202
 203         node = ofw_bus_get_node(dev);
 204         shift = uart_fdt_get_shift1(node);
 205         rv = clk_get_by_ofw_index(dev, 0, &sc->clk);
 206         if (rv != 0) {
 207                 device_printf(dev, "Cannot get UART clock: %d\n", rv);
 208                 return (ENXIO);
 209         }
 210         rv = clk_enable(sc->clk);
 211         if (rv != 0) {
 212                 device_printf(dev, "Cannot enable UART clock: %d\n", rv);
 213                 return (ENXIO);
 214         }
 215         rv = clk_get_freq(sc->clk, &freq);
 216         if (rv != 0) {
 217                 device_printf(dev, "Cannot enable UART clock: %d\n", rv);
 218                 return (ENXIO);
 219         }
 220         return (uart_bus_probe(dev, shift, (int)freq, 0, 0));
 221 }
 222
 223 static int
 224 tegra_uart_detach(device_t dev)
 225 {
 226         struct tegra_softc *sc;
 227
 228         sc = device_get_softc(dev);
 229         if (sc->clk != NULL) {
 230                 clk_release(sc->clk);
 231         }
 232
 233         return (uart_bus_detach(dev));
 234 }
 235
 236 static device_method_t tegra_uart_bus_methods[] = {
 237         /* Device interface */
 238         DEVMETHOD(device_probe,         tegra_uart_probe),
 239         DEVMETHOD(device_attach,        uart_bus_attach),
 240         DEVMETHOD(device_detach,        tegra_uart_detach),
 241         { 0, 0 }
 242 };
 243
 244 static driver_t tegra_uart_driver = {
 245         uart_driver_name,
 246         tegra_uart_bus_methods,
 247         sizeof(struct tegra_softc),
 248 };
 249
 250 DRIVER_MODULE(tegra_uart, simplebus,  tegra_uart_driver, uart_devclass,
 251     0, 0);