macgpio.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 2008 by Nathan Whitehorn. All rights reserved.
    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 ``AS IS'' AND ANY EXPRESS OR
   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
   20  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
   22  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   23  * 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  * $FreeBSD$
   28  */
   29 
   30 /*
   31  * Driver for MacIO GPIO controller
   32  */
   33 
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/kernel.h>
   37 #include <sys/malloc.h>
   38 #include <sys/module.h>
   39 #include <sys/bus.h>
   40 #include <sys/rman.h>
   41 
   42 #include <vm/vm.h>
   43 #include <vm/pmap.h>
   44 
   45 #include <machine/bus.h>
   46 #include <machine/intr_machdep.h>
   47 #include <machine/resource.h>
   48 #include <machine/vmparam.h>
   49 
   50 #include <dev/ofw/ofw_bus.h>
   51 #include <dev/ofw/ofw_bus_subr.h>
   52 #include <dev/ofw/openfirm.h>
   53 
   54 #include <powerpc/powermac/macgpiovar.h>
   55 
   56 /*
   57  * Macgpio softc
   58  */
   59 struct macgpio_softc {
   60         phandle_t       sc_node;
   61         struct resource *sc_gpios;
   62         int             sc_gpios_rid;
   63         uint32_t        sc_saved_gpio_levels[2];
   64         uint32_t        sc_saved_gpios[GPIO_COUNT];
   65         uint32_t        sc_saved_extint_gpios[GPIO_EXTINT_COUNT];
   66 };
   67 
   68 static MALLOC_DEFINE(M_MACGPIO, "macgpio", "macgpio device information");
   69 
   70 static int      macgpio_probe(device_t);
   71 static int      macgpio_attach(device_t);
   72 static int      macgpio_print_child(device_t dev, device_t child);
   73 static void     macgpio_probe_nomatch(device_t, device_t);
   74 static struct resource *macgpio_alloc_resource(device_t, device_t, int, int *,
   75                     rman_res_t, rman_res_t, rman_res_t, u_int);
   76 static int      macgpio_activate_resource(device_t, device_t, int, int,
   77                     struct resource *);
   78 static int      macgpio_deactivate_resource(device_t, device_t, int, int,
   79                     struct resource *);
   80 static ofw_bus_get_devinfo_t macgpio_get_devinfo;
   81 static int      macgpio_suspend(device_t dev);
   82 static int      macgpio_resume(device_t dev);
   83 
   84 /*
   85  * Bus interface definition
   86  */
   87 static device_method_t macgpio_methods[] = {
   88         /* Device interface */
   89         DEVMETHOD(device_probe,         macgpio_probe),
   90         DEVMETHOD(device_attach,        macgpio_attach),
   91         DEVMETHOD(device_detach,        bus_generic_detach),
   92         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
   93         DEVMETHOD(device_suspend,       macgpio_suspend),
   94         DEVMETHOD(device_resume,        macgpio_resume),
   95 
   96         /* Bus interface */
   97         DEVMETHOD(bus_print_child,      macgpio_print_child),
   98         DEVMETHOD(bus_probe_nomatch,    macgpio_probe_nomatch),
   99         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
  100         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),     
  101 
  102         DEVMETHOD(bus_alloc_resource,   macgpio_alloc_resource),
  103         DEVMETHOD(bus_activate_resource, macgpio_activate_resource),
  104         DEVMETHOD(bus_deactivate_resource, macgpio_deactivate_resource),
  105         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
  106 
  107         DEVMETHOD(bus_child_pnpinfo,    ofw_bus_gen_child_pnpinfo),
  108 
  109         /* ofw_bus interface */
  110         DEVMETHOD(ofw_bus_get_devinfo,  macgpio_get_devinfo),
  111         DEVMETHOD(ofw_bus_get_compat,   ofw_bus_gen_get_compat),
  112         DEVMETHOD(ofw_bus_get_model,    ofw_bus_gen_get_model),
  113         DEVMETHOD(ofw_bus_get_name,     ofw_bus_gen_get_name),
  114         DEVMETHOD(ofw_bus_get_node,     ofw_bus_gen_get_node),
  115         DEVMETHOD(ofw_bus_get_type,     ofw_bus_gen_get_type),
  116         { 0, 0 }
  117 };
  118 
  119 static driver_t macgpio_pci_driver = {
  120         "macgpio",
  121         macgpio_methods,
  122         sizeof(struct macgpio_softc)
  123 };
  124 
  125 EARLY_DRIVER_MODULE(macgpio, macio, macgpio_pci_driver, 0, 0, BUS_PASS_BUS);
  126 
  127 struct macgpio_devinfo {
  128         struct ofw_bus_devinfo mdi_obdinfo;
  129         struct resource_list mdi_resources;
  130 
  131         int gpio_num;
  132 };
  133 
  134 static int
  135 macgpio_probe(device_t dev)
  136 {
  137         const char *name;
  138 
  139         name = ofw_bus_get_name(dev);
  140         if (name && strcmp(name, "gpio") == 0) {
  141                 device_set_desc(dev, "MacIO GPIO Controller");
  142                 return (0);
  143         }
  144 
  145         return (ENXIO); 
  146 }
  147 
  148 /*
  149  * Scan Open Firmware child nodes, and attach these as children
  150  * of the macgpio bus
  151  */
  152 static int 
  153 macgpio_attach(device_t dev)
  154 {
  155         struct macgpio_softc *sc;
  156         struct macgpio_devinfo *dinfo;
  157         phandle_t root, child, iparent;
  158         device_t cdev;
  159         uint32_t irq[2];
  160 
  161         sc = device_get_softc(dev);
  162         root = sc->sc_node = ofw_bus_get_node(dev);
  163 
  164         sc->sc_gpios = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
  165             &sc->sc_gpios_rid, RF_ACTIVE);
  166 
  167         /*
  168          * Iterate through the sub-devices
  169          */
  170         for (child = OF_child(root); child != 0; child = OF_peer(child)) {
  171                 dinfo = malloc(sizeof(*dinfo), M_MACGPIO, M_WAITOK | M_ZERO);
  172                 if (ofw_bus_gen_setup_devinfo(&dinfo->mdi_obdinfo, child) !=
  173                     0) {
  174                         free(dinfo, M_MACGPIO);
  175                         continue;
  176                 }
  177 
  178                 if (OF_getencprop(child, "reg", &dinfo->gpio_num,
  179                     sizeof(dinfo->gpio_num)) != sizeof(dinfo->gpio_num)) {
  180                         /*
  181                          * Some early GPIO controllers don't provide GPIO
  182                          * numbers for GPIOs designed only to provide
  183                          * interrupt resources.  We should still allow these
  184                          * to attach, but with caution.
  185                          */
  186 
  187                         dinfo->gpio_num = -1;
  188                 }
  189 
  190                 resource_list_init(&dinfo->mdi_resources);
  191 
  192                 if (OF_getencprop(child, "interrupts", irq, sizeof(irq)) == 
  193                     sizeof(irq)) {
  194                         OF_searchencprop(child, "interrupt-parent", &iparent,
  195                             sizeof(iparent));
  196                         resource_list_add(&dinfo->mdi_resources, SYS_RES_IRQ,
  197                             0, MAP_IRQ(iparent, irq[0]),
  198                             MAP_IRQ(iparent, irq[0]), 1);
  199                 }
  200 
  201                 /* Fix messed-up offsets */
  202                 if (dinfo->gpio_num > 0x50)
  203                         dinfo->gpio_num -= 0x50;
  204 
  205                 cdev = device_add_child(dev, NULL, -1);
  206                 if (cdev == NULL) {
  207                         device_printf(dev, "<%s>: device_add_child failed\n",
  208                             dinfo->mdi_obdinfo.obd_name);
  209                         ofw_bus_gen_destroy_devinfo(&dinfo->mdi_obdinfo);
  210                         free(dinfo, M_MACGPIO);
  211                         continue;
  212                 }
  213                 device_set_ivars(cdev, dinfo);
  214         }
  215 
  216         return (bus_generic_attach(dev));
  217 }
  218 
  219 static int
  220 macgpio_print_child(device_t dev, device_t child)
  221 {
  222         struct macgpio_devinfo *dinfo;
  223         int retval = 0;
  224 
  225         dinfo = device_get_ivars(child);
  226 
  227         retval += bus_print_child_header(dev, child);
  228 
  229         if (dinfo->gpio_num >= GPIO_BASE)
  230                 printf(" gpio %d", dinfo->gpio_num - GPIO_BASE);
  231         else if (dinfo->gpio_num >= GPIO_EXTINT_BASE)
  232                 printf(" extint-gpio %d", dinfo->gpio_num - GPIO_EXTINT_BASE);
  233         else if (dinfo->gpio_num >= 0)
  234                 printf(" addr 0x%02x", dinfo->gpio_num); /* should not happen */
  235 
  236         resource_list_print_type(&dinfo->mdi_resources, "irq", SYS_RES_IRQ, 
  237             "%jd");
  238         retval += bus_print_child_footer(dev, child);
  239 
  240         return (retval);
  241 }
  242 
  243 static void
  244 macgpio_probe_nomatch(device_t dev, device_t child)
  245 {
  246         struct macgpio_devinfo *dinfo;
  247         const char *type;
  248 
  249         if (bootverbose) {
  250                 dinfo = device_get_ivars(child);
  251 
  252                 if ((type = ofw_bus_get_type(child)) == NULL)
  253                         type = "(unknown)";
  254                 device_printf(dev, "<%s, %s>", type, ofw_bus_get_name(child));
  255                 if (dinfo->gpio_num >= 0)
  256                         printf(" gpio %d",dinfo->gpio_num);
  257                 resource_list_print_type(&dinfo->mdi_resources, "irq", 
  258                     SYS_RES_IRQ, "%jd");
  259                 printf(" (no driver attached)\n");
  260         }
  261 }
  262 
  263 static struct resource *
  264 macgpio_alloc_resource(device_t bus, device_t child, int type, int *rid,
  265                      rman_res_t start, rman_res_t end, rman_res_t count,
  266                      u_int flags)
  267 {
  268         struct macgpio_devinfo *dinfo;
  269 
  270         dinfo = device_get_ivars(child);
  271 
  272         if (type != SYS_RES_IRQ)
  273                 return (NULL);
  274 
  275         return (resource_list_alloc(&dinfo->mdi_resources, bus, child, type, 
  276             rid, start, end, count, flags));
  277 }
  278 
  279 static int
  280 macgpio_activate_resource(device_t bus, device_t child, int type, int rid,
  281                            struct resource *res)
  282 {
  283         struct macgpio_softc *sc;
  284         struct macgpio_devinfo *dinfo;
  285         u_char val;
  286 
  287         sc = device_get_softc(bus);
  288         dinfo = device_get_ivars(child);
  289 
  290         if (type != SYS_RES_IRQ)
  291                 return ENXIO;
  292 
  293         if (dinfo->gpio_num >= 0) {
  294                 val = bus_read_1(sc->sc_gpios,dinfo->gpio_num);
  295                 val |= 0x80;
  296                 bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
  297         }
  298 
  299         return (bus_activate_resource(bus, type, rid, res));
  300 }
  301 
  302 static int
  303 macgpio_deactivate_resource(device_t bus, device_t child, int type, int rid,
  304                           struct resource *res)
  305 {
  306         struct macgpio_softc *sc;
  307         struct macgpio_devinfo *dinfo;
  308         u_char val;
  309 
  310         sc = device_get_softc(bus);
  311         dinfo = device_get_ivars(child);
  312 
  313         if (type != SYS_RES_IRQ)
  314                 return ENXIO;
  315 
  316         if (dinfo->gpio_num >= 0) {
  317                 val = bus_read_1(sc->sc_gpios,dinfo->gpio_num);
  318                 val &= ~0x80;
  319                 bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
  320         }
  321 
  322         return (bus_deactivate_resource(bus, type, rid, res));
  323 }
  324 
  325 uint8_t
  326 macgpio_read(device_t dev)
  327 {
  328         struct macgpio_softc *sc;
  329         struct macgpio_devinfo *dinfo;
  330 
  331         sc = device_get_softc(device_get_parent(dev));
  332         dinfo = device_get_ivars(dev);
  333 
  334         if (dinfo->gpio_num < 0)
  335                 return (0);
  336 
  337         return (bus_read_1(sc->sc_gpios,dinfo->gpio_num));
  338 }
  339 
  340 void
  341 macgpio_write(device_t dev, uint8_t val)
  342 {
  343         struct macgpio_softc *sc;
  344         struct macgpio_devinfo *dinfo;
  345 
  346         sc = device_get_softc(device_get_parent(dev));
  347         dinfo = device_get_ivars(dev);
  348 
  349         if (dinfo->gpio_num < 0)
  350                 return;
  351 
  352         bus_write_1(sc->sc_gpios,dinfo->gpio_num,val);
  353 }
  354 
  355 static const struct ofw_bus_devinfo *
  356 macgpio_get_devinfo(device_t dev, device_t child)
  357 {
  358         struct macgpio_devinfo *dinfo;
  359 
  360         dinfo = device_get_ivars(child);
  361         return (&dinfo->mdi_obdinfo);
  362 }
  363 
  364 static int
  365 macgpio_suspend(device_t dev)
  366 {
  367         struct macgpio_softc *sc;
  368         int i;
  369 
  370         sc = device_get_softc(dev);
  371         sc->sc_saved_gpio_levels[0] = bus_read_4(sc->sc_gpios, GPIO_LEVELS_0);
  372         sc->sc_saved_gpio_levels[1] = bus_read_4(sc->sc_gpios, GPIO_LEVELS_1);
  373 
  374         for (i = 0; i < GPIO_COUNT; i++)
  375                 sc->sc_saved_gpios[i] = bus_read_1(sc->sc_gpios, GPIO_BASE + i);
  376         for (i = 0; i < GPIO_EXTINT_COUNT; i++)
  377                 sc->sc_saved_extint_gpios[i] = bus_read_1(sc->sc_gpios, GPIO_EXTINT_BASE + i);
  378 
  379         return (0);
  380 }
  381 
  382 static int
  383 macgpio_resume(device_t dev)
  384 {
  385         struct macgpio_softc *sc;
  386         int i;
  387 
  388         sc = device_get_softc(dev);
  389         bus_write_4(sc->sc_gpios, GPIO_LEVELS_0, sc->sc_saved_gpio_levels[0]);
  390         bus_write_4(sc->sc_gpios, GPIO_LEVELS_1, sc->sc_saved_gpio_levels[1]);
  391 
  392         for (i = 0; i < GPIO_COUNT; i++)
  393                 bus_write_1(sc->sc_gpios, GPIO_BASE + i, sc->sc_saved_gpios[i]);
  394         for (i = 0; i < GPIO_EXTINT_COUNT; i++)
  395                 bus_write_1(sc->sc_gpios, GPIO_EXTINT_BASE + i, sc->sc_saved_extint_gpios[i]);
  396 
  397         return (0);
  398 }
Cache object: 0a7a1e1aa4e05f043585a66990f44ca1
[ 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/powerpc/powermac/macgpio.c

FreeBSD/Linux Kernel Cross Reference
sys/powerpc/powermac/macgpio.c
