]> git.openfabrics.org - ~shefty/rdma-dev.git/commitdiff
i2c/mux: Driver for PCA9541 I2C Master Selector
authorGuenter Roeck <guenter.roeck@ericsson.com>
Sun, 24 Oct 2010 16:16:58 +0000 (18:16 +0200)
committerJean Delvare <khali@endymion.delvare>
Sun, 24 Oct 2010 16:16:58 +0000 (18:16 +0200)
This patch adds support for PCA9541, an I2C Bus Master Selector.
The driver is modeled as single channel I2C Multiplexer to be able to utilize
the I2C multiplexer framework.

Signed-off-by: Guenter Roeck <guenter.roeck@ericsson.com>
Reviewed-by: Tom Grennan <tom.grennan@ericsson.com>
Acked-by: Jean Delvare <khali@linux-fr.org>
drivers/i2c/muxes/Kconfig
drivers/i2c/muxes/Makefile
drivers/i2c/muxes/pca9541.c [new file with mode: 0644]

index 4c9a99c4fcb0c364822e2d6163c3e81a9ad3040f..4d91d80bfd23276804d8cb29ae5d1f130e06842a 100644 (file)
@@ -5,6 +5,16 @@
 menu "Multiplexer I2C Chip support"
        depends on I2C_MUX
 
+config I2C_MUX_PCA9541
+       tristate "NXP PCA9541 I2C Master Selector"
+       depends on EXPERIMENTAL
+       help
+         If you say yes here you get support for the NXP PCA9541
+         I2C Master Selector.
+
+         This driver can also be built as a module.  If so, the module
+         will be called pca9541.
+
 config I2C_MUX_PCA954x
        tristate "Philips PCA954x I2C Mux/switches"
        depends on EXPERIMENTAL
index 6f497862bdc55a2b15252b514604b305e46e1604..d743806d9b42875dfb8832da002d31a5ec9ec6f4 100644 (file)
@@ -1,6 +1,7 @@
 #
 # Makefile for multiplexer I2C chip drivers.
 
+obj-$(CONFIG_I2C_MUX_PCA9541)  += pca9541.o
 obj-$(CONFIG_I2C_MUX_PCA954x)  += pca954x.o
 
 ccflags-$(CONFIG_I2C_DEBUG_BUS) := -DDEBUG
diff --git a/drivers/i2c/muxes/pca9541.c b/drivers/i2c/muxes/pca9541.c
new file mode 100644 (file)
index 0000000..ed699c5
--- /dev/null
@@ -0,0 +1,411 @@
+/*
+ * I2C multiplexer driver for PCA9541 bus master selector
+ *
+ * Copyright (c) 2010 Ericsson AB.
+ *
+ * Author: Guenter Roeck <guenter.roeck@ericsson.com>
+ *
+ * Derived from:
+ *  pca954x.c
+ *
+ *  Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it>
+ *  Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it>
+ *
+ * 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/init.h>
+#include <linux/jiffies.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/i2c-mux.h>
+
+#include <linux/i2c/pca954x.h>
+
+/*
+ * The PCA9541 is a bus master selector. It supports two I2C masters connected
+ * to a single slave bus.
+ *
+ * Before each bus transaction, a master has to acquire bus ownership. After the
+ * transaction is complete, bus ownership has to be released. This fits well
+ * into the I2C multiplexer framework, which provides select and release
+ * functions for this purpose. For this reason, this driver is modeled as
+ * single-channel I2C bus multiplexer.
+ *
+ * This driver assumes that the two bus masters are controlled by two different
+ * hosts. If a single host controls both masters, platform code has to ensure
+ * that only one of the masters is instantiated at any given time.
+ */
+
+#define PCA9541_CONTROL                0x01
+#define PCA9541_ISTAT          0x02
+
+#define PCA9541_CTL_MYBUS      (1 << 0)
+#define PCA9541_CTL_NMYBUS     (1 << 1)
+#define PCA9541_CTL_BUSON      (1 << 2)
+#define PCA9541_CTL_NBUSON     (1 << 3)
+#define PCA9541_CTL_BUSINIT    (1 << 4)
+#define PCA9541_CTL_TESTON     (1 << 6)
+#define PCA9541_CTL_NTESTON    (1 << 7)
+
+#define PCA9541_ISTAT_INTIN    (1 << 0)
+#define PCA9541_ISTAT_BUSINIT  (1 << 1)
+#define PCA9541_ISTAT_BUSOK    (1 << 2)
+#define PCA9541_ISTAT_BUSLOST  (1 << 3)
+#define PCA9541_ISTAT_MYTEST   (1 << 6)
+#define PCA9541_ISTAT_NMYTEST  (1 << 7)
+
+#define BUSON          (PCA9541_CTL_BUSON | PCA9541_CTL_NBUSON)
+#define MYBUS          (PCA9541_CTL_MYBUS | PCA9541_CTL_NMYBUS)
+#define mybus(x)       (!((x) & MYBUS) || ((x) & MYBUS) == MYBUS)
+#define busoff(x)      (!((x) & BUSON) || ((x) & BUSON) == BUSON)
+
+/* arbitration timeouts, in jiffies */
+#define ARB_TIMEOUT    (HZ / 8)        /* 125 ms until forcing bus ownership */
+#define ARB2_TIMEOUT   (HZ / 4)        /* 250 ms until acquisition failure */
+
+/* arbitration retry delays, in us */
+#define SELECT_DELAY_SHORT     50
+#define SELECT_DELAY_LONG      1000
+
+struct pca9541 {
+       struct i2c_adapter *mux_adap;
+       unsigned long select_timeout;
+       unsigned long arb_timeout;
+};
+
+static const struct i2c_device_id pca9541_id[] = {
+       {"pca9541", 0},
+       {}
+};
+
+MODULE_DEVICE_TABLE(i2c, pca9541_id);
+
+/*
+ * Write to chip register. Don't use i2c_transfer()/i2c_smbus_xfer()
+ * as they will try to lock the adapter a second time.
+ */
+static int pca9541_reg_write(struct i2c_client *client, u8 command, u8 val)
+{
+       struct i2c_adapter *adap = client->adapter;
+       int ret;
+
+       if (adap->algo->master_xfer) {
+               struct i2c_msg msg;
+               char buf[2];
+
+               msg.addr = client->addr;
+               msg.flags = 0;
+               msg.len = 2;
+               buf[0] = command;
+               buf[1] = val;
+               msg.buf = buf;
+               ret = adap->algo->master_xfer(adap, &msg, 1);
+       } else {
+               union i2c_smbus_data data;
+
+               data.byte = val;
+               ret = adap->algo->smbus_xfer(adap, client->addr,
+                                            client->flags,
+                                            I2C_SMBUS_WRITE,
+                                            command,
+                                            I2C_SMBUS_BYTE_DATA, &data);
+       }
+
+       return ret;
+}
+
+/*
+ * Read from chip register. Don't use i2c_transfer()/i2c_smbus_xfer()
+ * as they will try to lock adapter a second time.
+ */
+static int pca9541_reg_read(struct i2c_client *client, u8 command)
+{
+       struct i2c_adapter *adap = client->adapter;
+       int ret;
+       u8 val;
+
+       if (adap->algo->master_xfer) {
+               struct i2c_msg msg[2] = {
+                       {
+                               .addr = client->addr,
+                               .flags = 0,
+                               .len = 1,
+                               .buf = &command
+                       },
+                       {
+                               .addr = client->addr,
+                               .flags = I2C_M_RD,
+                               .len = 1,
+                               .buf = &val
+                       }
+               };
+               ret = adap->algo->master_xfer(adap, msg, 2);
+               if (ret == 2)
+                       ret = val;
+               else if (ret >= 0)
+                       ret = -EIO;
+       } else {
+               union i2c_smbus_data data;
+
+               ret = adap->algo->smbus_xfer(adap, client->addr,
+                                            client->flags,
+                                            I2C_SMBUS_READ,
+                                            command,
+                                            I2C_SMBUS_BYTE_DATA, &data);
+               if (!ret)
+                       ret = data.byte;
+       }
+       return ret;
+}
+
+/*
+ * Arbitration management functions
+ */
+
+/* Release bus. Also reset NTESTON and BUSINIT if it was set. */
+static void pca9541_release_bus(struct i2c_client *client)
+{
+       int reg;
+
+       reg = pca9541_reg_read(client, PCA9541_CONTROL);
+       if (reg >= 0 && !busoff(reg) && mybus(reg))
+               pca9541_reg_write(client, PCA9541_CONTROL,
+                                 (reg & PCA9541_CTL_NBUSON) >> 1);
+}
+
+/*
+ * Arbitration is defined as a two-step process. A bus master can only activate
+ * the slave bus if it owns it; otherwise it has to request ownership first.
+ * This multi-step process ensures that access contention is resolved
+ * gracefully.
+ *
+ * Bus Ownership       Other master    Action
+ * state               requested access
+ * ----------------------------------------------------
+ * off -               yes             wait for arbitration timeout or
+ *                                     for other master to drop request
+ * off no              no              take ownership
+ * off yes             no              turn on bus
+ * on  yes             -               done
+ * on  no              -               wait for arbitration timeout or
+ *                                     for other master to release bus
+ *
+ * The main contention point occurs if the slave bus is off and both masters
+ * request ownership at the same time. In this case, one master will turn on
+ * the slave bus, believing that it owns it. The other master will request
+ * bus ownership. Result is that the bus is turned on, and master which did
+ * _not_ own the slave bus before ends up owning it.
+ */
+
+/* Control commands per PCA9541 datasheet */
+static const u8 pca9541_control[16] = {
+       4, 0, 1, 5, 4, 4, 5, 5, 0, 0, 1, 1, 0, 4, 5, 1
+};
+
+/*
+ * Channel arbitration
+ *
+ * Return values:
+ *  <0: error
+ *  0 : bus not acquired
+ *  1 : bus acquired
+ */
+static int pca9541_arbitrate(struct i2c_client *client)
+{
+       struct pca9541 *data = i2c_get_clientdata(client);
+       int reg;
+
+       reg = pca9541_reg_read(client, PCA9541_CONTROL);
+       if (reg < 0)
+               return reg;
+
+       if (busoff(reg)) {
+               int istat;
+               /*
+                * Bus is off. Request ownership or turn it on unless
+                * other master requested ownership.
+                */
+               istat = pca9541_reg_read(client, PCA9541_ISTAT);
+               if (!(istat & PCA9541_ISTAT_NMYTEST)
+                   || time_is_before_eq_jiffies(data->arb_timeout)) {
+                       /*
+                        * Other master did not request ownership,
+                        * or arbitration timeout expired. Take the bus.
+                        */
+                       pca9541_reg_write(client,
+                                         PCA9541_CONTROL,
+                                         pca9541_control[reg & 0x0f]
+                                         | PCA9541_CTL_NTESTON);
+                       data->select_timeout = SELECT_DELAY_SHORT;
+               } else {
+                       /*
+                        * Other master requested ownership.
+                        * Set extra long timeout to give it time to acquire it.
+                        */
+                       data->select_timeout = SELECT_DELAY_LONG * 2;
+               }
+       } else if (mybus(reg)) {
+               /*
+                * Bus is on, and we own it. We are done with acquisition.
+                * Reset NTESTON and BUSINIT, then return success.
+                */
+               if (reg & (PCA9541_CTL_NTESTON | PCA9541_CTL_BUSINIT))
+                       pca9541_reg_write(client,
+                                         PCA9541_CONTROL,
+                                         reg & ~(PCA9541_CTL_NTESTON
+                                                 | PCA9541_CTL_BUSINIT));
+               return 1;
+       } else {
+               /*
+                * Other master owns the bus.
+                * If arbitration timeout has expired, force ownership.
+                * Otherwise request it.
+                */
+               data->select_timeout = SELECT_DELAY_LONG;
+               if (time_is_before_eq_jiffies(data->arb_timeout)) {
+                       /* Time is up, take the bus and reset it. */
+                       pca9541_reg_write(client,
+                                         PCA9541_CONTROL,
+                                         pca9541_control[reg & 0x0f]
+                                         | PCA9541_CTL_BUSINIT
+                                         | PCA9541_CTL_NTESTON);
+               } else {
+                       /* Request bus ownership if needed */
+                       if (!(reg & PCA9541_CTL_NTESTON))
+                               pca9541_reg_write(client,
+                                                 PCA9541_CONTROL,
+                                                 reg | PCA9541_CTL_NTESTON);
+               }
+       }
+       return 0;
+}
+
+static int pca9541_select_chan(struct i2c_adapter *adap, void *client, u32 chan)
+{
+       struct pca9541 *data = i2c_get_clientdata(client);
+       int ret;
+       unsigned long timeout = jiffies + ARB2_TIMEOUT;
+               /* give up after this time */
+
+       data->arb_timeout = jiffies + ARB_TIMEOUT;
+               /* force bus ownership after this time */
+
+       do {
+               ret = pca9541_arbitrate(client);
+               if (ret)
+                       return ret < 0 ? ret : 0;
+
+               if (data->select_timeout == SELECT_DELAY_SHORT)
+                       udelay(data->select_timeout);
+               else
+                       msleep(data->select_timeout / 1000);
+       } while (time_is_after_eq_jiffies(timeout));
+
+       return -ETIMEDOUT;
+}
+
+static int pca9541_release_chan(struct i2c_adapter *adap,
+                               void *client, u32 chan)
+{
+       pca9541_release_bus(client);
+       return 0;
+}
+
+/*
+ * I2C init/probing/exit functions
+ */
+static int pca9541_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+       struct i2c_adapter *adap = client->adapter;
+       struct pca954x_platform_data *pdata = client->dev.platform_data;
+       struct pca9541 *data;
+       int force;
+       int ret = -ENODEV;
+
+       if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_BYTE_DATA))
+               goto err;
+
+       data = kzalloc(sizeof(struct pca9541), GFP_KERNEL);
+       if (!data) {
+               ret = -ENOMEM;
+               goto err;
+       }
+
+       i2c_set_clientdata(client, data);
+
+       /*
+        * I2C accesses are unprotected here.
+        * We have to lock the adapter before releasing the bus.
+        */
+       i2c_lock_adapter(adap);
+       pca9541_release_bus(client);
+       i2c_unlock_adapter(adap);
+
+       /* Create mux adapter */
+
+       force = 0;
+       if (pdata)
+               force = pdata->modes[0].adap_id;
+       data->mux_adap = i2c_add_mux_adapter(adap, client, force, 0,
+                                            pca9541_select_chan,
+                                            pca9541_release_chan);
+
+       if (data->mux_adap == NULL) {
+               dev_err(&client->dev, "failed to register master selector\n");
+               goto exit_free;
+       }
+
+       dev_info(&client->dev, "registered master selector for I2C %s\n",
+                client->name);
+
+       return 0;
+
+exit_free:
+       kfree(data);
+err:
+       return ret;
+}
+
+static int pca9541_remove(struct i2c_client *client)
+{
+       struct pca9541 *data = i2c_get_clientdata(client);
+
+       i2c_del_mux_adapter(data->mux_adap);
+
+       kfree(data);
+       return 0;
+}
+
+static struct i2c_driver pca9541_driver = {
+       .driver = {
+                  .name = "pca9541",
+                  .owner = THIS_MODULE,
+                  },
+       .probe = pca9541_probe,
+       .remove = pca9541_remove,
+       .id_table = pca9541_id,
+};
+
+static int __init pca9541_init(void)
+{
+       return i2c_add_driver(&pca9541_driver);
+}
+
+static void __exit pca9541_exit(void)
+{
+       i2c_del_driver(&pca9541_driver);
+}
+
+module_init(pca9541_init);
+module_exit(pca9541_exit);
+
+MODULE_AUTHOR("Guenter Roeck <guenter.roeck@ericsson.com>");
+MODULE_DESCRIPTION("PCA9541 I2C master selector driver");
+MODULE_LICENSE("GPL v2");