sys/arm/nvidia/tegra_rtc.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  * RTC driver for Tegra SoCs.
  32  */
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/bus.h>
  36 #include <sys/clock.h>
  37 #include <sys/kernel.h>
  38 #include <sys/limits.h>
  39 #include <sys/lock.h>
  40 #include <sys/mutex.h>
  41 #include <sys/module.h>
  42 #include <sys/resource.h>
  43
  44 #include <machine/bus.h>
  45 #include <machine/resource.h>
  46 #include <sys/rman.h>
  47
  48 #include <dev/extres/clk/clk.h>
  49 #include <dev/ofw/ofw_bus.h>
  50 #include <dev/ofw/ofw_bus_subr.h>
  51
  52 #include "clock_if.h"
  53
  54 #define RTC_CONTROL                             0x00
  55 #define RTC_BUSY                                0x04
  56 #define  RTC_BUSY_STATUS                                (1 << 0)
  57 #define RTC_SECONDS                             0x08
  58 #define RTC_SHADOW_SECONDS                      0x0c
  59 #define RTC_MILLI_SECONDS                       0x10
  60 #define RTC_SECONDS_ALARM0                      0x14
  61 #define RTC_SECONDS_ALARM1                      0x18
  62 #define RTC_MILLI_SECONDS_ALARM                 0x1c
  63 #define RTC_SECONDS_COUNTDOWN_ALARM             0x20
  64 #define RTC_MILLI_SECONDS_COUNTDOW_ALARM        0x24
  65 #define RTC_INTR_MASK                           0x28
  66 #define  RTC_INTR_MSEC_CDN_ALARM                        (1 << 4)
  67 #define  RTC_INTR_SEC_CDN_ALARM                         (1 << 3)
  68 #define  RTC_INTR_MSEC_ALARM                            (1 << 2)
  69 #define  RTC_INTR_SEC_ALARM1                            (1 << 1)
  70 #define  RTC_INTR_SEC_ALARM0                            (1 << 0)
  71
  72 #define RTC_INTR_STATUS                         0x2c
  73 #define RTC_INTR_SOURCE                         0x30
  74 #define RTC_INTR_SET                            0x34
  75 #define RTC_CORRECTION_FACTOR                   0x38
  76
  77 #define WR4(_sc, _r, _v)        bus_write_4((_sc)->mem_res, (_r), (_v))
  78 #define RD4(_sc, _r)            bus_read_4((_sc)->mem_res, (_r))
  79
  80 #define LOCK(_sc)               mtx_lock(&(_sc)->mtx)
  81 #define UNLOCK(_sc)             mtx_unlock(&(_sc)->mtx)
  82 #define SLEEP(_sc, timeout)                                             \
  83         mtx_sleep(sc, &sc->mtx, 0, "rtcwait", timeout);
  84 #define LOCK_INIT(_sc)                                                  \
  85         mtx_init(&_sc->mtx, device_get_nameunit(_sc->dev), "tegra_rtc", MTX_DEF)
  86 #define LOCK_DESTROY(_sc)       mtx_destroy(&_sc->mtx)
  87 #define ASSERT_LOCKED(_sc)      mtx_assert(&_sc->mtx, MA_OWNED)
  88 #define ASSERT_UNLOCKED(_sc)    mtx_assert(&_sc->mtx, MA_NOTOWNED)
  89
  90 static struct ofw_compat_data compat_data[] = {
  91         {"nvidia,tegra124-rtc", 1},
  92         {NULL,                  0}
  93 };
  94
  95 struct tegra_rtc_softc {
  96         device_t                dev;
  97         struct mtx              mtx;
  98
  99         struct resource         *mem_res;
 100         struct resource         *irq_res;
 101         void                    *irq_h;
 102
 103         clk_t                   clk;
 104         uint32_t                core_freq;
 105 };
 106
 107 static void
 108 tegra_rtc_wait(struct tegra_rtc_softc *sc)
 109 {
 110         int timeout;
 111
 112         for (timeout = 500; timeout >0; timeout--) {
 113                 if ((RD4(sc, RTC_BUSY) & RTC_BUSY_STATUS) == 0)
 114                         break;
 115                 DELAY(1);
 116         }
 117         if (timeout <= 0)
 118                 device_printf(sc->dev, "Device busy timeouted\n");
 119
 120 }
 121
 122 /*
 123  * Get the time of day clock and return it in ts.
 124  * Return 0 on success, an error number otherwise.
 125  */
 126 static int
 127 tegra_rtc_gettime(device_t dev, struct timespec *ts)
 128 {
 129         struct tegra_rtc_softc *sc;
 130         struct timeval tv;
 131         uint32_t msec, sec;
 132
 133         sc = device_get_softc(dev);
 134
 135         LOCK(sc);
 136         msec = RD4(sc, RTC_MILLI_SECONDS);
 137         sec = RD4(sc, RTC_SHADOW_SECONDS);
 138         UNLOCK(sc);
 139         tv.tv_sec = sec;
 140         tv.tv_usec = msec * 1000;
 141         TIMEVAL_TO_TIMESPEC(&tv, ts);
 142         return (0);
 143 }
 144
 145
 146 static int
 147 tegra_rtc_settime(device_t dev, struct timespec *ts)
 148 {
 149         struct tegra_rtc_softc *sc;
 150         struct timeval tv;
 151
 152         sc = device_get_softc(dev);
 153
 154         LOCK(sc);
 155         TIMESPEC_TO_TIMEVAL(&tv, ts);
 156         tegra_rtc_wait(sc);
 157         WR4(sc, RTC_SECONDS, tv.tv_sec);
 158         UNLOCK(sc);
 159
 160         return (0);
 161 }
 162
 163
 164 static void
 165 tegra_rtc_intr(void *arg)
 166 {
 167         struct tegra_rtc_softc *sc;
 168         uint32_t status;
 169
 170         sc = (struct tegra_rtc_softc *)arg;
 171         LOCK(sc);
 172         status = RD4(sc, RTC_INTR_STATUS);
 173         WR4(sc, RTC_INTR_STATUS, status);
 174         UNLOCK(sc);
 175 }
 176
 177 static int
 178 tegra_rtc_probe(device_t dev)
 179 {
 180         if (!ofw_bus_status_okay(dev))
 181                 return (ENXIO);
 182
 183         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 184                 return (ENXIO);
 185
 186         return (BUS_PROBE_DEFAULT);
 187 }
 188
 189 static int
 190 tegra_rtc_attach(device_t dev)
 191 {
 192         int rv, rid;
 193         struct tegra_rtc_softc *sc;
 194
 195         sc = device_get_softc(dev);
 196         sc->dev = dev;
 197
 198         LOCK_INIT(sc);
 199
 200         /* Get the memory resource for the register mapping. */
 201         rid = 0;
 202         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 203             RF_ACTIVE);
 204         if (sc->mem_res == NULL) {
 205                 device_printf(dev, "Cannot map registers.\n");
 206                 rv = ENXIO;
 207                 goto fail;
 208         }
 209
 210         /* Allocate our IRQ resource. */
 211         rid = 0;
 212         sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 213             RF_ACTIVE);
 214         if (sc->irq_res == NULL) {
 215                 device_printf(dev, "Cannot allocate interrupt.\n");
 216                 rv = ENXIO;
 217                 goto fail;
 218         }
 219
 220         /* OFW resources. */
 221         rv = clk_get_by_ofw_index(dev, 0, 0, &sc->clk);
 222         if (rv != 0) {
 223                 device_printf(dev, "Cannot get i2c clock: %d\n", rv);
 224                 goto fail;
 225         }
 226         rv = clk_enable(sc->clk);
 227         if (rv != 0) {
 228                 device_printf(dev, "Cannot enable clock: %d\n", rv);
 229                 goto fail;
 230         }
 231
 232         /* Init hardware. */
 233         WR4(sc, RTC_SECONDS_ALARM0, 0);
 234         WR4(sc, RTC_SECONDS_ALARM1, 0);
 235         WR4(sc, RTC_INTR_STATUS, 0xFFFFFFFF);
 236         WR4(sc, RTC_INTR_MASK, 0);
 237
 238         /* Setup  interrupt */
 239         rv = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 240             NULL, tegra_rtc_intr, sc, &sc->irq_h);
 241         if (rv) {
 242                 device_printf(dev, "Cannot setup interrupt.\n");
 243                 goto fail;
 244         }
 245
 246         /*
 247          * Register as a time of day clock with 1-second resolution.
 248          *
 249          * XXXX Not yet, we don't have support for multiple RTCs
 250          */
 251         /* clock_register(dev, 1000000); */
 252
 253         return (bus_generic_attach(dev));
 254
 255 fail:
 256         if (sc->clk != NULL)
 257                 clk_release(sc->clk);
 258         if (sc->irq_h != NULL)
 259                 bus_teardown_intr(dev, sc->irq_res, sc->irq_h);
 260         if (sc->irq_res != NULL)
 261                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
 262         if (sc->mem_res != NULL)
 263                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
 264         LOCK_DESTROY(sc);
 265
 266         return (rv);
 267 }
 268
 269 static int
 270 tegra_rtc_detach(device_t dev)
 271 {
 272         struct tegra_rtc_softc *sc;
 273
 274         sc = device_get_softc(dev);
 275         if (sc->irq_h != NULL)
 276                 bus_teardown_intr(dev, sc->irq_res, sc->irq_h);
 277         if (sc->irq_res != NULL)
 278                 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res);
 279         if (sc->mem_res != NULL)
 280                 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res);
 281
 282         LOCK_DESTROY(sc);
 283         return (bus_generic_detach(dev));
 284 }
 285
 286 static device_method_t tegra_rtc_methods[] = {
 287         /* Device interface */
 288         DEVMETHOD(device_probe,         tegra_rtc_probe),
 289         DEVMETHOD(device_attach,        tegra_rtc_attach),
 290         DEVMETHOD(device_detach,        tegra_rtc_detach),
 291
 292         /* clock interface */
 293         DEVMETHOD(clock_gettime,        tegra_rtc_gettime),
 294         DEVMETHOD(clock_settime,        tegra_rtc_settime),
 295
 296         DEVMETHOD_END
 297 };
 298
 299 static devclass_t tegra_rtc_devclass;
 300 static DEFINE_CLASS_0(rtc, tegra_rtc_driver, tegra_rtc_methods,
 301     sizeof(struct tegra_rtc_softc));
 302 DRIVER_MODULE(tegra_rtc, simplebus, tegra_rtc_driver, tegra_rtc_devclass,
 303     NULL, NULL);