sys/arm/ti/am335x/am335x_dmtpps.c

   1 /*-
   2  * Copyright (c) 2015 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 /*
  28  * AM335x PPS driver using DMTimer capture.
  29  *
  30  * Note that this PPS driver does not use an interrupt.  Instead it uses the
  31  * hardware's ability to latch the timer's count register in response to a
  32  * signal on an IO pin.  Each of timers 4-7 have an associated pin, and this
  33  * code allows any one of those to be used.
  34  *
  35  * The timecounter routines in kern_tc.c call the pps poll routine periodically
  36  * to see if a new counter value has been latched.  When a new value has been
  37  * latched, the only processing done in the poll routine is to capture the
  38  * current set of timecounter timehands (done with pps_capture()) and the
  39  * latched value from the timer.  The remaining work (done by pps_event() while
  40  * holding a mutex) is scheduled to be done later in a non-interrupt context.
  41  */
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include <sys/param.h>
  47 #include <sys/systm.h>
  48 #include <sys/bus.h>
  49 #include <sys/conf.h>
  50 #include <sys/kernel.h>
  51 #include <sys/module.h>
  52 #include <sys/malloc.h>
  53 #include <sys/mutex.h>
  54 #include <sys/rman.h>
  55 #include <sys/taskqueue.h>
  56 #include <sys/timepps.h>
  57 #include <sys/timetc.h>
  58 #include <machine/bus.h>
  59
  60 #include <dev/ofw/openfirm.h>
  61 #include <dev/ofw/ofw_bus.h>
  62 #include <dev/ofw/ofw_bus_subr.h>
  63
  64 #include <arm/ti/ti_prcm.h>
  65 #include <arm/ti/ti_hwmods.h>
  66 #include <arm/ti/ti_pinmux.h>
  67 #include <arm/ti/am335x/am335x_scm_padconf.h>
  68
  69 #include "am335x_dmtreg.h"
  70
  71 #define PPS_CDEV_NAME   "dmtpps"
  72
  73 struct dmtpps_softc {
  74         device_t                dev;
  75         int                     mem_rid;
  76         struct resource *       mem_res;
  77         int                     tmr_num;        /* N from hwmod str "timerN" */
  78         char                    tmr_name[12];   /* "DMTimerN" */
  79         uint32_t                tclr;           /* Cached TCLR register. */
  80         struct timecounter      tc;
  81         int                     pps_curmode;    /* Edge mode now set in hw. */
  82         struct task             pps_task;       /* For pps_event handling. */
  83         struct cdev *           pps_cdev;
  84         struct pps_state        pps_state;
  85         struct mtx              pps_mtx;
  86 };
  87
  88 static int dmtpps_tmr_num;      /* Set by probe() */
  89
  90 /* List of compatible strings for FDT tree */
  91 static struct ofw_compat_data compat_data[] = {
  92         {"ti,am335x-timer",     1},
  93         {"ti,am335x-timer-1ms", 1},
  94         {NULL,                  0},
  95 };
  96
  97 /*
  98  * A table relating pad names to the hardware timer number they can be mux'd to.
  99  */
 100 struct padinfo {
 101         char *  ballname;
 102         int     tmr_num;
 103 };
 104 static struct padinfo dmtpps_padinfo[] = {
 105         {"GPMC_ADVn_ALE",    4},
 106         {"I2C0_SDA",         4},
 107         {"MII1_TX_EN",       4},
 108         {"XDMA_EVENT_INTR0", 4},
 109         {"GPMC_BEn0_CLE",    5},
 110         {"MDC",              5},
 111         {"MMC0_DAT3",        5},
 112         {"UART1_RTSn",       5},
 113         {"GPMC_WEn",         6},
 114         {"MDIO",             6},
 115         {"MMC0_DAT2",        6},
 116         {"UART1_CTSn",       6},
 117         {"GPMC_OEn_REn",     7},
 118         {"I2C0_SCL",         7},
 119         {"UART0_CTSn",       7},
 120         {"XDMA_EVENT_INTR1", 7},
 121         {NULL, 0}
 122 };
 123
 124 /*
 125  * This is either brilliantly user-friendly, or utterly lame...
 126  *
 127  * The am335x chip is used on the popular Beaglebone boards.  Those boards have
 128  * pins for all four capture-capable timers available on the P8 header. Allow
 129  * users to configure the input pin by giving the name of the header pin.
 130  */
 131 struct nicknames {
 132         const char * nick;
 133         const char * name;
 134 };
 135 static struct nicknames dmtpps_pin_nicks[] = {
 136         {"P8-7",  "GPMC_ADVn_ALE"},
 137         {"P8-9",  "GPMC_BEn0_CLE"},
 138         {"P8-10", "GPMC_WEn"},
 139         {"P8-8",  "GPMC_OEn_REn",},
 140         {NULL, NULL}
 141 };
 142
 143 #define DMTIMER_READ4(sc, reg)          bus_read_4((sc)->mem_res, (reg))
 144 #define DMTIMER_WRITE4(sc, reg, val)    bus_write_4((sc)->mem_res, (reg), (val))
 145
 146 /*
 147  * Translate a short friendly case-insensitive name to its canonical name.
 148  */
 149 static const char *
 150 dmtpps_translate_nickname(const char *nick)
 151 {
 152         struct nicknames *nn;
 153
 154         for (nn = dmtpps_pin_nicks; nn->nick != NULL; nn++)
 155                 if (strcasecmp(nick, nn->nick) == 0)
 156                         return nn->name;
 157         return (nick);
 158 }
 159
 160 /*
 161  * See if our tunable is set to the name of the input pin.  If not, that's NOT
 162  * an error, return 0.  If so, try to configure that pin as a timer capture
 163  * input pin, and if that works, then we have our timer unit number and if it
 164  * fails that IS an error, return -1.
 165  */
 166 static int
 167 dmtpps_find_tmr_num_by_tunable(void)
 168 {
 169         struct padinfo *pi;
 170         char iname[20];
 171         char muxmode[12];
 172         const char * ballname;
 173         int err;
 174
 175         if (!TUNABLE_STR_FETCH("hw.am335x_dmtpps.input", iname, sizeof(iname)))
 176                 return (0);
 177         ballname = dmtpps_translate_nickname(iname);
 178         for (pi = dmtpps_padinfo; pi->ballname != NULL; pi++) {
 179                 if (strcmp(ballname, pi->ballname) != 0)
 180                         continue;
 181                 snprintf(muxmode, sizeof(muxmode), "timer%d", pi->tmr_num);
 182                 err = ti_pinmux_padconf_set(pi->ballname, muxmode,
 183                     PADCONF_INPUT);
 184                 if (err != 0) {
 185                         printf("am335x_dmtpps: unable to configure capture pin "
 186                             "for %s to input mode\n", muxmode);
 187                         return (-1);
 188                 } else if (bootverbose) {
 189                         printf("am335x_dmtpps: configured pin %s as input "
 190                             "for %s\n", iname, muxmode);
 191                 }
 192                 return (pi->tmr_num);
 193         }
 194
 195         /* Invalid name in the tunable, that's an error. */
 196         printf("am335x_dmtpps: unknown pin name '%s'\n", iname);
 197         return (-1);
 198 }
 199
 200 /*
 201  * Ask the pinmux driver whether any pin has been configured as a TIMER4..TIMER7
 202  * input pin.  If so, return the timer number, if not return 0.
 203  */
 204 static int
 205 dmtpps_find_tmr_num_by_padconf(void)
 206 {
 207         int err;
 208         unsigned int padstate;
 209         const char * padmux;
 210         struct padinfo *pi;
 211         char muxmode[12];
 212
 213         for (pi = dmtpps_padinfo; pi->ballname != NULL; pi++) {
 214                 err = ti_pinmux_padconf_get(pi->ballname, &padmux, &padstate);
 215                 snprintf(muxmode, sizeof(muxmode), "timer%d", pi->tmr_num);
 216                 if (err == 0 && (padstate & RXACTIVE) != 0 &&
 217                     strcmp(muxmode, padmux) == 0)
 218                         return (pi->tmr_num);
 219         }
 220         /* Nothing found, not an error. */
 221         return (0);
 222 }
 223
 224 /*
 225  * Figure out which hardware timer number to use based on input pin
 226  * configuration.  This is done just once, the first time probe() runs.
 227  */
 228 static int
 229 dmtpps_find_tmr_num(void)
 230 {
 231         int tmr_num;
 232
 233         if ((tmr_num = dmtpps_find_tmr_num_by_tunable()) == 0)
 234                 tmr_num = dmtpps_find_tmr_num_by_padconf();
 235
 236         if (tmr_num <= 0) {
 237                 printf("am335x_dmtpps: PPS driver not enabled: unable to find "
 238                     "or configure a capture input pin\n");
 239                 tmr_num = -1; /* Must return non-zero to prevent re-probing. */
 240         }
 241         return (tmr_num);
 242 }
 243
 244 static void
 245 dmtpps_set_hw_capture(struct dmtpps_softc *sc, bool force_off)
 246 {
 247         int newmode;
 248
 249         if (force_off)
 250                 newmode = 0;
 251         else
 252                 newmode = sc->pps_state.ppsparam.mode & PPS_CAPTUREASSERT;
 253
 254         if (newmode == sc->pps_curmode)
 255                 return;
 256         sc->pps_curmode = newmode;
 257
 258         if (newmode == PPS_CAPTUREASSERT)
 259                 sc->tclr |= DMT_TCLR_CAPTRAN_LOHI;
 260         else
 261                 sc->tclr &= ~DMT_TCLR_CAPTRAN_MASK;
 262         DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
 263 }
 264
 265 static unsigned
 266 dmtpps_get_timecount(struct timecounter *tc)
 267 {
 268         struct dmtpps_softc *sc;
 269
 270         sc = tc->tc_priv;
 271
 272         return (DMTIMER_READ4(sc, DMT_TCRR));
 273 }
 274
 275 static void
 276 dmtpps_poll(struct timecounter *tc)
 277 {
 278         struct dmtpps_softc *sc;
 279
 280         sc = tc->tc_priv;
 281
 282         /*
 283          * If a new value has been latched we've got a PPS event.  Capture the
 284          * timecounter data, then override the capcount field (pps_capture()
 285          * populates it from the current DMT_TCRR register) with the latched
 286          * value from the TCAR1 register.
 287          *
 288          * There is no locking here, by design.  pps_capture() writes into an
 289          * area of struct pps_state which is read only by pps_event().  The
 290          * synchronization of access to that area is temporal rather than
 291          * interlock based... we write in this routine and trigger the task that
 292          * will read the data, so no simultaneous access can occur.
 293          *
 294          * Note that we don't have the TCAR interrupt enabled, but the hardware
 295          * still provides the status bits in the "RAW" status register even when
 296          * they're masked from generating an irq.  However, when clearing the
 297          * TCAR status to re-arm the capture for the next second, we have to
 298          * write to the IRQ status register, not the RAW register.  Quirky.
 299          */
 300         if (DMTIMER_READ4(sc, DMT_IRQSTATUS_RAW) & DMT_IRQ_TCAR) {
 301                 pps_capture(&sc->pps_state);
 302                 sc->pps_state.capcount = DMTIMER_READ4(sc, DMT_TCAR1);
 303                 DMTIMER_WRITE4(sc, DMT_IRQSTATUS, DMT_IRQ_TCAR);
 304                 taskqueue_enqueue(taskqueue_fast, &sc->pps_task);
 305         }
 306 }
 307
 308 static void
 309 dmtpps_event(void *arg, int pending)
 310 {
 311         struct dmtpps_softc *sc;
 312
 313         sc = arg;
 314
 315         /* This is the task function that gets enqueued by poll_pps.  Once the
 316          * time has been captured by the timecounter polling code which runs in
 317          * primary interrupt context, the remaining (more expensive) work to
 318          * process the event is done later in a threaded context.
 319          *
 320          * Here there is an interlock that protects the event data in struct
 321          * pps_state.  That data can be accessed at any time from userland via
 322          * ioctl() calls so we must ensure that there is no read access to
 323          * partially updated data while pps_event() does its work.
 324          */
 325         mtx_lock(&sc->pps_mtx);
 326         pps_event(&sc->pps_state, PPS_CAPTUREASSERT);
 327         mtx_unlock(&sc->pps_mtx);
 328 }
 329
 330 static int
 331 dmtpps_open(struct cdev *dev, int flags, int fmt,
 332     struct thread *td)
 333 {
 334         struct dmtpps_softc *sc;
 335
 336         sc = dev->si_drv1;
 337
 338         /*
 339          * Begin polling for pps and enable capture in the hardware whenever the
 340          * device is open.  Doing this stuff again is harmless if this isn't the
 341          * first open.
 342          */
 343         sc->tc.tc_poll_pps = dmtpps_poll;
 344         dmtpps_set_hw_capture(sc, false);
 345
 346         return 0;
 347 }
 348
 349 static  int
 350 dmtpps_close(struct cdev *dev, int flags, int fmt,
 351     struct thread *td)
 352 {
 353         struct dmtpps_softc *sc;
 354
 355         sc = dev->si_drv1;
 356
 357         /*
 358          * Stop polling and disable capture on last close.  Use the force-off
 359          * flag to override the configured mode and turn off the hardware.
 360          */
 361         sc->tc.tc_poll_pps = NULL;
 362         dmtpps_set_hw_capture(sc, true);
 363
 364         return 0;
 365 }
 366
 367 static int
 368 dmtpps_ioctl(struct cdev *dev, u_long cmd, caddr_t data,
 369     int flags, struct thread *td)
 370 {
 371         struct dmtpps_softc *sc;
 372         int err;
 373
 374         sc = dev->si_drv1;
 375
 376         /* Let the kernel do the heavy lifting for ioctl. */
 377         mtx_lock(&sc->pps_mtx);
 378         err = pps_ioctl(cmd, data, &sc->pps_state);
 379         mtx_unlock(&sc->pps_mtx);
 380         if (err != 0)
 381                 return (err);
 382
 383         /*
 384          * The capture mode could have changed, set the hardware to whatever
 385          * mode is now current.  Effectively a no-op if nothing changed.
 386          */
 387         dmtpps_set_hw_capture(sc, false);
 388
 389         return (err);
 390 }
 391
 392 static struct cdevsw dmtpps_cdevsw = {
 393         .d_version =    D_VERSION,
 394         .d_open =       dmtpps_open,
 395         .d_close =      dmtpps_close,
 396         .d_ioctl =      dmtpps_ioctl,
 397         .d_name =       PPS_CDEV_NAME,
 398 };
 399
 400 static int
 401 dmtpps_probe(device_t dev)
 402 {
 403         char strbuf[64];
 404         int tmr_num;
 405
 406         if (!ofw_bus_status_okay(dev))
 407                 return (ENXIO);
 408
 409         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 410                 return (ENXIO);
 411
 412         /*
 413          * If we haven't chosen which hardware timer to use yet, go do that now.
 414          * We need to know that to decide whether to return success for this
 415          * hardware timer instance or not.
 416          */
 417         if (dmtpps_tmr_num == 0)
 418                 dmtpps_tmr_num = dmtpps_find_tmr_num();
 419
 420         /*
 421          * Figure out which hardware timer is being probed and see if it matches
 422          * the configured timer number determined earlier.
 423          */
 424         tmr_num = ti_hwmods_get_unit(dev, "timer");
 425         if (dmtpps_tmr_num != tmr_num)
 426                 return (ENXIO);
 427
 428         snprintf(strbuf, sizeof(strbuf), "AM335x PPS-Capture DMTimer%d",
 429             tmr_num);
 430         device_set_desc_copy(dev, strbuf);
 431
 432         return(BUS_PROBE_DEFAULT);
 433 }
 434
 435 static int
 436 dmtpps_attach(device_t dev)
 437 {
 438         struct dmtpps_softc *sc;
 439         clk_ident_t timer_id;
 440         int err, sysclk_freq;
 441
 442         sc = device_get_softc(dev);
 443         sc->dev = dev;
 444
 445         /* Get the base clock frequency. */
 446         err = ti_prcm_clk_get_source_freq(SYS_CLK, &sysclk_freq);
 447
 448         /* Enable clocks and power on the device. */
 449         if ((timer_id = ti_hwmods_get_clock(dev)) == INVALID_CLK_IDENT)
 450                 return (ENXIO);
 451         if ((err = ti_prcm_clk_set_source(timer_id, SYSCLK_CLK)) != 0)
 452                 return (err);
 453         if ((err = ti_prcm_clk_enable(timer_id)) != 0)
 454                 return (err);
 455
 456         /* Request the memory resources. */
 457         sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 458             &sc->mem_rid, RF_ACTIVE);
 459         if (sc->mem_res == NULL) {
 460                 return (ENXIO);
 461         }
 462
 463         /* Figure out which hardware timer this is and set the name string. */
 464         sc->tmr_num = ti_hwmods_get_unit(dev, "timer");
 465         snprintf(sc->tmr_name, sizeof(sc->tmr_name), "DMTimer%d", sc->tmr_num);
 466
 467         /*
 468          * Configure the timer pulse/capture pin to input/capture mode.  This is
 469          * required in addition to configuring the pin as input with the pinmux
 470          * controller (which was done via fdt data or tunable at probe time).
 471          */
 472         sc->tclr = DMT_TCLR_GPO_CFG;
 473         DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
 474
 475         /* Set up timecounter hardware, start it. */
 476         DMTIMER_WRITE4(sc, DMT_TSICR, DMT_TSICR_RESET);
 477         while (DMTIMER_READ4(sc, DMT_TIOCP_CFG) & DMT_TIOCP_RESET)
 478                 continue;
 479
 480         sc->tclr |= DMT_TCLR_START | DMT_TCLR_AUTOLOAD;
 481         DMTIMER_WRITE4(sc, DMT_TLDR, 0);
 482         DMTIMER_WRITE4(sc, DMT_TCRR, 0);
 483         DMTIMER_WRITE4(sc, DMT_TCLR, sc->tclr);
 484
 485         /* Register the timecounter. */
 486         sc->tc.tc_name           = sc->tmr_name;
 487         sc->tc.tc_get_timecount  = dmtpps_get_timecount;
 488         sc->tc.tc_counter_mask   = ~0u;
 489         sc->tc.tc_frequency      = sysclk_freq;
 490         sc->tc.tc_quality        = 1000;
 491         sc->tc.tc_priv           = sc;
 492
 493         tc_init(&sc->tc);
 494
 495         /*
 496          * Indicate our PPS capabilities.  Have the kernel init its part of the
 497          * pps_state struct and add its capabilities.
 498          *
 499          * While the hardware has a mode to capture each edge, it's not clear we
 500          * can use it that way, because there's only a single interrupt/status
 501          * bit to say something was captured, but not which edge it was.  For
 502          * now, just say we can only capture assert events (the positive-going
 503          * edge of the pulse).
 504          */
 505         mtx_init(&sc->pps_mtx, "dmtpps", NULL, MTX_DEF);
 506         sc->pps_state.ppscap = PPS_CAPTUREASSERT;
 507         sc->pps_state.driver_abi = PPS_ABI_VERSION;
 508         sc->pps_state.driver_mtx = &sc->pps_mtx;
 509         pps_init_abi(&sc->pps_state);
 510
 511         /*
 512          * Init the task that does deferred pps_event() processing after
 513          * the polling routine has captured a pps pulse time.
 514          */
 515         TASK_INIT(&sc->pps_task, 0, dmtpps_event, sc);
 516
 517         /* Create the PPS cdev. */
 518         sc->pps_cdev = make_dev(&dmtpps_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
 519             PPS_CDEV_NAME);
 520         sc->pps_cdev->si_drv1 = sc;
 521
 522         if (bootverbose)
 523                 device_printf(sc->dev, "Using %s for PPS device /dev/%s\n",
 524                     sc->tmr_name, PPS_CDEV_NAME);
 525
 526         return (0);
 527 }
 528
 529 static int
 530 dmtpps_detach(device_t dev)
 531 {
 532
 533         /*
 534          * There is no way to remove a timecounter once it has been registered,
 535          * even if it's not in use, so we can never detach.  If we were
 536          * dynamically loaded as a module this will prevent unloading.
 537          */
 538         return (EBUSY);
 539 }
 540
 541 static device_method_t dmtpps_methods[] = {
 542         DEVMETHOD(device_probe,         dmtpps_probe),
 543         DEVMETHOD(device_attach,        dmtpps_attach),
 544         DEVMETHOD(device_detach,        dmtpps_detach),
 545         { 0, 0 }
 546 };
 547
 548 static driver_t dmtpps_driver = {
 549         "am335x_dmtpps",
 550         dmtpps_methods,
 551         sizeof(struct dmtpps_softc),
 552 };
 553
 554 static devclass_t dmtpps_devclass;
 555
 556 DRIVER_MODULE(am335x_dmtpps, simplebus, dmtpps_driver, dmtpps_devclass, 0, 0);
 557 MODULE_DEPEND(am335x_dmtpps, am335x_prcm, 1, 1, 1);
 558