forked from Minki/linux
6a497e9d58
Subsystem improvements: - Do away with the last users of the obsolete Kconfig options ARCH_REQUIRE_GPIOLIB and ARCH_WANT_OPTIONAL_GPIOLIB (the latter always sounded like an item on a wishlist to Santa Claus to me). We can now select GPIOLIB and be done with it, for all archs. After some struggle it even work on UM. Not that it has GPIO, but if it wants to, it can select the library. - Continued efforts to make drivers properly either tristate or bool. - Introduce a warning for drivers assigning default triggers to their irqchip lines when probed from device tree, so we find and fix these ambigous drivers. It is agreed that in the OF config path, the device tree defines trigger characteristics. - The same warning, mutatis mutandis, for ACPI-probed GPIO irqchips. - We introduce the ability to mark certain IRQ lines as "unusable" as they can be taken by BIOS/firmware, unrouted in silicon and generally nasty if you use them, and such things. This is put to good use in the STMPE driver and also in the Cherryview pin control driver. - A new "mockup" virtual GPIO device that can be used for testing. The plan is to add unit tests under tools/* for exercising this device and verify that the kernel code paths are working as they should. - Make memory-mapped I/O-drivers depend on HAS_IOMEM. This was implicit all the time, but when people started building UM with allyesconfig or allmodconfig it exploded in their face. - Move some stray bits of device tree and ACPI HW description callbacks down into their respective implementation silo. These were causing issues when compiling on !HAS_IOMEM as well, so now eventually UM compiles the GPIOLIB library if it wants to. New drivers: - New driver for the Aspeed GPIO front-end companion to the pin controller merged through the pin control tree. - New driver for the LP873x PMIC GPIO portions. - New driver for Technologic Systems' I2C FPGA GPIO such as TS4900, TS-7970, TS-7990 and TS-4100. - New driver for the Broadcom BCM63xx series including BCM6338 and BCM6345. - New driver for the Intel WhiskeyCove PMIC GPIO. - New driver for the Allwinner AXP209 PMIC GPIO portions. - New driver for Diamond Systems 48 line GPIO-MM, another of these port-mapped I/O expansion cards. - Support the STMicroelectronics STMPE1600 variant in the STMPE driver. Driver improvements: - The STMPE driver now supports rising/falling edge detection properly for IRQs. - The PCA954x will now fetch and enable its VCC regulator properly. - Major rework of the PCA953x driver with the goal of eventually switching it over to use regmap and thus modernize it even more. - Switch the IOP driver to use the generic MMIO GPIO library. - Move the ages old HTC EGPIO (extended GPIO) GPIO expander driver over to this subsystem from MFD, achieveing some separation of concerns. -----BEGIN PGP SIGNATURE----- iQIcBAABAgAGBQJX9OvDAAoJEEEQszewGV1zsPQP/3VLy1fNIpMF0DDyq5tA/GNv sinnaPgMtt+qBrM2sbJcTVwV9xtHrs12CC3+2lAhBCIEm4YfHbXvaUMNE+aKJzk4 ZM7/rb8WMUxjQqzDKStdETsQGo6fxh0qU81OEQNbX9alir20jik9DvTufcs6xCgx sqh8KsNGO4Y6tiuKZ6mTZvIjVhMwiTm0NBSDKhdim0DdsOcuxyh6xVOj/0LB2Ei6 g75X1w++wjh0ryY3bzaeWkQSlXDC6eEKeez7VaEkSUyrxH86buomy0+aP0fqs7vY LRZzn/TC97YLT6hslS/OhB7uXrDIY2POSwO/SvusJcveGP7WPGyGr5mDtA4ATRWI ios0DBWl629kHfhAMzg3kPJS8LfjCerapvtbdAgqvhH+Vb5IPFx45vypDkR2WtJ7 bNAySIRMQSHZvJSCvYzjqh8AbWdE4i4k70tFXRMOpWeKIvRVI1cDvLD6cLn3hATM IPTytM6i2xqnzcq7mK7EJ18afcR0mv1jHgGAv4M0RMkyJ2IrURvFyZIvUB2MTyuL PEBh1ZvTs+MO50eeFwzltY91eagkzgWB0f6sm3l7I7bL2oxE2f/WVcVL9jWbgwpF otjFO27u0/6rIulfLUQzDo3gbOq7UaN0VTW4E9CYbOtFtNzCxjFIKTv0IJhTu4TT OSur7oFpzAMOGYlpYP8j =ABbi -----END PGP SIGNATURE----- Merge tag 'gpio-v4.9-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.9 series: Subsystem improvements: - do away with the last users of the obsolete Kconfig options ARCH_REQUIRE_GPIOLIB and ARCH_WANT_OPTIONAL_GPIOLIB (the latter always sounded like an item on a wishlist to Santa Claus to me). We can now select GPIOLIB and be done with it, for all archs. After some struggle it even work on UM. Not that it has GPIO, but if it wants to, it can select the library. - continued efforts to make drivers properly either tristate or bool. - introduce a warning for drivers assigning default triggers to their irqchip lines when probed from device tree, so we find and fix these ambigous drivers. It is agreed that in the OF config path, the device tree defines trigger characteristics. - the same warning, mutatis mutandis, for ACPI-probed GPIO irqchips. - we introduce the ability to mark certain IRQ lines as "unusable" as they can be taken by BIOS/firmware, unrouted in silicon and generally nasty if you use them, and such things. This is put to good use in the STMPE driver and also in the Cherryview pin control driver. - a new "mockup" virtual GPIO device that can be used for testing. The plan is to add unit tests under tools/* for exercising this device and verify that the kernel code paths are working as they should. - make memory-mapped I/O-drivers depend on HAS_IOMEM. This was implicit all the time, but when people started building UM with allyesconfig or allmodconfig it exploded in their face. - move some stray bits of device tree and ACPI HW description callbacks down into their respective implementation silo. These were causing issues when compiling on !HAS_IOMEM as well, so now eventually UM compiles the GPIOLIB library if it wants to. New drivers: - new driver for the Aspeed GPIO front-end companion to the pin controller merged through the pin control tree. - new driver for the LP873x PMIC GPIO portions. - new driver for Technologic Systems' I2C FPGA GPIO such as TS4900, TS-7970, TS-7990 and TS-4100. - new driver for the Broadcom BCM63xx series including BCM6338 and BCM6345. - new driver for the Intel WhiskeyCove PMIC GPIO. - new driver for the Allwinner AXP209 PMIC GPIO portions. - new driver for Diamond Systems 48 line GPIO-MM, another of these port-mapped I/O expansion cards. - support the STMicroelectronics STMPE1600 variant in the STMPE driver. Driver improvements: - the STMPE driver now supports rising/falling edge detection properly for IRQs. - the PCA954x will now fetch and enable its VCC regulator properly. - major rework of the PCA953x driver with the goal of eventually switching it over to use regmap and thus modernize it even more. - switch the IOP driver to use the generic MMIO GPIO library. - move the ages old HTC EGPIO (extended GPIO) GPIO expander driver over to this subsystem from MFD, achieveing some separation of concerns" * tag 'gpio-v4.9-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio: (81 commits) gpio: add missing static inline gpio: OF: localize some gpiochip init functions gpio: acpi: separation of concerns gpio: OF: separation of concerns gpio: make memory-mapped drivers depend on HAS_IOMEM gpio: stmpe: use BIT() macro gpio: stmpe: forbid unused lines to be mapped as IRQs mfd/gpio: Move HTC GPIO driver to GPIO subsystem gpio: MAINTAINERS: Add an entry for GPIO mockup driver gpio/mockup: add virtual gpio device gpio: Added zynq specific check for special pins on bank zero gpio: axp209: Implement get_direction gpio: aspeed: remove redundant return value check gpio: loongson1: remove redundant return value check ARM: omap2: fix missing include gpio: tc3589x: fix up complaints on unsigned gpio: tc3589x: add .get_direction() and small cleanup gpio: f7188x: use gpiochip_get_data instead of container_of gpio: tps65218: use devm_gpiochip_add_data() for gpio registration gpio: aspeed: fix return value check in aspeed_gpio_probe() ...
537 lines
13 KiB
C
537 lines
13 KiB
C
/*
|
|
* OF helpers for the GPIO API
|
|
*
|
|
* Copyright (c) 2007-2008 MontaVista Software, Inc.
|
|
*
|
|
* Author: Anton Vorontsov <avorontsov@ru.mvista.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*/
|
|
|
|
#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(struct gpio_chip *chip, void *data)
|
|
{
|
|
return chip->gpiodev->dev.of_node == data;
|
|
}
|
|
|
|
static struct gpio_chip *of_find_gpiochip_by_node(struct device_node *np)
|
|
{
|
|
return gpiochip_find(np, of_gpiochip_match_node);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* 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(np, propname, "#gpio-cells", index,
|
|
&gpiospec);
|
|
if (ret) {
|
|
pr_debug("%s: can't parse '%s' property of node '%s[%d]'\n",
|
|
__func__, propname, np->full_name, index);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
chip = of_find_gpiochip_by_node(gpiospec.np);
|
|
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;
|
|
|
|
pr_debug("%s: parsed '%s' property of node '%s[%d]' - status (%d)\n",
|
|
__func__, propname, np->full_name, 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);
|
|
|
|
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;
|
|
|
|
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);
|
|
if (!IS_ERR(desc) || (PTR_ERR(desc) != -ENOENT))
|
|
break;
|
|
}
|
|
|
|
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_ACTIVE_LOW)
|
|
*flags |= GPIO_OPEN_DRAIN;
|
|
else
|
|
*flags |= GPIO_OPEN_SOURCE;
|
|
}
|
|
|
|
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
|
|
* @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,
|
|
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;
|
|
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;
|
|
|
|
ret = of_property_read_u32_array(np, "gpios", gpiospec.args, tmp);
|
|
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 (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 (%s): no hogging state specified, bailing out\n",
|
|
desc_to_gpio(desc), np->name);
|
|
return ERR_PTR(-EINVAL);
|
|
}
|
|
|
|
if (name && of_property_read_string(np, "line-name", name))
|
|
*name = np->name;
|
|
|
|
return desc;
|
|
}
|
|
|
|
/**
|
|
* of_gpiochip_set_names() - set up the names of the lines
|
|
* @chip: GPIO chip whose lines should be named, if possible
|
|
*/
|
|
static void of_gpiochip_set_names(struct gpio_chip *gc)
|
|
{
|
|
struct gpio_device *gdev = gc->gpiodev;
|
|
struct device_node *np = gc->of_node;
|
|
int i;
|
|
int nstrings;
|
|
|
|
nstrings = of_property_count_strings(np, "gpio-line-names");
|
|
if (nstrings <= 0)
|
|
/* Lines names not present */
|
|
return;
|
|
|
|
/* This is normally not what you want */
|
|
if (gdev->ngpio != nstrings)
|
|
dev_info(&gdev->dev, "gpio-line-names specifies %d line "
|
|
"names but there are %d lines on the chip\n",
|
|
nstrings, gdev->ngpio);
|
|
|
|
/*
|
|
* Make sure to not index beyond the end of the number of descriptors
|
|
* of the GPIO device.
|
|
*/
|
|
for (i = 0; i < gdev->ngpio; i++) {
|
|
const char *name;
|
|
int ret;
|
|
|
|
ret = of_property_read_string_index(np,
|
|
"gpio-line-names",
|
|
i,
|
|
&name);
|
|
if (ret) {
|
|
if (ret != -ENODATA)
|
|
dev_err(&gdev->dev,
|
|
"unable to name line %d: %d\n",
|
|
i, ret);
|
|
break;
|
|
}
|
|
gdev->descs[i].name = name;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 retures 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;
|
|
int ret;
|
|
|
|
for_each_available_child_of_node(chip->of_node, np) {
|
|
if (!of_property_read_bool(np, "gpio-hog"))
|
|
continue;
|
|
|
|
desc = of_parse_own_gpio(np, chip, &name, &lflags, &dflags);
|
|
if (IS_ERR(desc))
|
|
continue;
|
|
|
|
ret = gpiod_hog(desc, name, lflags, dflags);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
|
|
* @gc: pointer to the gpio_chip structure
|
|
* @np: device node of the GPIO chip
|
|
* @gpio_spec: 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 = kstrdup(np->full_name, GFP_KERNEL);
|
|
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("%s: GPIO chip registration failed with status %d\n",
|
|
np->full_name, 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);
|
|
|
|
#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("%s: Group name of numeric GPIO ranges must be the empty string.\n",
|
|
np->full_name);
|
|
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("%s: Illegal gpio-range format.\n",
|
|
np->full_name);
|
|
break;
|
|
}
|
|
|
|
if (!group_names) {
|
|
pr_err("%s: GPIO group range requested but no %s property.\n",
|
|
np->full_name, group_names_propname);
|
|
break;
|
|
}
|
|
|
|
ret = of_property_read_string_index(np,
|
|
group_names_propname,
|
|
index, &name);
|
|
if (ret)
|
|
break;
|
|
|
|
if (!strlen(name)) {
|
|
pr_err("%s: Group name of GPIO group range cannot be the empty string.\n",
|
|
np->full_name);
|
|
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) && (chip->parent))
|
|
chip->of_node = chip->parent->of_node;
|
|
|
|
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;
|
|
|
|
status = of_gpiochip_add_pin_range(chip);
|
|
if (status)
|
|
return status;
|
|
|
|
/* If the chip defines names itself, these take precedence */
|
|
if (!chip->names)
|
|
of_gpiochip_set_names(chip);
|
|
|
|
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);
|
|
}
|