Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

5 files changed, 628 insertions, 10 deletions

diff --git a/drivers/i2c/muxes/Kconfig b/drivers/i2c/muxes/Kconfig
index 4c9a99c4fcb0..90b7a0163899 100644
--- a/drivers/i2c/muxes/Kconfig
+++ b/drivers/i2c/muxes/Kconfig
@@ -5,6 +5,28 @@
 menu "Multiplexer I2C Chip support"
         depends on I2C_MUX
 
+config I2C_MUX_GPIO
+        tristate "GPIO-based I2C multiplexer"
+        depends on GENERIC_GPIO
+        help
+          If you say yes to this option, support will be included for a
+          GPIO based I2C multiplexer. This driver provides access to
+          I2C busses connected through a MUX, which is controlled
+          through GPIO pins.
+
+          This driver can also be built as a module.  If so, the module
+          will be called gpio-i2cmux.
+
+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
diff --git a/drivers/i2c/muxes/Makefile b/drivers/i2c/muxes/Makefile
index bd83b5274815..4640436ea61f 100644
--- a/drivers/i2c/muxes/Makefile
+++ b/drivers/i2c/muxes/Makefile
@@ -1,8 +1,8 @@
 #
 # Makefile for multiplexer I2C chip drivers.
 
+obj-$(CONFIG_I2C_MUX_GPIO)      += gpio-i2cmux.o
+obj-$(CONFIG_I2C_MUX_PCA9541)   += pca9541.o
 obj-$(CONFIG_I2C_MUX_PCA954x)   += pca954x.o
 
-ifeq ($(CONFIG_I2C_DEBUG_BUS),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
+ccflags-$(CONFIG_I2C_DEBUG_BUS) := -DDEBUG
diff --git a/drivers/i2c/muxes/gpio-i2cmux.c b/drivers/i2c/muxes/gpio-i2cmux.c
new file mode 100644
index 000000000000..7b6ce624cd6e
--- /dev/null
+++ b/drivers/i2c/muxes/gpio-i2cmux.c
@@ -0,0 +1,184 @@
+/*
+ * I2C multiplexer using GPIO API
+ *
+ * Peter Korsgaard <peter.korsgaard@barco.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/i2c.h>
+#include <linux/i2c-mux.h>
+#include <linux/gpio-i2cmux.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+
+struct gpiomux {
+        struct i2c_adapter *parent;
+        struct i2c_adapter **adap; /* child busses */
+        struct gpio_i2cmux_platform_data data;
+};
+
+static void gpiomux_set(const struct gpiomux *mux, unsigned val)
+{
+        int i;
+
+        for (i = 0; i < mux->data.n_gpios; i++)
+                gpio_set_value(mux->data.gpios[i], val & (1 << i));
+}
+
+static int gpiomux_select(struct i2c_adapter *adap, void *data, u32 chan)
+{
+        struct gpiomux *mux = data;
+
+        gpiomux_set(mux, mux->data.values[chan]);
+
+        return 0;
+}
+
+static int gpiomux_deselect(struct i2c_adapter *adap, void *data, u32 chan)
+{
+        struct gpiomux *mux = data;
+
+        gpiomux_set(mux, mux->data.idle);
+
+        return 0;
+}
+
+static int __devinit gpiomux_probe(struct platform_device *pdev)
+{
+        struct gpiomux *mux;
+        struct gpio_i2cmux_platform_data *pdata;
+        struct i2c_adapter *parent;
+        int (*deselect) (struct i2c_adapter *, void *, u32);
+        unsigned initial_state;
+        int i, ret;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "Missing platform data\n");
+                return -ENODEV;
+        }
+
+        parent = i2c_get_adapter(pdata->parent);
+        if (!parent) {
+                dev_err(&pdev->dev, "Parent adapter (%d) not found\n",
+                        pdata->parent);
+                return -ENODEV;
+        }
+
+        mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+        if (!mux) {
+                ret = -ENOMEM;
+                goto alloc_failed;
+        }
+
+        mux->parent = parent;
+        mux->data = *pdata;
+        mux->adap = kzalloc(sizeof(struct i2c_adapter *) * pdata->n_values,
+                            GFP_KERNEL);
+        if (!mux->adap) {
+                ret = -ENOMEM;
+                goto alloc_failed2;
+        }
+
+        if (pdata->idle != GPIO_I2CMUX_NO_IDLE) {
+                initial_state = pdata->idle;
+                deselect = gpiomux_deselect;
+        } else {
+                initial_state = pdata->values[0];
+                deselect = NULL;
+        }
+
+        for (i = 0; i < pdata->n_gpios; i++) {
+                ret = gpio_request(pdata->gpios[i], "gpio-i2cmux");
+                if (ret)
+                        goto err_request_gpio;
+                gpio_direction_output(pdata->gpios[i],
+                                      initial_state & (1 << i));
+        }
+
+        for (i = 0; i < pdata->n_values; i++) {
+                u32 nr = pdata->base_nr ? (pdata->base_nr + i) : 0;
+
+                mux->adap[i] = i2c_add_mux_adapter(parent, mux, nr, i,
+                                                   gpiomux_select, deselect);
+                if (!mux->adap[i]) {
+                        ret = -ENODEV;
+                        dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
+                        goto add_adapter_failed;
+                }
+        }
+
+        dev_info(&pdev->dev, "%d port mux on %s adapter\n",
+                 pdata->n_values, parent->name);
+
+        platform_set_drvdata(pdev, mux);
+
+        return 0;
+
+add_adapter_failed:
+        for (; i > 0; i--)
+                i2c_del_mux_adapter(mux->adap[i - 1]);
+        i = pdata->n_gpios;
+err_request_gpio:
+        for (; i > 0; i--)
+                gpio_free(pdata->gpios[i - 1]);
+        kfree(mux->adap);
+alloc_failed2:
+        kfree(mux);
+alloc_failed:
+        i2c_put_adapter(parent);
+
+        return ret;
+}
+
+static int __devexit gpiomux_remove(struct platform_device *pdev)
+{
+        struct gpiomux *mux = platform_get_drvdata(pdev);
+        int i;
+
+        for (i = 0; i < mux->data.n_values; i++)
+                i2c_del_mux_adapter(mux->adap[i]);
+
+        for (i = 0; i < mux->data.n_gpios; i++)
+                gpio_free(mux->data.gpios[i]);
+
+        platform_set_drvdata(pdev, NULL);
+        i2c_put_adapter(mux->parent);
+        kfree(mux->adap);
+        kfree(mux);
+
+        return 0;
+}
+
+static struct platform_driver gpiomux_driver = {
+        .probe  = gpiomux_probe,
+        .remove = __devexit_p(gpiomux_remove),
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "gpio-i2cmux",
+        },
+};
+
+static int __init gpiomux_init(void)
+{
+        return platform_driver_register(&gpiomux_driver);
+}
+
+static void __exit gpiomux_exit(void)
+{
+        platform_driver_unregister(&gpiomux_driver);
+}
+
+module_init(gpiomux_init);
+module_exit(gpiomux_exit);
+
+MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver");
+MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:gpio-i2cmux");
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");
diff --git a/drivers/i2c/muxes/pca954x.c b/drivers/i2c/muxes/pca954x.c
index 6f9accf3189d..6f8953664636 100644
--- a/drivers/i2c/muxes/pca954x.c
+++ b/drivers/i2c/muxes/pca954x.c
@@ -181,8 +181,8 @@ static int pca954x_deselect_mux(struct i2c_adapter *adap,
 /*
  * I2C init/probing/exit functions
  */
-static int __devinit pca954x_probe(struct i2c_client *client,
-                                   const struct i2c_device_id *id)
+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;
@@ -201,10 +201,11 @@ static int __devinit pca954x_probe(struct i2c_client *client,
 
         i2c_set_clientdata(client, data);
 
-        /* Read the mux register at addr to verify
-         * that the mux is in fact present.
+        /* Write the mux register at addr to verify
+         * that the mux is in fact present. This also
+         * initializes the mux to disconnected state.
          */
-        if (i2c_smbus_read_byte(client) < 0) {
+        if (i2c_smbus_write_byte(client, 0) < 0) {
                 dev_warn(&client->dev, "probe failed\n");
                 goto exit_free;
         }
@@ -255,7 +256,7 @@ err:
         return ret;
 }
 
-static int __devexit pca954x_remove(struct i2c_client *client)
+static int pca954x_remove(struct i2c_client *client)
 {
         struct pca954x *data = i2c_get_clientdata(client);
         const struct chip_desc *chip = &chips[data->type];
@@ -279,7 +280,7 @@ static struct i2c_driver pca954x_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = pca954x_probe,
-        .remove         = __devexit_p(pca954x_remove),
+        .remove         = pca954x_remove,
         .id_table       = pca954x_id,
 };