drivers/gpio/gpio-shared-proxy.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2025 Linaro Ltd.
 */

#include <linux/auxiliary_bus.h>
#include <linux/cleanup.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/gpio/consumer.h>
#include <linux/gpio/driver.h>
#include <linux/lockdep.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/string_choices.h>
#include <linux/types.h>

#include "gpiolib-shared.h"

struct gpio_shared_proxy_data {
	struct gpio_chip gc;
	struct gpio_shared_desc *shared_desc;
	struct device *dev;
	bool voted_change;
};

static int
gpio_shared_proxy_set_unlocked(struct gpio_shared_proxy_data *proxy, int value)
{
	struct gpio_shared_desc *shared_desc = proxy->shared_desc;
	struct gpio_desc *desc = shared_desc->desc;
	int ret = 0;

	lockdep_assert_held(&shared_desc->mutex);

	if (value != shared_desc->def_val) {
	       /* User wants to vote for a value change. */
		if (proxy->voted_change)
			/* Already voted for a change, nothing to do. */
			goto out;

		/* Haven't voted for a value change yet. */
		if (!shared_desc->votecnt) {
			/*
			 * Current value is default, need to actually set value
			 * to the opposite.
			 */
			ret = gpiod_set_value_cansleep(desc, value);
			if (ret)
				goto out;
		}

		shared_desc->votecnt++;
		proxy->voted_change = true;

		goto out;
	}

	/* Desired value is the default. */
	if (!proxy->voted_change)
		/* We didn't vote for change previously, nothing to do. */
		goto out;

	/* We previously voted for change. */
	if (shared_desc->votecnt == 1) {
		/* This is the last remaining vote for change, set value to default. */
		ret = gpiod_set_value_cansleep(desc, shared_desc->def_val);
		if (ret)
			goto out;
	}

	shared_desc->votecnt--;
	proxy->voted_change = false;

out:
	if (shared_desc->votecnt)
		dev_dbg(proxy->dev,
			"Voted for value '%s', effective value is '%s', number of votes: %u\n",
			str_high_low(value), str_high_low(!shared_desc->def_val),
			shared_desc->votecnt);
	else
		dev_dbg(proxy->dev, "Voted for value '%s', effective value is '%s'\n",
			str_high_low(value), str_high_low(shared_desc->def_val));

	return ret;
}

static int gpio_shared_proxy_request(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
	struct gpio_shared_desc *shared_desc = proxy->shared_desc;

	guard(mutex)(&shared_desc->mutex);

	proxy->shared_desc->usecnt++;

	dev_dbg(proxy->dev, "Shared GPIO requested, number of users: %u\n",
		proxy->shared_desc->usecnt);

	return 0;
}

static void gpio_shared_proxy_free(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
	struct gpio_shared_desc *shared_desc = proxy->shared_desc;
	int ret;

	guard(mutex)(&shared_desc->mutex);

	if (proxy->voted_change) {
		ret = gpio_shared_proxy_set_unlocked(proxy, shared_desc->def_val);
		if (ret)
			dev_err(proxy->dev,
				"Failed to unset the shared GPIO value on release: %d\n", ret);
	}

	proxy->shared_desc->usecnt--;

	dev_dbg(proxy->dev, "Shared GPIO freed, number of users: %u\n",
		proxy->shared_desc->usecnt);
}

static int gpio_shared_proxy_set_config(struct gpio_chip *gc,
					unsigned int offset, unsigned long cfg)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
	struct gpio_shared_desc *shared_desc = proxy->shared_desc;
	struct gpio_desc *desc = shared_desc->desc;
	int ret;

	guard(mutex)(&shared_desc->mutex);

	if (shared_desc->usecnt > 1) {
		if (shared_desc->cfg != cfg) {
			dev_dbg(proxy->dev,
				"Shared GPIO's configuration already set, accepting changes but users may conflict!!\n");
		} else {
			dev_dbg(proxy->dev, "Equal config requested, nothing to do\n");
			return 0;
		}
	}

	ret = gpiod_set_config(desc, cfg);
	if (ret && ret != -ENOTSUPP)
		return ret;

	shared_desc->cfg = cfg;
	return 0;
}

static int gpio_shared_proxy_direction_input(struct gpio_chip *gc,
					     unsigned int offset)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
	struct gpio_shared_desc *shared_desc = proxy->shared_desc;
	struct gpio_desc *desc = shared_desc->desc;
	int dir;

	guard(mutex)(&shared_desc->mutex);

	if (shared_desc->usecnt == 1) {
		dev_dbg(proxy->dev,
			"Only one user of this shared GPIO, allowing to set direction to input\n");

		return gpiod_direction_input(desc);
	}

	dir = gpiod_get_direction(desc);
	if (dir < 0)
		return dir;

	if (dir == GPIO_LINE_DIRECTION_OUT) {
		dev_dbg(proxy->dev,
			"Shared GPIO's direction already set to output, refusing to change\n");
		return -EPERM;
	}

	return 0;
}

static int gpio_shared_proxy_direction_output(struct gpio_chip *gc,
					      unsigned int offset, int value)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
	struct gpio_shared_desc *shared_desc = proxy->shared_desc;
	struct gpio_desc *desc = shared_desc->desc;
	int ret, dir;

	guard(mutex)(&shared_desc->mutex);

	if (shared_desc->usecnt == 1) {
		dev_dbg(proxy->dev,
			"Only one user of this shared GPIO, allowing to set direction to output with value '%s'\n",
			str_high_low(value));

		ret = gpiod_direction_output(desc, value);
		if (ret)
			return ret;

		shared_desc->def_val = value;
		shared_desc->votecnt = 0;
		proxy->voted_change = false;

		return 0;
	}

	dir = gpiod_get_direction(desc);
	if (dir < 0)
		return dir;

	if (dir == GPIO_LINE_DIRECTION_IN) {
		dev_dbg(proxy->dev,
			"Shared GPIO's direction already set to input, refusing to change\n");
		return -EPERM;
	}

	return gpio_shared_proxy_set_unlocked(proxy, value);
}

static int gpio_shared_proxy_get_cansleep(struct gpio_chip *gc,
					  unsigned int offset)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);

	return gpiod_get_value_cansleep(proxy->shared_desc->desc);
}

static int gpio_shared_proxy_set_cansleep(struct gpio_chip *gc,
					  unsigned int offset, int value)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);

	guard(mutex)(&proxy->shared_desc->mutex);

	return gpio_shared_proxy_set_unlocked(proxy, value);
}

static int gpio_shared_proxy_get_direction(struct gpio_chip *gc,
					   unsigned int offset)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);

	return gpiod_get_direction(proxy->shared_desc->desc);
}

static int gpio_shared_proxy_to_irq(struct gpio_chip *gc, unsigned int offset)
{
	struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);

	return gpiod_to_irq(proxy->shared_desc->desc);
}

static int gpio_shared_proxy_probe(struct auxiliary_device *adev,
				   const struct auxiliary_device_id *id)
{
	struct gpio_shared_proxy_data *proxy;
	struct gpio_shared_desc *shared_desc;
	struct device *dev = &adev->dev;
	struct gpio_chip *gc;

	shared_desc = devm_gpiod_shared_get(dev);
	if (IS_ERR(shared_desc))
		return PTR_ERR(shared_desc);

	proxy = devm_kzalloc(dev, sizeof(*proxy), GFP_KERNEL);
	if (!proxy)
		return -ENOMEM;

	proxy->shared_desc = shared_desc;
	proxy->dev = dev;

	gc = &proxy->gc;
	gc->base = -1;
	gc->ngpio = 1;
	gc->label = dev_name(dev);
	gc->parent = dev;
	gc->owner = THIS_MODULE;
	/*
	 * Under the descriptor mutex the proxy may call
	 * gpiod_set_config()/gpiod_direction_*(), which can reach pinctrl
	 * paths that take a mutex (e.g. gpiod_set_config() ->
	 * gpiochip_generic_config() -> pinctrl_gpio_set_config()), independent
	 * of the underlying chip's can_sleep. So the descriptor lock must be a
	 * mutex and the proxy gpiochip is therefore always sleeping; drive the
	 * underlying GPIO through the cansleep value accessors, which are valid
	 * for both sleeping and non-sleeping chips.
	 */
	gc->can_sleep = true;

	gc->request = gpio_shared_proxy_request;
	gc->free = gpio_shared_proxy_free;
	gc->set_config = gpio_shared_proxy_set_config;
	gc->direction_input = gpio_shared_proxy_direction_input;
	gc->direction_output = gpio_shared_proxy_direction_output;
	gc->set = gpio_shared_proxy_set_cansleep;
	gc->get = gpio_shared_proxy_get_cansleep;
	gc->get_direction = gpio_shared_proxy_get_direction;
	gc->to_irq = gpio_shared_proxy_to_irq;

	return devm_gpiochip_add_data(dev, &proxy->gc, proxy);
}

static const struct auxiliary_device_id gpio_shared_proxy_id_table[] = {
	{ .name = "gpiolib_shared.proxy" },
	{},
};
MODULE_DEVICE_TABLE(auxiliary, gpio_shared_proxy_id_table);

static struct auxiliary_driver gpio_shared_proxy_driver = {
	.driver = {
		.name = "gpio-shared-proxy",
		.suppress_bind_attrs = true,
	},
	.probe = gpio_shared_proxy_probe,
	.id_table = gpio_shared_proxy_id_table,
};
module_auxiliary_driver(gpio_shared_proxy_driver);

MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");
MODULE_DESCRIPTION("Shared GPIO mux driver.");
MODULE_LICENSE("GPL");