// 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 intgpio_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");