gpio: shared-proxy: implement the shared GPIO proxy driver

Add a virtual GPIO proxy driver which arbitrates access to a single
shared GPIO by multiple users. It works together with the core shared
GPIO support from GPIOLIB and functions by acquiring a reference to a
shared GPIO descriptor exposed by gpiolib-shared and making sure that
the state of the GPIO stays consistent.

In general: if there's only one user at the moment: allow it to do
anything as if this was a normal GPIO (in essence: just propagate calls
to the underlying real hardware driver). If there are more users: don't
allow to change the direction set by the initial user, allow to change
configuration options but warn about possible conflicts and finally:
treat the output-high value as a reference counted, logical "GPIO
enabled" setting, meaning: the GPIO value is set to high when the first
user requests it to be high and back to low once the last user stops
"voting" for high.

Reviewed-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Link: https://lore.kernel.org/r/20251112-gpio-shared-v4-4-b51f97b1abd8@linaro.org
Signed-off-by: Bartosz Golaszewski <bartosz.golaszewski@linaro.org>

diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 92139e75484fadc75fbbcecf2736d80054a62198..b8b6537290b0676586f98f3e648d3ba76e81b69b 100644 (file)
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -2025,6 +2025,15 @@ config GPIO_SIM
          This enables the GPIO simulator - a configfs-based GPIO testing
          driver.
 
+config GPIO_SHARED_PROXY
+       tristate "Proxy driver for non-exclusive GPIOs"
+       default m
+       depends on GPIO_SHARED || COMPILE_TEST
+       select AUXILIARY_BUS
+       help
+         This enables the GPIO shared proxy driver - an abstraction layer
+         for GPIO pins that are shared by multiple devices.
+
 endmenu
 
 menu "GPIO Debugging utilities"

diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index f702f7e27e5b4017e7eab3019dae4ec912d534f8..d0020bc70b84f6fb9949165070c21725a60f47e2 100644 (file)
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -160,6 +160,7 @@ obj-$(CONFIG_ARCH_SA1100)           += gpio-sa1100.o
 obj-$(CONFIG_GPIO_SAMA5D2_PIOBU)       += gpio-sama5d2-piobu.o
 obj-$(CONFIG_GPIO_SCH311X)             += gpio-sch311x.o
 obj-$(CONFIG_GPIO_SCH)                 += gpio-sch.o
+obj-$(CONFIG_GPIO_SHARED_PROXY)                += gpio-shared-proxy.o
 obj-$(CONFIG_GPIO_SIFIVE)              += gpio-sifive.o
 obj-$(CONFIG_GPIO_SIM)                 += gpio-sim.o
 obj-$(CONFIG_GPIO_SIOX)                        += gpio-siox.o

diff --git a/drivers/gpio/gpio-shared-proxy.c b/drivers/gpio/gpio-shared-proxy.c
new file mode 100644 (file)
index 0000000..3ef2c40
--- /dev/null
+++ b/drivers/gpio/gpio-shared-proxy.c
@@ -0,0 +1,333 @@
+// 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/mod_devicetable.h>
+#include <linux/module.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_high;
+};
+
+static int
+gpio_shared_proxy_set_unlocked(struct gpio_shared_proxy_data *proxy,
+                              int (*set_func)(struct gpio_desc *desc, int value),
+                              int value)
+{
+       struct gpio_shared_desc *shared_desc = proxy->shared_desc;
+       struct gpio_desc *desc = shared_desc->desc;
+       int ret = 0;
+
+       gpio_shared_lockdep_assert(shared_desc);
+
+       if (value) {
+              /* User wants to set value to high. */
+               if (proxy->voted_high)
+                       /* Already voted for high, nothing to do. */
+                       goto out;
+
+               /* Haven't voted for high yet. */
+               if (!shared_desc->highcnt) {
+                       /*
+                        * Current value is low, need to actually set value
+                        * to high.
+                        */
+                       ret = set_func(desc, 1);
+                       if (ret)
+                               goto out;
+               }
+
+               shared_desc->highcnt++;
+               proxy->voted_high = true;
+
+               goto out;
+       }
+
+       /* Desired value is low. */
+       if (!proxy->voted_high)
+               /* We didn't vote for high, nothing to do. */
+               goto out;
+
+       /* We previously voted for high. */
+       if (shared_desc->highcnt == 1) {
+               /* This is the last remaining vote for high, set value  to low. */
+               ret = set_func(desc, 0);
+               if (ret)
+                       goto out;
+       }
+
+       shared_desc->highcnt--;
+       proxy->voted_high = false;
+
+out:
+       if (shared_desc->highcnt)
+               dev_dbg(proxy->dev,
+                       "Voted for value '%s', effective value is 'high', number of votes for 'high': %u\n",
+                       str_high_low(value), shared_desc->highcnt);
+       else
+               dev_dbg(proxy->dev, "Voted for value 'low', effective value is 'low'\n");
+
+       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(gpio_shared_desc_lock)(shared_desc);
+
+       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;
+
+       guard(gpio_shared_desc_lock)(shared_desc);
+
+       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(gpio_shared_desc_lock)(shared_desc);
+
+       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(gpio_shared_desc_lock)(shared_desc);
+
+       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(gpio_shared_desc_lock)(shared_desc);
+
+       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;
+
+               if (value) {
+                       proxy->voted_high = true;
+                       shared_desc->highcnt = 1;
+               } else {
+                       proxy->voted_high = false;
+                       shared_desc->highcnt = 0;
+               }
+
+               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, gpiod_direction_output, value);
+}
+
+static int gpio_shared_proxy_get(struct gpio_chip *gc, unsigned int offset)
+{
+       struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
+
+       return gpiod_get_value(proxy->shared_desc->desc);
+}
+
+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_do_set(struct gpio_shared_proxy_data *proxy,
+                                   int (*set_func)(struct gpio_desc *desc, int value),
+                                   int value)
+{
+       guard(gpio_shared_desc_lock)(proxy->shared_desc);
+
+       return gpio_shared_proxy_set_unlocked(proxy, set_func, value);
+}
+
+static int gpio_shared_proxy_set(struct gpio_chip *gc, unsigned int offset,
+                                int value)
+{
+       struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
+
+       return gpio_shared_proxy_do_set(proxy, gpiod_set_value, value);
+}
+
+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);
+
+       return gpio_shared_proxy_do_set(proxy, gpiod_set_value_cansleep, 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;
+       gc->can_sleep = shared_desc->can_sleep;
+
+       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;
+       if (gc->can_sleep) {
+               gc->set = gpio_shared_proxy_set_cansleep;
+               gc->get = gpio_shared_proxy_get_cansleep;
+       } else {
+               gc->set = gpio_shared_proxy_set;
+               gc->get = gpio_shared_proxy_get;
+       }
+       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",
+       },
+       .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");