1 files changed, 411 insertions, 0 deletions

diff --git a/drivers/i2c/muxes/pca9541.c b/drivers/i2c/muxes/pca9541.c
new file mode 100644
index 000000000000..ed699c5aa79d
--- /dev/null
+++ b/drivers/i2c/muxes/pca9541.c
@@ -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");