i2c: Multiplexed I2C bus core support.

Subject: [PATCH 1/2] i2c: Multiplexed I2C bus core support.

---
 drivers/i2c/Kconfig        |   10 +++
 drivers/i2c/Makefile       |    3 +-
 drivers/i2c/i2c-core.c     |   73 +++++++++++++++++--
 drivers/i2c/i2c-dev.c      |   32 ++++++++-
 drivers/i2c/i2c-mux.c      |  167
++++++++++++++++++++++++++++++++++++++++++++
 drivers/i2c/muxes/Kconfig  |    8 ++
 drivers/i2c/muxes/Makefile |    6 ++
 include/linux/i2c.h        |   14 ++++
 8 files changed, 303 insertions(+), 10 deletions(-)
 create mode 100755 drivers/i2c/i2c-mux.c
 create mode 100755 drivers/i2c/muxes/Kconfig
 create mode 100755 drivers/i2c/muxes/Makefile

index d7ece13..0c2f86a 100755
@@ -35,6 +35,16 @@ config I2C_COMPAT
 	  other user-space package which expects i2c adapters to be class
 	  devices. If you don't know, say Y.
 
+config I2C_MUX
+	tristate "I2C bus multiplexing support"
+	depends on I2C
+	help
+	  Say Y here if you want the I2C core to support the ability to
+	  handle multiplexed I2C bus topologies, by presenting each
+	  multiplexed segment as a I2C adapter.
+
+source drivers/i2c/muxes/Kconfig
+
 config I2C_CHARDEV
 	tristate "I2C device interface"
 	help

index ba26e6c..281e2a7 100755
@@ -4,8 +4,9 @@
 
 obj-$(CONFIG_I2C_BOARDINFO)	+= i2c-boardinfo.o
 obj-$(CONFIG_I2C)		+= i2c-core.o
+obj-$(CONFIG_I2C_MUX)		+= i2c-mux.o
 obj-$(CONFIG_I2C_CHARDEV)	+= i2c-dev.o
-obj-y				+= busses/ chips/ algos/
+obj-y				+= busses/ chips/ muxes/ algos/
 
 ifeq ($(CONFIG_I2C_DEBUG_CORE),y)
 EXTRA_CFLAGS += -DDEBUG

index 2965043..83119ae 100644
@@ -20,7 +20,9 @@
 /* With some changes from Kyösti Mälkki <[email protected]>.
    All SMBus-related things are written by Frodo Looijaard <[email protected]>
    SMBus 2.0 support by Mark Studebaker <mdsxyz123-/[email protected]> and
-   Jean Delvare <[email protected]> */
+      Jean Delvare <[email protected]>
+   Mux support by Rodolfo Giometti <giometti-AVVDYK/kqiJWk0Htik3J/[email protected]> and
+      Michael Lawnick <[email protected]>*/
 
 #include <linux/module.h>
 #include <linux/kernel.h>

@@ -937,9 +939,66 @@ static int __i2c_check_addr(struct device *dev,

void *addrp)
return 0;
}

+static int i2c_check_clients(struct i2c_adapter *adapter, int addr) +{
+ int result = 0;
+
+ result = device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
+
+ if (!result && (adapter->dev.parent->bus == &i2c_bus_type))
+ result = i2c_check_clients(to_i2c_adapter(adapter->dev.parent), addr);
+
+ return result;
+}
+
static int i2c_check_addr(struct i2c_adapter *adapter, int addr) {
- return device_for_each_child(&adapter->dev, &addr, __i2c_check_addr);
+ int result = 0;
+
+ result = i2c_check_clients(adapter, addr);
+
+ if (!result && (adapter->dev.parent->bus == &i2c_bus_type))
+ {
+ struct i2c_client dummy;
+ char buff;
+
+ dummy.adapter = to_i2c_adapter(adapter->dev.parent);
+ dummy.addr = addr;
+ dummy.flags = 0;
+
+ result = i2c_master_recv(&dummy, &buff, 1) == 1;
+ }
+
+ return result;
+}
+
+static void i2c_mux_tree_lock(struct i2c_adapter *adap) +{
+ mutex_lock_nested(&adap->bus_lock, SINGLE_DEPTH_NESTING);
+ if(adap->dev.parent->bus == &i2c_bus_type)
+ i2c_mux_tree_lock(to_i2c_adapter(adap->dev.parent));
+}
+
+static int i2c_mux_tree_trylock(struct i2c_adapter *adap) +{
+ int ret;
+
+ ret = mutex_trylock(&adap->bus_lock);
+
+ if(ret && (adap->dev.parent->bus == &i2c_bus_type)) {
+ ret = i2c_mux_tree_trylock(to_i2c_adapter(adap->dev.parent));
+ if (!ret)
+ mutex_unlock(&adap->bus_lock);
+ }
+
+ return ret;
+}
+
+static void i2c_mux_tree_unlock(struct i2c_adapter *adap) +{
+ if(adap->dev.parent->bus == &i2c_bus_type)
+ i2c_mux_tree_unlock(to_i2c_adapter(adap->dev.parent));
+ mutex_unlock(&adap->bus_lock);
}

/**
@@ -1092,12 +1151,12 @@ int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
#endif

if (in_atomic() || irqs_disabled()) {
- ret = mutex_trylock(&adap->bus_lock);
+ ret = i2c_mux_tree_trylock(adap);
if (!ret)
/* I2C activity is ongoing. */ return -EAGAIN;
} else {
- mutex_lock_nested(&adap->bus_lock, adap->level);
+ i2c_mux_tree_lock(adap);
}

/* Retry automatically on arbitration loss */
@@ -1109,7 +1168,7 @@ int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
if (time_after(jiffies, orig_jiffies + adap->timeout))
break;
}
- mutex_unlock(&adap->bus_lock);
+ i2c_mux_tree_unlock(adap);

return ret;
} else {
@@ -1913,7 +1972,7 @@ s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
flags &= I2C_M_TEN | I2C_CLIENT_PEC;

if (adapter->algo->smbus_xfer) {
- mutex_lock(&adapter->bus_lock);
+ i2c_mux_tree_lock(adapter);

/* Retry automatically on arbitration loss */ orig_jiffies = jiffies;
@@ -1927,7 +1986,7 @@ s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
orig_jiffies + adapter->timeout))
break;
}
- mutex_unlock(&adapter->bus_lock);
+ i2c_mux_tree_unlock(adapter);
} else
res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,
command, protocol, data);

index 7e13d2d..ce2f1a1 100644
@@ -190,16 +190,44 @@ static int i2cdev_check(struct device *dev, void

*addrp)

if (!client || client->addr != *(unsigned int *)addrp)
return 0;
-
+
return dev->driver ? -EBUSY : 0;
}

+static int i2cdev_check_clients(struct i2c_adapter *adapter, int addr) +{
+ int result = 0;
+
+ result = device_for_each_child(&adapter->dev, &addr, i2cdev_check);
+
+ if (!result && (adapter->dev.parent->bus == &i2c_bus_type))
+ result = i2cdev_check_clients(to_i2c_adapter(adapter->dev.parent), addr);
+
+ return result;
+}
+
/* This address checking function differs from the one in i2c-core
in that it considers an address with a registered device, but no driver bound to it, as NOT busy. */
static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int
addr)
{
- return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
+ int result = 0;
+
+ result = i2cdev_check_clients(adapter, addr);
+
+ if (!result && (adapter->dev.parent->bus == &i2c_bus_type))
+ {
+ struct i2c_client dummy;
+ char buff;
+
+ dummy.adapter = to_i2c_adapter(adapter->dev.parent);
+ dummy.addr = addr;
+ dummy.flags = 0;
+
+ result = i2c_master_recv(&dummy, &buff, 1) == 1;
+ }
+
+ return result;
}

static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,

new file mode 100755
index 0000000..014d488
@@ -0,0 +1,167 @@
+/*
+ * Multiplexed I2C bus driver.
+ *
+ * Copyright (c) 2008-2009 Rodolfo Giometti <[email protected]>
+ * Copyright (c) 2008-2009 Eurotech S.p.A. <[email protected]>
+ *
+ * Simplifies access to complex multiplexed I2C bus topologies, by

presenting
+ * each multiplexed bus segment as a virtual I2C adapter. Supports multi-level
+ * mux'ing (mux behind a mux).
+ *
+ * Based on:

+ *    i2c-virt.c from Kumar Gala <[email protected]>
+ *    i2c-virtual.c from Copyright (c) 2004 Google, Inc. (Ken Harrenstien)
+ *    i2c-virtual.c from Brian Kuschak <bkuschak-/[email protected]>

+ * which was:
+ * Adapted from i2c-adap-ibm_ocp.c
+ * Original file Copyright 2000-2002 MontaVista Software Inc.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/i2c-id.h>
+
+struct i2c_mux_priv {
+ struct i2c_adapter adap;
+ struct i2c_algorithm algo;
+
+ struct i2c_adapter *parent_adap;
+ void *client; /* The mux chip/device */
+ u32 id; /* the mux id */
+
+ int (*select)(struct i2c_adapter *, void *, u32);
+ int (*deselect)(struct i2c_adapter *, void *, u32);
+};
+
+#define VIRT_TIMEOUT (HZ/2)
+#define VIRT_RETRIES 3
+
+static int i2c_mux_master_xfer(struct i2c_adapter *adap,
+ struct i2c_msg msgs[], int num)
+{
+ struct i2c_mux_priv *priv = adap->algo_data;
+ struct i2c_adapter *parent = priv->parent_adap;
+ int ret;
+
+ /* Select the right mux port and perform the transfer. */
+
+ ret = priv->select(parent, priv->client, priv->id);
+ if (ret >= 0)
+ ret = parent->algo->master_xfer(parent, msgs, num);
+ priv->deselect(parent, priv->client, priv->id);
+
+ return ret;
+}
+
+static int i2c_mux_smbus_xfer(struct i2c_adapter *adap,
+ u16 addr, unsigned short flags,
+ char read_write, u8 command,
+ int size, union i2c_smbus_data *data)
+{
+ struct i2c_mux_priv *priv = adap->algo_data;
+ struct i2c_adapter *parent = priv->parent_adap;
+ int ret;
+
+ /* Select the right mux port and perform the transfer. */
+
+ ret = priv->select(parent, priv->client, priv->id);
+ if (ret == 0)
+ ret = parent->algo->smbus_xfer(parent, addr, flags,
+ read_write, command, size, data);
+ priv->deselect(parent, priv->client, priv->id);
+
+ return ret;
+}
+
+/* Return the parent's functionality for the virtual adapter */ +static u32 i2c_mux_functionality(struct i2c_adapter *adap)
+{
+ struct i2c_mux_priv *priv = adap->algo_data;
+ struct i2c_adapter *parent = priv->parent_adap;
+
+ return parent->algo->functionality(parent);
+}
+
+struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
+ void *client, u32 force_nr, u32 mux_val,
+ int (*select_cb) (struct i2c_adapter *,
+ void *, u32),
+ int (*deselect_cb) (struct i2c_adapter *,
+ void *, u32))
+{
+ struct i2c_mux_priv *priv;
+ int ret;
+
+ priv = kzalloc(sizeof(struct i2c_mux_priv), GFP_KERNEL);
+ if (!priv)
+ return NULL;
+
+ /* Set up private adapter data */
+ priv->parent_adap = parent;
+ priv->client = client;
+ priv->id = mux_val;
+ priv->select = select_cb;
+ priv->deselect = deselect_cb;
+
+ /* Need to do algo dynamically because we don't know ahead
+ * of time what sort of physical adapter we'll be dealing with.
+ */
+ if (parent->algo->master_xfer)
+ priv->algo.master_xfer = i2c_mux_master_xfer;
+ if (parent->algo->smbus_xfer)
+ priv->algo.smbus_xfer = i2c_mux_smbus_xfer;
+ priv->algo.functionality = i2c_mux_functionality;
+
+ /* Now fill out new adapter structure */
+ snprintf(priv->adap.name, sizeof(priv->adap.name),
+ "i2c-%d-mux (mux %02x)",
+ i2c_adapter_id(parent), mux_val);
+ priv->adap.owner = THIS_MODULE;
+ priv->adap.id = i2c_adapter_id(parent);
+ priv->adap.algo = &priv->algo;
+ priv->adap.algo_data = priv;
+ priv->adap.timeout = VIRT_TIMEOUT;
+ priv->adap.retries = VIRT_RETRIES;
+ priv->adap.dev.parent = &parent->dev;
+
+ if (force_nr) {
+ priv->adap.nr = force_nr;
+ ret = i2c_add_numbered_adapter(&priv->adap);
+ } else {
+ ret = i2c_add_adapter(&priv->adap);
+ }
+ if (ret < 0) {
+ kfree(priv);
+ return NULL;
+ }
+
+ dev_info(&parent->dev, "i2c-mux-%d: Virtual I2C bus - "
+ "physical bus i2c-%d, client %02x, port %d\n",
+ i2c_adapter_id(&priv->adap), i2c_adapter_id(parent), ((struct
i2c_client*)priv->client)->addr, mux_val);
+
+ return &priv->adap;
+}
+EXPORT_SYMBOL_GPL(i2c_add_mux_adapter);
+
+int i2c_del_mux_adapter(struct i2c_adapter *adap)
+{
+ struct i2c_mux_priv *priv = adap->algo_data;
+ int ret;
+
+ ret = i2c_del_adapter(adap);
+ if (ret < 0)
+ return ret;
+ kfree(priv);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(i2c_del_mux_adapter);
+
+MODULE_AUTHOR("Rodolfo Giometti <[email protected]>"); +MODULE_DESCRIPTION("Virtual I2C driver for multiplexed I2C busses"); +MODULE_LICENSE("GPL v2");

new file mode 100755
index 0000000..95b9bde
@@ -0,0 +1,8 @@
+#
+# Multiplexer I2C chip drivers configuration
+#
+
+menu "Multiplexer I2C Chip support"
+	depends on I2C && I2C_MUX && EXPERIMENTAL
+
+endmenu

new file mode 100755
index 0000000..0416a52
@@ -0,0 +1,6 @@
+#
+# Makefile for multiplexer I2C chip drivers.
+
+ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
+EXTRA_CFLAGS += -DDEBUG -DI2C_DEBUG_CORE
+endif

index 7b40cda..24ff2e5 100755
@@ -580,6 +580,20 @@ union i2c_smbus_data {
 #define I2C_SMBUS_BLOCK_PROC_CALL   7		/* SMBus 2.0 */
 #define I2C_SMBUS_I2C_BLOCK_DATA    8
 
+/*
+ * Called to create a 'virtual' i2c bus which represents a multiplexed bus
+ * segment.  The client and mux_val are passed to the select and deselect
+ * callback functions to perform hardware-specific mux control.
+ */
+struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
+				void *client, u32 force_nr, u32 mux_val,
+				int (*select_cb) (struct i2c_adapter *,
+						void *, u32),
+				int (*deselect_cb) (struct i2c_adapter *,
+						void *, u32));
+
+int i2c_del_mux_adapter(struct i2c_adapter *adap);
+
 
 #ifdef __KERNEL__
 

1.6.1.2

Subject: [PATCH 2/2] i2c: driver for PCA954x I2C multiplexer series.

---
 drivers/i2c/muxes/Kconfig   |    9 ++
 drivers/i2c/muxes/Makefile  |    2 +
 drivers/i2c/muxes/pca954x.c |  325
+++++++++++++++++++++++++++++++++++++++++++
 include/linux/i2c/pca954x.h |   13 ++
 4 files changed, 349 insertions(+), 0 deletions(-)
 create mode 100755 drivers/i2c/muxes/pca954x.c
 create mode 100755 include/linux/i2c/pca954x.h

index 95b9bde..72c7055 100755
@@ -5,4 +5,13 @@
 menu "Multiplexer I2C Chip support"
 	depends on I2C && I2C_MUX && EXPERIMENTAL
 
+config I2CMUX_PCA954x
+	tristate "Philips PCA953x I2C Mux/switches"
+	help
+	  If you say yes here you get support for the Philips PCA954x
+	  I2C mux/switch devices.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called pca954x.
+
 endmenu

index 0416a52..2338d4c 100755
@@ -1,6 +1,8 @@
 #
 # Makefile for multiplexer I2C chip drivers.
 
+obj-$(CONFIG_I2CMUX_PCA954x)	+= pca954x.o
+
 ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG -DI2C_DEBUG_CORE
 endif

new file mode 100755
index 0000000..0440a69
@@ -0,0 +1,325 @@
+/*
+ * I2C multiplexer
+ *
+ * Copyright (c) 2008-2009 Rodolfo Giometti <[email protected]>
+ * Copyright (c) 2008-2009 Eurotech S.p.A. <[email protected]>
+ *
+ * This module supports the PCA954x series of I2C multiplexer/switch chips
+ * made by Philips Semiconductors.
+ * This includes the:
+ *     PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547
+ *     and PCA9548.
+ *
+ * These chips are all controlled via the I2C bus itself, and all have a
+ * single 8-bit register (normally at 0x70).  The upstream "parent" bus

fans
+ * out to two, four, or eight downstream busses or channels; which of these
+ * are selected is determined by the chip type and register contents. A
+ * mux can select only one sub-bus at a time; a switch can select any
+ * combination simultaneously.
+ *
+ * Based on:
+ * pca954x.c from Kumar Gala <[email protected]>
+ * Copyright (C) 2006
+ *
+ * Based on:
+ * pca954x.c from Ken Harrenstien
+ * Copyright (C) 2004 Google, Inc. (Ken Harrenstien)
+ *
+ * Based on:
+ * i2c-virtual_cb.c from Brian Kuschak <bkuschak-/[email protected]>
+ * and

+ *    pca9540.c from Jean Delvare <[email protected]>, which was
+ *    based on pcf8574.c from the same project by Frodo Looijaard,
+ *    Philip Edelbrock, Dan Eaton and Aurelien Jarno.

+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+
+#include <linux/i2c/pca954x.h>
+
+#define PCA954X_MAX_NCHANS 8
+
+enum pca_type {
+ pca_9540,
+ pca_9542,
+ pca_9543,
+ pca_9544,
+ pca_9545,
+ pca_9546,
+ pca_9547,
+ pca_9548,
+};
+
+struct pca954x {
+ struct i2c_client *client;
+ struct i2c_client dev;
+ unsigned int type;
+ struct i2c_adapter *virt_adaps[PCA954X_MAX_NCHANS];
+
+ u8 last_chan;
+ unsigned int deselect_on_exit:1;
+ int (*is_chan_connected)(struct i2c_adapter *adap,
+ struct i2c_client *client, u32 chan);
+};
+
+struct chip_desc {
+ u8 nchans;
+ u8 enable; /* used for muxes only */
+ enum muxtype {
+ pca954x_ismux = 0,
+ pca954x_isswi
+ } muxtype;
+};
+
+/* Provide specs for the PCA954x types we know about */ +static struct chip_desc chips[] = {
+ [pca_9540] = {
+ .nchans = 2,
+ .enable = 0x4,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9542] = {
+ .nchans = 2,
+ .enable = 0x4,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9543] = {
+ .nchans = 2,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+ [pca_9544] = {
+ .nchans = 4,
+ .enable = 0x4,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9545] = {
+ .nchans = 4,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+ [pca_9546] = {
+ .nchans = 4,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+ [pca_9547] = {
+ .nchans = 8,
+ .enable = 0x8,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9548] = {
+ .nchans = 8,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+};
+
+static const struct i2c_device_id pca954x_id[] = {
+ { "pca9540", pca_9540 },
+ { "pca9542", pca_9542 },
+ { "pca9543", pca_9543 },
+ { "pca9544", pca_9544 },
+ { "pca9545", pca_9545 },
+ { "pca9546", pca_9546 },
+ { "pca9547", pca_9547 },
+ { "pca9548", pca_9548 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, pca954x_id);
+
+static int pca954x_xfer(struct i2c_adapter *adap,
+ struct i2c_client *client, int read_write, u8 *val)
+{
+ int ret = -ENODEV;
+
+ if (adap->algo->master_xfer) {
+ struct i2c_msg msg;
+ char buf[1];
+
+ msg.addr = client->addr;
+ msg.flags = (read_write == I2C_SMBUS_READ ? I2C_M_RD : 0);
+ msg.len = 1;
+ buf[0] = *val;
+ msg.buf = buf;
+ ret = adap->algo->master_xfer(adap, &msg, 1);
+ } else if (adap->algo->smbus_xfer) {
+ union i2c_smbus_data data;
+ ret = adap->algo->smbus_xfer(adap, client->addr,
+ client->flags & I2C_M_TEN,
+ read_write,
+ *val, I2C_SMBUS_BYTE, &data);
+ }
+
+ return ret;
+}
+
+static int pca954x_select_chan(struct i2c_adapter *adap,
+ void *client, u32 chan)
+{
+ struct pca954x *data = i2c_get_clientdata((struct i2c_client *) client);
+ struct chip_desc *chip = &chips[data->type];
+ u8 regval = 0;
+ int ret = 0;
+
+ /* Callback to check for bus connection */
+ if (data->is_chan_connected) {
+ ret = data->is_chan_connected(adap, client, chan);
+ if (!ret)
+ return -EBUSY;
+ }
+
+ /* we make switches look like muxes, not sure how to be smarter */
+ if (chip->muxtype == pca954x_ismux)
+ regval = chan | chip->enable;
+ else
+ regval = 1 << chan;
+
+ /* Only select the channel if its different from the last channel */
+ if (data->last_chan != chan) {
+ ret = pca954x_xfer(adap, client, I2C_SMBUS_WRITE, &regval);
+ data->last_chan = chan;
+ }
+
+ return ret;
+}
+
+static int pca954x_deselect_mux(struct i2c_adapter *adap,
+ void *client, u32 chan)
+{
+ struct pca954x *data = i2c_get_clientdata((struct i2c_client *) client);
+ struct chip_desc *chip = &chips[data->type];
+ u8 regval = 0;
+
+ /* Check if we have to stay on the last channel we selected */
+ if (!data->deselect_on_exit && (chip->muxtype == pca954x_ismux))
+ return 0;
+
+ /* Signal we are deselecting active channel */
+ data->last_chan = -1;
+
+ regval = chan | ~chip->enable;
+ return pca954x_xfer(adap, client, I2C_SMBUS_WRITE, &regval);
+}
+
+/*
+ * I2C init/probing/exit functions
+ */
+static int pca954x_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent);
+ struct pca954x_platform_data *pdata = client->dev.platform_data;
+ int i, n, f;
+ struct pca954x *data;
+ int ret = -ENODEV;
+
+ if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE))
+ goto err;
+
+ data = kzalloc(sizeof(struct pca954x), GFP_KERNEL);
+ if (!data) {
+ ret = -ENOMEM;
+ goto err;
+ }
+
+ i2c_set_clientdata(client, data);
+
+ /* Read the mux register at addr. This does two things: it verifies
+ * that the mux is in fact present, and fetches its current
+ * contents for possible use with a future deselect algorithm.
+ */
+ i = i2c_smbus_read_byte(client);
+ if (i < 0) {
+ dev_warn(&client->dev, "probe failed\n");
+ goto exit_free;
+ }
+
+ data->type = id->driver_data;
+ data->last_chan = -1; /* force the first selection */
+
+ /* Now create virtual busses and adapters for them */
+ for (i = 0; i < chips[data->type].nchans; i++) {
+ f = 0; /* dynamic adap number */
+ if (pdata && (i < pdata->num_modes))
+ f = pdata->modes[i].adap_id; /* force static number */
+
+ data->virt_adaps[i] = i2c_add_mux_adapter(adap, client, f, i,
+ &pca954x_select_chan,
+ &pca954x_deselect_mux);
+ if (data->virt_adaps[i] == NULL) {
+ ret = -ENODEV;
+ goto virt_reg_failed;
+ }
+
+ data->deselect_on_exit = pdata ?
+ pdata->modes[i].deselect_on_exit : 1;
+ data->is_chan_connected = pdata ?
+ pdata->modes[i].is_chan_connected : NULL;
+ }
+
+ dev_info(&client->dev, "registered %d virtual busses for I2C %s %s\n",
+ i, chips[data->type].muxtype == pca954x_ismux ?
+ "mux" : "switch", client->name);
+
+ return 0;
+
+virt_reg_failed:
+ for (n = 0; n < i; n++)
+ i2c_del_mux_adapter(data->virt_adaps[n]);
+exit_free:
+ kfree(data);
+err:
+ return ret;
+}
+
+static int __devexit pca954x_remove(struct i2c_client *client) +{
+ struct pca954x *data = i2c_get_clientdata(client);
+ struct chip_desc *chip = &chips[data->type];
+ int i, err;
+
+ for (i = 0; i < chip->nchans; ++i)
+ if (data->virt_adaps[i]) {
+ err = i2c_del_mux_adapter(data->virt_adaps[i]);
+ if (err)
+ return err;
+ data->virt_adaps[i] = NULL;
+ }
+
+ kfree(data);
+ return 0;
+}
+
+static struct i2c_driver pca954x_driver = {
+ .driver = {
+ .name = "pca954x",
+ .owner = THIS_MODULE,
+ },
+ .probe = pca954x_probe,
+ .remove = __devexit_p(pca954x_remove),
+ .id_table = pca954x_id,
+};
+
+static int __init pca954x_init(void)
+{
+ return i2c_add_driver(&pca954x_driver);
+}
+
+static void __exit pca954x_exit(void)
+{
+ i2c_del_driver(&pca954x_driver);
+}
+
+module_init(pca954x_init);
+module_exit(pca954x_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <[email protected]>"); +MODULE_DESCRIPTION("PCA954x I2C mux/switch driver"); +MODULE_LICENSE("GPL v2");

new file mode 100755
index 0000000..18d5e79
@@ -0,0 +1,13 @@
+/* Platform data for the PCA954x I2C multiplexers */
+
+struct pca954x_platform_mode {
+	int		adap_id;
+	unsigned int	deselect_on_exit:1;
+	int		(*is_chan_connected)(struct i2c_adapter *adap,
+					struct i2c_client *client, u32 chan);
+};
+
+struct pca954x_platform_data {
+	struct pca954x_platform_mode *modes;
+	int num_modes;
+};

1.6.1.2

ignore this noise please

Sometimes you check and check and... and then sh*# happens.

Subject: [PATCH 2/2] i2c: driver for PCA954x I2C multiplexer series.

---
 drivers/i2c/muxes/Kconfig   |    9 ++
 drivers/i2c/muxes/Makefile  |    2 +
 drivers/i2c/muxes/pca954x.c |  325
+++++++++++++++++++++++++++++++++++++++++++
 include/linux/i2c/pca954x.h |   13 ++
 4 files changed, 349 insertions(+), 0 deletions(-)
 create mode 100755 drivers/i2c/muxes/pca954x.c
 create mode 100755 include/linux/i2c/pca954x.h

index 95b9bde..72c7055 100755
@@ -5,4 +5,13 @@
 menu "Multiplexer I2C Chip support"
 	depends on I2C && I2C_MUX && EXPERIMENTAL
 
+config I2CMUX_PCA954x
+	tristate "Philips PCA953x I2C Mux/switches"
+	help
+	  If you say yes here you get support for the Philips PCA954x
+	  I2C mux/switch devices.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called pca954x.
+
 endmenu

index 0416a52..2338d4c 100755
@@ -1,6 +1,8 @@
 #
 # Makefile for multiplexer I2C chip drivers.
 
+obj-$(CONFIG_I2CMUX_PCA954x)	+= pca954x.o
+
 ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG -DI2C_DEBUG_CORE
 endif

new file mode 100755
index 0000000..0440a69
@@ -0,0 +1,325 @@
+/*
+ * I2C multiplexer
+ *
+ * Copyright (c) 2008-2009 Rodolfo Giometti <[email protected]>
+ * Copyright (c) 2008-2009 Eurotech S.p.A. <[email protected]>
+ *
+ * This module supports the PCA954x series of I2C multiplexer/switch chips
+ * made by Philips Semiconductors.
+ * This includes the:
+ *     PCA9540, PCA9542, PCA9543, PCA9544, PCA9545, PCA9546, PCA9547
+ *     and PCA9548.
+ *
+ * These chips are all controlled via the I2C bus itself, and all have a
+ * single 8-bit register (normally at 0x70).  The upstream "parent" bus

fans
+ * out to two, four, or eight downstream busses or channels; which of these
+ * are selected is determined by the chip type and register contents. A
+ * mux can select only one sub-bus at a time; a switch can select any
+ * combination simultaneously.
+ *
+ * Based on:
+ * pca954x.c from Kumar Gala <[email protected]>
+ * Copyright (C) 2006
+ *
+ * Based on:
+ * pca954x.c from Ken Harrenstien
+ * Copyright (C) 2004 Google, Inc. (Ken Harrenstien)
+ *
+ * Based on:
+ * i2c-virtual_cb.c from Brian Kuschak <bkuschak-/[email protected]>
+ * and

+ *    pca9540.c from Jean Delvare <[email protected]>, which was
+ *    based on pcf8574.c from the same project by Frodo Looijaard,
+ *    Philip Edelbrock, Dan Eaton and Aurelien Jarno.

+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+
+#include <linux/i2c/pca954x.h>
+
+#define PCA954X_MAX_NCHANS 8
+
+enum pca_type {
+ pca_9540,
+ pca_9542,
+ pca_9543,
+ pca_9544,
+ pca_9545,
+ pca_9546,
+ pca_9547,
+ pca_9548,
+};
+
+struct pca954x {
+ struct i2c_client *client;
+ struct i2c_client dev;
+ unsigned int type;
+ struct i2c_adapter *virt_adaps[PCA954X_MAX_NCHANS];
+
+ u8 last_chan;
+ unsigned int deselect_on_exit:1;
+ int (*is_chan_connected)(struct i2c_adapter *adap,
+ struct i2c_client *client, u32 chan);
+};
+
+struct chip_desc {
+ u8 nchans;
+ u8 enable; /* used for muxes only */
+ enum muxtype {
+ pca954x_ismux = 0,
+ pca954x_isswi
+ } muxtype;
+};
+
+/* Provide specs for the PCA954x types we know about */ +static struct chip_desc chips[] = {
+ [pca_9540] = {
+ .nchans = 2,
+ .enable = 0x4,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9542] = {
+ .nchans = 2,
+ .enable = 0x4,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9543] = {
+ .nchans = 2,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+ [pca_9544] = {
+ .nchans = 4,
+ .enable = 0x4,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9545] = {
+ .nchans = 4,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+ [pca_9546] = {
+ .nchans = 4,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+ [pca_9547] = {
+ .nchans = 8,
+ .enable = 0x8,
+ .muxtype = pca954x_ismux,
+ },
+ [pca_9548] = {
+ .nchans = 8,
+ .enable = 0x0,
+ .muxtype = pca954x_isswi,
+ },
+};
+
+static const struct i2c_device_id pca954x_id[] = {
+ { "pca9540", pca_9540 },
+ { "pca9542", pca_9542 },
+ { "pca9543", pca_9543 },
+ { "pca9544", pca_9544 },
+ { "pca9545", pca_9545 },
+ { "pca9546", pca_9546 },
+ { "pca9547", pca_9547 },
+ { "pca9548", pca_9548 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, pca954x_id);
+
+static int pca954x_xfer(struct i2c_adapter *adap,
+ struct i2c_client *client, int read_write, u8 *val)
+{
+ int ret = -ENODEV;
+
+ if (adap->algo->master_xfer) {
+ struct i2c_msg msg;
+ char buf[1];
+
+ msg.addr = client->addr;
+ msg.flags = (read_write == I2C_SMBUS_READ ? I2C_M_RD : 0);
+ msg.len = 1;
+ buf[0] = *val;
+ msg.buf = buf;
+ ret = adap->algo->master_xfer(adap, &msg, 1);
+ } else if (adap->algo->smbus_xfer) {
+ union i2c_smbus_data data;
+ ret = adap->algo->smbus_xfer(adap, client->addr,
+ client->flags & I2C_M_TEN,
+ read_write,
+ *val, I2C_SMBUS_BYTE, &data);
+ }
+
+ return ret;
+}
+
+static int pca954x_select_chan(struct i2c_adapter *adap,
+ void *client, u32 chan)
+{
+ struct pca954x *data = i2c_get_clientdata((struct i2c_client *) client);
+ struct chip_desc *chip = &chips[data->type];
+ u8 regval = 0;
+ int ret = 0;
+
+ /* Callback to check for bus connection */
+ if (data->is_chan_connected) {
+ ret = data->is_chan_connected(adap, client, chan);
+ if (!ret)
+ return -EBUSY;
+ }
+
+ /* we make switches look like muxes, not sure how to be smarter */
+ if (chip->muxtype == pca954x_ismux)
+ regval = chan | chip->enable;
+ else
+ regval = 1 << chan;
+
+ /* Only select the channel if its different from the last channel */
+ if (data->last_chan != chan) {
+ ret = pca954x_xfer(adap, client, I2C_SMBUS_WRITE, &regval);
+ data->last_chan = chan;
+ }
+
+ return ret;
+}
+
+static int pca954x_deselect_mux(struct i2c_adapter *adap,
+ void *client, u32 chan)
+{
+ struct pca954x *data = i2c_get_clientdata((struct i2c_client *) client);
+ struct chip_desc *chip = &chips[data->type];
+ u8 regval = 0;
+
+ /* Check if we have to stay on the last channel we selected */
+ if (!data->deselect_on_exit && (chip->muxtype == pca954x_ismux))
+ return 0;
+
+ /* Signal we are deselecting active channel */
+ data->last_chan = -1;
+
+ regval = chan | ~chip->enable;
+ return pca954x_xfer(adap, client, I2C_SMBUS_WRITE, &regval);
+}
+
+/*
+ * I2C init/probing/exit functions
+ */
+static int pca954x_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct i2c_adapter *adap = to_i2c_adapter(client->dev.parent);
+ struct pca954x_platform_data *pdata = client->dev.platform_data;
+ int i, n, f;
+ struct pca954x *data;
+ int ret = -ENODEV;
+
+ if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE))
+ goto err;
+
+ data = kzalloc(sizeof(struct pca954x), GFP_KERNEL);
+ if (!data) {
+ ret = -ENOMEM;
+ goto err;
+ }
+
+ i2c_set_clientdata(client, data);
+
+ /* Read the mux register at addr. This does two things: it verifies
+ * that the mux is in fact present, and fetches its current
+ * contents for possible use with a future deselect algorithm.
+ */
+ i = i2c_smbus_read_byte(client);
+ if (i < 0) {
+ dev_warn(&client->dev, "probe failed\n");
+ goto exit_free;
+ }
+
+ data->type = id->driver_data;
+ data->last_chan = -1; /* force the first selection */
+
+ /* Now create virtual busses and adapters for them */
+ for (i = 0; i < chips[data->type].nchans; i++) {
+ f = 0; /* dynamic adap number */
+ if (pdata && (i < pdata->num_modes))
+ f = pdata->modes[i].adap_id; /* force static number */
+
+ data->virt_adaps[i] = i2c_add_mux_adapter(adap, client, f, i,
+ &pca954x_select_chan,
+ &pca954x_deselect_mux);
+ if (data->virt_adaps[i] == NULL) {
+ ret = -ENODEV;
+ goto virt_reg_failed;
+ }
+
+ data->deselect_on_exit = pdata ?
+ pdata->modes[i].deselect_on_exit : 1;
+ data->is_chan_connected = pdata ?
+ pdata->modes[i].is_chan_connected : NULL;
+ }
+
+ dev_info(&client->dev, "registered %d virtual busses for I2C %s %s\n",
+ i, chips[data->type].muxtype == pca954x_ismux ?
+ "mux" : "switch", client->name);
+
+ return 0;
+
+virt_reg_failed:
+ for (n = 0; n < i; n++)
+ i2c_del_mux_adapter(data->virt_adaps[n]);
+exit_free:
+ kfree(data);
+err:
+ return ret;
+}
+
+static int __devexit pca954x_remove(struct i2c_client *client) +{
+ struct pca954x *data = i2c_get_clientdata(client);
+ struct chip_desc *chip = &chips[data->type];
+ int i, err;
+
+ for (i = 0; i < chip->nchans; ++i)
+ if (data->virt_adaps[i]) {
+ err = i2c_del_mux_adapter(data->virt_adaps[i]);
+ if (err)
+ return err;
+ data->virt_adaps[i] = NULL;
+ }
+
+ kfree(data);
+ return 0;
+}
+
+static struct i2c_driver pca954x_driver = {
+ .driver = {
+ .name = "pca954x",
+ .owner = THIS_MODULE,
+ },
+ .probe = pca954x_probe,
+ .remove = __devexit_p(pca954x_remove),
+ .id_table = pca954x_id,
+};
+
+static int __init pca954x_init(void)
+{
+ return i2c_add_driver(&pca954x_driver);
+}
+
+static void __exit pca954x_exit(void)
+{
+ i2c_del_driver(&pca954x_driver);
+}
+
+module_init(pca954x_init);
+module_exit(pca954x_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <[email protected]>"); +MODULE_DESCRIPTION("PCA954x I2C mux/switch driver"); +MODULE_LICENSE("GPL v2");

new file mode 100755
index 0000000..18d5e79
@@ -0,0 +1,13 @@
+/* Platform data for the PCA954x I2C multiplexers */
+
+struct pca954x_platform_mode {
+	int		adap_id;
+	unsigned int	deselect_on_exit:1;
+	int		(*is_chan_connected)(struct i2c_adapter *adap,
+					struct i2c_client *client, u32 chan);
+};
+
+struct pca954x_platform_data {
+	struct pca954x_platform_mode *modes;
+	int num_modes;
+};

-- 1.6.1.2 -- To unsubscribe from this list: send the line "unsubscribe linux-i2c" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html

Hi Michael,

Review:

Jean Delvare

Hi Michael,

I've done this, and the tests results so far look good. If you can submit updated patches addressing my concerns, they should be ready to go in kernel 2.6.35. Further improvements and fixes can happen later.

Thanks,

Jean Delvare

Michael Lawnick said the following:

Ping.

(I dream to see it in .34)

KR
Michael

Hi Michael,

This isn't going to happen, sorry. The new i2c feature in 2.6.34 will be SMBus alert support, which had been waiting for about 2 years. Multiplexing support will have to wait for the next merge window. Right now I am working on flushing my patch queues as much as I can. Even if I had the time to look into your patches this week (and honestly it doesn't seem realistic) it would be too late to make it into this merge window. Your patches will need some testing which can't realistically be achieved in a couple days.

I understand that you are getting impatient and I would be as well if I were you, but I'm doing the best I can with the limited time I have.

Jean Delvare

Jean Delvare said the following:

I just had a dream ...

KR
Michael

Hi Michael,

Sorry for the long delay. Here finally comes a review of your code.

Your e-mail client wraps long lines, this caused your patch to not apply. I had to edit it manually before I was able to apply it. Please fix your setup so that I don't have to do it again next time.

Please also make sure to run your patch through scripts/checkpatch.pl. I found many trailing whitespace, and even after removing them, the script still finds 9 style errors which should be fixed.

I would prefer the term "separate I2C adapter" rather than "virtual I2C adapter". There's nothing virtual about these bus segments. i2c-stub is a virtual I2C adapter.

"from Copyright" looks bad.

There's probably no point in going that far in history. I doubt i2c-adap-ibm_ocp.c was a bus multiplexer driver.

This is wrong and will crash for non-I2C mux chips. You just can't assume that it is safe to cast priv->client to an i2c_client.

Jean Delvare

One thing I forgot:

As discussed some weeks ago, this isn't actually sufficient. You don't only need to check the parent segments for address business, you also need to check all child segments, recursively. If any child segment has a device using the address in question, then you can't use it.

This may be more difficult to implement. In particular, you'll have to pay attention to locking.

Jean Delvare

Jean Delvare said the following:

:-) This can't happen if we keep the part you commented on in the other mail about probing for client one level above. Then this situation can't arise.

KR
Michael

I don't understand. In your code, the probe is done at the parent level, where address business had already been tested. What is needed is child segments checking, so the other side of the tree. I just can't see how your code would help with that.

Can you please explain why the probe is needed, and what it is doing that the standard address business check didn't cover already?

Jean Delvare

Jean Delvare said the following:

Well, these are my thoughts:

The generic situation is

--- MUXn-1 --- MUXn -+- MUXn+1 ---

                     |
                client/device

A device gets physically visible on all buses beyond the one it is connected to.

Given the bus tree we can decide whether a device is really present on a particular bus if we
- H/W probe it on selected level. If does not respond, the current bus is wrong.
- H/W probe it one level higher. If it responds, the current bus is wrong. The first probing is already done in standard initialization sequence. I added the second probing. By recursively calling __i2c_check_addr() it is possible to reduce H/W-probing to ambiguous cases.

The current implementation implies that mux'es are reset to 'neutral' after every bus transaction. If this would not be the case, switching of MUXn+1 to neutral needed to be added.

KR
Michael

Hi Michael,

True.

Please note that we don't have to do this. Other code, in the kernel or in user-space, is responsible for telling us where the devices are, and we should trust them. Auto-detected devices is a purely optional extension, the usage of which is discouraged as much as possible. My opinion is that I2C device auto-detection should be simply prohibited on multiplexes I2C buses (that is, such i2c_adapters would have their class set to 0). I even would like to enforce this, by either preventing the instantiation of a mux device on an i2c_adapter with a non-0 class, or by resetting the class to 0, with a big warning in the kernel logs, as soon as a mux device is instantiated.

As a matter of fact, your own code sets the adapter class to 0 for all "virtual adapters" (which I call branches.)

Or the device simply doesn't respond to the message format you used. There is no universal probe transaction for I2C devices.

And if it doesn't respond, you can't conclude.

I'm not sure I really understand what you mean there, so please let me repeat here: by default, no probing is done at the hardware level when an I2C device (i2c_client) is instantiated. i2c_register_board_info() and i2c_new_device() do not issue any transaction on the bus. Only i2c_new_probed() device and i2c_driver's .detect() callbacks do, and using these isn't recommended. The former is fine-grained enough that it should work in combination with muxes, but the latter isn't.

We don't want to do hardware probing at all to determine address business. Look at the i2c-core code as it exists today: address business is a solely software issue as far as i2c-core is concerned; I see no good reason to change that just because we add support for multiplexing.

So, in order to determine whether an address is busy, we have to check all parent bus segments (which you already do) and all child bus segments (recursively.) Please change your patch to do this.

As I said in my review, I don't think we want to switch all muxes back to neutral after every transaction, because it is very costly for I2C-based muxes (and your pca954x driver even offers a way to bypass the reset.) There is also the problem of the initial state of the mux chip, before we load its driver: we have no reason to believe it is in neutral state. On top of that, not all muxes _can_ be switched to neutral. Think of simple muxes controlled by a single GPIO, these have always exactly one child branch selected.

Add to this that I don't know of any mux chip which can be auto-detected. You will always have to explicitly instantiate the mux device, so you might as well explicitly instantiate all other devices on that bus. We might extend i2c_new_device() to create multiple devices at once (like i2c_register_board_info does) for this purpose.

I hope this clarified my point.

Jean Delvare

Jean Delvare said the following:

I think you were clear, given the unhappiness I feel :-(

I'll be back...

Kind Regards,
Michael

Jean Delvare said the following:

Thank you!

[Very much comments snipped]
It will take a while to process that, so reply to certain points and V2
might last some day^wwee^w time.

KR
Michael

Given how long it took me to review the code, I can't blame you for that ;)

Jean Delvare