sys/dev/fdt/simple_mfd.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2018 Rubicon Communications, LLC (Netgate)
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/bus.h>
  35 #include <sys/kernel.h>
  36 #include <sys/lock.h>
  37 #include <sys/module.h>
  38 #include <sys/mutex.h>
  39 #include <sys/rman.h>
  40
  41 #include <machine/bus.h>
  42
  43 #include <dev/fdt/simplebus.h>
  44
  45 #include <dev/ofw/ofw_bus.h>
  46 #include <dev/ofw/ofw_bus_subr.h>
  47
  48 #include <dev/fdt/simple_mfd.h>
  49
  50 device_t simple_mfd_add_device(device_t dev, phandle_t node, u_int order,
  51     const char *name, int unit, struct simplebus_devinfo *di);
  52 struct simplebus_devinfo *simple_mfd_setup_dinfo(device_t dev, phandle_t node,
  53     struct simplebus_devinfo *di);
  54
  55 #include "syscon_if.h"
  56 #include <dev/extres/syscon/syscon.h>
  57
  58 MALLOC_DECLARE(M_SYSCON);
  59
  60 static uint32_t simple_mfd_syscon_read_4(struct syscon *syscon,
  61     bus_size_t offset);
  62 static int simple_mfd_syscon_write_4(struct syscon *syscon, bus_size_t offset,
  63     uint32_t val);
  64 static int simple_mfd_syscon_modify_4(struct syscon *syscon, bus_size_t offset,
  65     uint32_t clear_bits, uint32_t set_bits);
  66
  67 #define SYSCON_LOCK(_sc)                mtx_lock_spin(&(_sc)->mtx)
  68 #define SYSCON_UNLOCK(_sc)              mtx_unlock_spin(&(_sc)->mtx)
  69 #define SYSCON_LOCK_INIT(_sc)           mtx_init(&(_sc)->mtx,   \
  70     device_get_nameunit((_sc)->dev), "syscon", MTX_SPIN)
  71 #define SYSCON_LOCK_DESTROY(_sc)        mtx_destroy(&(_sc)->mtx);
  72 #define SYSCON_ASSERT_LOCKED(_sc)       mtx_assert(&(_sc)->mtx, MA_OWNED);
  73 #define SYSCON_ASSERT_UNLOCKED(_sc)     mtx_assert(&(_sc)->mtx, MA_NOTOWNED);
  74
  75 static syscon_method_t simple_mfd_syscon_methods[] = {
  76         SYSCONMETHOD(syscon_read_4,     simple_mfd_syscon_read_4),
  77         SYSCONMETHOD(syscon_write_4,    simple_mfd_syscon_write_4),
  78         SYSCONMETHOD(syscon_modify_4,   simple_mfd_syscon_modify_4),
  79
  80         SYSCONMETHOD_END
  81 };
  82 DEFINE_CLASS_1(simple_mfd_syscon, simple_mfd_syscon_class,
  83     simple_mfd_syscon_methods, 0, syscon_class);
  84
  85 static uint32_t
  86 simple_mfd_syscon_read_4(struct syscon *syscon, bus_size_t offset)
  87 {
  88         struct simple_mfd_softc *sc;
  89         uint32_t val;
  90
  91         sc = device_get_softc(syscon->pdev);
  92
  93         SYSCON_LOCK(sc);
  94         val = bus_read_4(sc->mem_res, offset);
  95         SYSCON_UNLOCK(sc);
  96         return (val);
  97 }
  98
  99 static int
 100 simple_mfd_syscon_write_4(struct syscon *syscon, bus_size_t offset,
 101     uint32_t val)
 102 {
 103         struct simple_mfd_softc *sc;
 104
 105         sc = device_get_softc(syscon->pdev);
 106
 107         SYSCON_LOCK(sc);
 108         bus_write_4(sc->mem_res, offset, val);
 109         SYSCON_UNLOCK(sc);
 110         return (0);
 111 }
 112
 113 static int
 114 simple_mfd_syscon_modify_4(struct syscon *syscon, bus_size_t offset,
 115     uint32_t clear_bits, uint32_t set_bits)
 116 {
 117         struct simple_mfd_softc *sc;
 118         uint32_t val;
 119
 120         sc = device_get_softc(syscon->pdev);
 121
 122         SYSCON_LOCK(sc);
 123         val = bus_read_4(sc->mem_res, offset);
 124         val &= ~clear_bits;
 125         val |= set_bits;
 126         bus_write_4(sc->mem_res, offset, val);
 127         SYSCON_UNLOCK(sc);
 128         return (0);
 129 }
 130 static int
 131 simple_mfd_syscon_get_handle(device_t dev, struct syscon **syscon)
 132 {
 133         struct simple_mfd_softc *sc;
 134
 135         sc = device_get_softc(dev);
 136         *syscon = sc->syscon;
 137         if (*syscon == NULL)
 138                 return (ENODEV);
 139         return (0);
 140 }
 141
 142 static int
 143 simple_mfd_probe(device_t dev)
 144 {
 145
 146         if (!ofw_bus_status_okay(dev))
 147                 return (ENXIO);
 148         if (!ofw_bus_is_compatible(dev, "simple-mfd"))
 149                 return (ENXIO);
 150
 151         device_set_desc(dev, "Simple MFD (Multi-Functions Device)");
 152
 153         return (BUS_PROBE_GENERIC);
 154 }
 155
 156 static int
 157 simple_mfd_attach(device_t dev)
 158 {
 159         struct simple_mfd_softc *sc;
 160         phandle_t node, child;
 161         device_t cdev;
 162         int rid;
 163
 164         sc = device_get_softc(dev);
 165         node = ofw_bus_get_node(dev);
 166
 167         sc->dev = dev;
 168         rid = 0;
 169
 170         /* Parse address-cells and size-cells from the parent node as a fallback */
 171         if (OF_getencprop(node, "#address-cells", &sc->sc.acells,
 172             sizeof(sc->sc.acells)) == -1) {
 173                 if (OF_getencprop(OF_parent(node), "#address-cells", &sc->sc.acells,
 174                     sizeof(sc->sc.acells)) == -1) {
 175                         sc->sc.acells = 2;
 176                 }
 177         }
 178         if (OF_getencprop(node, "#size-cells", &sc->sc.scells,
 179             sizeof(sc->sc.scells)) == -1) {
 180                 if (OF_getencprop(OF_parent(node), "#size-cells", &sc->sc.scells,
 181                     sizeof(sc->sc.scells)) == -1) {
 182                         sc->sc.scells = 1;
 183                 }
 184         }
 185
 186         /* If the node has a ranges prop, parse it so children mapping will be done correctly */
 187         if (OF_hasprop(node, "ranges")) {
 188                 if (simplebus_fill_ranges(node, &sc->sc) < 0) {
 189                         device_printf(dev, "could not get ranges\n");
 190                         return (ENXIO);
 191                 }
 192         }
 193
 194         /* Attach child devices */
 195         for (child = OF_child(node); child > 0; child = OF_peer(child)) {
 196                 cdev = simple_mfd_add_device(dev, child, 0, NULL, -1, NULL);
 197                 if (cdev != NULL)
 198                         device_probe_and_attach(cdev);
 199         }
 200
 201         if (ofw_bus_is_compatible(dev, "syscon")) {
 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,
 206                             "Cannot allocate memory resource\n");
 207                         return (ENXIO);
 208                 }
 209
 210                 SYSCON_LOCK_INIT(sc);
 211                 sc->syscon = syscon_create_ofw_node(dev,
 212                     &simple_mfd_syscon_class, ofw_bus_get_node(dev));
 213                 if (sc->syscon == NULL) {
 214                         device_printf(dev,
 215                             "Failed to create/register syscon\n");
 216                         return (ENXIO);
 217                 }
 218         }
 219         return (bus_generic_attach(dev));
 220 }
 221
 222 static int
 223 simple_mfd_detach(device_t dev)
 224 {
 225         struct simple_mfd_softc *sc;
 226
 227         sc = device_get_softc(dev);
 228         if (ofw_bus_is_compatible(dev, "syscon")) {
 229                 if (sc->syscon != NULL) {
 230                         syscon_unregister(sc->syscon);
 231                         free(sc->syscon, M_SYSCON);
 232                 }
 233
 234                 SYSCON_LOCK_DESTROY(sc);
 235
 236                 if (sc->mem_res != NULL)
 237                         bus_release_resource(dev, SYS_RES_MEMORY, 0,
 238                             sc->mem_res);
 239         }
 240         return (0);
 241 }
 242
 243 struct simplebus_devinfo *
 244 simple_mfd_setup_dinfo(device_t dev, phandle_t node,
 245     struct simplebus_devinfo *di)
 246 {
 247         struct simplebus_softc *sc;
 248         struct simplebus_devinfo *ndi;
 249
 250         sc = device_get_softc(dev);
 251         if (di == NULL)
 252                 ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
 253         else
 254                 ndi = di;
 255         if (ofw_bus_gen_setup_devinfo(&ndi->obdinfo, node) != 0) {
 256                 if (di == NULL)
 257                         free(ndi, M_DEVBUF);
 258                 return (NULL);
 259         }
 260
 261         /* reg resources is from the parent but interrupts is on the node itself */
 262         resource_list_init(&ndi->rl);
 263         ofw_bus_reg_to_rl(dev, OF_parent(node), sc->acells, sc->scells, &ndi->rl);
 264         ofw_bus_intr_to_rl(dev, node, &ndi->rl, NULL);
 265
 266         return (ndi);
 267 }
 268
 269 device_t
 270 simple_mfd_add_device(device_t dev, phandle_t node, u_int order,
 271     const char *name, int unit, struct simplebus_devinfo *di)
 272 {
 273         struct simplebus_devinfo *ndi;
 274         device_t cdev;
 275
 276         if ((ndi = simple_mfd_setup_dinfo(dev, node, di)) == NULL)
 277                 return (NULL);
 278         cdev = device_add_child_ordered(dev, order, name, unit);
 279         if (cdev == NULL) {
 280                 device_printf(dev, "<%s>: device_add_child failed\n",
 281                     ndi->obdinfo.obd_name);
 282                 resource_list_free(&ndi->rl);
 283                 ofw_bus_gen_destroy_devinfo(&ndi->obdinfo);
 284                 if (di == NULL)
 285                         free(ndi, M_DEVBUF);
 286                 return (NULL);
 287         }
 288         device_set_ivars(cdev, ndi);
 289
 290         return(cdev);
 291 }
 292
 293 static device_method_t simple_mfd_methods[] = {
 294         /* syscon interface */
 295         DEVMETHOD(syscon_get_handle,    simple_mfd_syscon_get_handle),
 296         /* Device interface */
 297         DEVMETHOD(device_probe,         simple_mfd_probe),
 298         DEVMETHOD(device_attach,        simple_mfd_attach),
 299         DEVMETHOD(device_detach,        simple_mfd_detach),
 300
 301         DEVMETHOD_END
 302 };
 303
 304 DEFINE_CLASS_1(simple_mfd, simple_mfd_driver, simple_mfd_methods,
 305   sizeof(struct simple_mfd_softc), simplebus_driver);
 306
 307 static devclass_t simple_mfd_devclass;
 308
 309 EARLY_DRIVER_MODULE(simple_mfd, simplebus, simple_mfd_driver,
 310     simple_mfd_devclass, 0, 0, BUS_PASS_BUS + BUS_PASS_ORDER_LATE);
 311 MODULE_VERSION(simple_mfd, 1);