[people/ms/u-boot.git] / drivers / gpio / gpio-uclass.c

/*
 * Copyright (c) 2013 Google, Inc
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <fdtdec.h>
#include <malloc.h>
#include <asm/gpio.h>
#include <linux/ctype.h>

DECLARE_GLOBAL_DATA_PTR;

/**
 * gpio_to_device() - Convert global GPIO number to device, number
 *
 * Convert the GPIO number to an entry in the list of GPIOs
 * or GPIO blocks registered with the GPIO controller. Returns
 * entry on success, NULL on error.
 *
 * @gpio:	The numeric representation of the GPIO
 * @desc:	Returns description (desc->flags will always be 0)
 * @return 0 if found, -ENOENT if not found
 */
static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc)
{
	struct gpio_dev_priv *uc_priv;
	struct udevice *dev;
	int ret;

	for (ret = uclass_first_device(UCLASS_GPIO, &dev);
	     dev;
	     ret = uclass_next_device(&dev)) {
		uc_priv = dev_get_uclass_priv(dev);
		if (gpio >= uc_priv->gpio_base &&
		    gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
			desc->dev = dev;
			desc->offset = gpio - uc_priv->gpio_base;
			desc->flags = 0;
			return 0;
		}
	}

	/* No such GPIO */
	return ret ? ret : -ENOENT;
}

int gpio_lookup_name(const char *name, struct udevice **devp,
		     unsigned int *offsetp, unsigned int *gpiop)
{
	struct gpio_dev_priv *uc_priv = NULL;
	struct udevice *dev;
	ulong offset;
	int numeric;
	int ret;

	if (devp)
		*devp = NULL;
	numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1;
	for (ret = uclass_first_device(UCLASS_GPIO, &dev);
	     dev;
	     ret = uclass_next_device(&dev)) {
		int len;

		uc_priv = dev_get_uclass_priv(dev);
		if (numeric != -1) {
			offset = numeric - uc_priv->gpio_base;
			/* Allow GPIOs to be numbered from 0 */
			if (offset >= 0 && offset < uc_priv->gpio_count)
				break;
		}

		len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0;

		if (!strncasecmp(name, uc_priv->bank_name, len)) {
			if (!strict_strtoul(name + len, 10, &offset))
				break;
		}
	}

	if (!dev)
		return ret ? ret : -EINVAL;

	if (devp)
		*devp = dev;
	if (offsetp)
		*offsetp = offset;
	if (gpiop)
		*gpiop = uc_priv->gpio_base + offset;

	return 0;
}

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);

	/* Use the first argument as the offset by default */
	if (args->args_count > 0)
		desc->offset = args->args[0];
	else
		desc->offset = -1;
	desc->flags = 0;

	return ops->xlate ? ops->xlate(desc->dev, desc, args) : 0;
}

static int dm_gpio_request(struct gpio_desc *desc, const char *label)
{
	struct udevice *dev = desc->dev;
	struct gpio_dev_priv *uc_priv;
	char *str;
	int ret;

	uc_priv = dev_get_uclass_priv(dev);
	if (uc_priv->name[desc->offset])
		return -EBUSY;
	str = strdup(label);
	if (!str)
		return -ENOMEM;
	if (gpio_get_ops(dev)->request) {
		ret = gpio_get_ops(dev)->request(dev, desc->offset, label);
		if (ret) {
			free(str);
			return ret;
		}
	}
	uc_priv->name[desc->offset] = str;

	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
 * label:	Name for the requested GPIO
 *
 * The label is copied and allocated so the caller does not need to keep
 * the pointer around.
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns 0 on success, negative value on error.
 */
int gpio_request(unsigned gpio, const char *label)
{
	struct gpio_desc desc;
	int ret;

	ret = gpio_to_device(gpio, &desc);
	if (ret)
		return ret;

	return dm_gpio_request(&desc, label);
}

/**
 * gpio_requestf() - [COMPAT] Request GPIO
 * @gpio:	GPIO number
 * @fmt:	Format string for the requested GPIO
 * @...:	Arguments for the printf() format string
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns 0 on success, negative value on error.
 */
int gpio_requestf(unsigned gpio, const char *fmt, ...)
{
	va_list args;
	char buf[40];

	va_start(args, fmt);
	vscnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);
	return gpio_request(gpio, buf);
}

int _dm_gpio_free(struct udevice *dev, uint offset)
{
	struct gpio_dev_priv *uc_priv;
	int ret;

	uc_priv = dev_get_uclass_priv(dev);
	if (!uc_priv->name[offset])
		return -ENXIO;
	if (gpio_get_ops(dev)->free) {
		ret = gpio_get_ops(dev)->free(dev, offset);
		if (ret)
			return ret;
	}

	free(uc_priv->name[offset]);
	uc_priv->name[offset] = NULL;

	return 0;
}

/**
 * gpio_free() - [COMPAT] Relinquish GPIO
 * gpio:	GPIO number
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns 0 on success, negative value on error.
 */
int gpio_free(unsigned gpio)
{
	struct gpio_desc desc;
	int ret;

	ret = gpio_to_device(gpio, &desc);
	if (ret)
		return ret;

	return _dm_gpio_free(desc.dev, desc.offset);
}

static int check_reserved(struct gpio_desc *desc, const char *func)
{
	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(desc->dev);

	if (!uc_priv->name[desc->offset]) {
		printf("%s: %s: error: gpio %s%d not reserved\n",
		       desc->dev->name, func,
		       uc_priv->bank_name ? uc_priv->bank_name : "",
		       desc->offset);
		return -EBUSY;
	}

	return 0;
}

/**
 * gpio_direction_input() - [COMPAT] Set GPIO direction to input
 * gpio:	GPIO number
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns 0 on success, negative value on error.
 */
int gpio_direction_input(unsigned gpio)
{
	struct gpio_desc desc;
	int ret;

	ret = gpio_to_device(gpio, &desc);
	if (ret)
		return ret;
	ret = check_reserved(&desc, "dir_input");
	if (ret)
		return ret;

	return gpio_get_ops(desc.dev)->direction_input(desc.dev, desc.offset);
}

/**
 * gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value
 * gpio:	GPIO number
 * value:	Logical value to be set on the GPIO pin
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns 0 on success, negative value on error.
 */
int gpio_direction_output(unsigned gpio, int value)
{
	struct gpio_desc desc;
	int ret;

	ret = gpio_to_device(gpio, &desc);
	if (ret)
		return ret;
	ret = check_reserved(&desc, "dir_output");
	if (ret)
		return ret;

	return gpio_get_ops(desc.dev)->direction_output(desc.dev,
							desc.offset, value);
}

int dm_gpio_get_value(struct gpio_desc *desc)
{
	int value;
	int ret;

	ret = check_reserved(desc, "get_value");
	if (ret)
		return ret;

	value = gpio_get_ops(desc->dev)->get_value(desc->dev, desc->offset);

	return desc->flags & GPIOD_ACTIVE_LOW ? !value : value;
}

int dm_gpio_set_value(struct gpio_desc *desc, int value)
{
	int ret;

	ret = check_reserved(desc, "set_value");
	if (ret)
		return ret;

	if (desc->flags & GPIOD_ACTIVE_LOW)
		value = !value;
	gpio_get_ops(desc->dev)->set_value(desc->dev, desc->offset, value);
	return 0;
}

int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags)
{
	struct udevice *dev = desc->dev;
	struct dm_gpio_ops *ops = gpio_get_ops(dev);
	int ret;

	ret = check_reserved(desc, "set_dir");
	if (ret)
		return ret;

	if (flags & GPIOD_IS_OUT) {
		int value = flags & GPIOD_IS_OUT_ACTIVE ? 1 : 0;

		if (flags & GPIOD_ACTIVE_LOW)
			value = !value;
		ret = ops->direction_output(dev, desc->offset, value);
	} else  if (flags & GPIOD_IS_IN) {
		ret = ops->direction_input(dev, desc->offset);
	}
	if (ret)
		return ret;
	/*
	 * Update desc->flags here, so that GPIO_ACTIVE_LOW is honoured in
	 * futures
	 */
	desc->flags = flags;

	return 0;
}

int dm_gpio_set_dir(struct gpio_desc *desc)
{
	return dm_gpio_set_dir_flags(desc, desc->flags);
}

/**
 * gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value
 * gpio:	GPIO number
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns the value of the GPIO pin, or negative value
 * on error.
 */
int gpio_get_value(unsigned gpio)
{
	int ret;

	struct gpio_desc desc;

	ret = gpio_to_device(gpio, &desc);
	if (ret)
		return ret;
	return dm_gpio_get_value(&desc);
}

/**
 * gpio_set_value() - [COMPAT] Configure logical value on GPIO pin
 * gpio:	GPIO number
 * value:	Logical value to be set on the GPIO pin.
 *
 * This function implements the API that's compatible with current
 * GPIO API used in U-Boot. The request is forwarded to particular
 * GPIO driver. Returns 0 on success, negative value on error.
 */
int gpio_set_value(unsigned gpio, int value)
{
	struct gpio_desc desc;
	int ret;

	ret = gpio_to_device(gpio, &desc);
	if (ret)
		return ret;
	return dm_gpio_set_value(&desc, value);
}

const char *gpio_get_bank_info(struct udevice *dev, int *bit_count)
{
	struct gpio_dev_priv *priv;

	/* Must be called on an active device */
	priv = dev_get_uclass_priv(dev);
	assert(priv);

	*bit_count = priv->gpio_count;
	return priv->bank_name;
}

static const char * const gpio_function[GPIOF_COUNT] = {
	"input",
	"output",
	"unused",
	"unknown",
	"func",
};

int get_function(struct udevice *dev, int offset, bool skip_unused,
		 const char **namep)
{
	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
	struct dm_gpio_ops *ops = gpio_get_ops(dev);

	BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
	if (!device_active(dev))
		return -ENODEV;
	if (offset < 0 || offset >= uc_priv->gpio_count)
		return -EINVAL;
	if (namep)
		*namep = uc_priv->name[offset];
	if (skip_unused && !uc_priv->name[offset])
		return GPIOF_UNUSED;
	if (ops->get_function) {
		int ret;

		ret = ops->get_function(dev, offset);
		if (ret < 0)
			return ret;
		if (ret >= ARRAY_SIZE(gpio_function))
			return -ENODATA;
		return ret;
	}

	return GPIOF_UNKNOWN;
}

int gpio_get_function(struct udevice *dev, int offset, const char **namep)
{
	return get_function(dev, offset, true, namep);
}

int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep)
{
	return get_function(dev, offset, false, namep);
}

int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
{
	struct dm_gpio_ops *ops = gpio_get_ops(dev);
	struct gpio_dev_priv *priv;
	char *str = buf;
	int func;
	int ret;
	int len;

	BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));

	*buf = 0;
	priv = dev_get_uclass_priv(dev);
	ret = gpio_get_raw_function(dev, offset, NULL);
	if (ret < 0)
		return ret;
	func = ret;
	len = snprintf(str, buffsize, "%s%d: %s",
		       priv->bank_name ? priv->bank_name : "",
		       offset, gpio_function[func]);
	if (func == GPIOF_INPUT || func == GPIOF_OUTPUT ||
	    func == GPIOF_UNUSED) {
		const char *label;
		bool used;

		ret = ops->get_value(dev, offset);
		if (ret < 0)
			return ret;
		used = gpio_get_function(dev, offset, &label) != GPIOF_UNUSED;
		snprintf(str + len, buffsize - len, ": %d [%c]%s%s",
			 ret,
			 used ? 'x' : ' ',
			 used ? " " : "",
			 label ? label : "");
	}

	return 0;
}

/*
 * get a number comprised of multiple GPIO values. gpio_num_array points to
 * the array of gpio pin numbers to scan, terminated by -1.
 */
unsigned gpio_get_values_as_int(const int *gpio_num_array)
{
	int gpio;
	unsigned bitmask = 1;
	unsigned vector = 0;

	while (bitmask &&
	       ((gpio = *gpio_num_array++) != -1)) {
		if (gpio_get_value(gpio))
			vector |= bitmask;
		bitmask <<= 1;
	}
	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 < max_count; count++) {
		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)
{
	struct gpio_dev_priv *uc_priv;
	struct udevice *dev;
	struct uclass *uc;
	unsigned base;
	int ret;

	ret = uclass_get(UCLASS_GPIO, &uc);
	if (ret)
		return ret;

	/* Ensure that we have a base for each bank */
	base = 0;
	uclass_foreach_dev(dev, uc) {
		if (device_active(dev) && dev != removed_dev) {
			uc_priv = dev_get_uclass_priv(dev);
			uc_priv->gpio_base = base;
			base += uc_priv->gpio_count;
		}
	}

	return 0;
}

int gpio_get_number(struct gpio_desc *desc)
{
	struct udevice *dev = desc->dev;
	struct gpio_dev_priv *uc_priv;

	if (!dev)
		return -1;
	uc_priv = dev->uclass_priv;

	return uc_priv->gpio_base + desc->offset;
}

static int gpio_post_probe(struct udevice *dev)
{
	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);

	uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *));
	if (!uc_priv->name)
		return -ENOMEM;

	return gpio_renumber(NULL);
}

static int gpio_pre_remove(struct udevice *dev)
{
	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
	int i;

	for (i = 0; i < uc_priv->gpio_count; i++) {
		if (uc_priv->name[i])
			free(uc_priv->name[i]);
	}
	free(uc_priv->name);

	return gpio_renumber(dev);
}

UCLASS_DRIVER(gpio) = {
	.id		= UCLASS_GPIO,
	.name		= "gpio",
	.post_probe	= gpio_post_probe,
	.pre_remove	= gpio_pre_remove,
	.per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
};
Commit	Line	Data
96495d90 SG	1	/*
	2	* Copyright (c) 2013 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
	7	#include <common.h>
	8	#include <dm.h>
	9	#include <errno.h>
0dac4d51	10	#include <fdtdec.h>
b892d127	11	#include <malloc.h>
96495d90	12	#include <asm/gpio.h>
fe1ef503	13	#include <linux/ctype.h>
96495d90	14
3669e0e7 SG	15	DECLARE_GLOBAL_DATA_PTR;
3669e0e7 SG	16
96495d90 SG	17	/**
96495d90 SG	18	* gpio_to_device() - Convert global GPIO number to device, number
96495d90 SG	19	*
	20	* Convert the GPIO number to an entry in the list of GPIOs
	21	* or GPIO blocks registered with the GPIO controller. Returns
	22	* entry on success, NULL on error.
ae7123f8 SG	23	*
	24	* @gpio: The numeric representation of the GPIO
	25	* @desc: Returns description (desc->flags will always be 0)
	26	* @return 0 if found, -ENOENT if not found
96495d90	27	*/
ae7123f8	28	static int gpio_to_device(unsigned int gpio, struct gpio_desc *desc)
96495d90 SG	29	{
96495d90 SG	30	struct gpio_dev_priv *uc_priv;
54c5d08a	31	struct udevice *dev;
96495d90 SG	32	int ret;
	33
	34	for (ret = uclass_first_device(UCLASS_GPIO, &dev);
	35	dev;
	36	ret = uclass_next_device(&dev)) {
e564f054	37	uc_priv = dev_get_uclass_priv(dev);
96495d90 SG	38	if (gpio >= uc_priv->gpio_base &&
96495d90 SG	39	gpio < uc_priv->gpio_base + uc_priv->gpio_count) {
ae7123f8 SG	40	desc->dev = dev;
	41	desc->offset = gpio - uc_priv->gpio_base;
	42	desc->flags = 0;
96495d90 SG	43	return 0;
	44	}
	45	}
	46
	47	/* No such GPIO */
ae7123f8	48	return ret ? ret : -ENOENT;
96495d90 SG	49	}
96495d90 SG	50
54c5d08a	51	int gpio_lookup_name(const char name, struct udevice *devp,
96495d90 SG	52	unsigned int offsetp, unsigned int gpiop)
96495d90 SG	53	{
fe1ef503	54	struct gpio_dev_priv *uc_priv = NULL;
54c5d08a	55	struct udevice *dev;
fe1ef503 SG	56	ulong offset;
fe1ef503 SG	57	int numeric;
96495d90 SG	58	int ret;
	59
	60	if (devp)
	61	*devp = NULL;
fe1ef503	62	numeric = isdigit(*name) ? simple_strtoul(name, NULL, 10) : -1;
96495d90 SG	63	for (ret = uclass_first_device(UCLASS_GPIO, &dev);
	64	dev;
	65	ret = uclass_next_device(&dev)) {
96495d90 SG	66	int len;
96495d90 SG	67
e564f054	68	uc_priv = dev_get_uclass_priv(dev);
fe1ef503 SG	69	if (numeric != -1) {
	70	offset = numeric - uc_priv->gpio_base;
	71	/* Allow GPIOs to be numbered from 0 */
	72	if (offset >= 0 && offset < uc_priv->gpio_count)
	73	break;
	74	}
	75
96495d90 SG	76	len = uc_priv->bank_name ? strlen(uc_priv->bank_name) : 0;
96495d90 SG	77
939cda5b	78	if (!strncasecmp(name, uc_priv->bank_name, len)) {
fe1ef503 SG	79	if (!strict_strtoul(name + len, 10, &offset))
fe1ef503 SG	80	break;
96495d90 SG	81	}
	82	}
	83
fe1ef503 SG	84	if (!dev)
	85	return ret ? ret : -EINVAL;
	86
	87	if (devp)
	88	*devp = dev;
	89	if (offsetp)
	90	*offsetp = offset;
	91	if (gpiop)
	92	*gpiop = uc_priv->gpio_base + offset;
	93
	94	return 0;
96495d90 SG	95	}
96495d90 SG	96
3669e0e7 SG	97	static int gpio_find_and_xlate(struct gpio_desc *desc,
3669e0e7 SG	98	struct fdtdec_phandle_args *args)
0dac4d51 SG	99	{
	100	struct dm_gpio_ops *ops = gpio_get_ops(desc->dev);
	101
	102	/* Use the first argument as the offset by default */
	103	if (args->args_count > 0)
	104	desc->offset = args->args[0];
	105	else
	106	desc->offset = -1;
	107	desc->flags = 0;
	108
	109	return ops->xlate ? ops->xlate(desc->dev, desc, args) : 0;
	110	}
	111
ae7123f8 SG	112	static int dm_gpio_request(struct gpio_desc desc, const char label)
	113	{
	114	struct udevice *dev = desc->dev;
	115	struct gpio_dev_priv *uc_priv;
	116	char *str;
	117	int ret;
	118
e564f054	119	uc_priv = dev_get_uclass_priv(dev);
ae7123f8 SG	120	if (uc_priv->name[desc->offset])
	121	return -EBUSY;
	122	str = strdup(label);
	123	if (!str)
	124	return -ENOMEM;
	125	if (gpio_get_ops(dev)->request) {
	126	ret = gpio_get_ops(dev)->request(dev, desc->offset, label);
	127	if (ret) {
	128	free(str);
	129	return ret;
	130	}
	131	}
	132	uc_priv->name[desc->offset] = str;
	133
	134	return 0;
	135	}
	136
3669e0e7 SG	137	static int dm_gpio_requestf(struct gpio_desc desc, const char fmt, ...)
	138	{
	139	va_list args;
	140	char buf[40];
	141
	142	va_start(args, fmt);
	143	vscnprintf(buf, sizeof(buf), fmt, args);
	144	va_end(args);
	145	return dm_gpio_request(desc, buf);
	146	}
	147
96495d90 SG	148	/**
	149	* gpio_request() - [COMPAT] Request GPIO
	150	* gpio: GPIO number
	151	* label: Name for the requested GPIO
	152	*
b892d127 SG	153	* The label is copied and allocated so the caller does not need to keep
	154	* the pointer around.
	155	*
96495d90 SG	156	* This function implements the API that's compatible with current
	157	* GPIO API used in U-Boot. The request is forwarded to particular
	158	* GPIO driver. Returns 0 on success, negative value on error.
	159	*/
	160	int gpio_request(unsigned gpio, const char *label)
	161	{
ae7123f8	162	struct gpio_desc desc;
96495d90 SG	163	int ret;
96495d90 SG	164
ae7123f8	165	ret = gpio_to_device(gpio, &desc);
96495d90 SG	166	if (ret)
	167	return ret;
	168
ae7123f8	169	return dm_gpio_request(&desc, label);
96495d90 SG	170	}
96495d90 SG	171
d44f597b SG	172	/**
	173	* gpio_requestf() - [COMPAT] Request GPIO
	174	* @gpio: GPIO number
	175	* @fmt: Format string for the requested GPIO
	176	* @...: Arguments for the printf() format string
	177	*
	178	* This function implements the API that's compatible with current
	179	* GPIO API used in U-Boot. The request is forwarded to particular
	180	* GPIO driver. Returns 0 on success, negative value on error.
	181	*/
	182	int gpio_requestf(unsigned gpio, const char *fmt, ...)
	183	{
	184	va_list args;
	185	char buf[40];
	186
	187	va_start(args, fmt);
	188	vscnprintf(buf, sizeof(buf), fmt, args);
	189	va_end(args);
	190	return gpio_request(gpio, buf);
	191	}
	192
ae7123f8	193	int _dm_gpio_free(struct udevice *dev, uint offset)
96495d90	194	{
b892d127	195	struct gpio_dev_priv *uc_priv;
96495d90 SG	196	int ret;
96495d90 SG	197
e564f054	198	uc_priv = dev_get_uclass_priv(dev);
b892d127 SG	199	if (!uc_priv->name[offset])
	200	return -ENXIO;
	201	if (gpio_get_ops(dev)->free) {
	202	ret = gpio_get_ops(dev)->free(dev, offset);
	203	if (ret)
	204	return ret;
	205	}
	206
	207	free(uc_priv->name[offset]);
	208	uc_priv->name[offset] = NULL;
	209
	210	return 0;
	211	}
	212
ae7123f8 SG	213	/**
	214	* gpio_free() - [COMPAT] Relinquish GPIO
	215	* gpio: GPIO number
	216	*
	217	* This function implements the API that's compatible with current
	218	* GPIO API used in U-Boot. The request is forwarded to particular
	219	* GPIO driver. Returns 0 on success, negative value on error.
	220	*/
	221	int gpio_free(unsigned gpio)
b892d127	222	{
ae7123f8 SG	223	struct gpio_desc desc;
	224	int ret;
	225
	226	ret = gpio_to_device(gpio, &desc);
	227	if (ret)
	228	return ret;
	229
	230	return _dm_gpio_free(desc.dev, desc.offset);
	231	}
b892d127	232
ae7123f8 SG	233	static int check_reserved(struct gpio_desc desc, const char func)
ae7123f8 SG	234	{
e564f054	235	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(desc->dev);
ae7123f8 SG	236
ae7123f8 SG	237	if (!uc_priv->name[desc->offset]) {
b892d127	238	printf("%s: %s: error: gpio %s%d not reserved\n",
ae7123f8 SG	239	desc->dev->name, func,
	240	uc_priv->bank_name ? uc_priv->bank_name : "",
	241	desc->offset);
b892d127 SG	242	return -EBUSY;
	243	}
	244
	245	return 0;
96495d90 SG	246	}
	247
	248	/**
	249	* gpio_direction_input() - [COMPAT] Set GPIO direction to input
	250	* gpio: GPIO number
	251	*
	252	* This function implements the API that's compatible with current
	253	* GPIO API used in U-Boot. The request is forwarded to particular
	254	* GPIO driver. Returns 0 on success, negative value on error.
	255	*/
	256	int gpio_direction_input(unsigned gpio)
	257	{
ae7123f8	258	struct gpio_desc desc;
96495d90 SG	259	int ret;
96495d90 SG	260
ae7123f8 SG	261	ret = gpio_to_device(gpio, &desc);
	262	if (ret)
	263	return ret;
	264	ret = check_reserved(&desc, "dir_input");
96495d90 SG	265	if (ret)
	266	return ret;
	267
ae7123f8	268	return gpio_get_ops(desc.dev)->direction_input(desc.dev, desc.offset);
96495d90 SG	269	}
	270
	271	/**
	272	* gpio_direction_output() - [COMPAT] Set GPIO direction to output and set value
	273	* gpio: GPIO number
	274	* value: Logical value to be set on the GPIO pin
	275	*
	276	* This function implements the API that's compatible with current
	277	* GPIO API used in U-Boot. The request is forwarded to particular
	278	* GPIO driver. Returns 0 on success, negative value on error.
	279	*/
	280	int gpio_direction_output(unsigned gpio, int value)
	281	{
ae7123f8	282	struct gpio_desc desc;
96495d90 SG	283	int ret;
96495d90 SG	284
ae7123f8 SG	285	ret = gpio_to_device(gpio, &desc);
	286	if (ret)
	287	return ret;
	288	ret = check_reserved(&desc, "dir_output");
	289	if (ret)
	290	return ret;
	291
	292	return gpio_get_ops(desc.dev)->direction_output(desc.dev,
	293	desc.offset, value);
	294	}
	295
	296	int dm_gpio_get_value(struct gpio_desc *desc)
	297	{
	298	int value;
	299	int ret;
	300
	301	ret = check_reserved(desc, "get_value");
96495d90 SG	302	if (ret)
	303	return ret;
	304
ae7123f8 SG	305	value = gpio_get_ops(desc->dev)->get_value(desc->dev, desc->offset);
	306
	307	return desc->flags & GPIOD_ACTIVE_LOW ? !value : value;
	308	}
	309
	310	int dm_gpio_set_value(struct gpio_desc *desc, int value)
	311	{
	312	int ret;
	313
	314	ret = check_reserved(desc, "set_value");
	315	if (ret)
	316	return ret;
	317
	318	if (desc->flags & GPIOD_ACTIVE_LOW)
	319	value = !value;
	320	gpio_get_ops(desc->dev)->set_value(desc->dev, desc->offset, value);
	321	return 0;
	322	}
	323
	324	int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags)
	325	{
	326	struct udevice *dev = desc->dev;
	327	struct dm_gpio_ops *ops = gpio_get_ops(dev);
	328	int ret;
	329
	330	ret = check_reserved(desc, "set_dir");
	331	if (ret)
	332	return ret;
	333
	334	if (flags & GPIOD_IS_OUT) {
	335	int value = flags & GPIOD_IS_OUT_ACTIVE ? 1 : 0;
	336
	337	if (flags & GPIOD_ACTIVE_LOW)
	338	value = !value;
	339	ret = ops->direction_output(dev, desc->offset, value);
	340	} else if (flags & GPIOD_IS_IN) {
	341	ret = ops->direction_input(dev, desc->offset);
	342	}
	343	if (ret)
	344	return ret;
	345	/*
	346	* Update desc->flags here, so that GPIO_ACTIVE_LOW is honoured in
	347	* futures
	348	*/
	349	desc->flags = flags;
	350
	351	return 0;
	352	}
	353
	354	int dm_gpio_set_dir(struct gpio_desc *desc)
	355	{
	356	return dm_gpio_set_dir_flags(desc, desc->flags);
96495d90 SG	357	}
	358
	359	/**
	360	* gpio_get_value() - [COMPAT] Sample GPIO pin and return it's value
	361	* gpio: GPIO number
	362	*
	363	* This function implements the API that's compatible with current
	364	* GPIO API used in U-Boot. The request is forwarded to particular
	365	* GPIO driver. Returns the value of the GPIO pin, or negative value
	366	* on error.
	367	*/
	368	int gpio_get_value(unsigned gpio)
	369	{
96495d90 SG	370	int ret;
96495d90 SG	371
ae7123f8 SG	372	struct gpio_desc desc;
	373
	374	ret = gpio_to_device(gpio, &desc);
96495d90 SG	375	if (ret)
96495d90 SG	376	return ret;
ae7123f8	377	return dm_gpio_get_value(&desc);
96495d90 SG	378	}
	379
	380	/**
	381	* gpio_set_value() - [COMPAT] Configure logical value on GPIO pin
	382	* gpio: GPIO number
	383	* value: Logical value to be set on the GPIO pin.
	384	*
	385	* This function implements the API that's compatible with current
	386	* GPIO API used in U-Boot. The request is forwarded to particular
	387	* GPIO driver. Returns 0 on success, negative value on error.
	388	*/
	389	int gpio_set_value(unsigned gpio, int value)
	390	{
ae7123f8	391	struct gpio_desc desc;
96495d90 SG	392	int ret;
96495d90 SG	393
ae7123f8	394	ret = gpio_to_device(gpio, &desc);
96495d90 SG	395	if (ret)
96495d90 SG	396	return ret;
ae7123f8	397	return dm_gpio_set_value(&desc, value);
96495d90 SG	398	}
96495d90 SG	399
54c5d08a	400	const char gpio_get_bank_info(struct udevice dev, int *bit_count)
96495d90 SG	401	{
	402	struct gpio_dev_priv *priv;
	403
	404	/* Must be called on an active device */
e564f054	405	priv = dev_get_uclass_priv(dev);
96495d90 SG	406	assert(priv);
	407
	408	*bit_count = priv->gpio_count;
	409	return priv->bank_name;
	410	}
	411
6449a506 SG	412	static const char * const gpio_function[GPIOF_COUNT] = {
	413	"input",
	414	"output",
	415	"unused",
	416	"unknown",
	417	"func",
	418	};
	419
	420	int get_function(struct udevice *dev, int offset, bool skip_unused,
	421	const char **namep)
	422	{
e564f054	423	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
6449a506 SG	424	struct dm_gpio_ops *ops = gpio_get_ops(dev);
	425
	426	BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
	427	if (!device_active(dev))
	428	return -ENODEV;
	429	if (offset < 0 \|\| offset >= uc_priv->gpio_count)
	430	return -EINVAL;
	431	if (namep)
	432	*namep = uc_priv->name[offset];
	433	if (skip_unused && !uc_priv->name[offset])
	434	return GPIOF_UNUSED;
	435	if (ops->get_function) {
	436	int ret;
	437
	438	ret = ops->get_function(dev, offset);
	439	if (ret < 0)
	440	return ret;
	441	if (ret >= ARRAY_SIZE(gpio_function))
	442	return -ENODATA;
	443	return ret;
	444	}
	445
	446	return GPIOF_UNKNOWN;
	447	}
	448
	449	int gpio_get_function(struct udevice dev, int offset, const char *namep)
	450	{
	451	return get_function(dev, offset, true, namep);
	452	}
	453
	454	int gpio_get_raw_function(struct udevice dev, int offset, const char *namep)
	455	{
	456	return get_function(dev, offset, false, namep);
	457	}
	458
0757535a SG	459	int gpio_get_status(struct udevice dev, int offset, char buf, int buffsize)
	460	{
	461	struct dm_gpio_ops *ops = gpio_get_ops(dev);
	462	struct gpio_dev_priv *priv;
	463	char *str = buf;
	464	int func;
	465	int ret;
	466	int len;
	467
	468	BUILD_BUG_ON(GPIOF_COUNT != ARRAY_SIZE(gpio_function));
	469
	470	*buf = 0;
e564f054	471	priv = dev_get_uclass_priv(dev);
0757535a SG	472	ret = gpio_get_raw_function(dev, offset, NULL);
	473	if (ret < 0)
	474	return ret;
	475	func = ret;
	476	len = snprintf(str, buffsize, "%s%d: %s",
	477	priv->bank_name ? priv->bank_name : "",
	478	offset, gpio_function[func]);
	479	if (func == GPIOF_INPUT \|\| func == GPIOF_OUTPUT \|\|
	480	func == GPIOF_UNUSED) {
	481	const char *label;
	482	bool used;
	483
	484	ret = ops->get_value(dev, offset);
	485	if (ret < 0)
	486	return ret;
	487	used = gpio_get_function(dev, offset, &label) != GPIOF_UNUSED;
	488	snprintf(str + len, buffsize - len, ": %d [%c]%s%s",
	489	ret,
	490	used ? 'x' : ' ',
	491	used ? " " : "",
	492	label ? label : "");
	493	}
	494
	495	return 0;
	496	}
	497
e5901c94 SG	498	/*
	499	* get a number comprised of multiple GPIO values. gpio_num_array points to
	500	* the array of gpio pin numbers to scan, terminated by -1.
	501	*/
	502	unsigned gpio_get_values_as_int(const int *gpio_num_array)
	503	{
	504	int gpio;
	505	unsigned bitmask = 1;
	506	unsigned vector = 0;
	507
	508	while (bitmask &&
	509	((gpio = *gpio_num_array++) != -1)) {
	510	if (gpio_get_value(gpio))
	511	vector \|= bitmask;
	512	bitmask <<= 1;
	513	}
	514	return vector;
	515	}
	516
3669e0e7 SG	517	static int _gpio_request_by_name_nodev(const void *blob, int node,
	518	const char *list_name, int index,
	519	struct gpio_desc *desc, int flags,
	520	bool add_index)
	521	{
	522	struct fdtdec_phandle_args args;
	523	int ret;
	524
	525	desc->dev = NULL;
	526	desc->offset = 0;
	527	ret = fdtdec_parse_phandle_with_args(blob, node, list_name,
	528	"#gpio-cells", 0, index, &args);
	529	if (ret) {
	530	debug("%s: fdtdec_parse_phandle_with_args failed\n", __func__);
	531	goto err;
	532	}
	533
	534	ret = uclass_get_device_by_of_offset(UCLASS_GPIO, args.node,
	535	&desc->dev);
	536	if (ret) {
	537	debug("%s: uclass_get_device_by_of_offset failed\n", __func__);
	538	goto err;
	539	}
	540	ret = gpio_find_and_xlate(desc, &args);
	541	if (ret) {
	542	debug("%s: gpio_find_and_xlate failed\n", __func__);
	543	goto err;
	544	}
	545	ret = dm_gpio_requestf(desc, add_index ? "%s.%s%d" : "%s.%s",
	546	fdt_get_name(blob, node, NULL),
	547	list_name, index);
	548	if (ret) {
	549	debug("%s: dm_gpio_requestf failed\n", __func__);
	550	goto err;
	551	}
	552	ret = dm_gpio_set_dir_flags(desc, flags \| desc->flags);
	553	if (ret) {
	554	debug("%s: dm_gpio_set_dir failed\n", __func__);
	555	goto err;
	556	}
	557
	558	return 0;
	559	err:
	560	debug("%s: Node '%s', property '%s', failed to request GPIO index %d: %d\n",
	561	__func__, fdt_get_name(blob, node, NULL), list_name, index, ret);
	562	return ret;
	563	}
	564
	565	int gpio_request_by_name_nodev(const void *blob, int node,
	566	const char *list_name, int index,
	567	struct gpio_desc *desc, int flags)
	568	{
	569	return _gpio_request_by_name_nodev(blob, node, list_name, index, desc,
	570	flags, index > 0);
	571	}
	572
	573	int gpio_request_by_name(struct udevice dev, const char list_name, int index,
	574	struct gpio_desc *desc, int flags)
	575	{
	576	/*
	577	* This isn't ideal since we don't use dev->name in the debug()
	578	* calls in gpio_request_by_name(), but we can do this until
	579	* gpio_request_by_name_nodev() can be dropped.
	580	*/
581	return gpio_request_by_name_nodev(gd->fdt_blob, dev->of_offset,
582	list_name, index, desc, flags);
583	}
584
585	int gpio_request_list_by_name_nodev(const void *blob, int node,
586	const char *list_name,
587	struct gpio_desc *desc, int max_count,
588	int flags)
589	{
590	int count;
591	int ret;
592
2984e7a1	593	for (count = 0; count < max_count; count++) {
3669e0e7 SG	594	ret = _gpio_request_by_name_nodev(blob, node, list_name, count,
	595	&desc[count], flags, true);
	596	if (ret == -ENOENT)
	597	break;
	598	else if (ret)
	599	goto err;
	600	}
	601
	602	/* We ran out of GPIOs in the list */
	603	return count;
	604
	605	err:
	606	gpio_free_list_nodev(desc, count - 1);
	607
	608	return ret;
	609	}
	610
	611	int gpio_request_list_by_name(struct udevice dev, const char list_name,
	612	struct gpio_desc *desc, int max_count,
	613	int flags)
	614	{
	615	/*
	616	* This isn't ideal since we don't use dev->name in the debug()
	617	* calls in gpio_request_by_name(), but we can do this until
	618	* gpio_request_list_by_name_nodev() can be dropped.
	619	*/
	620	return gpio_request_list_by_name_nodev(gd->fdt_blob, dev->of_offset,
	621	list_name, desc, max_count,
	622	flags);
	623	}
	624
	625	int gpio_get_list_count(struct udevice dev, const char list_name)
	626	{
	627	int ret;
	628
	629	ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev->of_offset,
	630	list_name, "#gpio-cells", 0, -1,
	631	NULL);
	632	if (ret) {
	633	debug("%s: Node '%s', property '%s', GPIO count failed: %d\n",
	634	__func__, dev->name, list_name, ret);
	635	}
	636
	637	return ret;
	638	}
	639
	640	int dm_gpio_free(struct udevice dev, struct gpio_desc desc)
	641	{
	642	/* For now, we don't do any checking of dev */
	643	return _dm_gpio_free(desc->dev, desc->offset);
	644	}
	645
	646	int gpio_free_list(struct udevice dev, struct gpio_desc desc, int count)
	647	{
	648	int i;
	649
	650	/* For now, we don't do any checking of dev */
	651	for (i = 0; i < count; i++)
	652	dm_gpio_free(dev, &desc[i]);
	653
	654	return 0;
	655	}
	656
	657	int gpio_free_list_nodev(struct gpio_desc *desc, int count)
658	{
659	return gpio_free_list(NULL, desc, count);
660	}
661
96495d90	662	/* We need to renumber the GPIOs when any driver is probed/removed */
b892d127	663	static int gpio_renumber(struct udevice *removed_dev)
96495d90 SG	664	{
96495d90 SG	665	struct gpio_dev_priv *uc_priv;
54c5d08a	666	struct udevice *dev;
96495d90 SG	667	struct uclass *uc;
	668	unsigned base;
	669	int ret;
	670
	671	ret = uclass_get(UCLASS_GPIO, &uc);
	672	if (ret)
	673	return ret;
	674
	675	/* Ensure that we have a base for each bank */
	676	base = 0;
	677	uclass_foreach_dev(dev, uc) {
b892d127	678	if (device_active(dev) && dev != removed_dev) {
e564f054	679	uc_priv = dev_get_uclass_priv(dev);
96495d90 SG	680	uc_priv->gpio_base = base;
	681	base += uc_priv->gpio_count;
	682	}
	683	}
	684
	685	return 0;
	686	}
	687
56a71f89 SG	688	int gpio_get_number(struct gpio_desc *desc)
	689	{
	690	struct udevice *dev = desc->dev;
	691	struct gpio_dev_priv *uc_priv;
	692
	693	if (!dev)
	694	return -1;
	695	uc_priv = dev->uclass_priv;
	696
	697	return uc_priv->gpio_base + desc->offset;
	698	}
	699
54c5d08a	700	static int gpio_post_probe(struct udevice *dev)
96495d90	701	{
e564f054	702	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
b892d127 SG	703
	704	uc_priv->name = calloc(uc_priv->gpio_count, sizeof(char *));
	705	if (!uc_priv->name)
	706	return -ENOMEM;
	707
	708	return gpio_renumber(NULL);
96495d90 SG	709	}
96495d90 SG	710
54c5d08a	711	static int gpio_pre_remove(struct udevice *dev)
96495d90	712	{
e564f054	713	struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
b892d127 SG	714	int i;
	715
	716	for (i = 0; i < uc_priv->gpio_count; i++) {
	717	if (uc_priv->name[i])
	718	free(uc_priv->name[i]);
	719	}
	720	free(uc_priv->name);
	721
	722	return gpio_renumber(dev);
96495d90 SG	723	}
	724
	725	UCLASS_DRIVER(gpio) = {
	726	.id = UCLASS_GPIO,
	727	.name = "gpio",
	728	.post_probe = gpio_post_probe,
	729	.pre_remove = gpio_pre_remove,
	730	.per_device_auto_alloc_size = sizeof(struct gpio_dev_priv),
	731	};