simple_mfd.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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_unlocked_read_4,    simple_mfd_syscon_read_4),
   77         SYSCONMETHOD(syscon_unlocked_write_4,   simple_mfd_syscon_write_4),
   78         SYSCONMETHOD(syscon_unlocked_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         SYSCON_ASSERT_LOCKED(sc);
   93         val = bus_read_4(sc->mem_res, offset);
   94         return (val);
   95 }
   96 
   97 static int
   98 simple_mfd_syscon_write_4(struct syscon *syscon, bus_size_t offset,
   99     uint32_t val)
  100 {
  101         struct simple_mfd_softc *sc;
  102 
  103         sc = device_get_softc(syscon->pdev);
  104         SYSCON_ASSERT_LOCKED(sc);
  105         bus_write_4(sc->mem_res, offset, val);
  106         return (0);
  107 }
  108 
  109 static int
  110 simple_mfd_syscon_modify_4(struct syscon *syscon, bus_size_t offset,
  111     uint32_t clear_bits, uint32_t set_bits)
  112 {
  113         struct simple_mfd_softc *sc;
  114         uint32_t val;
  115 
  116         sc = device_get_softc(syscon->pdev);
  117         SYSCON_ASSERT_LOCKED(sc);
  118         val = bus_read_4(sc->mem_res, offset);
  119         val &= ~clear_bits;
  120         val |= set_bits;
  121         bus_write_4(sc->mem_res, offset, val);
  122         return (0);
  123 }
  124 
  125 static int
  126 simple_mfd_syscon_get_handle(device_t dev, struct syscon **syscon)
  127 {
  128         struct simple_mfd_softc *sc;
  129 
  130         sc = device_get_softc(dev);
  131         *syscon = sc->syscon;
  132         if (*syscon == NULL)
  133                 return (ENODEV);
  134         return (0);
  135 }
  136 
  137 static void
  138 simple_mfd_syscon_lock(device_t dev)
  139 {
  140         struct simple_mfd_softc *sc;
  141 
  142         sc = device_get_softc(dev);
  143         SYSCON_LOCK(sc);
  144 }
  145 
  146 static void
  147 simple_mfd_syscon_unlock(device_t dev)
  148 {
  149         struct simple_mfd_softc *sc;
  150 
  151         sc = device_get_softc(dev);
  152         SYSCON_UNLOCK(sc);
  153 }
  154 
  155 static int
  156 simple_mfd_probe(device_t dev)
  157 {
  158 
  159         if (!ofw_bus_status_okay(dev))
  160                 return (ENXIO);
  161         if (!ofw_bus_is_compatible(dev, "simple-mfd"))
  162                 return (ENXIO);
  163 
  164         device_set_desc(dev, "Simple MFD (Multi-Functions Device)");
  165 
  166         return (BUS_PROBE_GENERIC);
  167 }
  168 
  169 static int
  170 simple_mfd_attach(device_t dev)
  171 {
  172         struct simple_mfd_softc *sc;
  173         phandle_t node, child;
  174         device_t cdev;
  175         int rid;
  176 
  177         sc = device_get_softc(dev);
  178         node = ofw_bus_get_node(dev);
  179 
  180         sc->dev = dev;
  181         rid = 0;
  182 
  183         /* Parse address-cells and size-cells from the parent node as a fallback */
  184         if (OF_getencprop(node, "#address-cells", &sc->sc.acells,
  185             sizeof(sc->sc.acells)) == -1) {
  186                 if (OF_getencprop(OF_parent(node), "#address-cells", &sc->sc.acells,
  187                     sizeof(sc->sc.acells)) == -1) {
  188                         sc->sc.acells = 2;
  189                 }
  190         }
  191         if (OF_getencprop(node, "#size-cells", &sc->sc.scells,
  192             sizeof(sc->sc.scells)) == -1) {
  193                 if (OF_getencprop(OF_parent(node), "#size-cells", &sc->sc.scells,
  194                     sizeof(sc->sc.scells)) == -1) {
  195                         sc->sc.scells = 1;
  196                 }
  197         }
  198 
  199         /* If the node has a ranges prop, parse it so children mapping will be done correctly */
  200         if (OF_hasprop(node, "ranges")) {
  201                 if (simplebus_fill_ranges(node, &sc->sc) < 0) {
  202                         device_printf(dev, "could not get ranges\n");
  203                         return (ENXIO);
  204                 }
  205         }
  206 
  207         /* Attach child devices */
  208         for (child = OF_child(node); child > 0; child = OF_peer(child)) {
  209                 cdev = simple_mfd_add_device(dev, child, 0, NULL, -1, NULL);
  210                 if (cdev != NULL)
  211                         device_probe_and_attach(cdev);
  212         }
  213 
  214         if (ofw_bus_is_compatible(dev, "syscon")) {
  215                 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
  216                     RF_ACTIVE);
  217                 if (sc->mem_res == NULL) {
  218                         device_printf(dev,
  219                             "Cannot allocate memory resource\n");
  220                         return (ENXIO);
  221                 }
  222 
  223                 SYSCON_LOCK_INIT(sc);
  224                 sc->syscon = syscon_create_ofw_node(dev,
  225                     &simple_mfd_syscon_class, ofw_bus_get_node(dev));
  226                 if (sc->syscon == NULL) {
  227                         device_printf(dev,
  228                             "Failed to create/register syscon\n");
  229                         return (ENXIO);
  230                 }
  231         }
  232         return (bus_generic_attach(dev));
  233 }
  234 
  235 static int
  236 simple_mfd_detach(device_t dev)
  237 {
  238         struct simple_mfd_softc *sc;
  239 
  240         sc = device_get_softc(dev);
  241         if (ofw_bus_is_compatible(dev, "syscon")) {
  242                 if (sc->syscon != NULL) {
  243                         syscon_unregister(sc->syscon);
  244                         free(sc->syscon, M_SYSCON);
  245                 }
  246 
  247                 SYSCON_LOCK_DESTROY(sc);
  248 
  249                 if (sc->mem_res != NULL)
  250                         bus_release_resource(dev, SYS_RES_MEMORY, 0,
  251                             sc->mem_res);
  252         }
  253         return (0);
  254 }
  255 
  256 struct simplebus_devinfo *
  257 simple_mfd_setup_dinfo(device_t dev, phandle_t node,
  258     struct simplebus_devinfo *di)
  259 {
  260         struct simplebus_softc *sc;
  261         struct simplebus_devinfo *ndi;
  262 
  263         sc = device_get_softc(dev);
  264         if (di == NULL)
  265                 ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
  266         else
  267                 ndi = di;
  268         if (ofw_bus_gen_setup_devinfo(&ndi->obdinfo, node) != 0) {
  269                 if (di == NULL)
  270                         free(ndi, M_DEVBUF);
  271                 return (NULL);
  272         }
  273 
  274         /* reg resources is from the parent but interrupts is on the node itself */
  275         resource_list_init(&ndi->rl);
  276         ofw_bus_reg_to_rl(dev, OF_parent(node), sc->acells, sc->scells, &ndi->rl);
  277         ofw_bus_intr_to_rl(dev, node, &ndi->rl, NULL);
  278 
  279         return (ndi);
  280 }
  281 
  282 device_t
  283 simple_mfd_add_device(device_t dev, phandle_t node, u_int order,
  284     const char *name, int unit, struct simplebus_devinfo *di)
  285 {
  286         struct simplebus_devinfo *ndi;
  287         device_t cdev;
  288 
  289         if ((ndi = simple_mfd_setup_dinfo(dev, node, di)) == NULL)
  290                 return (NULL);
  291         cdev = device_add_child_ordered(dev, order, name, unit);
  292         if (cdev == NULL) {
  293                 device_printf(dev, "<%s>: device_add_child failed\n",
  294                     ndi->obdinfo.obd_name);
  295                 resource_list_free(&ndi->rl);
  296                 ofw_bus_gen_destroy_devinfo(&ndi->obdinfo);
  297                 if (di == NULL)
  298                         free(ndi, M_DEVBUF);
  299                 return (NULL);
  300         }
  301         device_set_ivars(cdev, ndi);
  302 
  303         return(cdev);
  304 }
  305 
  306 static device_method_t simple_mfd_methods[] = {
  307         /* syscon interface */
  308         DEVMETHOD(syscon_get_handle,    simple_mfd_syscon_get_handle),
  309         DEVMETHOD(syscon_device_lock,   simple_mfd_syscon_lock),
  310         DEVMETHOD(syscon_device_unlock, simple_mfd_syscon_unlock),
  311 
  312         /* Device interface */
  313         DEVMETHOD(device_probe,         simple_mfd_probe),
  314         DEVMETHOD(device_attach,        simple_mfd_attach),
  315         DEVMETHOD(device_detach,        simple_mfd_detach),
  316 
  317         DEVMETHOD_END
  318 };
  319 
  320 DEFINE_CLASS_1(simple_mfd, simple_mfd_driver, simple_mfd_methods,
  321   sizeof(struct simple_mfd_softc), simplebus_driver);
  322 
  323 EARLY_DRIVER_MODULE(simple_mfd, simplebus, simple_mfd_driver, 0, 0,
  324     BUS_PASS_BUS + BUS_PASS_ORDER_LATE);
  325 MODULE_VERSION(simple_mfd, 1);
Cache object: 38b26bfaf1310bbaec94175ebe535f94
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/fdt/simple_mfd.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/fdt/simple_mfd.c
