Merge branch 'devel' of master.kernel.org:/home/rmk/linux-2.6-arm

* 'devel' of master.kernel.org:/home/rmk/linux-2.6-arm: (416 commits)
  ARM: DMA: add support for DMA debugging
  ARM: PL011: add DMA burst threshold support for ST variants
  ARM: PL011: Add support for transmit DMA
  ARM: PL011: Ensure IRQs are disabled in UART interrupt handler
  ARM: PL011: Separate hardware FIFO size from TTY FIFO size
  ARM: PL011: Allow better handling of vendor data
  ARM: PL011: Ensure error flags are clear at startup
  ARM: PL011: include revision number in boot-time port printk
  ARM: vexpress: add sched_clock() for Versatile Express
  ARM i.MX53: Make MX53 EVK bootable
  ARM i.MX53: Some bug fix about MX53 MSL code
  ARM: 6607/1: sa1100: Update platform device registration
  ARM: 6606/1: sa1100: Fix platform device registration
  ARM i.MX51: rename IPU irqs
  ARM i.MX51: Add ipu clock support
  ARM: imx/mx27_3ds: Add PMIC support
  ARM: DMA: Replace page_to_dma()/dma_to_page() with pfn_to_dma()/dma_to_pfn()
  mx51: fix usb clock support
  MX51: Add support for usb host 2
  arch/arm/plat-mxc/ehci.c: fix errors/typos
  ...

1 files changed, 422 insertions, 0 deletions

diff --git a/drivers/mfd/tc3589x.c b/drivers/mfd/tc3589x.c
new file mode 100644
index 000000000000..729dbeed2ce0
--- /dev/null
+++ b/drivers/mfd/tc3589x.c
@@ -0,0 +1,422 @@
+/*
+ * Copyright (C) ST-Ericsson SA 2010
+ *
+ * License Terms: GNU General Public License, version 2
+ * Author: Hanumath Prasad <hanumath.prasad@stericsson.com> for ST-Ericsson
+ * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/tc3589x.h>
+
+#define TC3589x_CLKMODE_MODCTL_SLEEP            0x0
+#define TC3589x_CLKMODE_MODCTL_OPERATION        (1 << 0)
+
+/**
+ * tc3589x_reg_read() - read a single TC3589x register
+ * @tc3589x:    Device to read from
+ * @reg:        Register to read
+ */
+int tc3589x_reg_read(struct tc3589x *tc3589x, u8 reg)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(tc3589x->i2c, reg);
+        if (ret < 0)
+                dev_err(tc3589x->dev, "failed to read reg %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc3589x_reg_read);
+
+/**
+ * tc3589x_reg_read() - write a single TC3589x register
+ * @tc3589x:    Device to write to
+ * @reg:        Register to read
+ * @data:       Value to write
+ */
+int tc3589x_reg_write(struct tc3589x *tc3589x, u8 reg, u8 data)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(tc3589x->i2c, reg, data);
+        if (ret < 0)
+                dev_err(tc3589x->dev, "failed to write reg %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc3589x_reg_write);
+
+/**
+ * tc3589x_block_read() - read multiple TC3589x registers
+ * @tc3589x:    Device to read from
+ * @reg:        First register
+ * @length:     Number of registers
+ * @values:     Buffer to write to
+ */
+int tc3589x_block_read(struct tc3589x *tc3589x, u8 reg, u8 length, u8 *values)
+{
+        int ret;
+
+        ret = i2c_smbus_read_i2c_block_data(tc3589x->i2c, reg, length, values);
+        if (ret < 0)
+                dev_err(tc3589x->dev, "failed to read regs %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc3589x_block_read);
+
+/**
+ * tc3589x_block_write() - write multiple TC3589x registers
+ * @tc3589x:    Device to write to
+ * @reg:        First register
+ * @length:     Number of registers
+ * @values:     Values to write
+ */
+int tc3589x_block_write(struct tc3589x *tc3589x, u8 reg, u8 length,
+                        const u8 *values)
+{
+        int ret;
+
+        ret = i2c_smbus_write_i2c_block_data(tc3589x->i2c, reg, length,
+                                             values);
+        if (ret < 0)
+                dev_err(tc3589x->dev, "failed to write regs %#x: %d\n",
+                        reg, ret);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc3589x_block_write);
+
+/**
+ * tc3589x_set_bits() - set the value of a bitfield in a TC3589x register
+ * @tc3589x:    Device to write to
+ * @reg:        Register to write
+ * @mask:       Mask of bits to set
+ * @values:     Value to set
+ */
+int tc3589x_set_bits(struct tc3589x *tc3589x, u8 reg, u8 mask, u8 val)
+{
+        int ret;
+
+        mutex_lock(&tc3589x->lock);
+
+        ret = tc3589x_reg_read(tc3589x, reg);
+        if (ret < 0)
+                goto out;
+
+        ret &= ~mask;
+        ret |= val;
+
+        ret = tc3589x_reg_write(tc3589x, reg, ret);
+
+out:
+        mutex_unlock(&tc3589x->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(tc3589x_set_bits);
+
+static struct resource gpio_resources[] = {
+        {
+                .start  = TC3589x_INT_GPIIRQ,
+                .end    = TC3589x_INT_GPIIRQ,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource keypad_resources[] = {
+        {
+                .start  = TC3589x_INT_KBDIRQ,
+                .end    = TC3589x_INT_KBDIRQ,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell tc3589x_dev_gpio[] = {
+        {
+                .name           = "tc3589x-gpio",
+                .num_resources  = ARRAY_SIZE(gpio_resources),
+                .resources      = &gpio_resources[0],
+        },
+};
+
+static struct mfd_cell tc3589x_dev_keypad[] = {
+        {
+                .name           = "tc3589x-keypad",
+                .num_resources  = ARRAY_SIZE(keypad_resources),
+                .resources      = &keypad_resources[0],
+        },
+};
+
+static irqreturn_t tc3589x_irq(int irq, void *data)
+{
+        struct tc3589x *tc3589x = data;
+        int status;
+
+again:
+        status = tc3589x_reg_read(tc3589x, TC3589x_IRQST);
+        if (status < 0)
+                return IRQ_NONE;
+
+        while (status) {
+                int bit = __ffs(status);
+
+                handle_nested_irq(tc3589x->irq_base + bit);
+                status &= ~(1 << bit);
+        }
+
+        /*
+         * A dummy read or write (to any register) appears to be necessary to
+         * have the last interrupt clear (for example, GPIO IC write) take
+         * effect. In such a case, recheck for any interrupt which is still
+         * pending.
+         */
+        status = tc3589x_reg_read(tc3589x, TC3589x_IRQST);
+        if (status)
+                goto again;
+
+        return IRQ_HANDLED;
+}
+
+static int tc3589x_irq_init(struct tc3589x *tc3589x)
+{
+        int base = tc3589x->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + TC3589x_NR_INTERNAL_IRQS; irq++) {
+                set_irq_chip_data(irq, tc3589x);
+                set_irq_chip_and_handler(irq, &dummy_irq_chip,
+                                         handle_edge_irq);
+                set_irq_nested_thread(irq, 1);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID);
+#else
+                set_irq_noprobe(irq);
+#endif
+        }
+
+        return 0;
+}
+
+static void tc3589x_irq_remove(struct tc3589x *tc3589x)
+{
+        int base = tc3589x->irq_base;
+        int irq;
+
+        for (irq = base; irq < base + TC3589x_NR_INTERNAL_IRQS; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip_and_handler(irq, NULL, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
+
+static int tc3589x_chip_init(struct tc3589x *tc3589x)
+{
+        int manf, ver, ret;
+
+        manf = tc3589x_reg_read(tc3589x, TC3589x_MANFCODE);
+        if (manf < 0)
+                return manf;
+
+        ver = tc3589x_reg_read(tc3589x, TC3589x_VERSION);
+        if (ver < 0)
+                return ver;
+
+        if (manf != TC3589x_MANFCODE_MAGIC) {
+                dev_err(tc3589x->dev, "unknown manufacturer: %#x\n", manf);
+                return -EINVAL;
+        }
+
+        dev_info(tc3589x->dev, "manufacturer: %#x, version: %#x\n", manf, ver);
+
+        /*
+         * Put everything except the IRQ module into reset;
+         * also spare the GPIO module for any pin initialization
+         * done during pre-kernel boot
+         */
+        ret = tc3589x_reg_write(tc3589x, TC3589x_RSTCTRL,
+                                TC3589x_RSTCTRL_TIMRST
+                                | TC3589x_RSTCTRL_ROTRST
+                                | TC3589x_RSTCTRL_KBDRST);
+        if (ret < 0)
+                return ret;
+
+        /* Clear the reset interrupt. */
+        return tc3589x_reg_write(tc3589x, TC3589x_RSTINTCLR, 0x1);
+}
+
+static int __devinit tc3589x_device_init(struct tc3589x *tc3589x)
+{
+        int ret = 0;
+        unsigned int blocks = tc3589x->pdata->block;
+
+        if (blocks & TC3589x_BLOCK_GPIO) {
+                ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_gpio,
+                                ARRAY_SIZE(tc3589x_dev_gpio), NULL,
+                                tc3589x->irq_base);
+                if (ret) {
+                        dev_err(tc3589x->dev, "failed to add gpio child\n");
+                        return ret;
+                }
+                dev_info(tc3589x->dev, "added gpio block\n");
+        }
+
+        if (blocks & TC3589x_BLOCK_KEYPAD) {
+                ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_keypad,
+                                ARRAY_SIZE(tc3589x_dev_keypad), NULL,
+                                tc3589x->irq_base);
+                if (ret) {
+                        dev_err(tc3589x->dev, "failed to keypad child\n");
+                        return ret;
+                }
+                dev_info(tc3589x->dev, "added keypad block\n");
+        }
+
+        return ret;
+}
+
+static int __devinit tc3589x_probe(struct i2c_client *i2c,
+                                   const struct i2c_device_id *id)
+{
+        struct tc3589x_platform_data *pdata = i2c->dev.platform_data;
+        struct tc3589x *tc3589x;
+        int ret;
+
+        if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA
+                                     | I2C_FUNC_SMBUS_I2C_BLOCK))
+                return -EIO;
+
+        tc3589x = kzalloc(sizeof(struct tc3589x), GFP_KERNEL);
+        if (!tc3589x)
+                return -ENOMEM;
+
+        mutex_init(&tc3589x->lock);
+
+        tc3589x->dev = &i2c->dev;
+        tc3589x->i2c = i2c;
+        tc3589x->pdata = pdata;
+        tc3589x->irq_base = pdata->irq_base;
+        tc3589x->num_gpio = id->driver_data;
+
+        i2c_set_clientdata(i2c, tc3589x);
+
+        ret = tc3589x_chip_init(tc3589x);
+        if (ret)
+                goto out_free;
+
+        ret = tc3589x_irq_init(tc3589x);
+        if (ret)
+                goto out_free;
+
+        ret = request_threaded_irq(tc3589x->i2c->irq, NULL, tc3589x_irq,
+                                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                   "tc3589x", tc3589x);
+        if (ret) {
+                dev_err(tc3589x->dev, "failed to request IRQ: %d\n", ret);
+                goto out_removeirq;
+        }
+
+        ret = tc3589x_device_init(tc3589x);
+        if (ret) {
+                dev_err(tc3589x->dev, "failed to add child devices\n");
+                goto out_freeirq;
+        }
+
+        return 0;
+
+out_freeirq:
+        free_irq(tc3589x->i2c->irq, tc3589x);
+out_removeirq:
+        tc3589x_irq_remove(tc3589x);
+out_free:
+        kfree(tc3589x);
+        return ret;
+}
+
+static int __devexit tc3589x_remove(struct i2c_client *client)
+{
+        struct tc3589x *tc3589x = i2c_get_clientdata(client);
+
+        mfd_remove_devices(tc3589x->dev);
+
+        free_irq(tc3589x->i2c->irq, tc3589x);
+        tc3589x_irq_remove(tc3589x);
+
+        kfree(tc3589x);
+
+        return 0;
+}
+
+static int tc3589x_suspend(struct device *dev)
+{
+        struct tc3589x *tc3589x = dev_get_drvdata(dev);
+        struct i2c_client *client = tc3589x->i2c;
+        int ret = 0;
+
+        /* put the system to sleep mode */
+        if (!device_may_wakeup(&client->dev))
+                ret = tc3589x_reg_write(tc3589x, TC3589x_CLKMODE,
+                                TC3589x_CLKMODE_MODCTL_SLEEP);
+
+        return ret;
+}
+
+static int tc3589x_resume(struct device *dev)
+{
+        struct tc3589x *tc3589x = dev_get_drvdata(dev);
+        struct i2c_client *client = tc3589x->i2c;
+        int ret = 0;
+
+        /* enable the system into operation */
+        if (!device_may_wakeup(&client->dev))
+                ret = tc3589x_reg_write(tc3589x, TC3589x_CLKMODE,
+                                TC3589x_CLKMODE_MODCTL_OPERATION);
+
+        return ret;
+}
+
+static const SIMPLE_DEV_PM_OPS(tc3589x_dev_pm_ops, tc3589x_suspend,
+                                                tc3589x_resume);
+
+static const struct i2c_device_id tc3589x_id[] = {
+        { "tc3589x", 24 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, tc3589x_id);
+
+static struct i2c_driver tc3589x_driver = {
+        .driver.name    = "tc3589x",
+        .driver.owner   = THIS_MODULE,
+#ifdef CONFIG_PM
+        .driver.pm      = &tc3589x_dev_pm_ops,
+#endif
+        .probe          = tc3589x_probe,
+        .remove         = __devexit_p(tc3589x_remove),
+        .id_table       = tc3589x_id,
+};
+
+static int __init tc3589x_init(void)
+{
+        return i2c_add_driver(&tc3589x_driver);
+}
+subsys_initcall(tc3589x_init);
+
+static void __exit tc3589x_exit(void)
+{
+        i2c_del_driver(&tc3589x_driver);
+}
+module_exit(tc3589x_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("TC3589x MFD core driver");
+MODULE_AUTHOR("Hanumath Prasad, Rabin Vincent");