sys/dev/gpio/gpiopps.c

   1 /*-
   2  * Copyright (c) 2016 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 #include <sys/param.h>
  31 #include <sys/gpio.h>
  32 #include <sys/kernel.h>
  33 #include <sys/lock.h>
  34 #include <sys/module.h>
  35 #include <sys/bus.h>
  36 #include <sys/conf.h>
  37 #include <sys/timepps.h>
  38
  39 #include <dev/gpio/gpiobusvar.h>
  40
  41 #include "opt_platform.h"
  42
  43 #ifdef FDT
  44 #include <dev/ofw/ofw_bus.h>
  45
  46 static struct ofw_compat_data compat_data[] = {
  47         {"pps-gpio",    1},
  48         {NULL,          0}
  49 };
  50 SIMPLEBUS_PNP_INFO(compat_data);
  51 #endif /* FDT */
  52
  53 static devclass_t pps_devclass;
  54
  55 struct pps_softc {
  56         device_t         dev;
  57         gpio_pin_t       gpin;
  58         void            *ihandler;
  59         struct resource *ires;
  60         int              irid;
  61         struct cdev     *pps_cdev;
  62         struct pps_state pps_state;
  63         struct mtx       pps_mtx;
  64         bool             falling_edge;
  65 };
  66
  67 #define PPS_CDEV_NAME   "gpiopps"
  68
  69 static int
  70 gpiopps_open(struct cdev *dev, int flags, int fmt, struct thread *td)
  71 {
  72         struct pps_softc *sc = dev->si_drv1;
  73
  74         /* We can't be unloaded while open, so mark ourselves BUSY. */
  75         mtx_lock(&sc->pps_mtx);
  76         if (device_get_state(sc->dev) < DS_BUSY) {
  77                 device_busy(sc->dev);
  78         }
  79         mtx_unlock(&sc->pps_mtx);
  80
  81         return 0;
  82 }
  83
  84 static  int
  85 gpiopps_close(struct cdev *dev, int flags, int fmt, struct thread *td)
  86 {
  87         struct pps_softc *sc = dev->si_drv1;
  88
  89         /*
  90          * Un-busy on last close. We rely on the vfs counting stuff to only call
  91          * this routine on last-close, so we don't need any open-count logic.
  92          */
  93         mtx_lock(&sc->pps_mtx);
  94         device_unbusy(sc->dev);
  95         mtx_unlock(&sc->pps_mtx);
  96
  97         return 0;
  98 }
  99
 100 static int
 101 gpiopps_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
 102 {
 103         struct pps_softc *sc = dev->si_drv1;
 104         int err;
 105
 106         /* Let the kernel do the heavy lifting for ioctl. */
 107         mtx_lock(&sc->pps_mtx);
 108         err = pps_ioctl(cmd, data, &sc->pps_state);
 109         mtx_unlock(&sc->pps_mtx);
 110
 111         return err;
 112 }
 113
 114 static struct cdevsw pps_cdevsw = {
 115         .d_version =    D_VERSION,
 116         .d_open =       gpiopps_open,
 117         .d_close =      gpiopps_close,
 118         .d_ioctl =      gpiopps_ioctl,
 119         .d_name =       PPS_CDEV_NAME,
 120 };
 121
 122 static int
 123 gpiopps_ifltr(void *arg)
 124 {
 125         struct pps_softc *sc = arg;
 126
 127         /*
 128          * There is no locking here by design... The kernel cleverly captures
 129          * the current time into an area of the pps_state structure which is
 130          * written only by the pps_capture() routine and read only by the
 131          * pps_event() routine.  We don't need lock-based management of access
 132          * to the capture area because we have time-based access management:  we
 133          * can't be reading and writing concurently because we can't be running
 134          * both the threaded and filter handlers concurrently (because a new
 135          * hardware interrupt can't happen until the threaded handler for the
 136          * current interrupt exits, after which the system does the EOI that
 137          * enables a new hardware interrupt).
 138          */
 139         pps_capture(&sc->pps_state);
 140         return (FILTER_SCHEDULE_THREAD);
 141 }
 142
 143 static void
 144 gpiopps_ithrd(void *arg)
 145 {
 146         struct pps_softc *sc = arg;
 147
 148         /*
 149          * Go create a pps event from the data captured in the filter handler.
 150          *
 151          * Note that we DO need locking here, unlike the case with the filter
 152          * handler.  The pps_event() routine updates the non-capture part of the
 153          * pps_state structure, and the ioctl() code could be accessing that
 154          * data right now in a non-interrupt context, so we need an interlock.
 155          */
 156         mtx_lock(&sc->pps_mtx);
 157         pps_event(&sc->pps_state, PPS_CAPTUREASSERT);
 158         mtx_unlock(&sc->pps_mtx);
 159 }
 160
 161 static int
 162 gpiopps_detach(device_t dev)
 163 {
 164         struct pps_softc *sc = device_get_softc(dev);
 165
 166         if (sc->pps_cdev != NULL)
 167                 destroy_dev(sc->pps_cdev);
 168         if (sc->ihandler != NULL)
 169                 bus_teardown_intr(dev, sc->ires, sc->ihandler);
 170         if (sc->ires != NULL)
 171                 bus_release_resource(dev, SYS_RES_IRQ, sc->irid, sc->ires);
 172         if (sc->gpin != NULL)
 173                 gpiobus_release_pin(GPIO_GET_BUS(sc->gpin->dev), sc->gpin->pin);
 174         return (0);
 175 }
 176
 177 #ifdef FDT
 178 static int
 179 gpiopps_fdt_attach(device_t dev)
 180 {
 181         struct pps_softc *sc;
 182         struct make_dev_args devargs;
 183         phandle_t node;
 184         uint32_t edge, pincaps;
 185         int err;
 186
 187         sc = device_get_softc(dev);
 188         sc->dev = dev;
 189
 190         mtx_init(&sc->pps_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
 191
 192         /* Initialize the pps_state struct. */
 193         sc->pps_state.ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
 194         sc->pps_state.driver_abi = PPS_ABI_VERSION;
 195         sc->pps_state.driver_mtx = &sc->pps_mtx;
 196         pps_init_abi(&sc->pps_state);
 197
 198         /* Check which edge we're configured to capture (default is rising). */
 199         if (ofw_bus_has_prop(dev, "assert-falling-edge"))
 200                 edge = GPIO_INTR_EDGE_FALLING;
 201         else
 202                 edge = GPIO_INTR_EDGE_RISING;
 203
 204         /*
 205          * Look up the configured gpio pin and ensure it can be configured for
 206          * the interrupt mode we need.
 207          */
 208         node = ofw_bus_get_node(dev);
 209         if ((err = gpio_pin_get_by_ofw_idx(dev, node, 0, &sc->gpin)) != 0) {
 210                 device_printf(dev, "Cannot obtain gpio pin\n");
 211                 return (err);
 212         }
 213         device_printf(dev, "PPS input on %s pin %u\n",
 214             device_get_nameunit(sc->gpin->dev), sc->gpin->pin);
 215
 216         if ((err = gpio_pin_getcaps(sc->gpin, &pincaps)) != 0) {
 217                 device_printf(dev, "Cannot query capabilities of gpio pin\n");
 218                 gpiopps_detach(dev);
 219                 return (err);
 220         }
 221         if ((pincaps & edge) == 0) {
 222                 device_printf(dev, "Pin cannot be configured for the requested signal edge\n");
 223                 gpiopps_detach(dev);
 224                 return (ENOTSUP);
 225         }
 226
 227         /*
 228          * Transform our 'gpios' property into an interrupt resource and set up
 229          * the interrupt.
 230          */
 231         if ((sc->ires = gpio_alloc_intr_resource(dev, &sc->irid, RF_ACTIVE,
 232             sc->gpin, edge)) == NULL) {
 233                 device_printf(dev, "Cannot allocate an IRQ for the GPIO\n");
 234                 gpiopps_detach(dev);
 235                 return (err);
 236         }
 237
 238         err = bus_setup_intr(dev, sc->ires, INTR_TYPE_CLK | INTR_MPSAFE,
 239             gpiopps_ifltr, gpiopps_ithrd, sc, &sc->ihandler);
 240         if (err != 0) {
 241                 device_printf(dev, "Unable to setup pps irq handler\n");
 242                 gpiopps_detach(dev);
 243                 return (err);
 244         }
 245
 246         /* Create the RFC 2783 pps-api cdev. */
 247         make_dev_args_init(&devargs);
 248         devargs.mda_devsw = &pps_cdevsw;
 249         devargs.mda_uid = UID_ROOT;
 250         devargs.mda_gid = GID_WHEEL;
 251         devargs.mda_mode = 0660;
 252         devargs.mda_si_drv1 = sc;
 253         err = make_dev_s(&devargs, &sc->pps_cdev, PPS_CDEV_NAME "%d",
 254             device_get_unit(dev));
 255         if (err != 0) {
 256                 device_printf(dev, "Unable to create pps cdev\n");
 257                 gpiopps_detach(dev);
 258                 return (err);
 259         }
 260
 261         return (0);
 262 }
 263
 264 static int
 265 gpiopps_fdt_probe(device_t dev)
 266 {
 267
 268         if (!ofw_bus_status_okay(dev))
 269                 return (ENXIO);
 270
 271         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data != 0) {
 272                 device_set_desc(dev, "GPIO PPS");
 273                 return (BUS_PROBE_DEFAULT);
 274         }
 275
 276         return (ENXIO);
 277 }
 278
 279 static device_method_t pps_fdt_methods[] = {
 280         DEVMETHOD(device_probe,         gpiopps_fdt_probe),
 281         DEVMETHOD(device_attach,        gpiopps_fdt_attach),
 282         DEVMETHOD(device_detach,        gpiopps_detach),
 283
 284         DEVMETHOD_END
 285 };
 286
 287 static driver_t pps_fdt_driver = {
 288         "gpiopps",
 289         pps_fdt_methods,
 290         sizeof(struct pps_softc),
 291 };
 292
 293 DRIVER_MODULE(gpiopps, simplebus, pps_fdt_driver, pps_devclass, 0, 0);
 294
 295 #endif /* FDT */