dm: gpio: Add better functions to request GPIOs
At present U-Boot sort-of supports the standard way of reading GPIOs from device tree nodes, but the support is incomplete, a bit clunky and only works for GPIO bindings where #gpio-cells is 2. Add new functions to request GPIOs, taking full account of the device tree binding. These permit requesting a GPIO with a simple call like: gpio_request_by_name(dev, "cd-gpios", 0, &desc, GPIOD_IS_IN); This will request the GPIO, looking at the device's node which might be this, for example: cd-gpios = <&gpio TEGRA_GPIO(B, 3) GPIO_ACTIVE_LOW>; The GPIO will be set to input mode in this case and polarity will be honoured by the GPIO calls. It is also possible to request and free a list of GPIOs. Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass
parent
0dac4d51f5
commit
3669e0e759
|
|
@ -12,6 +12,8 @@
|
|||
#include <asm/gpio.h>
|
||||
#include <linux/ctype.h>
|
||||
|
||||
DECLARE_GLOBAL_DATA_PTR;
|
||||
|
||||
/**
|
||||
* gpio_to_device() - Convert global GPIO number to device, number
|
||||
*
|
||||
|
|
@ -92,8 +94,8 @@ int gpio_lookup_name(const char *name, struct udevice **devp,
|
|||
return 0;
|
||||
}
|
||||
|
||||
int gpio_find_and_xlate(struct gpio_desc *desc,
|
||||
struct fdtdec_phandle_args *args)
|
||||
static int gpio_find_and_xlate(struct gpio_desc *desc,
|
||||
struct fdtdec_phandle_args *args)
|
||||
{
|
||||
struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
|
||||
|
||||
|
|
@ -132,6 +134,17 @@ static int dm_gpio_request(struct gpio_desc *desc, const char *label)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int dm_gpio_requestf(struct gpio_desc *desc, const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
char buf[40];
|
||||
|
||||
va_start(args, fmt);
|
||||
vscnprintf(buf, sizeof(buf), fmt, args);
|
||||
va_end(args);
|
||||
return dm_gpio_request(desc, buf);
|
||||
}
|
||||
|
||||
/**
|
||||
* gpio_request() - [COMPAT] Request GPIO
|
||||
* gpio: GPIO number
|
||||
|
|
@ -501,6 +514,155 @@ unsigned gpio_get_values_as_int(const int *gpio_num_array)
|
|||
return vector;
|
||||
}
|
||||
|
||||
static int _gpio_request_by_name_nodev(const void *blob, int node,
|
||||
const char *list_name, int index,
|
||||
struct gpio_desc *desc, int flags,
|
||||
bool add_index)
|
||||
{
|
||||
struct fdtdec_phandle_args args;
|
||||
int ret;
|
||||
|
||||
desc->dev = NULL;
|
||||
desc->offset = 0;
|
||||
ret = fdtdec_parse_phandle_with_args(blob, node, list_name,
|
||||
"#gpio-cells", 0, index, &args);
|
||||
if (ret) {
|
||||
debug("%s: fdtdec_parse_phandle_with_args failed\n", __func__);
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = uclass_get_device_by_of_offset(UCLASS_GPIO, args.node,
|
||||
&desc->dev);
|
||||
if (ret) {
|
||||
debug("%s: uclass_get_device_by_of_offset failed\n", __func__);
|
||||
goto err;
|
||||
}
|
||||
ret = gpio_find_and_xlate(desc, &args);
|
||||
if (ret) {
|
||||
debug("%s: gpio_find_and_xlate failed\n", __func__);
|
||||
goto err;
|
||||
}
|
||||
ret = dm_gpio_requestf(desc, add_index ? "%s.%s%d" : "%s.%s",
|
||||
fdt_get_name(blob, node, NULL),
|
||||
list_name, index);
|
||||
if (ret) {
|
||||
debug("%s: dm_gpio_requestf failed\n", __func__);
|
||||
goto err;
|
||||
}
|
||||
ret = dm_gpio_set_dir_flags(desc, flags | desc->flags);
|
||||
if (ret) {
|
||||
debug("%s: dm_gpio_set_dir failed\n", __func__);
|
||||
goto err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
err:
|
||||
debug("%s: Node '%s', property '%s', failed to request GPIO index %d: %d\n",
|
||||
__func__, fdt_get_name(blob, node, NULL), list_name, index, ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int gpio_request_by_name_nodev(const void *blob, int node,
|
||||
const char *list_name, int index,
|
||||
struct gpio_desc *desc, int flags)
|
||||
{
|
||||
return _gpio_request_by_name_nodev(blob, node, list_name, index, desc,
|
||||
flags, index > 0);
|
||||
}
|
||||
|
||||
int gpio_request_by_name(struct udevice *dev, const char *list_name, int index,
|
||||
struct gpio_desc *desc, int flags)
|
||||
{
|
||||
/*
|
||||
* This isn't ideal since we don't use dev->name in the debug()
|
||||
* calls in gpio_request_by_name(), but we can do this until
|
||||
* gpio_request_by_name_nodev() can be dropped.
|
||||
*/
|
||||
return gpio_request_by_name_nodev(gd->fdt_blob, dev->of_offset,
|
||||
list_name, index, desc, flags);
|
||||
}
|
||||
|
||||
int gpio_request_list_by_name_nodev(const void *blob, int node,
|
||||
const char *list_name,
|
||||
struct gpio_desc *desc, int max_count,
|
||||
int flags)
|
||||
{
|
||||
int count;
|
||||
int ret;
|
||||
|
||||
for (count = 0; ; count++) {
|
||||
if (count >= max_count) {
|
||||
ret = -ENOSPC;
|
||||
goto err;
|
||||
}
|
||||
ret = _gpio_request_by_name_nodev(blob, node, list_name, count,
|
||||
&desc[count], flags, true);
|
||||
if (ret == -ENOENT)
|
||||
break;
|
||||
else if (ret)
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* We ran out of GPIOs in the list */
|
||||
return count;
|
||||
|
||||
err:
|
||||
gpio_free_list_nodev(desc, count - 1);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int gpio_request_list_by_name(struct udevice *dev, const char *list_name,
|
||||
struct gpio_desc *desc, int max_count,
|
||||
int flags)
|
||||
{
|
||||
/*
|
||||
* This isn't ideal since we don't use dev->name in the debug()
|
||||
* calls in gpio_request_by_name(), but we can do this until
|
||||
* gpio_request_list_by_name_nodev() can be dropped.
|
||||
*/
|
||||
return gpio_request_list_by_name_nodev(gd->fdt_blob, dev->of_offset,
|
||||
list_name, desc, max_count,
|
||||
flags);
|
||||
}
|
||||
|
||||
int gpio_get_list_count(struct udevice *dev, const char *list_name)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev->of_offset,
|
||||
list_name, "#gpio-cells", 0, -1,
|
||||
NULL);
|
||||
if (ret) {
|
||||
debug("%s: Node '%s', property '%s', GPIO count failed: %d\n",
|
||||
__func__, dev->name, list_name, ret);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc)
|
||||
{
|
||||
/* For now, we don't do any checking of dev */
|
||||
return _dm_gpio_free(desc->dev, desc->offset);
|
||||
}
|
||||
|
||||
int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* For now, we don't do any checking of dev */
|
||||
for (i = 0; i < count; i++)
|
||||
dm_gpio_free(dev, &desc[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int gpio_free_list_nodev(struct gpio_desc *desc, int count)
|
||||
{
|
||||
return gpio_free_list(NULL, desc, count);
|
||||
}
|
||||
|
||||
/* We need to renumber the GPIOs when any driver is probed/removed */
|
||||
static int gpio_renumber(struct udevice *removed_dev)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include <fdtdec.h>
|
||||
#include <malloc.h>
|
||||
#include <asm/gpio.h>
|
||||
#include <dt-bindings/gpio/gpio.h>
|
||||
|
||||
DECLARE_GLOBAL_DATA_PTR;
|
||||
|
||||
|
|
@ -130,12 +131,31 @@ static int sb_gpio_get_function(struct udevice *dev, unsigned offset)
|
|||
return GPIOF_INPUT;
|
||||
}
|
||||
|
||||
static int sb_gpio_xlate(struct udevice *dev, struct gpio_desc *desc,
|
||||
struct fdtdec_phandle_args *args)
|
||||
{
|
||||
desc->offset = args->args[0];
|
||||
if (args->args_count < 2)
|
||||
return 0;
|
||||
if (args->args[1] & GPIO_ACTIVE_LOW)
|
||||
desc->flags |= GPIOD_ACTIVE_LOW;
|
||||
if (args->args[1] & 2)
|
||||
desc->flags |= GPIOD_IS_IN;
|
||||
if (args->args[1] & 4)
|
||||
desc->flags |= GPIOD_IS_OUT;
|
||||
if (args->args[1] & 8)
|
||||
desc->flags |= GPIOD_IS_OUT_ACTIVE;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct dm_gpio_ops gpio_sandbox_ops = {
|
||||
.direction_input = sb_gpio_direction_input,
|
||||
.direction_output = sb_gpio_direction_output,
|
||||
.get_value = sb_gpio_get_value,
|
||||
.set_value = sb_gpio_set_value,
|
||||
.get_function = sb_gpio_get_function,
|
||||
.xlate = sb_gpio_xlate,
|
||||
};
|
||||
|
||||
static int sandbox_gpio_ofdata_to_platdata(struct udevice *dev)
|
||||
|
|
|
|||
|
|
@ -111,6 +111,18 @@ struct gpio_desc {
|
|||
*/
|
||||
};
|
||||
|
||||
/**
|
||||
* dm_gpio_is_valid() - Check if a GPIO is gpio_is_valie
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return true if valid, false if not
|
||||
*/
|
||||
static inline bool dm_gpio_is_valid(struct gpio_desc *desc)
|
||||
{
|
||||
return desc->dev != NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* gpio_get_status() - get the current GPIO status as a string
|
||||
*
|
||||
|
|
@ -313,4 +325,191 @@ int gpio_lookup_name(const char *name, struct udevice **devp,
|
|||
*/
|
||||
unsigned gpio_get_values_as_int(const int *gpio_list);
|
||||
|
||||
/**
|
||||
* gpio_request_by_name() - Locate and request a GPIO by name
|
||||
*
|
||||
* This operates by looking up the given list name in the device (device
|
||||
* tree property) and requesting the GPIO for use. The property must exist
|
||||
* in @dev's node.
|
||||
*
|
||||
* Use @flags to specify whether the GPIO should be an input or output. In
|
||||
* principle this can also come from the device tree binding but most
|
||||
* bindings don't provide this information. Specifically, when the GPIO uclass
|
||||
* calls the xlate() method, it can return default flags, which are then
|
||||
* ORed with this @flags.
|
||||
*
|
||||
* If we find that requesting the GPIO is not always needed we could add a
|
||||
* new function or a new GPIOD_NO_REQUEST flag.
|
||||
*
|
||||
* At present driver model has no reference counting so if one device
|
||||
* requests a GPIO which subsequently is unbound, the @desc->dev pointer
|
||||
* will be invalid. However this will only happen if the GPIO device is
|
||||
* unbound, not if it is removed, so this seems like a reasonable limitation
|
||||
* for now. There is no real use case for unbinding drivers in normal
|
||||
* operation.
|
||||
*
|
||||
* The device tree binding is doc/device-tree-bindings/gpio/gpio.txt in
|
||||
* generate terms and each specific device may add additional details in
|
||||
* a binding file in the same directory.
|
||||
*
|
||||
* @dev: Device requesting the GPIO
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @index: Index number of the GPIO in that list use request (0=first)
|
||||
* @desc: Returns GPIO description information. If there is no such
|
||||
* GPIO, dev->dev will be NULL.
|
||||
* @flags: Indicates the GPIO input/output settings (GPIOD_...)
|
||||
* @return 0 if OK, -ENOENT if the GPIO does not exist, -EINVAL if there is
|
||||
* something wrong with the list, or other -ve for another error (e.g.
|
||||
* -EBUSY if a GPIO was already requested)
|
||||
*/
|
||||
int gpio_request_by_name(struct udevice *dev, const char *list_name,
|
||||
int index, struct gpio_desc *desc, int flags);
|
||||
|
||||
/**
|
||||
* gpio_request_list_by_name() - Request a list of GPIOs
|
||||
*
|
||||
* Reads all the GPIOs from a list and requetss them. See
|
||||
* gpio_request_by_name() for additional details. Lists should not be
|
||||
* misused to hold unrelated or optional GPIOs. They should only be used
|
||||
* for things like parallel data lines. A zero phandle terminates the list
|
||||
* the list.
|
||||
*
|
||||
* This function will either succeed, and request all GPIOs in the list, or
|
||||
* fail and request none (it will free already-requested GPIOs in case of
|
||||
* an error part-way through).
|
||||
*
|
||||
* @dev: Device requesting the GPIO
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @desc_list: Returns a list of GPIO description information
|
||||
* @max_count: Maximum number of GPIOs to return (@desc_list must be at least
|
||||
* this big)
|
||||
* @flags: Indicates the GPIO input/output settings (GPIOD_...)
|
||||
* @return number of GPIOs requested, or -ve on error
|
||||
*/
|
||||
int gpio_request_list_by_name(struct udevice *dev, const char *list_name,
|
||||
struct gpio_desc *desc_list, int max_count,
|
||||
int flags);
|
||||
|
||||
/**
|
||||
* gpio_get_list_count() - Returns the number of GPIOs in a list
|
||||
*
|
||||
* Counts the GPIOs in a list. See gpio_request_by_name() for additional
|
||||
* details.
|
||||
*
|
||||
* @dev: Device requesting the GPIO
|
||||
* @list_name: Name of GPIO list (e.g. "board-id-gpios")
|
||||
* @return number of GPIOs (0 for an empty property) or -ENOENT if the list
|
||||
* does not exist
|
||||
*/
|
||||
int gpio_get_list_count(struct udevice *dev, const char *list_name);
|
||||
|
||||
/**
|
||||
* gpio_request_by_name_nodev() - request GPIOs without a device
|
||||
*
|
||||
* This is a version of gpio_request_list_by_name() that does not use a
|
||||
* device. Avoid it unless the caller is not yet using driver model
|
||||
*/
|
||||
int gpio_request_by_name_nodev(const void *blob, int node,
|
||||
const char *list_name,
|
||||
int index, struct gpio_desc *desc, int flags);
|
||||
|
||||
/**
|
||||
* gpio_request_list_by_name_nodev() - request GPIOs without a device
|
||||
*
|
||||
* This is a version of gpio_request_list_by_name() that does not use a
|
||||
* device. Avoid it unless the caller is not yet using driver model
|
||||
*/
|
||||
int gpio_request_list_by_name_nodev(const void *blob, int node,
|
||||
const char *list_name,
|
||||
struct gpio_desc *desc_list, int max_count,
|
||||
int flags);
|
||||
|
||||
/**
|
||||
* dm_gpio_free() - Free a single GPIO
|
||||
*
|
||||
* This frees a single GPIOs previously returned from gpio_request_by_name().
|
||||
*
|
||||
* @dev: Device which requested the GPIO
|
||||
* @desc: GPIO to free
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* gpio_free_list() - Free a list of GPIOs
|
||||
*
|
||||
* This frees a list of GPIOs previously returned from
|
||||
* gpio_request_list_by_name().
|
||||
*
|
||||
* @dev: Device which requested the GPIOs
|
||||
* @desc: List of GPIOs to free
|
||||
* @count: Number of GPIOs in the list
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count);
|
||||
|
||||
/**
|
||||
* gpio_free_list_nodev() - free GPIOs without a device
|
||||
*
|
||||
* This is a version of gpio_free_list() that does not use a
|
||||
* device. Avoid it unless the caller is not yet using driver model
|
||||
*/
|
||||
int gpio_free_list_nodev(struct gpio_desc *desc, int count);
|
||||
|
||||
/**
|
||||
* dm_gpio_get_value() - Get the value of a GPIO
|
||||
*
|
||||
* This is the driver model version of the existing gpio_get_value() function
|
||||
* and should be used instead of that.
|
||||
*
|
||||
* For now, these functions have a dm_ prefix since they conflict with
|
||||
* existing names.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return GPIO value (0 for inactive, 1 for active) or -ve on error
|
||||
*/
|
||||
int dm_gpio_get_value(struct gpio_desc *desc);
|
||||
|
||||
int dm_gpio_set_value(struct gpio_desc *desc, int value);
|
||||
|
||||
/**
|
||||
* dm_gpio_set_dir() - Set the direction for a GPIO
|
||||
*
|
||||
* This sets up the direction according tot the provided flags. It will do
|
||||
* nothing unless the direction is actually specified.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return 0 if OK, -ve on error
|
||||
*/
|
||||
int dm_gpio_set_dir(struct gpio_desc *desc);
|
||||
|
||||
/**
|
||||
* dm_gpio_set_dir_flags() - Set direction using specific flags
|
||||
*
|
||||
* This is like dm_gpio_set_dir() except that the flags value is provided
|
||||
* instead of being used from desc->flags. This is needed because in many
|
||||
* cases the GPIO description does not include direction information.
|
||||
* Note that desc->flags is updated by this function.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @flags: New flags to use
|
||||
* @return 0 if OK, -ve on error, in which case desc->flags is not updated
|
||||
*/
|
||||
int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags);
|
||||
|
||||
/**
|
||||
* gpio_get_number() - Get the global GPIO number of a GPIO
|
||||
*
|
||||
* This should only be used for debugging or interest. It returns the nummber
|
||||
* that should be used for gpio_get_value() etc. to access this GPIO.
|
||||
*
|
||||
* @desc: GPIO description containing device, offset and flags,
|
||||
* previously returned by gpio_request_by_name()
|
||||
* @return GPIO number, or -ve if not found
|
||||
*/
|
||||
int gpio_get_number(struct gpio_desc *desc);
|
||||
|
||||
#endif /* _ASM_GENERIC_GPIO_H_ */
|
||||
|
|
|
|||
|
|
@ -174,5 +174,72 @@ static int dm_test_gpio_leak(struct dm_test_state *dms)
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
DM_TEST(dm_test_gpio_leak, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
|
||||
|
||||
/* Test that we can find GPIOs using phandles */
|
||||
static int dm_test_gpio_phandles(struct dm_test_state *dms)
|
||||
{
|
||||
struct gpio_desc desc, desc_list[8], desc_list2[8];
|
||||
struct udevice *dev, *gpio_a, *gpio_b;
|
||||
|
||||
ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
|
||||
ut_asserteq_str("a-test", dev->name);
|
||||
|
||||
ut_assertok(gpio_request_by_name(dev, "test-gpios", 1, &desc, 0));
|
||||
ut_assertok(uclass_get_device(UCLASS_GPIO, 1, &gpio_a));
|
||||
ut_assertok(uclass_get_device(UCLASS_GPIO, 2, &gpio_b));
|
||||
ut_asserteq_str("base-gpios", gpio_a->name);
|
||||
ut_asserteq(true, !!device_active(gpio_a));
|
||||
ut_asserteq_ptr(gpio_a, desc.dev);
|
||||
ut_asserteq(4, desc.offset);
|
||||
/* GPIOF_INPUT is the sandbox GPIO driver default */
|
||||
ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_a, 4, NULL));
|
||||
ut_assertok(dm_gpio_free(dev, &desc));
|
||||
|
||||
ut_asserteq(-ENOENT, gpio_request_by_name(dev, "test-gpios", 3, &desc,
|
||||
0));
|
||||
ut_asserteq_ptr(NULL, desc.dev);
|
||||
ut_asserteq(desc.offset, 0);
|
||||
ut_asserteq(-ENOENT, gpio_request_by_name(dev, "test-gpios", 5, &desc,
|
||||
0));
|
||||
|
||||
/* Last GPIO is ignord as it comes after <0> */
|
||||
ut_asserteq(3, gpio_request_list_by_name(dev, "test-gpios", desc_list,
|
||||
ARRAY_SIZE(desc_list), 0));
|
||||
ut_asserteq(-EBUSY, gpio_request_list_by_name(dev, "test-gpios",
|
||||
desc_list2,
|
||||
ARRAY_SIZE(desc_list2),
|
||||
0));
|
||||
ut_assertok(gpio_free_list(dev, desc_list, 3));
|
||||
ut_asserteq(3, gpio_request_list_by_name(dev, "test-gpios", desc_list,
|
||||
ARRAY_SIZE(desc_list),
|
||||
GPIOD_IS_OUT |
|
||||
GPIOD_IS_OUT_ACTIVE));
|
||||
ut_asserteq_ptr(gpio_a, desc_list[0].dev);
|
||||
ut_asserteq(1, desc_list[0].offset);
|
||||
ut_asserteq_ptr(gpio_a, desc_list[1].dev);
|
||||
ut_asserteq(4, desc_list[1].offset);
|
||||
ut_asserteq_ptr(gpio_b, desc_list[2].dev);
|
||||
ut_asserteq(5, desc_list[2].offset);
|
||||
ut_asserteq(1, dm_gpio_get_value(desc_list));
|
||||
ut_assertok(gpio_free_list(dev, desc_list, 3));
|
||||
|
||||
ut_asserteq(6, gpio_request_list_by_name(dev, "test2-gpios", desc_list,
|
||||
ARRAY_SIZE(desc_list), 0));
|
||||
/* This was set to output previously, so still will be */
|
||||
ut_asserteq(GPIOF_OUTPUT, gpio_get_function(gpio_a, 1, NULL));
|
||||
|
||||
/* Active low should invert the input value */
|
||||
ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_b, 6, NULL));
|
||||
ut_asserteq(1, dm_gpio_get_value(&desc_list[2]));
|
||||
|
||||
ut_asserteq(GPIOF_INPUT, gpio_get_function(gpio_b, 7, NULL));
|
||||
ut_asserteq(GPIOF_OUTPUT, gpio_get_function(gpio_b, 8, NULL));
|
||||
ut_asserteq(0, dm_gpio_get_value(&desc_list[4]));
|
||||
ut_asserteq(GPIOF_OUTPUT, gpio_get_function(gpio_b, 9, NULL));
|
||||
ut_asserteq(1, dm_gpio_get_value(&desc_list[5]));
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
DM_TEST(dm_test_gpio_phandles, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
|
||||
|
|
|
|||
|
|
@ -22,6 +22,11 @@
|
|||
ping-expect = <0>;
|
||||
ping-add = <0>;
|
||||
u-boot,dm-pre-reloc;
|
||||
test-gpios = <&gpio_a 1>, <&gpio_a 4>, <&gpio_b 5 0 3 2 1>,
|
||||
<0>, <&gpio_a 12>;
|
||||
test2-gpios = <&gpio_a 1>, <&gpio_a 4>, <&gpio_b 6 1 3 2 1>,
|
||||
<&gpio_b 7 2 3 2 1>, <&gpio_b 8 4 3 2 1>,
|
||||
<&gpio_b 9 0xc 3 2 1>;
|
||||
};
|
||||
|
||||
junk {
|
||||
|
|
@ -83,12 +88,16 @@
|
|||
|
||||
gpio_a: base-gpios {
|
||||
compatible = "sandbox,gpio";
|
||||
gpio-controller;
|
||||
#gpio-cells = <1>;
|
||||
gpio-bank-name = "a";
|
||||
num-gpios = <20>;
|
||||
};
|
||||
|
||||
extra-gpios {
|
||||
gpio_b: extra-gpios {
|
||||
compatible = "sandbox,gpio";
|
||||
gpio-controller;
|
||||
#gpio-cells = <5>;
|
||||
gpio-bank-name = "b";
|
||||
num-gpios = <10>;
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in New Issue