amdgpio.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 Advanced Micro Devices
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD$");
   31 
   32 #include "opt_acpi.h"
   33 
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/bus.h>
   37 #include <sys/gpio.h>
   38 #include <sys/interrupt.h>
   39 #include <sys/kernel.h>
   40 #include <sys/lock.h>
   41 #include <sys/module.h>
   42 #include <sys/mutex.h>
   43 #include <sys/proc.h>
   44 #include <sys/rman.h>
   45 #include <sys/sysctl.h>
   46 
   47 #include <machine/bus.h>
   48 #include <machine/resource.h>
   49 
   50 #include <contrib/dev/acpica/include/acpi.h>
   51 #include <contrib/dev/acpica/include/accommon.h>
   52 
   53 #include <dev/acpica/acpivar.h>
   54 #include <dev/gpio/gpiobusvar.h>
   55 
   56 #include "gpio_if.h"
   57 #include "amdgpio.h"
   58 
   59 static struct resource_spec amdgpio_spec[] = {
   60         { SYS_RES_MEMORY, 0, RF_ACTIVE },
   61         { -1, 0, 0 }
   62 };
   63 
   64 static inline uint32_t
   65 amdgpio_read_4(struct amdgpio_softc *sc, bus_size_t off)
   66 {
   67         return (bus_read_4(sc->sc_res[0], off));
   68 }
   69 
   70 static inline void
   71 amdgpio_write_4(struct amdgpio_softc *sc, bus_size_t off,
   72                 uint32_t val)
   73 {
   74         bus_write_4(sc->sc_res[0], off, val);
   75 }
   76 
   77 static bool
   78 amdgpio_is_pin_output(struct amdgpio_softc *sc, uint32_t pin)
   79 {
   80         uint32_t reg, val;
   81         bool ret;
   82 
   83         /* Get the current pin state */
   84         AMDGPIO_LOCK(sc);
   85 
   86         reg = AMDGPIO_PIN_REGISTER(pin);
   87         val = amdgpio_read_4(sc, reg);
   88 
   89         if (val & BIT(OUTPUT_ENABLE_OFF))
   90                 ret = true;
   91         else
   92                 ret = false;
   93 
   94         AMDGPIO_UNLOCK(sc);
   95 
   96         return (ret);
   97 }
   98 
   99 static device_t
  100 amdgpio_get_bus(device_t dev)
  101 {
  102         struct amdgpio_softc *sc;
  103 
  104         sc = device_get_softc(dev);
  105 
  106         dprintf("busdev %p\n", sc->sc_busdev);
  107         return (sc->sc_busdev);
  108 }
  109 
  110 static int
  111 amdgpio_pin_max(device_t dev, int *maxpin)
  112 {
  113         struct amdgpio_softc *sc;
  114 
  115         sc = device_get_softc(dev);
  116 
  117         *maxpin = sc->sc_npins - 1;
  118         dprintf("npins %d maxpin %d\n", sc->sc_npins, *maxpin);
  119 
  120         return (0);
  121 }
  122 
  123 static bool
  124 amdgpio_valid_pin(struct amdgpio_softc *sc, int pin)
  125 {
  126         dprintf("pin %d\n", pin);
  127         if (sc->sc_res[0] == NULL)
  128                 return (false);
  129 
  130         if ((sc->sc_gpio_pins[pin].gp_pin == pin) &&
  131                 (sc->sc_gpio_pins[pin].gp_caps != 0))
  132                 return (true);
  133 
  134         return (false);
  135 }
  136 
  137 static int
  138 amdgpio_pin_getname(device_t dev, uint32_t pin, char *name)
  139 {
  140         struct amdgpio_softc *sc;
  141 
  142         dprintf("pin %d\n", pin);
  143         sc = device_get_softc(dev);
  144 
  145         if (!amdgpio_valid_pin(sc, pin))
  146                 return (EINVAL);
  147 
  148         /* Set a very simple name */
  149         snprintf(name, GPIOMAXNAME, "%s", sc->sc_gpio_pins[pin].gp_name);
  150         name[GPIOMAXNAME - 1] = '\0';
  151 
  152         dprintf("pin %d name %s\n", pin, name);
  153 
  154         return (0);
  155 }
  156 
  157 static int
  158 amdgpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
  159 {
  160         struct amdgpio_softc *sc;
  161 
  162         sc = device_get_softc(dev);
  163 
  164         dprintf("pin %d\n", pin);
  165         if (!amdgpio_valid_pin(sc, pin))
  166                 return (EINVAL);
  167 
  168         *caps = sc->sc_gpio_pins[pin].gp_caps;
  169 
  170         dprintf("pin %d caps 0x%x\n", pin, *caps);
  171 
  172         return (0);
  173 }
  174 
  175 static int
  176 amdgpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
  177 {
  178         struct amdgpio_softc *sc;
  179 
  180         sc = device_get_softc(dev);
  181 
  182         dprintf("pin %d\n", pin);
  183         if (!amdgpio_valid_pin(sc, pin))
  184                 return (EINVAL);
  185 
  186         AMDGPIO_LOCK(sc);
  187 
  188         *flags = sc->sc_gpio_pins[pin].gp_flags;
  189 
  190         dprintf("pin %d flags 0x%x\n", pin, *flags);
  191 
  192         AMDGPIO_UNLOCK(sc);
  193 
  194         return (0);
  195 }
  196 
  197 static int
  198 amdgpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
  199 {
  200         struct amdgpio_softc *sc;
  201         uint32_t reg, val, allowed;
  202 
  203         sc = device_get_softc(dev);
  204 
  205         dprintf("pin %d flags 0x%x\n", pin, flags);
  206         if (!amdgpio_valid_pin(sc, pin))
  207                 return (EINVAL);
  208 
  209         allowed = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT;
  210 
  211         /*
  212          * Only directtion flag allowed
  213          */
  214         if (flags & ~allowed)
  215                 return (EINVAL);
  216 
  217         /*
  218          * Not both directions simultaneously
  219          */
  220         if ((flags & allowed) == allowed)
  221                 return (EINVAL);
  222 
  223         /* Set the GPIO mode and state */
  224         AMDGPIO_LOCK(sc);
  225 
  226         reg = AMDGPIO_PIN_REGISTER(pin);
  227         val = amdgpio_read_4(sc, reg);
  228 
  229         if (flags & GPIO_PIN_INPUT) {
  230                 val &= ~BIT(OUTPUT_ENABLE_OFF);
  231                 sc->sc_gpio_pins[pin].gp_flags = GPIO_PIN_INPUT;
  232         } else {
  233                 val |= BIT(OUTPUT_ENABLE_OFF);
  234                 sc->sc_gpio_pins[pin].gp_flags = GPIO_PIN_OUTPUT;
  235         }
  236 
  237         amdgpio_write_4(sc, reg, val);
  238 
  239         dprintf("pin %d flags 0x%x val 0x%x gp_flags 0x%x\n",
  240                 pin, flags, val, sc->sc_gpio_pins[pin].gp_flags);
  241 
  242         AMDGPIO_UNLOCK(sc);
  243 
  244         return (0);
  245 }
  246 
  247 static int
  248 amdgpio_pin_get(device_t dev, uint32_t pin, unsigned int *value)
  249 {
  250         struct amdgpio_softc *sc;
  251         uint32_t reg, val;
  252 
  253         sc = device_get_softc(dev);
  254 
  255         dprintf("pin %d\n", pin);
  256         if (!amdgpio_valid_pin(sc, pin))
  257                 return (EINVAL);
  258 
  259         *value = 0;
  260 
  261         AMDGPIO_LOCK(sc);
  262 
  263         reg = AMDGPIO_PIN_REGISTER(pin);
  264         val = amdgpio_read_4(sc, reg);
  265 
  266         if ((sc->sc_gpio_pins[pin].gp_flags & GPIO_PIN_OUTPUT) != 0) {
  267                 if (val & BIT(OUTPUT_VALUE_OFF))
  268                         *value = GPIO_PIN_HIGH;
  269                 else
  270                         *value = GPIO_PIN_LOW;
  271         } else {
  272                 if (val & BIT(PIN_STS_OFF))
  273                         *value = GPIO_PIN_HIGH;
  274                 else
  275                         *value = GPIO_PIN_LOW;
  276         }
  277 
  278         dprintf("pin %d value 0x%x\n", pin, *value);
  279 
  280         AMDGPIO_UNLOCK(sc);
  281 
  282         return (0);
  283 }
  284 
  285 static int
  286 amdgpio_pin_set(device_t dev, uint32_t pin, unsigned int value)
  287 {
  288         struct amdgpio_softc *sc;
  289         uint32_t reg, val;
  290 
  291         sc = device_get_softc(dev);
  292 
  293         dprintf("pin %d value 0x%x\n", pin, value);
  294         if (!amdgpio_valid_pin(sc, pin))
  295                 return (EINVAL);
  296 
  297         if (!amdgpio_is_pin_output(sc, pin))
  298                 return (EINVAL);
  299 
  300         AMDGPIO_LOCK(sc);
  301 
  302         reg = AMDGPIO_PIN_REGISTER(pin);
  303         val = amdgpio_read_4(sc, reg);
  304 
  305         if (value == GPIO_PIN_LOW)
  306                 val &= ~BIT(OUTPUT_VALUE_OFF);
  307         else
  308                 val |= BIT(OUTPUT_VALUE_OFF);
  309 
  310         amdgpio_write_4(sc, reg, val);
  311 
  312         dprintf("pin %d value 0x%x val 0x%x\n", pin, value, val);
  313 
  314         AMDGPIO_UNLOCK(sc);
  315 
  316         return (0);
  317 }
  318 
  319 static int
  320 amdgpio_pin_toggle(device_t dev, uint32_t pin)
  321 {
  322         struct amdgpio_softc *sc;
  323         uint32_t reg, val;
  324 
  325         sc = device_get_softc(dev);
  326 
  327         dprintf("pin %d\n", pin);
  328         if (!amdgpio_valid_pin(sc, pin))
  329                 return (EINVAL);
  330 
  331         if (!amdgpio_is_pin_output(sc, pin))
  332                 return (EINVAL);
  333 
  334         /* Toggle the pin */
  335         AMDGPIO_LOCK(sc);
  336 
  337         reg = AMDGPIO_PIN_REGISTER(pin);
  338         val = amdgpio_read_4(sc, reg);
  339         dprintf("pin %d value before 0x%x\n", pin, val);
  340         val = val ^ BIT(OUTPUT_VALUE_OFF);
  341         dprintf("pin %d value after 0x%x\n", pin, val);
  342         amdgpio_write_4(sc, reg, val);
  343 
  344         AMDGPIO_UNLOCK(sc);
  345 
  346         return (0);
  347 }
  348 
  349 static int
  350 amdgpio_probe(device_t dev)
  351 {
  352         static char *gpio_ids[] = { "AMD0030", "AMDI0030", NULL };
  353         int rv;
  354 
  355         if (acpi_disabled("gpio"))
  356                 return (ENXIO);
  357         rv = ACPI_ID_PROBE(device_get_parent(dev), dev, gpio_ids, NULL);
  358         if (rv <= 0)
  359                 device_set_desc(dev, "AMD GPIO Controller");
  360 
  361         return (rv);
  362 }
  363 
  364 static int
  365 amdgpio_attach(device_t dev)
  366 {
  367         struct amdgpio_softc *sc;
  368         int i, pin, bank;
  369 
  370         sc = device_get_softc(dev);
  371         sc->sc_dev = dev;
  372         sc->sc_handle = acpi_get_handle(dev);
  373 
  374         AMDGPIO_LOCK_INIT(sc);
  375 
  376         sc->sc_nbanks = AMD_GPIO_NUM_PIN_BANK;
  377         sc->sc_npins = AMD_GPIO_PINS_MAX;
  378         sc->sc_bank_prefix = AMD_GPIO_PREFIX;
  379         sc->sc_pin_info = kernzp_pins;
  380         sc->sc_ngroups = nitems(kernzp_groups);
  381         sc->sc_groups = kernzp_groups;
  382 
  383         if (bus_alloc_resources(dev, amdgpio_spec, sc->sc_res)) {
  384                 device_printf(dev, "could not allocate resources\n");
  385                 goto err_rsrc;
  386         }
  387 
  388         sc->sc_bst = rman_get_bustag(sc->sc_res[0]);
  389         sc->sc_bsh = rman_get_bushandle(sc->sc_res[0]);
  390 
  391         /* Initialize all possible pins to be Invalid */
  392         for (i = 0; i < AMD_GPIO_PINS_MAX ; i++) {
  393                 snprintf(sc->sc_gpio_pins[i].gp_name, GPIOMAXNAME,
  394                         "Unexposed PIN %d", i);
  395                 sc->sc_gpio_pins[i].gp_pin = -1;
  396                 sc->sc_gpio_pins[i].gp_caps = 0;
  397                 sc->sc_gpio_pins[i].gp_flags = 0;
  398         }
  399 
  400         /* Initialize only driver exposed pins with appropriate capabilities */
  401         for (i = 0; i < AMD_GPIO_PINS_EXPOSED ; i++) {
  402                 pin = kernzp_pins[i].pin_num;
  403                 bank = pin/AMD_GPIO_PINS_PER_BANK;
  404                 snprintf(sc->sc_gpio_pins[pin].gp_name, GPIOMAXNAME, "%s%d_%s",
  405                         AMD_GPIO_PREFIX, bank, kernzp_pins[i].pin_name);
  406                 sc->sc_gpio_pins[pin].gp_pin = pin;
  407                 sc->sc_gpio_pins[pin].gp_caps = AMDGPIO_DEFAULT_CAPS;
  408                 sc->sc_gpio_pins[pin].gp_flags =
  409                     amdgpio_is_pin_output(sc, pin) ?
  410                     GPIO_PIN_OUTPUT : GPIO_PIN_INPUT;
  411         }
  412 
  413         sc->sc_busdev = gpiobus_attach_bus(dev);
  414         if (sc->sc_busdev == NULL) {
  415                 device_printf(dev, "could not attach gpiobus\n");
  416                 goto err_bus;
  417         }
  418 
  419         return (0);
  420 
  421 err_bus:
  422         bus_release_resources(dev, amdgpio_spec, sc->sc_res);
  423 
  424 err_rsrc:
  425         AMDGPIO_LOCK_DESTROY(sc);
  426 
  427         return (ENXIO);
  428 }
  429 
  430 static int
  431 amdgpio_detach(device_t dev)
  432 {
  433         struct amdgpio_softc *sc;
  434         sc = device_get_softc(dev);
  435 
  436         if (sc->sc_busdev)
  437                 gpiobus_detach_bus(dev);
  438 
  439         bus_release_resources(dev, amdgpio_spec, sc->sc_res);
  440 
  441         AMDGPIO_LOCK_DESTROY(sc);
  442 
  443         return (0);
  444 }
  445 
  446 static device_method_t amdgpio_methods[] = {
  447         /* Device interface */
  448         DEVMETHOD(device_probe, amdgpio_probe),
  449         DEVMETHOD(device_attach, amdgpio_attach),
  450         DEVMETHOD(device_detach, amdgpio_detach),
  451 
  452         /* GPIO protocol */
  453         DEVMETHOD(gpio_get_bus, amdgpio_get_bus),
  454         DEVMETHOD(gpio_pin_max, amdgpio_pin_max),
  455         DEVMETHOD(gpio_pin_getname, amdgpio_pin_getname),
  456         DEVMETHOD(gpio_pin_getcaps, amdgpio_pin_getcaps),
  457         DEVMETHOD(gpio_pin_getflags, amdgpio_pin_getflags),
  458         DEVMETHOD(gpio_pin_setflags, amdgpio_pin_setflags),
  459         DEVMETHOD(gpio_pin_get, amdgpio_pin_get),
  460         DEVMETHOD(gpio_pin_set, amdgpio_pin_set),
  461         DEVMETHOD(gpio_pin_toggle, amdgpio_pin_toggle),
  462 
  463         DEVMETHOD_END
  464 };
  465 
  466 static driver_t amdgpio_driver = {
  467         "gpio",
  468         amdgpio_methods,
  469         sizeof(struct amdgpio_softc),
  470 };
  471 
  472 DRIVER_MODULE(amdgpio, acpi, amdgpio_driver, 0, 0);
  473 MODULE_DEPEND(amdgpio, acpi, 1, 1, 1);
  474 MODULE_DEPEND(amdgpio, gpiobus, 1, 1, 1);
  475 MODULE_VERSION(amdgpio, 1);
Cache object: ebbc2d90ab586be5164654e3c938f447
[ 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/amdgpio/amdgpio.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/amdgpio/amdgpio.c
