mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 00:40:03 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
Core changes: - A patch series from Hans Verkuil to make it possible to enable/disable IRQs on a GPIO line at runtime and drive GPIO lines as output without having to put/get them from scratch. The irqchip callbacks have been improved so that they can use only the fastpatch callbacks to enable/disable irqs like any normal irqchip, especially the gpiod_lock_as_irq() has been improved to be callable in fastpath context. A bunch of rework had to be done to achieve this but it is a big win since I never liked to restrict this to slowpath. The only call requireing slowpath was try_module_get() and this is kept at the .request_resources() slowpath callback. In the GPIO CEC driver this is a big win sine a single line is used for both outgoing and incoming traffic, and this needs to use IRQs for incoming traffic while actively driving the line for outgoing traffic. - Janusz Krzysztofik improved the GPIO array API to pass a "cookie" (struct gpio_array) and a bitmap for setting or getting multiple GPIO lines at once. This improvement orginated in a specific need to speed up an OMAP1 driver and has led to a much better API and real performance gains when the state of the array can be used to bypass a lot of checks and code when we want things to go really fast. The previous code would minimize the number of calls down to the driver callbacks assuming the CPU speed was orders of magnitude faster than the I/O latency, but this assumption was wrong on several platforms: what we needed to do was to profile and improve the speed on the hot path of the array functions and this change is now completed. - Clean out the painful and hard to grasp BNF experiments from the device tree bindings. Future approaches are looking into using JSON schema for this purpose. (Rob Herring is floating a patch series.) New drivers: - The RCAR driver now supports r8a774a1 (RZ/G2M). - Synopsys GPIO via CREGs driver. Major improvements: - Modernization of the EP93xx driver to use irqdomain and other contemporary concepts. - The ingenic driver has been merged into the Ingenic pin control driver and removed from the GPIO subsystem. - Debounce support in the ftgpio010 driver. -----BEGIN PGP SIGNATURE----- iQIcBAABAgAGBQJbzdyOAAoJEEEQszewGV1zfYcP/0HBEAOPhHD/i5OQxfKs1msh mFT/t/IbTmRpCgbEv4CDx4Kc/InE0sUnQr1TL/1WvU6uObM6Ncxq5Z90MvyrgzYu BqQHq2k2tORvkVSNRxcfD/BAAoo1EerXts1kDhutvdKfepfS6DxpENwzvsFgkVlq 2jj1cdZztjv8A+9cspHDpQP+jDvl1VSc10nR5fRu1TttSpUwzRJaB30NBNXJmMJc 5KUr67lEbsQRPsBvFErU11bydPqhfT+pXmODcfIwS0EtATQ8WC5mkSb/Ooei0fvT oZ7uR3Os8tMf7isOKssEyFabKwhnfOEt6TBt9em0TfUtInOo0Dc7r8TfBcn57fyZ xg2R9DQEVRfac8bjhF/BI5KHuN9IMGDDvj6XApumQVliZbISRjMnh3jte6RpcV0A Ejqz8FeDY13qvEdOnW1EPpwmXdDVWiEAq0ebGLStKNls+/4gB2HmyxGUOzJf+og5 hujsxcJzGQqjCe0moeY/1d7vsy0ZjbHoS+p5fy79U212y2O7onEzFU92AX89bxKC rx2eCNmiZxCUy1nqu8edO62VnH6QdnqG3o+a4DJfCSHPvFM/E/NX9zHemZubQQ4I rYXNy4bL4tEG9cqWMfBxWrpiDZw7H6l8kXwdZG8IMyRU9BcKu96amgZ+jBXwzoaB JZelAAUWB9APghJYFr7o =YosT -----END PGP SIGNATURE----- Merge tag 'gpio-v4.20-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio Pull GPIO updates from Linus Walleij: "This is the bulk of GPIO changes for the v4.20 series: Core changes: - A patch series from Hans Verkuil to make it possible to enable/disable IRQs on a GPIO line at runtime and drive GPIO lines as output without having to put/get them from scratch. The irqchip callbacks have been improved so that they can use only the fastpatch callbacks to enable/disable irqs like any normal irqchip, especially the gpiod_lock_as_irq() has been improved to be callable in fastpath context. A bunch of rework had to be done to achieve this but it is a big win since I never liked to restrict this to slowpath. The only call requireing slowpath was try_module_get() and this is kept at the .request_resources() slowpath callback. In the GPIO CEC driver this is a big win sine a single line is used for both outgoing and incoming traffic, and this needs to use IRQs for incoming traffic while actively driving the line for outgoing traffic. - Janusz Krzysztofik improved the GPIO array API to pass a "cookie" (struct gpio_array) and a bitmap for setting or getting multiple GPIO lines at once. This improvement orginated in a specific need to speed up an OMAP1 driver and has led to a much better API and real performance gains when the state of the array can be used to bypass a lot of checks and code when we want things to go really fast. The previous code would minimize the number of calls down to the driver callbacks assuming the CPU speed was orders of magnitude faster than the I/O latency, but this assumption was wrong on several platforms: what we needed to do was to profile and improve the speed on the hot path of the array functions and this change is now completed. - Clean out the painful and hard to grasp BNF experiments from the device tree bindings. Future approaches are looking into using JSON schema for this purpose. (Rob Herring is floating a patch series.) New drivers: - The RCAR driver now supports r8a774a1 (RZ/G2M). - Synopsys GPIO via CREGs driver. Major improvements: - Modernization of the EP93xx driver to use irqdomain and other contemporary concepts. - The ingenic driver has been merged into the Ingenic pin control driver and removed from the GPIO subsystem. - Debounce support in the ftgpio010 driver" * tag 'gpio-v4.20-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio: (116 commits) gpio: Clarify kerneldoc on gpiochip_set_chained_irqchip() gpio: Remove unused 'irqchip' argument to gpiochip_set_cascaded_irqchip() gpio: Drop parent irq assignment during cascade setup mmc: pwrseq_simple: Fix incorrect handling of GPIO bitmap gpio: fix SNPS_CREG kconfig dependency warning gpiolib: Initialize gdev field before is used gpio: fix kernel-doc after devres.c file rename gpio: fix doc string for devm_gpiochip_add_data() to not talk about irq_chip gpio: syscon: Fix possible NULL ptr usage gpiolib: Show correct direction from the beginning pinctrl: msm: Use init_valid_mask exported function gpiolib: Add init_valid_mask exported function GPIO: add single-register GPIO via CREG driver dt-bindings: Document the Synopsys GPIO via CREG bindings gpio: mockup: use device properties instead of platform_data gpio: Slightly more helpful debugfs gpio: omap: Remove set but not used variable 'dev' gpio: omap: drop omap_gpio_list Accept partial 'gpio-line-names' property. gpio: omap: get rid of the conditional PM runtime calls ...
698 lines
18 KiB
C
698 lines
18 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* OF helpers for the GPIO API
|
|
*
|
|
* Copyright (c) 2007-2008 MontaVista Software, Inc.
|
|
*
|
|
* Author: Anton Vorontsov <avorontsov@ru.mvista.com>
|
|
*/
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/module.h>
|
|
#include <linux/io.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/pinctrl/pinctrl.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/gpio/machine.h>
|
|
|
|
#include "gpiolib.h"
|
|
|
|
static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, void *data)
|
|
{
|
|
struct of_phandle_args *gpiospec = data;
|
|
|
|
return chip->gpiodev->dev.of_node == gpiospec->np &&
|
|
chip->of_xlate &&
|
|
chip->of_xlate(chip, gpiospec, NULL) >= 0;
|
|
}
|
|
|
|
static struct gpio_chip *of_find_gpiochip_by_xlate(
|
|
struct of_phandle_args *gpiospec)
|
|
{
|
|
return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate);
|
|
}
|
|
|
|
static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
|
|
struct of_phandle_args *gpiospec,
|
|
enum of_gpio_flags *flags)
|
|
{
|
|
int ret;
|
|
|
|
if (chip->of_gpio_n_cells != gpiospec->args_count)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
ret = chip->of_xlate(chip, gpiospec, flags);
|
|
if (ret < 0)
|
|
return ERR_PTR(ret);
|
|
|
|
return gpiochip_get_desc(chip, ret);
|
|
}
|
|
|
|
static void of_gpio_flags_quirks(struct device_node *np,
|
|
enum of_gpio_flags *flags,
|
|
int index)
|
|
{
|
|
/*
|
|
* Some GPIO fixed regulator quirks.
|
|
* Note that active low is the default.
|
|
*/
|
|
if (IS_ENABLED(CONFIG_REGULATOR) &&
|
|
(of_device_is_compatible(np, "regulator-fixed") ||
|
|
of_device_is_compatible(np, "reg-fixed-voltage") ||
|
|
of_device_is_compatible(np, "regulator-gpio"))) {
|
|
/*
|
|
* The regulator GPIO handles are specified such that the
|
|
* presence or absence of "enable-active-high" solely controls
|
|
* the polarity of the GPIO line. Any phandle flags must
|
|
* be actively ignored.
|
|
*/
|
|
if (*flags & OF_GPIO_ACTIVE_LOW) {
|
|
pr_warn("%s GPIO handle specifies active low - ignored\n",
|
|
of_node_full_name(np));
|
|
*flags &= ~OF_GPIO_ACTIVE_LOW;
|
|
}
|
|
if (!of_property_read_bool(np, "enable-active-high"))
|
|
*flags |= OF_GPIO_ACTIVE_LOW;
|
|
}
|
|
/*
|
|
* Legacy open drain handling for fixed voltage regulators.
|
|
*/
|
|
if (IS_ENABLED(CONFIG_REGULATOR) &&
|
|
of_device_is_compatible(np, "reg-fixed-voltage") &&
|
|
of_property_read_bool(np, "gpio-open-drain")) {
|
|
*flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN);
|
|
pr_info("%s uses legacy open drain flag - update the DTS if you can\n",
|
|
of_node_full_name(np));
|
|
}
|
|
|
|
/*
|
|
* Legacy handling of SPI active high chip select. If we have a
|
|
* property named "cs-gpios" we need to inspect the child node
|
|
* to determine if the flags should have inverted semantics.
|
|
*/
|
|
if (IS_ENABLED(CONFIG_SPI_MASTER) &&
|
|
of_property_read_bool(np, "cs-gpios")) {
|
|
struct device_node *child;
|
|
u32 cs;
|
|
int ret;
|
|
|
|
for_each_child_of_node(np, child) {
|
|
ret = of_property_read_u32(child, "reg", &cs);
|
|
if (!ret)
|
|
continue;
|
|
if (cs == index) {
|
|
/*
|
|
* SPI children have active low chip selects
|
|
* by default. This can be specified negatively
|
|
* by just omitting "spi-cs-high" in the
|
|
* device node, or actively by tagging on
|
|
* GPIO_ACTIVE_LOW as flag in the device
|
|
* tree. If the line is simultaneously
|
|
* tagged as active low in the device tree
|
|
* and has the "spi-cs-high" set, we get a
|
|
* conflict and the "spi-cs-high" flag will
|
|
* take precedence.
|
|
*/
|
|
if (of_property_read_bool(np, "spi-cs-high")) {
|
|
if (*flags & OF_GPIO_ACTIVE_LOW) {
|
|
pr_warn("%s GPIO handle specifies active low - ignored\n",
|
|
of_node_full_name(np));
|
|
*flags &= ~OF_GPIO_ACTIVE_LOW;
|
|
}
|
|
} else {
|
|
if (!(*flags & OF_GPIO_ACTIVE_LOW))
|
|
pr_info("%s enforce active low on chipselect handle\n",
|
|
of_node_full_name(np));
|
|
*flags |= OF_GPIO_ACTIVE_LOW;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
|
|
* @np: device node to get GPIO from
|
|
* @propname: property name containing gpio specifier(s)
|
|
* @index: index of the GPIO
|
|
* @flags: a flags pointer to fill in
|
|
*
|
|
* Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
|
|
* value on the error condition. If @flags is not NULL the function also fills
|
|
* in flags for the GPIO.
|
|
*/
|
|
struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
|
|
const char *propname, int index, enum of_gpio_flags *flags)
|
|
{
|
|
struct of_phandle_args gpiospec;
|
|
struct gpio_chip *chip;
|
|
struct gpio_desc *desc;
|
|
int ret;
|
|
|
|
ret = of_parse_phandle_with_args_map(np, propname, "gpio", index,
|
|
&gpiospec);
|
|
if (ret) {
|
|
pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
|
|
__func__, propname, np, index);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
chip = of_find_gpiochip_by_xlate(&gpiospec);
|
|
if (!chip) {
|
|
desc = ERR_PTR(-EPROBE_DEFER);
|
|
goto out;
|
|
}
|
|
|
|
desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
|
|
if (IS_ERR(desc))
|
|
goto out;
|
|
|
|
if (flags)
|
|
of_gpio_flags_quirks(np, flags, index);
|
|
|
|
pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
|
|
__func__, propname, np, index,
|
|
PTR_ERR_OR_ZERO(desc));
|
|
|
|
out:
|
|
of_node_put(gpiospec.np);
|
|
|
|
return desc;
|
|
}
|
|
|
|
int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
|
|
int index, enum of_gpio_flags *flags)
|
|
{
|
|
struct gpio_desc *desc;
|
|
|
|
desc = of_get_named_gpiod_flags(np, list_name, index, flags);
|
|
|
|
if (IS_ERR(desc))
|
|
return PTR_ERR(desc);
|
|
else
|
|
return desc_to_gpio(desc);
|
|
}
|
|
EXPORT_SYMBOL(of_get_named_gpio_flags);
|
|
|
|
/*
|
|
* The SPI GPIO bindings happened before we managed to establish that GPIO
|
|
* properties should be named "foo-gpios" so we have this special kludge for
|
|
* them.
|
|
*/
|
|
static struct gpio_desc *of_find_spi_gpio(struct device *dev, const char *con_id,
|
|
enum of_gpio_flags *of_flags)
|
|
{
|
|
char prop_name[32]; /* 32 is max size of property name */
|
|
struct device_node *np = dev->of_node;
|
|
struct gpio_desc *desc;
|
|
|
|
/*
|
|
* Hopefully the compiler stubs the rest of the function if this
|
|
* is false.
|
|
*/
|
|
if (!IS_ENABLED(CONFIG_SPI_MASTER))
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
/* Allow this specifically for "spi-gpio" devices */
|
|
if (!of_device_is_compatible(np, "spi-gpio") || !con_id)
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
/* Will be "gpio-sck", "gpio-mosi" or "gpio-miso" */
|
|
snprintf(prop_name, sizeof(prop_name), "%s-%s", "gpio", con_id);
|
|
|
|
desc = of_get_named_gpiod_flags(np, prop_name, 0, of_flags);
|
|
return desc;
|
|
}
|
|
|
|
/*
|
|
* Some regulator bindings happened before we managed to establish that GPIO
|
|
* properties should be named "foo-gpios" so we have this special kludge for
|
|
* them.
|
|
*/
|
|
static struct gpio_desc *of_find_regulator_gpio(struct device *dev, const char *con_id,
|
|
enum of_gpio_flags *of_flags)
|
|
{
|
|
/* These are the connection IDs we accept as legacy GPIO phandles */
|
|
const char *whitelist[] = {
|
|
"wlf,ldoena", /* Arizona */
|
|
"wlf,ldo1ena", /* WM8994 */
|
|
"wlf,ldo2ena", /* WM8994 */
|
|
};
|
|
struct device_node *np = dev->of_node;
|
|
struct gpio_desc *desc;
|
|
int i;
|
|
|
|
if (!IS_ENABLED(CONFIG_REGULATOR))
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
if (!con_id)
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
i = match_string(whitelist, ARRAY_SIZE(whitelist), con_id);
|
|
if (i < 0)
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
desc = of_get_named_gpiod_flags(np, con_id, 0, of_flags);
|
|
return desc;
|
|
}
|
|
|
|
struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
|
|
unsigned int idx,
|
|
enum gpio_lookup_flags *flags)
|
|
{
|
|
char prop_name[32]; /* 32 is max size of property name */
|
|
enum of_gpio_flags of_flags;
|
|
struct gpio_desc *desc;
|
|
unsigned int i;
|
|
|
|
/* Try GPIO property "foo-gpios" and "foo-gpio" */
|
|
for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
|
|
if (con_id)
|
|
snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
|
|
gpio_suffixes[i]);
|
|
else
|
|
snprintf(prop_name, sizeof(prop_name), "%s",
|
|
gpio_suffixes[i]);
|
|
|
|
desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
|
|
&of_flags);
|
|
/*
|
|
* -EPROBE_DEFER in our case means that we found a
|
|
* valid GPIO property, but no controller has been
|
|
* registered so far.
|
|
*
|
|
* This means we don't need to look any further for
|
|
* alternate name conventions, and we should really
|
|
* preserve the return code for our user to be able to
|
|
* retry probing later.
|
|
*/
|
|
if (IS_ERR(desc) && PTR_ERR(desc) == -EPROBE_DEFER)
|
|
return desc;
|
|
|
|
if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
|
|
break;
|
|
}
|
|
|
|
/* Special handling for SPI GPIOs if used */
|
|
if (IS_ERR(desc))
|
|
desc = of_find_spi_gpio(dev, con_id, &of_flags);
|
|
|
|
/* Special handling for regulator GPIOs if used */
|
|
if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)
|
|
desc = of_find_regulator_gpio(dev, con_id, &of_flags);
|
|
|
|
if (IS_ERR(desc))
|
|
return desc;
|
|
|
|
if (of_flags & OF_GPIO_ACTIVE_LOW)
|
|
*flags |= GPIO_ACTIVE_LOW;
|
|
|
|
if (of_flags & OF_GPIO_SINGLE_ENDED) {
|
|
if (of_flags & OF_GPIO_OPEN_DRAIN)
|
|
*flags |= GPIO_OPEN_DRAIN;
|
|
else
|
|
*flags |= GPIO_OPEN_SOURCE;
|
|
}
|
|
|
|
if (of_flags & OF_GPIO_TRANSITORY)
|
|
*flags |= GPIO_TRANSITORY;
|
|
|
|
return desc;
|
|
}
|
|
|
|
/**
|
|
* of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
|
|
* @np: device node to get GPIO from
|
|
* @chip: GPIO chip whose hog is parsed
|
|
* @idx: Index of the GPIO to parse
|
|
* @name: GPIO line name
|
|
* @lflags: gpio_lookup_flags - returned from of_find_gpio() or
|
|
* of_parse_own_gpio()
|
|
* @dflags: gpiod_flags - optional GPIO initialization flags
|
|
*
|
|
* Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
|
|
* value on the error condition.
|
|
*/
|
|
static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
|
|
struct gpio_chip *chip,
|
|
unsigned int idx, const char **name,
|
|
enum gpio_lookup_flags *lflags,
|
|
enum gpiod_flags *dflags)
|
|
{
|
|
struct device_node *chip_np;
|
|
enum of_gpio_flags xlate_flags;
|
|
struct of_phandle_args gpiospec;
|
|
struct gpio_desc *desc;
|
|
unsigned int i;
|
|
u32 tmp;
|
|
int ret;
|
|
|
|
chip_np = chip->of_node;
|
|
if (!chip_np)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
xlate_flags = 0;
|
|
*lflags = 0;
|
|
*dflags = 0;
|
|
|
|
ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
|
|
if (ret)
|
|
return ERR_PTR(ret);
|
|
|
|
gpiospec.np = chip_np;
|
|
gpiospec.args_count = tmp;
|
|
|
|
for (i = 0; i < tmp; i++) {
|
|
ret = of_property_read_u32_index(np, "gpios", idx * tmp + i,
|
|
&gpiospec.args[i]);
|
|
if (ret)
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
|
|
if (IS_ERR(desc))
|
|
return desc;
|
|
|
|
if (xlate_flags & OF_GPIO_ACTIVE_LOW)
|
|
*lflags |= GPIO_ACTIVE_LOW;
|
|
if (xlate_flags & OF_GPIO_TRANSITORY)
|
|
*lflags |= GPIO_TRANSITORY;
|
|
|
|
if (of_property_read_bool(np, "input"))
|
|
*dflags |= GPIOD_IN;
|
|
else if (of_property_read_bool(np, "output-low"))
|
|
*dflags |= GPIOD_OUT_LOW;
|
|
else if (of_property_read_bool(np, "output-high"))
|
|
*dflags |= GPIOD_OUT_HIGH;
|
|
else {
|
|
pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n",
|
|
desc_to_gpio(desc), np);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
if (name && of_property_read_string(np, "line-name", name))
|
|
*name = np->name;
|
|
|
|
return desc;
|
|
}
|
|
|
|
/**
|
|
* of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
|
|
* @chip: gpio chip to act on
|
|
*
|
|
* This is only used by of_gpiochip_add to request/set GPIO initial
|
|
* configuration.
|
|
* It returns error if it fails otherwise 0 on success.
|
|
*/
|
|
static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
|
|
{
|
|
struct gpio_desc *desc = NULL;
|
|
struct device_node *np;
|
|
const char *name;
|
|
enum gpio_lookup_flags lflags;
|
|
enum gpiod_flags dflags;
|
|
unsigned int i;
|
|
int ret;
|
|
|
|
for_each_available_child_of_node(chip->of_node, np) {
|
|
if (!of_property_read_bool(np, "gpio-hog"))
|
|
continue;
|
|
|
|
for (i = 0;; i++) {
|
|
desc = of_parse_own_gpio(np, chip, i, &name, &lflags,
|
|
&dflags);
|
|
if (IS_ERR(desc))
|
|
break;
|
|
|
|
ret = gpiod_hog(desc, name, lflags, dflags);
|
|
if (ret < 0) {
|
|
of_node_put(np);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags
|
|
* @gc: pointer to the gpio_chip structure
|
|
* @gpiospec: GPIO specifier as found in the device tree
|
|
* @flags: a flags pointer to fill in
|
|
*
|
|
* This is simple translation function, suitable for the most 1:1 mapped
|
|
* GPIO chips. This function performs only one sanity check: whether GPIO
|
|
* is less than ngpios (that is specified in the gpio_chip).
|
|
*/
|
|
int of_gpio_simple_xlate(struct gpio_chip *gc,
|
|
const struct of_phandle_args *gpiospec, u32 *flags)
|
|
{
|
|
/*
|
|
* We're discouraging gpio_cells < 2, since that way you'll have to
|
|
* write your own xlate function (that will have to retrieve the GPIO
|
|
* number and the flags from a single gpio cell -- this is possible,
|
|
* but not recommended).
|
|
*/
|
|
if (gc->of_gpio_n_cells < 2) {
|
|
WARN_ON(1);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
|
|
return -EINVAL;
|
|
|
|
if (gpiospec->args[0] >= gc->ngpio)
|
|
return -EINVAL;
|
|
|
|
if (flags)
|
|
*flags = gpiospec->args[1];
|
|
|
|
return gpiospec->args[0];
|
|
}
|
|
EXPORT_SYMBOL(of_gpio_simple_xlate);
|
|
|
|
/**
|
|
* of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
|
|
* @np: device node of the GPIO chip
|
|
* @mm_gc: pointer to the of_mm_gpio_chip allocated structure
|
|
* @data: driver data to store in the struct gpio_chip
|
|
*
|
|
* To use this function you should allocate and fill mm_gc with:
|
|
*
|
|
* 1) In the gpio_chip structure:
|
|
* - all the callbacks
|
|
* - of_gpio_n_cells
|
|
* - of_xlate callback (optional)
|
|
*
|
|
* 3) In the of_mm_gpio_chip structure:
|
|
* - save_regs callback (optional)
|
|
*
|
|
* If succeeded, this function will map bank's memory and will
|
|
* do all necessary work for you. Then you'll able to use .regs
|
|
* to manage GPIOs from the callbacks.
|
|
*/
|
|
int of_mm_gpiochip_add_data(struct device_node *np,
|
|
struct of_mm_gpio_chip *mm_gc,
|
|
void *data)
|
|
{
|
|
int ret = -ENOMEM;
|
|
struct gpio_chip *gc = &mm_gc->gc;
|
|
|
|
gc->label = kasprintf(GFP_KERNEL, "%pOF", np);
|
|
if (!gc->label)
|
|
goto err0;
|
|
|
|
mm_gc->regs = of_iomap(np, 0);
|
|
if (!mm_gc->regs)
|
|
goto err1;
|
|
|
|
gc->base = -1;
|
|
|
|
if (mm_gc->save_regs)
|
|
mm_gc->save_regs(mm_gc);
|
|
|
|
mm_gc->gc.of_node = np;
|
|
|
|
ret = gpiochip_add_data(gc, data);
|
|
if (ret)
|
|
goto err2;
|
|
|
|
return 0;
|
|
err2:
|
|
iounmap(mm_gc->regs);
|
|
err1:
|
|
kfree(gc->label);
|
|
err0:
|
|
pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(of_mm_gpiochip_add_data);
|
|
|
|
/**
|
|
* of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
|
|
* @mm_gc: pointer to the of_mm_gpio_chip allocated structure
|
|
*/
|
|
void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
|
|
{
|
|
struct gpio_chip *gc = &mm_gc->gc;
|
|
|
|
if (!mm_gc)
|
|
return;
|
|
|
|
gpiochip_remove(gc);
|
|
iounmap(mm_gc->regs);
|
|
kfree(gc->label);
|
|
}
|
|
EXPORT_SYMBOL(of_mm_gpiochip_remove);
|
|
|
|
static void of_gpiochip_init_valid_mask(struct gpio_chip *chip)
|
|
{
|
|
int len, i;
|
|
u32 start, count;
|
|
struct device_node *np = chip->of_node;
|
|
|
|
len = of_property_count_u32_elems(np, "gpio-reserved-ranges");
|
|
if (len < 0 || len % 2 != 0)
|
|
return;
|
|
|
|
for (i = 0; i < len; i += 2) {
|
|
of_property_read_u32_index(np, "gpio-reserved-ranges",
|
|
i, &start);
|
|
of_property_read_u32_index(np, "gpio-reserved-ranges",
|
|
i + 1, &count);
|
|
if (start >= chip->ngpio || start + count >= chip->ngpio)
|
|
continue;
|
|
|
|
bitmap_clear(chip->valid_mask, start, count);
|
|
}
|
|
};
|
|
|
|
#ifdef CONFIG_PINCTRL
|
|
static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
|
|
{
|
|
struct device_node *np = chip->of_node;
|
|
struct of_phandle_args pinspec;
|
|
struct pinctrl_dev *pctldev;
|
|
int index = 0, ret;
|
|
const char *name;
|
|
static const char group_names_propname[] = "gpio-ranges-group-names";
|
|
struct property *group_names;
|
|
|
|
if (!np)
|
|
return 0;
|
|
|
|
group_names = of_find_property(np, group_names_propname, NULL);
|
|
|
|
for (;; index++) {
|
|
ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
|
|
index, &pinspec);
|
|
if (ret)
|
|
break;
|
|
|
|
pctldev = of_pinctrl_get(pinspec.np);
|
|
of_node_put(pinspec.np);
|
|
if (!pctldev)
|
|
return -EPROBE_DEFER;
|
|
|
|
if (pinspec.args[2]) {
|
|
if (group_names) {
|
|
of_property_read_string_index(np,
|
|
group_names_propname,
|
|
index, &name);
|
|
if (strlen(name)) {
|
|
pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
|
|
np);
|
|
break;
|
|
}
|
|
}
|
|
/* npins != 0: linear range */
|
|
ret = gpiochip_add_pin_range(chip,
|
|
pinctrl_dev_get_devname(pctldev),
|
|
pinspec.args[0],
|
|
pinspec.args[1],
|
|
pinspec.args[2]);
|
|
if (ret)
|
|
return ret;
|
|
} else {
|
|
/* npins == 0: special range */
|
|
if (pinspec.args[1]) {
|
|
pr_err("%pOF: Illegal gpio-range format.\n",
|
|
np);
|
|
break;
|
|
}
|
|
|
|
if (!group_names) {
|
|
pr_err("%pOF: GPIO group range requested but no %s property.\n",
|
|
np, group_names_propname);
|
|
break;
|
|
}
|
|
|
|
ret = of_property_read_string_index(np,
|
|
group_names_propname,
|
|
index, &name);
|
|
if (ret)
|
|
break;
|
|
|
|
if (!strlen(name)) {
|
|
pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
|
|
np);
|
|
break;
|
|
}
|
|
|
|
ret = gpiochip_add_pingroup_range(chip, pctldev,
|
|
pinspec.args[0], name);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#else
|
|
static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
|
|
#endif
|
|
|
|
int of_gpiochip_add(struct gpio_chip *chip)
|
|
{
|
|
int status;
|
|
|
|
if (!chip->of_node)
|
|
return 0;
|
|
|
|
if (!chip->of_xlate) {
|
|
chip->of_gpio_n_cells = 2;
|
|
chip->of_xlate = of_gpio_simple_xlate;
|
|
}
|
|
|
|
if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
|
|
return -EINVAL;
|
|
|
|
of_gpiochip_init_valid_mask(chip);
|
|
|
|
status = of_gpiochip_add_pin_range(chip);
|
|
if (status)
|
|
return status;
|
|
|
|
/* If the chip defines names itself, these take precedence */
|
|
if (!chip->names)
|
|
devprop_gpiochip_set_names(chip,
|
|
of_fwnode_handle(chip->of_node));
|
|
|
|
of_node_get(chip->of_node);
|
|
|
|
return of_gpiochip_scan_gpios(chip);
|
|
}
|
|
|
|
void of_gpiochip_remove(struct gpio_chip *chip)
|
|
{
|
|
gpiochip_remove_pin_ranges(chip);
|
|
of_node_put(chip->of_node);
|
|
}
|