[PATCH v7 0/2] i2c: i2c-gpio: Enhance driver for buses with shared SCL

[PATCH v7 0/2] i2c: i2c-gpio: Enhance driver for buses with shared SCL

[Markus Stockhausen]

This series adds support for devices with multiple I2C buses 
that share a single clock line.

Signed-off-by: Markus Stockhausen <markus.stockhausen@gmx.de>
---

v6 -> v7
  - Handle devicetree GPIO node attributes opaque. E.g. do not 
    interpret a pin from args[0]. With this generalize the shared 
    SCL detection by simply comparing all attributes.
  - Gracefully disable pin sharing if devicetree lookup does not 
    work as expected. This avoids interference with otherwise sane
    setups. 
  - Disable bit_test only if a (potentially) shared SCL pin is
    detected.
v6: https://lore.kernel.org/linux-i2c/20260714062018.3009830-1-markus.stockhausen@gmx.de/
v6 Sashiko: https://sashiko.dev/#/patchset/20260714062018.3009830-1-markus.stockhausen%40gmx.de

v5 -> v6
  - Add legacy system detection (without dts/fwnode)
  - Add skip_bit_test setting to algorithm options via pre-commit
  - Make use of skip_bit_test in the driver
v5: https://lore.kernel.org/linux-i2c/20260713062021.2995641-1-markus.stockhausen@gmx.de/
v5 Sashiko: https://sashiko.dev/#/patchset/20260713062021.2995641-1-markus.stockhausen%40gmx.de

v4 -> v5
  - Whitespace cleanup
  - Send to LKML for Sashiko review
  - Add Reviewed-by
v4: https://lore.kernel.org/linux-i2c/20260709062534.2864521-1-markus.stockhausen@gmx.de/

v3 -> v4
  - add Reviewed-by and Tested-by
v3: https://lore.kernel.org/linux-i2c/20260520173129.1382489-1-markus.stockhausen@gmx.de/

v2 -> v3
  - Fix lockdep_set_class() with DEBUG_LOCK_ALLOC=y
v2: https://lore.kernel.org/linux-i2c/20260518161013.900504-1-markus.stockhausen@gmx.de/

v1 -> v2
  - Convert fault injector to scl->gpio (reported by test robot)
  - Use rt_mutex and i2c_lock_operations instead of pre/post_xfer
    (logic taken from i2c-cht-wc.c and enhanced)
  - i2c_gpio_lookup_scl()
    - Improve list control flow
    - Improve comment
    - Carve out SCL node comparison into i2c_gpio_scl_matches()
  - Drop "valid" attribute and directly check gpiod instead
  - Improve fwnode args check for #gpio-cells=1 case
  - Add sda/scl cleanup during probe failures
  - Replace dev_info() with dev_dbg()
  - Reflect changed locking in commmit message
  - Tested with config option GPIO_SHARED/GPIO_SHARED_PROXY
    as requested by Bartosz
v1: https://lore.kernel.org/linux-i2c/20260514092042.3265986-1-markus.stockhausen@gmx.de/

v0 -> v1
  - Initially this enhancement was submitted as a new driver with
    a new devicetree structure. After some discussion Wolfram
    advised to make only an enhancement to the i2c-gpio driver.
v0: https://lore.kernel.org/linux-i2c/20260511162528.84508-1-markus.stockhausen@gmx.de/


Markus Stockhausen (2):
  i2c: algo: bit: Allow to skip bit test
  i2c: i2c-gpio: Enhance driver for buses with shared SCL

 drivers/i2c/algos/i2c-algo-bit.c |   2 +-
 drivers/i2c/busses/i2c-gpio.c    | 223 +++++++++++++++++++++++++++++--
 include/linux/i2c-algo-bit.h     |   1 +
 3 files changed, 211 insertions(+), 15 deletions(-)

-- 
2.54.0

[PATCH v7 1/2] i2c: algo: bit: Allow to skip bit test

[Markus Stockhausen]

An I2C bus can make use of shared resources. E.g. two GPIO based buses
that share a single SCL line. To synchronize access to the bus the driver
might use locking with the help of i2c_lock_operations(). While this
works for normal transfers it is not available during initialization.

Especially if i2c-algo-bit module is loaded with parameter bit_test
it will issue some basic sanity checks that will access the bus without
locking. This might interfere badly with concurrent transfers. Even
if these are well synchronized via locks.

Allow the consumer of an algorithm to override if the bit_test is allowed
or not. For this add a new boolean attribute named skip_bit_test to
i2c_algo_bit_data. If set the test is not run.

Signed-off-by: Markus Stockhausen <markus.stockhausen@gmx.de>
---
 drivers/i2c/algos/i2c-algo-bit.c | 2 +-
 include/linux/i2c-algo-bit.h     | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/drivers/i2c/algos/i2c-algo-bit.c b/drivers/i2c/algos/i2c-algo-bit.c
index d1d9a6c1a1e2..7ca565cbff5b 100644
--- a/drivers/i2c/algos/i2c-algo-bit.c
+++ b/drivers/i2c/algos/i2c-algo-bit.c
@@ -639,7 +639,7 @@ static int __i2c_bit_add_bus(struct i2c_adapter *adap,
 	struct i2c_algo_bit_data *bit_adap = adap->algo_data;
 	int ret;
 
-	if (bit_test) {
+	if (bit_test && !bit_adap->skip_bit_test) {
 		ret = test_bus(adap);
 		if (bit_test >= 2 && ret < 0)
 			return -ENODEV;
diff --git a/include/linux/i2c-algo-bit.h b/include/linux/i2c-algo-bit.h
index 7fd5575a368f..c4c43aec1e67 100644
--- a/include/linux/i2c-algo-bit.h
+++ b/include/linux/i2c-algo-bit.h
@@ -34,6 +34,7 @@ struct i2c_algo_bit_data {
 				   maximum 50 us for SMBus */
 	int timeout;		/* in jiffies */
 	bool can_do_atomic;	/* callbacks don't sleep, we can be atomic */
+	bool skip_bit_test;	/* override bit_test module parameter */
 };
 
 int i2c_bit_add_bus(struct i2c_adapter *);
-- 
2.54.0

[PATCH v7 2/2] i2c: i2c-gpio: Enhance driver for buses with shared SCL

[Markus Stockhausen]

Some lower end hardware (especially Realtek based switches) are
designed with multiple I2C buses that share a single clock line.
E.g. the D-Link DGS-1250-28X realizes 4 I2C SFP busses with 5 GPIOs.

Enhance the i2c-gpio driver so it can handle such hardware designs.

- Detect shared SCL GPIOs that are used by multiple I2C buses in the
  devicetree by using a "unique identifier". This is basically the
  phandle and all additional cells.

- The first probing instance allocates and requests the shared SCL
  GPIO with an associated rt_mutex. Subsequent instances detect the
  existing entry via the identifier and increment a reference count
  to reuse the descriptor.

- All data transfers are serialized via custom lock_ops that handle
  both the standard adapter bus lock and the shared SCL mutex. This
  ensures mutual exclusion across adapters sharing the clock line.

- This shared SCL detection works only for dts based systems where
  the GPIO node has at least one cell (usually the pin). GPIOs in
  legacy systems without devicetree will be handled individudally
  as before.

This patch was successfully tested on Linksys LGS310C that has two
SFP slots with two GPIO based I2C buses that share a single SCL.
Test environment: OpenWrt snapshot ported to kernel 6.19.14
including CONFIG_GPIO_SHARED=y and CONFIG_GPIO_SHARED_PROXY=y.

Signed-off-by: Markus Stockhausen <markus.stockhausen@gmx.de>
Tested-by: Sander Vanheule <sander@svanheule.net>
Reviewed-by: Bartosz Golaszewski <bartosz.golaszewski@oss.qualcomm.com>
Reviewed-by: Wolfram Sang <wsa+renesas@sang-engineering.com>
---
 drivers/i2c/busses/i2c-gpio.c | 223 +++++++++++++++++++++++++++++++---
 1 file changed, 209 insertions(+), 14 deletions(-)

diff --git a/drivers/i2c/busses/i2c-gpio.c b/drivers/i2c/busses/i2c-gpio.c
index f4355b17bfbf..b7521b7ece37 100644
--- a/drivers/i2c/busses/i2c-gpio.c
+++ b/drivers/i2c/busses/i2c-gpio.c
@@ -18,9 +18,21 @@
 #include <linux/property.h>
 #include <linux/slab.h>
 
+static LIST_HEAD(i2c_gpio_scl_list);
+static DEFINE_MUTEX(i2c_gpio_scl_list_lock);
+static struct lock_class_key i2c_gpio_scl_lock_key;
+
+struct i2c_gpio_scl_data {
+	struct fwnode_reference_args args;
+	struct gpio_desc *gpio;
+	struct rt_mutex lock;
+	struct list_head list;
+	refcount_t ref;
+};
+
 struct i2c_gpio_private_data {
 	struct gpio_desc *sda;
-	struct gpio_desc *scl;
+	struct i2c_gpio_scl_data *scl;
 	struct i2c_adapter adap;
 	struct i2c_algo_bit_data bit_data;
 	struct i2c_gpio_platform_data pdata;
@@ -31,6 +43,11 @@ struct i2c_gpio_private_data {
 #endif
 };
 
+static inline struct i2c_gpio_private_data *adap_to_priv(struct i2c_adapter *adap)
+{
+	return container_of(adap, struct i2c_gpio_private_data, adap);
+}
+
 /*
  * Toggle SDA by changing the output value of the pin. This is only
  * valid for pins configured as open drain (i.e. setting the value
@@ -53,7 +70,7 @@ static void i2c_gpio_setscl_val(void *data, int state)
 {
 	struct i2c_gpio_private_data *priv = data;
 
-	gpiod_set_value_cansleep(priv->scl, state);
+	gpiod_set_value_cansleep(priv->scl->gpio, state);
 }
 
 static int i2c_gpio_getsda(void *data)
@@ -67,9 +84,41 @@ static int i2c_gpio_getscl(void *data)
 {
 	struct i2c_gpio_private_data *priv = data;
 
-	return gpiod_get_value_cansleep(priv->scl);
+	return gpiod_get_value_cansleep(priv->scl->gpio);
+}
+
+static void i2c_gpio_lock_bus(struct i2c_adapter *adap, unsigned int flags)
+{
+	/* Take care about adapter lock. See i2c_adapter_lock_bus() and others. */
+	rt_mutex_lock_nested(&adap->bus_lock, i2c_adapter_depth(adap));
+	rt_mutex_lock(&adap_to_priv(adap)->scl->lock);
+}
+
+static int i2c_gpio_trylock_bus(struct i2c_adapter *adap, unsigned int flags)
+{
+	if (!rt_mutex_trylock(&adap->bus_lock))
+		return 0;
+
+	if (!rt_mutex_trylock(&adap_to_priv(adap)->scl->lock)) {
+		rt_mutex_unlock(&adap->bus_lock);
+		return 0;
+	}
+
+	return 1;
 }
 
+static void i2c_gpio_unlock_bus(struct i2c_adapter *adap, unsigned int flags)
+{
+	rt_mutex_unlock(&adap_to_priv(adap)->scl->lock);
+	rt_mutex_unlock(&adap->bus_lock);
+}
+
+static const struct i2c_lock_operations i2c_gpio_lock_ops = {
+	.lock_bus = i2c_gpio_lock_bus,
+	.trylock_bus = i2c_gpio_trylock_bus,
+	.unlock_bus = i2c_gpio_unlock_bus,
+};
+
 #ifdef CONFIG_I2C_GPIO_FAULT_INJECTOR
 
 #define setsda(bd, val)	((bd)->setsda((bd)->data, val))
@@ -165,14 +214,14 @@ DEFINE_DEBUGFS_ATTRIBUTE(fops_incomplete_write_byte, NULL, fops_incomplete_write
 static int i2c_gpio_fi_act_on_scl_irq(struct i2c_gpio_private_data *priv,
 				       irqreturn_t handler(int, void*))
 {
-	int ret, irq = gpiod_to_irq(priv->scl);
+	int ret, irq = gpiod_to_irq(priv->scl->gpio);
 
 	if (irq < 0)
 		return irq;
 
 	i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER);
 
-	ret = gpiod_direction_input(priv->scl);
+	ret = gpiod_direction_input(priv->scl->gpio);
 	if (ret)
 		goto unlock;
 
@@ -187,7 +236,7 @@ static int i2c_gpio_fi_act_on_scl_irq(struct i2c_gpio_private_data *priv,
 
 	free_irq(irq, priv);
  output:
-	ret = gpiod_direction_output(priv->scl, 1) ?: ret;
+	ret = gpiod_direction_output(priv->scl->gpio, 1) ?: ret;
  unlock:
 	i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER);
 
@@ -308,13 +357,17 @@ static struct gpio_desc *i2c_gpio_get_desc(struct device *dev,
 	struct gpio_desc *retdesc;
 	int ret;
 
-	retdesc = devm_gpiod_get(dev, con_id, gflags);
+	/*
+	 * Don't use resource-managed functions. SCL may be shared across adapters and has
+	 * its own lifetime management. SDA uses the same path for consistency.
+	 */
+	retdesc = gpiod_get(dev, con_id, gflags);
 	if (!IS_ERR(retdesc)) {
 		dev_dbg(dev, "got GPIO from name %s\n", con_id);
 		return retdesc;
 	}
 
-	retdesc = devm_gpiod_get_index(dev, NULL, index, gflags);
+	retdesc = gpiod_get_index(dev, NULL, index, gflags);
 	if (!IS_ERR(retdesc)) {
 		dev_dbg(dev, "got GPIO from index %u\n", index);
 		return retdesc;
@@ -336,6 +389,134 @@ static struct gpio_desc *i2c_gpio_get_desc(struct device *dev,
 	return retdesc;
 }
 
+static struct i2c_gpio_scl_data *i2c_gpio_create_scl(struct device *dev)
+{
+	struct fwnode_handle *fwnode = dev_fwnode(dev);
+	struct fwnode_reference_args args;
+	struct i2c_gpio_scl_data *scl;
+	bool sharable = false;
+	int ret;
+
+	/*
+	 * SCL gpios can be shared if they are defined in the devicetree and have at least one
+	 * cell in addition to the phandle. This is usually the pin. To support complex designs
+	 * with arbitrary of_xlate() mappings handle the node cells opaque.
+	 */
+	if (fwnode) {
+		ret = fwnode_property_get_reference_args(fwnode, "scl-gpios",
+							 "#gpio-cells", 0, 0, &args);
+		if (ret)
+			/* try the ancient way */
+			ret = fwnode_property_get_reference_args(fwnode, "gpios",
+								 "#gpio-cells", 0, 1, &args);
+
+		if (!ret) {
+			if (args.nargs >= 1)
+				sharable = true;
+			else
+				fwnode_handle_put(args.fwnode);
+		}
+	}
+
+	scl = kzalloc(sizeof(*scl), GFP_KERNEL);
+	if (!scl) {
+		if (sharable)
+			fwnode_handle_put(args.fwnode);
+		return ERR_PTR(-ENOMEM);
+	}
+
+	if (sharable) {
+		scl->args.fwnode = args.fwnode;
+		scl->args.nargs = args.nargs;
+		memcpy(scl->args.args, args.args, sizeof(args.args[0]) * args.nargs);
+	}
+
+	rt_mutex_init(&scl->lock);
+	lockdep_set_class(&scl->lock, &i2c_gpio_scl_lock_key);
+	refcount_set(&scl->ref, 1);
+
+	return scl;
+}
+
+static void i2c_gpio_free_scl(struct i2c_gpio_scl_data *scl)
+{
+	if (scl->args.fwnode)
+		fwnode_handle_put(scl->args.fwnode);
+	kfree(scl);
+}
+
+static bool i2c_gpio_scl_matches(struct i2c_gpio_scl_data *a, struct i2c_gpio_scl_data *b)
+{
+	if (!a->args.fwnode || !b->args.fwnode ||
+	    a->args.fwnode != b->args.fwnode || a->args.nargs != b->args.nargs)
+		return false;
+
+	return memcmp(a->args.args, b->args.args, sizeof(a->args.args[0]) * a->args.nargs) == 0;
+}
+
+/*
+ * Look up an existing or create a new shared SCL structure. Optimistic setup sequence always
+ * creates and tries to add a new entry to the list. This uses minimum locking and afterwards
+ * requests the GPIO without a lock held. Concurrent probes for the same SCL pin see the entry
+ * and do not race into a second gpiod_get(). Until everything is setup they terminate with
+ * -EPROBE_DEFER.
+ */
+static struct i2c_gpio_scl_data *i2c_gpio_lookup_scl(struct device *dev, enum gpiod_flags gflags)
+{
+	struct i2c_gpio_scl_data *scl, *new_scl;
+	struct gpio_desc *gpio;
+
+	new_scl = i2c_gpio_create_scl(dev);
+	if (IS_ERR(new_scl))
+		return new_scl;
+
+	scoped_guard(mutex, &i2c_gpio_scl_list_lock) {
+		list_for_each_entry(scl, &i2c_gpio_scl_list, list) {
+			if (!i2c_gpio_scl_matches(scl, new_scl))
+				continue;
+
+			i2c_gpio_free_scl(new_scl);
+			if (!scl->gpio)
+				return ERR_PTR(-EPROBE_DEFER);
+
+			refcount_inc(&scl->ref);
+			if (scl->args.fwnode)
+				dev_dbg(dev, "reusing shared SCL (%pfwP)\n", scl->args.fwnode);
+
+			return scl;
+		}
+		list_add(&new_scl->list, &i2c_gpio_scl_list);
+	}
+
+	gpio = i2c_gpio_get_desc(dev, "scl", 1, gflags);
+	if (IS_ERR(gpio)) {
+		scoped_guard(mutex, &i2c_gpio_scl_list_lock)
+			list_del(&new_scl->list);
+		i2c_gpio_free_scl(new_scl);
+
+		return ERR_CAST(gpio);
+	}
+
+	scoped_guard(mutex, &i2c_gpio_scl_list_lock)
+		new_scl->gpio = gpio;
+
+	if (new_scl->args.fwnode)
+		dev_dbg(dev, "registered shared SCL (%pfwP)\n", new_scl->args.fwnode);
+
+	return new_scl;
+}
+
+static void i2c_gpio_cleanup_scl(struct i2c_gpio_scl_data *scl)
+{
+	if (!refcount_dec_and_mutex_lock(&scl->ref, &i2c_gpio_scl_list_lock))
+		return;
+
+	list_del(&scl->list);
+	mutex_unlock(&i2c_gpio_scl_list_lock);
+	gpiod_put(scl->gpio);
+	i2c_gpio_free_scl(scl);
+}
+
 static int i2c_gpio_probe(struct platform_device *pdev)
 {
 	struct i2c_gpio_private_data *priv;
@@ -386,15 +567,18 @@ static int i2c_gpio_probe(struct platform_device *pdev)
 		gflags = GPIOD_OUT_HIGH;
 	else
 		gflags = GPIOD_OUT_HIGH_OPEN_DRAIN;
-	priv->scl = i2c_gpio_get_desc(dev, "scl", 1, gflags);
-	if (IS_ERR(priv->scl))
-		return PTR_ERR(priv->scl);
+	priv->scl = i2c_gpio_lookup_scl(dev, gflags);
+	if (IS_ERR(priv->scl)) {
+		ret = PTR_ERR(priv->scl);
+		goto err_cleanup_sda;
+	}
 
-	if (gpiod_cansleep(priv->sda) || gpiod_cansleep(priv->scl))
+	if (gpiod_cansleep(priv->sda) || gpiod_cansleep(priv->scl->gpio))
 		dev_warn(dev, "Slow GPIO pins might wreak havoc into I2C/SMBus bus timing");
 	else
 		bit_data->can_do_atomic = true;
 
+	bit_data->skip_bit_test = !!priv->scl->args.fwnode;
 	bit_data->setsda = i2c_gpio_setsda_val;
 	bit_data->setscl = i2c_gpio_setscl_val;
 
@@ -423,6 +607,8 @@ static int i2c_gpio_probe(struct platform_device *pdev)
 	else
 		snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);
 
+	/* Always use shared SCL aware locking */
+	adap->lock_ops = &i2c_gpio_lock_ops;
 	adap->algo_data = bit_data;
 	adap->class = I2C_CLASS_HWMON;
 	adap->dev.parent = dev;
@@ -431,7 +617,7 @@ static int i2c_gpio_probe(struct platform_device *pdev)
 	adap->nr = pdev->id;
 	ret = i2c_bit_add_numbered_bus(adap);
 	if (ret)
-		return ret;
+		goto err_cleanup_scl;
 
 	platform_set_drvdata(pdev, priv);
 
@@ -441,13 +627,20 @@ static int i2c_gpio_probe(struct platform_device *pdev)
 	 * from the descriptor, then provide that instead.
 	 */
 	dev_info(dev, "using lines %u (SDA) and %u (SCL%s)\n",
-		 desc_to_gpio(priv->sda), desc_to_gpio(priv->scl),
+		 desc_to_gpio(priv->sda), desc_to_gpio(priv->scl->gpio),
 		 pdata->scl_is_output_only
 		 ? ", no clock stretching" : "");
 
 	i2c_gpio_fault_injector_init(pdev);
 
 	return 0;
+
+err_cleanup_scl:
+	i2c_gpio_cleanup_scl(priv->scl);
+err_cleanup_sda:
+	gpiod_put(priv->sda);
+
+	return ret;
 }
 
 static void i2c_gpio_remove(struct platform_device *pdev)
@@ -459,6 +652,8 @@ static void i2c_gpio_remove(struct platform_device *pdev)
 	adap = &priv->adap;
 
 	i2c_del_adapter(adap);
+	i2c_gpio_cleanup_scl(priv->scl);
+	gpiod_put(priv->sda);
 }
 
 static const struct of_device_id i2c_gpio_dt_ids[] = {
-- 
2.54.0

AW: [PATCH v7 0/2] i2c: i2c-gpio: Enhance driver for buses with shared SCL

[Markus Stockhausen]

Hi Wolfram,
Hi Bartosz,

> Von: Markus Stockhausen <markus.stockhausen@gmx.de> 
> Gesendet: Dienstag, 14. Juli 2026 18:29
> An: wsa+renesas@sang-engineering.com; andi.shyti@kernel.org;
linusw@kernel.org; brgl@kernel.org; linux-i2c@vger.kernel.org;
linux-gpio@vger.kernel.org; linux-kernel@vger.kernel.org
> Cc: Markus Stockhausen <markus.stockhausen@gmx.de>
> Betreff: [PATCH v7 0/2] i2c: i2c-gpio: Enhance driver for buses with
shared SCL
> 
> This series adds support for devices with multiple I2C buses 
> that share a single clock line.
> 
> Signed-off-by: Markus Stockhausen <markus.stockhausen@gmx.de>

Thanks for your assistance and feedback. Finally Sashiko seems to be happy.

https://sashiko.dev/#/patchset/20260714162915.3018703-1-markus.stockhausen%4
0gmx.de

The core logic of the implementation is still the same you reviewed, With
Sashikos feedback the detection of sharable SCL pins has changed a bit. 
Maybe you can have a final look if i2c_gpio_create_scl() is ok for you now.

Thanks in advance.

Markus

Re: AW: [PATCH v7 0/2] i2c: i2c-gpio: Enhance driver for buses with shared SCL

[Wolfram Sang]

[-- Attachment #1: Type: text/plain, Size: 385 bytes --]

Hi Markus,

> Maybe you can have a final look if i2c_gpio_create_scl() is ok for you now.

I saw that Sashiko is happy now, good work! I want to test the updated
driver on some boards with simple i2c-gpio instances, just to double
check that there are no regressions. I ran into issue unrelated to your
patches, but I am positive I can resolve them today.

Happy hacking,

   Wolfram


[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]