sys/riscv/sifive/fe310_aon.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2019 Axiado Corporation
   5  * All rights reserved.
   6  *
   7  * This software was developed in part by Nick O'Brien and Rishul Naik
   8  * for Axiado Corporation.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/bus.h>
  38 #include <sys/clock.h>
  39 #include <sys/eventhandler.h>
  40 #include <sys/kernel.h>
  41 #include <sys/lock.h>
  42 #include <sys/module.h>
  43 #include <sys/mutex.h>
  44 #include <sys/rman.h>
  45 #include <sys/sdt.h>
  46 #include <sys/time.h>
  47 #include <sys/timespec.h>
  48 #include <sys/timex.h>
  49 #include <sys/watchdog.h>
  50
  51 #include <dev/ofw/ofw_bus.h>
  52 #include <dev/ofw/ofw_bus_subr.h>
  53
  54 #include <machine/bus.h>
  55 #include <machine/clock.h>
  56 #include <machine/intr.h>
  57 #include <machine/resource.h>
  58
  59 #include "clock_if.h"
  60
  61 #define FEAON_AON_WDT_BASE              0x0
  62 #define FEAON_AON_RTC_BASE              0x40
  63 #define FEAON_AON_CLKCFG_BASE           0x70
  64 #define FEAON_AON_BACKUP_BASE           0x80
  65 #define FEAON_AON_PMU_BASE              0x100
  66
  67 /* Watchdog specific */
  68 #define FEAON_WDT_CFG                   0x0
  69 #define FEAON_WDT_COUNT                 0x8
  70 #define FEAON_WDT_DOGS                  0x10
  71 #define FEAON_WDT_FEED                  0x18
  72 #define FEAON_WDT_KEY                   0x1C
  73 #define FEAON_WDT_CMP                   0x20
  74
  75 #define FEAON_WDT_CFG_SCALE_MASK        0xF
  76 #define FEAON_WDT_CFG_RST_EN            (1 << 8)
  77 #define FEAON_WDT_CFG_ZERO_CMP          (1 << 9)
  78 #define FEAON_WDT_CFG_EN_ALWAYS         (1 << 12)
  79 #define FEAON_WDT_CFG_EN_CORE_AWAKE     (1 << 13)
  80 #define FEAON_WDT_CFG_IP                (1 << 28)
  81
  82 #define FEAON_WDT_CMP_MASK              0xFFFF
  83
  84 #define FEAON_WDT_FEED_FOOD             0xD09F00D
  85
  86 #define FEAON_WDT_KEY_UNLOCK            0x51F15E
  87
  88 #define FEAON_WDT_TIMEBASE_FREQ         31250
  89 #define FEAON_WDT_TIMEBASE_RATIO        (NANOSECOND / FEAON_WDT_TIMEBASE_FREQ)
  90
  91 /* Real-time clock specific */
  92 #define FEAON_RTC_CFG                   0x40
  93 #define FEAON_RTC_LO                    0x48
  94 #define FEAON_RTC_HI                    0x4C
  95 #define FEAON_RTC_CMP                   0x60
  96
  97 #define FEAON_RTC_CFG_SCALE_MASK        0xF
  98 #define FEAON_RTC_CFG_EN                (1 << 12)
  99 #define FEAON_RTC_CFG_IP                (1 << 28)
 100
 101 #define FEAON_RTC_HI_MASK               0xFFFF
 102
 103 #define FEAON_RTC_TIMEBASE_FREQ         31250LL
 104
 105 #define FEAON_LOCK(sc)                  mtx_lock(&(sc)->mtx)
 106 #define FEAON_UNLOCK(sc)                mtx_unlock(&(sc)->mtx)
 107 #define FEAON_ASSERT_LOCKED(sc)         mtx_assert(&(sc)->mtx, MA_OWNED)
 108 #define FEAON_ASSERT_UNLOCKED(sc)       mtx_assert(&(sc)->mtx, MA_NOTOWNED)
 109
 110 #define FEAON_READ_4(sc, reg)           bus_read_4(sc->reg_res, reg)
 111 #define FEAON_WRITE_4(sc, reg, val)     bus_write_4(sc->reg_res, reg, val)
 112
 113 #define FEAON_WDT_WRITE_4(sc, reg, val) do {                                    \
 114                 FEAON_WRITE_4(sc, (FEAON_WDT_KEY), (FEAON_WDT_KEY_UNLOCK));     \
 115                 FEAON_WRITE_4(sc, reg, val);                                    \
 116         } while (0)
 117
 118 struct feaon_softc {
 119         device_t                dev;
 120         struct mtx              mtx;
 121
 122         /* Resources */
 123         int                     reg_rid;
 124         struct resource         *reg_res;
 125
 126         /* WDT */
 127         eventhandler_tag        ev_tag;
 128 };
 129
 130 static void
 131 feaon_wdt_event(void *arg, unsigned int cmd, int *err)
 132 {
 133         struct feaon_softc *sc;
 134         uint32_t scale, val;
 135         uint64_t time;
 136
 137         sc = (struct feaon_softc *)arg;
 138         FEAON_LOCK(sc);
 139
 140         /* First feed WDT */
 141         FEAON_WDT_WRITE_4(sc, FEAON_WDT_FEED, FEAON_WDT_FEED_FOOD);
 142
 143         if ((cmd & WD_INTERVAL) == WD_TO_NEVER) {
 144                 /* Disable WDT */
 145                 val = FEAON_READ_4(sc, FEAON_WDT_CFG);
 146                 val &= ~(FEAON_WDT_CFG_EN_ALWAYS | FEAON_WDT_CFG_EN_CORE_AWAKE);
 147                 FEAON_WDT_WRITE_4(sc, FEAON_WDT_CFG, val);
 148                 goto exit;
 149         }
 150
 151         /* Calculate time in WDT frequency */
 152         time = 1LL << (cmd & WD_INTERVAL);
 153         time /= FEAON_WDT_TIMEBASE_RATIO;
 154
 155         /* Fit time in CMP register with scale */
 156         scale = 0;
 157         while (time > FEAON_WDT_CMP_MASK) {
 158                 time >>= 1;
 159                 scale++;
 160         }
 161
 162         if (time > FEAON_WDT_CMP_MASK || scale > FEAON_WDT_CFG_SCALE_MASK) {
 163                 device_printf(sc->dev, "Time interval too large for WDT\n");
 164                 *err = EINVAL;
 165                 goto exit;
 166         }
 167
 168         /* Program WDT */
 169         val = FEAON_READ_4(sc, FEAON_WDT_CFG);
 170         val &= ~FEAON_WDT_CFG_SCALE_MASK;
 171         val |= scale | FEAON_WDT_CFG_RST_EN | FEAON_WDT_CFG_EN_ALWAYS |
 172             FEAON_WDT_CFG_ZERO_CMP;
 173
 174         FEAON_WDT_WRITE_4(sc, FEAON_WDT_CMP, (uint32_t)time);
 175         FEAON_WDT_WRITE_4(sc, FEAON_WDT_CFG, val);
 176
 177 exit:
 178         FEAON_UNLOCK(sc);
 179 }
 180
 181 static int
 182 feaon_rtc_settime(device_t dev, struct timespec *ts)
 183 {
 184         struct feaon_softc *sc;
 185         uint64_t time;
 186         uint32_t cfg;
 187         uint8_t scale;
 188
 189         scale = 0;
 190         sc = device_get_softc(dev);
 191
 192         FEAON_LOCK(sc);
 193
 194         clock_dbgprint_ts(dev, CLOCK_DBG_WRITE, ts);
 195
 196         time = ts->tv_sec * FEAON_RTC_TIMEBASE_FREQ;
 197
 198         /* Find an appropriate scale */
 199         while (time >= 0xFFFFFFFFFFFFLL) {
 200                 scale++;
 201                 time >>= 1;
 202         }
 203         if (scale > FEAON_RTC_CFG_SCALE_MASK) {
 204                 device_printf(sc->dev, "Time value too large for RTC\n");
 205                 FEAON_UNLOCK(sc);
 206                 return (1);
 207         }
 208         cfg = FEAON_READ_4(sc, FEAON_RTC_CFG) & ~FEAON_RTC_CFG_SCALE_MASK;
 209         cfg |= scale;
 210
 211         FEAON_WRITE_4(sc, FEAON_RTC_CFG, cfg);
 212         FEAON_WRITE_4(sc, FEAON_RTC_LO, (uint32_t)time);
 213         FEAON_WRITE_4(sc, FEAON_RTC_HI, (time >> 32) & FEAON_RTC_HI_MASK);
 214
 215         FEAON_UNLOCK(sc);
 216
 217         return (0);
 218 }
 219
 220 static int
 221 feaon_rtc_gettime(device_t dev, struct timespec *ts)
 222 {
 223         struct feaon_softc *sc;
 224         uint64_t time;
 225         uint8_t scale;
 226
 227         sc = device_get_softc(dev);
 228         FEAON_LOCK(sc);
 229
 230         time = FEAON_READ_4(sc, FEAON_RTC_LO);
 231         time |= ((uint64_t)FEAON_READ_4(sc, FEAON_RTC_HI)) << 32;
 232
 233         scale = FEAON_READ_4(sc, FEAON_RTC_CFG) & FEAON_RTC_CFG_SCALE_MASK;
 234         time <<= scale;
 235
 236         ts->tv_sec = time / FEAON_RTC_TIMEBASE_FREQ;
 237         ts->tv_nsec = (time % FEAON_RTC_TIMEBASE_FREQ) *
 238             (NANOSECOND / FEAON_RTC_TIMEBASE_FREQ);
 239
 240         clock_dbgprint_ts(dev, CLOCK_DBG_READ, ts);
 241
 242         FEAON_UNLOCK(sc);
 243
 244         return (0);
 245 }
 246
 247 static int
 248 feaon_attach(device_t dev)
 249 {
 250         struct feaon_softc *sc;
 251         int err;
 252
 253         sc = device_get_softc(dev);
 254         sc->dev = dev;
 255
 256         /* Mutex setup */
 257         mtx_init(&sc->mtx, device_get_nameunit(sc->dev), NULL, MTX_DEF);
 258
 259         /* Resource setup */
 260         sc->reg_rid = 0;
 261         if ((sc->reg_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 262             &sc->reg_rid, RF_ACTIVE)) == NULL) {
 263                 device_printf(dev, "Error allocating memory resource.\n");
 264                 err = ENXIO;
 265                 goto error;
 266         }
 267
 268         /* Enable RTC */
 269         clock_register(dev, 1000000); /* 1 sec resolution */
 270         FEAON_LOCK(sc);
 271         FEAON_WRITE_4(sc, FEAON_RTC_CFG, FEAON_RTC_CFG_EN);
 272         FEAON_UNLOCK(sc);
 273
 274         /* Register WDT */
 275         sc->ev_tag = EVENTHANDLER_REGISTER(watchdog_list, feaon_wdt_event, sc, 0);
 276
 277         return (0);
 278
 279 error:
 280         bus_release_resource(dev, SYS_RES_MEMORY, sc->reg_rid, sc->reg_res);
 281         mtx_destroy(&sc->mtx);
 282         return (err);
 283 }
 284
 285 static int
 286 feaon_probe(device_t dev)
 287 {
 288
 289         if (!ofw_bus_status_okay(dev))
 290                 return (ENXIO);
 291
 292         if (!ofw_bus_is_compatible(dev, "sifive,aon0"))
 293                 return (ENXIO);
 294
 295         device_set_desc(dev, "SiFive FE310 Always-On Controller");
 296         return (BUS_PROBE_DEFAULT);
 297 }
 298
 299 static device_method_t feaon_methods[] = {
 300         DEVMETHOD(device_probe, feaon_probe),
 301         DEVMETHOD(device_attach, feaon_attach),
 302
 303         /* RTC */
 304         DEVMETHOD(clock_gettime, feaon_rtc_gettime),
 305         DEVMETHOD(clock_settime, feaon_rtc_settime),
 306
 307         DEVMETHOD_END
 308 };
 309
 310 static driver_t feaon_driver = {
 311         "fe310aon",
 312         feaon_methods,
 313         sizeof(struct feaon_softc)
 314 };
 315
 316 static devclass_t feaon_devclass;
 317
 318 DRIVER_MODULE(fe310aon, simplebus, feaon_driver, feaon_devclass, 0, 0);