sys/arm/freescale/imx/imx_epit.c

   1 /*-
   2  * Copyright (c) 2017 Ian Lepore <ian@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  * Driver for imx Enhanced Programmable Interval Timer, a simple free-running
  32  * counter device that can be used as the system timecounter.  On imx5 a second
  33  * instance of the device is used as the system eventtimer.
  34  */
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/bus.h>
  39 #include <sys/kernel.h>
  40 #include <sys/module.h>
  41 #include <sys/malloc.h>
  42 #include <sys/rman.h>
  43 #include <sys/timeet.h>
  44 #include <sys/timetc.h>
  45 #include <sys/watchdog.h>
  46 #include <machine/bus.h>
  47 #include <machine/cpu.h>
  48 #include <machine/intr.h>
  49 #include <machine/machdep.h>
  50
  51 #include <dev/fdt/fdt_common.h>
  52 #include <dev/ofw/openfirm.h>
  53 #include <dev/ofw/ofw_bus.h>
  54 #include <dev/ofw/ofw_bus_subr.h>
  55
  56 #include <arm/freescale/imx/imx_ccmvar.h>
  57 #include <arm/freescale/imx/imx_machdep.h>
  58
  59 #define EPIT_CR                         0x00            /* Control register */
  60 #define   EPIT_CR_CLKSRC_SHIFT            24
  61 #define   EPIT_CR_CLKSRC_OFF               0
  62 #define   EPIT_CR_CLKSRC_IPG               1
  63 #define   EPIT_CR_CLKSRC_HFCLK             2
  64 #define   EPIT_CR_CLKSRC_LFCLK             3
  65 #define   EPIT_CR_STOPEN                  (1u << 21)
  66 #define   EPIT_CR_WAITEN                  (1u << 19)
  67 #define   EPIT_CR_DBGEN                   (1u << 18)
  68 #define   EPIT_CR_IOVW                    (1u << 17)
  69 #define   EPIT_CR_SWR                     (1u << 16)
  70 #define   EPIT_CR_RLD                     (1u <<  3)
  71 #define   EPIT_CR_OCIEN                   (1u <<  2)
  72 #define   EPIT_CR_ENMOD                   (1u <<  1)
  73 #define   EPIT_CR_EN                      (1u <<  0)
  74
  75 #define EPIT_SR                         0x04            /* Status register */
  76 #define   EPIT_SR_OCIF                    (1u << 0)
  77
  78 #define EPIT_LR                         0x08            /* Load register */
  79 #define EPIT_CMPR                       0x0c            /* Compare register */
  80 #define EPIT_CNR                        0x10            /* Counter register */
  81
  82 /*
  83  * Define event timer limits.
  84  *
  85  * In theory our minimum period is 1 tick, because to setup a oneshot we don't
  86  * need a read-modify-write sequence to calculate and set a compare register
  87  * value while the counter is running.  In practice the waveform diagrams in the
  88  * manual make it appear that a setting of 1 might cause it to miss the event,
  89  * so I'm setting the lower limit to 2 ticks.
  90  */
  91 #define ET_MIN_TICKS    2
  92 #define ET_MAX_TICKS    0xfffffffe
  93
  94 static u_int epit_tc_get_timecount(struct timecounter *tc);
  95
  96 struct epit_softc {
  97         device_t                dev;
  98         struct resource *       memres;
  99         struct resource *       intres;
 100         void *                  inthandle;
 101         uint32_t                clkfreq;
 102         uint32_t                ctlreg;
 103         uint32_t                period;
 104         struct timecounter      tc;
 105         struct eventtimer       et;
 106         bool                    oneshot;
 107 };
 108
 109 /*
 110  * Probe data.  For some reason, the standard linux dts files don't have
 111  * compatible properties on the epit devices (other properties are missing too,
 112  * like clocks, but we don't care as much about that).  So our probe routine
 113  * uses the name of the node (must contain "epit") and the address of the
 114  * registers as identifying marks.
 115  */
 116 static const uint32_t imx51_epit_ioaddr[2] = {0x73fac000, 0x73fb0000};
 117 static const uint32_t imx53_epit_ioaddr[2] = {0x53fac000, 0x53fb0000};
 118 static const uint32_t imx6_epit_ioaddr[2]  = {0x020d0000, 0x020d4000};
 119
 120 /* ocd_data is number of units to instantiate on the platform */
 121 static struct ofw_compat_data compat_data[] = {
 122         {"fsl,imx6ul-epit", 1},
 123         {"fsl,imx6sx-epit", 1},
 124         {"fsl,imx6q-epit",  1},
 125         {"fsl,imx6dl-epit", 1},
 126         {"fsl,imx53-epit",  2},
 127         {"fsl,imx51-epit",  2},
 128         {"fsl,imx31-epit",  2},
 129         {"fsl,imx27-epit",  2},
 130         {"fsl,imx25-epit",  2},
 131         {NULL,              0}
 132 };
 133
 134 static inline uint32_t
 135 RD4(struct epit_softc *sc, bus_size_t offset)
 136 {
 137
 138         return (bus_read_4(sc->memres, offset));
 139 }
 140
 141 static inline void
 142 WR4(struct epit_softc *sc, bus_size_t offset, uint32_t value)
 143 {
 144
 145         bus_write_4(sc->memres, offset, value);
 146 }
 147
 148 static inline void
 149 WR4B(struct epit_softc *sc, bus_size_t offset, uint32_t value)
 150 {
 151
 152         bus_write_4(sc->memres, offset, value);
 153         bus_barrier(sc->memres, offset, 4, BUS_SPACE_BARRIER_WRITE);
 154 }
 155
 156 static u_int
 157 epit_read_counter(struct epit_softc *sc)
 158 {
 159
 160         /*
 161          * Hardware is a downcounter, adjust to look like it counts up for use
 162          * with timecounter and DELAY.
 163          */
 164         return (0xffffffff - RD4(sc, EPIT_CNR));
 165 }
 166
 167 static void
 168 epit_do_delay(int usec, void *arg)
 169 {
 170         struct epit_softc *sc = arg;
 171         uint64_t curcnt, endcnt, startcnt, ticks;
 172
 173         /*
 174          * Calculate the tick count with 64-bit values so that it works for any
 175          * clock frequency.  Loop until the hardware count reaches start+ticks.
 176          * If the 32-bit hardware count rolls over while we're looping, just
 177          * manually do a carry into the high bits after each read; don't worry
 178          * that doing this on each loop iteration is inefficient -- we're trying
 179          * to waste time here.
 180          */
 181         ticks = 1 + ((uint64_t)usec * sc->clkfreq) / 1000000;
 182         curcnt = startcnt = epit_read_counter(sc);
 183         endcnt = startcnt + ticks;
 184         while (curcnt < endcnt) {
 185                 curcnt = epit_read_counter(sc);
 186                 if (curcnt < startcnt)
 187                         curcnt += 1ULL << 32;
 188         }
 189 }
 190
 191 static u_int
 192 epit_tc_get_timecount(struct timecounter *tc)
 193 {
 194
 195         return (epit_read_counter(tc->tc_priv));
 196 }
 197
 198 static int
 199 epit_tc_attach(struct epit_softc *sc)
 200 {
 201
 202         /* When the counter hits zero, reload with 0xffffffff.  Start it. */
 203         WR4(sc, EPIT_LR, 0xffffffff);
 204         WR4(sc, EPIT_CR, sc->ctlreg | EPIT_CR_EN);
 205
 206         /* Register as a timecounter. */
 207         sc->tc.tc_name          = "EPIT";
 208         sc->tc.tc_quality       = 1000;
 209         sc->tc.tc_frequency     = sc->clkfreq;
 210         sc->tc.tc_counter_mask  = 0xffffffff;
 211         sc->tc.tc_get_timecount = epit_tc_get_timecount;
 212         sc->tc.tc_priv          = sc;
 213         tc_init(&sc->tc);
 214
 215         /* We are the DELAY() implementation. */
 216         arm_set_delay(epit_do_delay, sc);
 217
 218         return (0);
 219 }
 220
 221 static int
 222 epit_et_start(struct eventtimer *et, sbintime_t first, sbintime_t period)
 223 {
 224         struct epit_softc *sc;
 225         uint32_t ticks;
 226
 227         sc = (struct epit_softc *)et->et_priv;
 228
 229         /*
 230          * Disable the timer and clear any pending status.  The timer may be
 231          * running or may have just expired if we're called to reschedule the
 232          * next event before the previous event time arrives.
 233          */
 234         WR4(sc, EPIT_CR, sc->ctlreg);
 235         WR4(sc, EPIT_SR, EPIT_SR_OCIF);
 236         if (period != 0) {
 237                 sc->oneshot = false;
 238                 ticks = ((uint32_t)et->et_frequency * period) >> 32;
 239         } else if (first != 0) {
 240                 sc->oneshot = true;
 241                 ticks = ((uint32_t)et->et_frequency * first) >> 32;
 242         } else {
 243                 return (EINVAL);
 244         }
 245
 246         /* Set the countdown load register and start the timer. */
 247         WR4(sc, EPIT_LR, ticks);
 248         WR4B(sc, EPIT_CR, sc->ctlreg | EPIT_CR_EN);
 249
 250         return (0);
 251 }
 252
 253 static int
 254 epit_et_stop(struct eventtimer *et)
 255 {
 256         struct epit_softc *sc;
 257
 258         sc = (struct epit_softc *)et->et_priv;
 259
 260         /* Disable the timer and clear any pending status. */
 261         WR4(sc, EPIT_CR, sc->ctlreg);
 262         WR4B(sc, EPIT_SR, EPIT_SR_OCIF);
 263
 264         return (0);
 265 }
 266
 267 static int
 268 epit_intr(void *arg)
 269 {
 270         struct epit_softc *sc;
 271         uint32_t status;
 272
 273         sc = arg;
 274
 275         /*
 276          * Disable a one-shot timer until a new event is scheduled so that the
 277          * counter doesn't wrap and fire again.  Do this before clearing the
 278          * status since a short period would make it fire again really soon.
 279          *
 280          * Clear interrupt status before invoking event callbacks.  The callback
 281          * often sets up a new one-shot timer event and if the interval is short
 282          * enough it can fire before we get out of this function.  If we cleared
 283          * at the bottom we'd miss the interrupt and hang until the clock wraps.
 284          */
 285         if (sc->oneshot)
 286                 WR4(sc, EPIT_CR, sc->ctlreg);
 287
 288         status = RD4(sc, EPIT_SR);
 289         WR4B(sc, EPIT_SR, status);
 290
 291         if ((status & EPIT_SR_OCIF) == 0)
 292                 return (FILTER_STRAY);
 293
 294         if (sc->et.et_active)
 295                 sc->et.et_event_cb(&sc->et, sc->et.et_arg);
 296
 297         return (FILTER_HANDLED);
 298 }
 299
 300 static int
 301 epit_et_attach(struct epit_softc *sc)
 302 {
 303         int err, rid;
 304
 305         rid = 0;
 306         sc->intres = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ, &rid,
 307             RF_ACTIVE);
 308         if (sc->intres == NULL) {
 309                 device_printf(sc->dev, "could not allocate interrupt\n");
 310                 return (ENXIO);
 311         }
 312
 313         err = bus_setup_intr(sc->dev, sc->intres, INTR_TYPE_CLK | INTR_MPSAFE,
 314             epit_intr, NULL, sc, &sc->inthandle);
 315         if (err != 0) {
 316                 device_printf(sc->dev, "unable to setup the irq handler\n");
 317                 return (err);
 318         }
 319
 320         /* To be an eventtimer, we need interrupts enabled. */
 321         sc->ctlreg |= EPIT_CR_OCIEN;
 322
 323         /* Register as an eventtimer. */
 324         sc->et.et_name = "EPIT";
 325         sc->et.et_flags = ET_FLAGS_ONESHOT | ET_FLAGS_PERIODIC;
 326         sc->et.et_quality = 1000;
 327         sc->et.et_frequency = sc->clkfreq;
 328         sc->et.et_min_period = ((uint64_t)ET_MIN_TICKS  << 32) / sc->clkfreq;
 329         sc->et.et_max_period = ((uint64_t)ET_MAX_TICKS  << 32) / sc->clkfreq;
 330         sc->et.et_start = epit_et_start;
 331         sc->et.et_stop = epit_et_stop;
 332         sc->et.et_priv = sc;
 333         et_register(&sc->et);
 334
 335         return (0);
 336 }
 337
 338 static int
 339 epit_probe(device_t dev)
 340 {
 341         struct resource *memres;
 342         rman_res_t ioaddr;
 343         int num_units, rid, unit;
 344
 345         if (!ofw_bus_status_okay(dev))
 346                 return (ENXIO);
 347
 348         /*
 349          * The FDT data for imx5 and imx6 EPIT hardware is missing or broken,
 350          * but it may get fixed some day, so first just do a normal check.  We
 351          * return success if the compatible string matches and we haven't
 352          * already instantiated the number of units needed on this platform.
 353          */
 354         unit = device_get_unit(dev);
 355         num_units = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
 356         if (unit < num_units) {
 357                 device_set_desc(dev, "i.MX EPIT timer");
 358                 return (BUS_PROBE_DEFAULT);
 359         }
 360
 361         /*
 362          * No compat string match, but for imx6 all the data we need is in the
 363          * node except the compat string, so do our own compatibility check
 364          * using the device name of the node and the register block address.
 365          */
 366         if (strstr(ofw_bus_get_name(dev), "epit") == NULL)
 367                 return (ENXIO);
 368
 369         rid = 0;
 370         memres = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_UNMAPPED);
 371         if (memres == NULL)
 372                 return (ENXIO);
 373         ioaddr = rman_get_start(memres);
 374         bus_free_resource(dev, SYS_RES_MEMORY, memres);
 375
 376         if (imx_soc_family() == 6) {
 377                 if (unit > 0)
 378                         return (ENXIO);
 379                 if (ioaddr != imx6_epit_ioaddr[unit])
 380                         return (ENXIO);
 381         } else {
 382                 if (unit > 1)
 383                         return (ENXIO);
 384                 switch (imx_soc_type()) {
 385                 case IMXSOC_51:
 386                         if (ioaddr != imx51_epit_ioaddr[unit])
 387                                 return (ENXIO);
 388                         break;
 389                 case IMXSOC_53:
 390                         if (ioaddr != imx53_epit_ioaddr[unit])
 391                                 return (ENXIO);
 392                         break;
 393                 default:
 394                         return (ENXIO);
 395                 }
 396                 /*
 397                  * XXX Right now we have no way to handle the fact that the
 398                  * entire EPIT node is missing, which means no interrupt data.
 399                  */
 400                 return (ENXIO);
 401         }
 402
 403         device_set_desc(dev, "i.MX EPIT timer");
 404         return (BUS_PROBE_DEFAULT);
 405 }
 406
 407 static int
 408 epit_attach(device_t dev)
 409 {
 410         struct epit_softc *sc;
 411         int err, rid;
 412         uint32_t clksrc;
 413
 414         sc = device_get_softc(dev);
 415         sc->dev = dev;
 416
 417         rid = 0;
 418         sc->memres = bus_alloc_resource_any(sc->dev, SYS_RES_MEMORY, &rid,
 419             RF_ACTIVE);
 420         if (sc->memres == NULL) {
 421                 device_printf(sc->dev, "could not allocate registers\n");
 422                 return (ENXIO);
 423         }
 424
 425         /*
 426          * For now, use ipg (66 MHz).  Some day we should get this from fdt.
 427          */
 428         clksrc = EPIT_CR_CLKSRC_IPG;
 429
 430         switch (clksrc) {
 431         default:
 432                 device_printf(dev,
 433                     "Unsupported clock source '%d', using IPG\n", clksrc);
 434                 /* FALLTHROUGH */
 435         case EPIT_CR_CLKSRC_IPG:
 436                 sc->clkfreq = imx_ccm_ipg_hz();
 437                 break;
 438         case EPIT_CR_CLKSRC_HFCLK:
 439                 sc->clkfreq = imx_ccm_perclk_hz();
 440                 break;
 441         case EPIT_CR_CLKSRC_LFCLK:
 442                 sc->clkfreq = 32768;
 443                 break;
 444         }
 445
 446         /*
 447          * Init: stop operations and clear all options, then set up options and
 448          * clock source, then do a soft-reset and wait for it to complete.
 449          */
 450         WR4(sc, EPIT_CR, 0);
 451
 452         sc->ctlreg =
 453             (clksrc << EPIT_CR_CLKSRC_SHIFT) |  /* Use selected clock */
 454             EPIT_CR_ENMOD  |                    /* Reload counter on enable */
 455             EPIT_CR_RLD    |                    /* Reload counter from LR */
 456             EPIT_CR_STOPEN |                    /* Run in STOP mode */
 457             EPIT_CR_WAITEN |                    /* Run in WAIT mode */
 458             EPIT_CR_DBGEN;                      /* Run in DEBUG mode */
 459
 460         WR4B(sc, EPIT_CR, sc->ctlreg | EPIT_CR_SWR);
 461         while (RD4(sc, EPIT_CR) & EPIT_CR_SWR)
 462                 continue;
 463
 464         /*
 465          * Unit 0 is the timecounter, 1 (if instantiated) is the eventtimer.
 466          */
 467         if (device_get_unit(sc->dev) == 0)
 468                 err = epit_tc_attach(sc);
 469         else
 470                 err = epit_et_attach(sc);
 471
 472         return (err);
 473 }
 474
 475 static device_method_t epit_methods[] = {
 476         DEVMETHOD(device_probe,         epit_probe),
 477         DEVMETHOD(device_attach,        epit_attach),
 478
 479         DEVMETHOD_END
 480 };
 481
 482 static driver_t epit_driver = {
 483         "imx_epit",
 484         epit_methods,
 485         sizeof(struct epit_softc),
 486 };
 487
 488 static devclass_t epit_devclass;
 489
 490 EARLY_DRIVER_MODULE(imx_epit, simplebus, epit_driver, epit_devclass, 0,
 491     0, BUS_PASS_TIMER);