4 files changed, 455 insertions, 0 deletions

diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index b9282cafa978..84d6ea2d74f4 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -440,6 +440,16 @@ config PMIC_ADP5520
           individual components like LCD backlight, LEDs, GPIOs and Kepad
           under the corresponding menus.
 
+config MFD_LP8788
+        bool "Texas Instruments LP8788 Power Management Unit Driver"
+        depends on I2C=y
+        select MFD_CORE
+        select REGMAP_I2C
+        select IRQ_DOMAIN
+        help
+          TI LP8788 PMU supports regulators, battery charger, RTC,
+          ADC, backlight driver and current sinks.
+
 config MFD_MAX77686
         bool "Maxim Semiconductor MAX77686 PMIC Support"
         depends on I2C=y && GENERIC_HARDIRQS
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index d16bc0220e1f..083acf97af26 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -89,6 +89,8 @@ obj-$(CONFIG_PMIC_DA9052)	+= da9052-core.o
 obj-$(CONFIG_MFD_DA9052_SPI)    += da9052-spi.o
 obj-$(CONFIG_MFD_DA9052_I2C)    += da9052-i2c.o
 
+obj-$(CONFIG_MFD_LP8788)        += lp8788.o lp8788-irq.o
+
 obj-$(CONFIG_MFD_MAX77686)      += max77686.o max77686-irq.o
 obj-$(CONFIG_MFD_MAX77693)      += max77693.o max77693-irq.o
 obj-$(CONFIG_MFD_MAX8907)       += max8907.o
diff --git a/drivers/mfd/lp8788-irq.c b/drivers/mfd/lp8788-irq.c
new file mode 100644
index 000000000000..c84ded5f8ece
--- /dev/null
+++ b/drivers/mfd/lp8788-irq.c
@@ -0,0 +1,198 @@
+/*
+ * TI LP8788 MFD - interrupt handler
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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/delay.h>
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/irqdomain.h>
+#include <linux/device.h>
+#include <linux/mfd/lp8788.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+/* register address */
+#define LP8788_INT_1                    0x00
+#define LP8788_INTEN_1                  0x03
+
+#define BASE_INTEN_ADDR                 LP8788_INTEN_1
+#define SIZE_REG                        8
+#define NUM_REGS                        3
+
+/*
+ * struct lp8788_irq_data
+ * @lp               : used for accessing to lp8788 registers
+ * @irq_lock         : mutex for enabling/disabling the interrupt
+ * @domain           : IRQ domain for handling nested interrupt
+ * @enabled          : status of enabled interrupt
+ */
+struct lp8788_irq_data {
+        struct lp8788 *lp;
+        struct mutex irq_lock;
+        struct irq_domain *domain;
+        int enabled[LP8788_INT_MAX];
+};
+
+static inline u8 _irq_to_addr(enum lp8788_int_id id)
+{
+        return id / SIZE_REG;
+}
+
+static inline u8 _irq_to_enable_addr(enum lp8788_int_id id)
+{
+        return _irq_to_addr(id) + BASE_INTEN_ADDR;
+}
+
+static inline u8 _irq_to_mask(enum lp8788_int_id id)
+{
+        return 1 << (id % SIZE_REG);
+}
+
+static inline u8 _irq_to_val(enum lp8788_int_id id, int enable)
+{
+        return enable << (id % SIZE_REG);
+}
+
+static void lp8788_irq_enable(struct irq_data *data)
+{
+        struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
+        irqd->enabled[data->hwirq] = 1;
+}
+
+static void lp8788_irq_disable(struct irq_data *data)
+{
+        struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
+        irqd->enabled[data->hwirq] = 0;
+}
+
+static void lp8788_irq_bus_lock(struct irq_data *data)
+{
+        struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
+
+        mutex_lock(&irqd->irq_lock);
+}
+
+static void lp8788_irq_bus_sync_unlock(struct irq_data *data)
+{
+        struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
+        enum lp8788_int_id irq = data->hwirq;
+        u8 addr, mask, val;
+
+        addr = _irq_to_enable_addr(irq);
+        mask = _irq_to_mask(irq);
+        val = _irq_to_val(irq, irqd->enabled[irq]);
+
+        lp8788_update_bits(irqd->lp, addr, mask, val);
+
+        mutex_unlock(&irqd->irq_lock);
+}
+
+static struct irq_chip lp8788_irq_chip = {
+        .name                   = "lp8788",
+        .irq_enable             = lp8788_irq_enable,
+        .irq_disable            = lp8788_irq_disable,
+        .irq_bus_lock           = lp8788_irq_bus_lock,
+        .irq_bus_sync_unlock    = lp8788_irq_bus_sync_unlock,
+};
+
+static irqreturn_t lp8788_irq_handler(int irq, void *ptr)
+{
+        struct lp8788_irq_data *irqd = ptr;
+        struct lp8788 *lp = irqd->lp;
+        u8 status[NUM_REGS], addr, mask;
+        bool handled;
+        int i;
+
+        if (lp8788_read_multi_bytes(lp, LP8788_INT_1, status, NUM_REGS))
+                return IRQ_NONE;
+
+        for (i = 0 ; i < LP8788_INT_MAX ; i++) {
+                addr = _irq_to_addr(i);
+                mask = _irq_to_mask(i);
+
+                /* reporting only if the irq is enabled */
+                if (status[addr] & mask) {
+                        handle_nested_irq(irq_find_mapping(irqd->domain, i));
+                        handled = true;
+                }
+        }
+
+        return handled ? IRQ_HANDLED : IRQ_NONE;
+}
+
+static int lp8788_irq_map(struct irq_domain *d, unsigned int virq,
+                        irq_hw_number_t hwirq)
+{
+        struct lp8788_irq_data *irqd = d->host_data;
+        struct irq_chip *chip = &lp8788_irq_chip;
+
+        irq_set_chip_data(virq, irqd);
+        irq_set_chip_and_handler(virq, chip, handle_edge_irq);
+        irq_set_nested_thread(virq, 1);
+
+#ifdef CONFIG_ARM
+        set_irq_flags(virq, IRQF_VALID);
+#else
+        irq_set_noprobe(virq);
+#endif
+
+        return 0;
+}
+
+static struct irq_domain_ops lp8788_domain_ops = {
+        .map = lp8788_irq_map,
+};
+
+int lp8788_irq_init(struct lp8788 *lp, int irq)
+{
+        struct lp8788_irq_data *irqd;
+        int ret;
+
+        if (irq <= 0) {
+                dev_warn(lp->dev, "invalid irq number: %d\n", irq);
+                return 0;
+        }
+
+        irqd = devm_kzalloc(lp->dev, sizeof(*irqd), GFP_KERNEL);
+        if (!irqd)
+                return -ENOMEM;
+
+        irqd->lp = lp;
+        irqd->domain = irq_domain_add_linear(lp->dev->of_node, LP8788_INT_MAX,
+                                        &lp8788_domain_ops, irqd);
+        if (!irqd->domain) {
+                dev_err(lp->dev, "failed to add irq domain err\n");
+                return -EINVAL;
+        }
+
+        lp->irqdm = irqd->domain;
+        mutex_init(&irqd->irq_lock);
+
+        ret = request_threaded_irq(irq, NULL, lp8788_irq_handler,
+                                IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                "lp8788-irq", irqd);
+        if (ret) {
+                dev_err(lp->dev, "failed to create a thread for IRQ_N\n");
+                return ret;
+        }
+
+        lp->irq = irq;
+
+        return 0;
+}
+
+void lp8788_irq_exit(struct lp8788 *lp)
+{
+        if (lp->irq)
+                free_irq(lp->irq, lp->irqdm);
+}
diff --git a/drivers/mfd/lp8788.c b/drivers/mfd/lp8788.c
new file mode 100644
index 000000000000..3e94a699833c
--- /dev/null
+++ b/drivers/mfd/lp8788.c
@@ -0,0 +1,245 @@
+/*
+ * TI LP8788 MFD - core interface
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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/err.h>
+#include <linux/i2c.h>
+#include <linux/mfd/core.h>
+#include <linux/mfd/lp8788.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#define MAX_LP8788_REGISTERS            0xA2
+
+#define MFD_DEV_SIMPLE(_name)                                   \
+{                                                               \
+        .name = LP8788_DEV_##_name,                             \
+}
+
+#define MFD_DEV_WITH_ID(_name, _id)                             \
+{                                                               \
+        .name = LP8788_DEV_##_name,                             \
+        .id = _id,                                              \
+}
+
+#define MFD_DEV_WITH_RESOURCE(_name, _resource, num_resource)   \
+{                                                               \
+        .name = LP8788_DEV_##_name,                             \
+        .resources = _resource,                                 \
+        .num_resources = num_resource,                          \
+}
+
+static struct resource chg_irqs[] = {
+        /* Charger Interrupts */
+        {
+                .start = LP8788_INT_CHG_INPUT_STATE,
+                .end   = LP8788_INT_PRECHG_TIMEOUT,
+                .name  = LP8788_CHG_IRQ,
+                .flags = IORESOURCE_IRQ,
+        },
+        /* Power Routing Switch Interrupts */
+        {
+                .start = LP8788_INT_ENTER_SYS_SUPPORT,
+                .end   = LP8788_INT_EXIT_SYS_SUPPORT,
+                .name  = LP8788_PRSW_IRQ,
+                .flags = IORESOURCE_IRQ,
+        },
+        /* Battery Interrupts */
+        {
+                .start = LP8788_INT_BATT_LOW,
+                .end   = LP8788_INT_NO_BATT,
+                .name  = LP8788_BATT_IRQ,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource rtc_irqs[] = {
+        {
+                .start = LP8788_INT_RTC_ALARM1,
+                .end   = LP8788_INT_RTC_ALARM2,
+                .name  = LP8788_ALM_IRQ,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell lp8788_devs[] = {
+        /* 4 bucks */
+        MFD_DEV_WITH_ID(BUCK, 1),
+        MFD_DEV_WITH_ID(BUCK, 2),
+        MFD_DEV_WITH_ID(BUCK, 3),
+        MFD_DEV_WITH_ID(BUCK, 4),
+
+        /* 12 digital ldos */
+        MFD_DEV_WITH_ID(DLDO, 1),
+        MFD_DEV_WITH_ID(DLDO, 2),
+        MFD_DEV_WITH_ID(DLDO, 3),
+        MFD_DEV_WITH_ID(DLDO, 4),
+        MFD_DEV_WITH_ID(DLDO, 5),
+        MFD_DEV_WITH_ID(DLDO, 6),
+        MFD_DEV_WITH_ID(DLDO, 7),
+        MFD_DEV_WITH_ID(DLDO, 8),
+        MFD_DEV_WITH_ID(DLDO, 9),
+        MFD_DEV_WITH_ID(DLDO, 10),
+        MFD_DEV_WITH_ID(DLDO, 11),
+        MFD_DEV_WITH_ID(DLDO, 12),
+
+        /* 10 analog ldos */
+        MFD_DEV_WITH_ID(ALDO, 1),
+        MFD_DEV_WITH_ID(ALDO, 2),
+        MFD_DEV_WITH_ID(ALDO, 3),
+        MFD_DEV_WITH_ID(ALDO, 4),
+        MFD_DEV_WITH_ID(ALDO, 5),
+        MFD_DEV_WITH_ID(ALDO, 6),
+        MFD_DEV_WITH_ID(ALDO, 7),
+        MFD_DEV_WITH_ID(ALDO, 8),
+        MFD_DEV_WITH_ID(ALDO, 9),
+        MFD_DEV_WITH_ID(ALDO, 10),
+
+        /* ADC */
+        MFD_DEV_SIMPLE(ADC),
+
+        /* battery charger */
+        MFD_DEV_WITH_RESOURCE(CHARGER, chg_irqs, ARRAY_SIZE(chg_irqs)),
+
+        /* rtc */
+        MFD_DEV_WITH_RESOURCE(RTC, rtc_irqs, ARRAY_SIZE(rtc_irqs)),
+
+        /* backlight */
+        MFD_DEV_SIMPLE(BACKLIGHT),
+
+        /* current sink for vibrator */
+        MFD_DEV_SIMPLE(VIBRATOR),
+
+        /* current sink for keypad LED */
+        MFD_DEV_SIMPLE(KEYLED),
+};
+
+int lp8788_read_byte(struct lp8788 *lp, u8 reg, u8 *data)
+{
+        int ret;
+        unsigned int val;
+
+        ret = regmap_read(lp->regmap, reg, &val);
+        if (ret < 0) {
+                dev_err(lp->dev, "failed to read 0x%.2x\n", reg);
+                return ret;
+        }
+
+        *data = (u8)val;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(lp8788_read_byte);
+
+int lp8788_read_multi_bytes(struct lp8788 *lp, u8 reg, u8 *data, size_t count)
+{
+        return regmap_bulk_read(lp->regmap, reg, data, count);
+}
+EXPORT_SYMBOL_GPL(lp8788_read_multi_bytes);
+
+int lp8788_write_byte(struct lp8788 *lp, u8 reg, u8 data)
+{
+        return regmap_write(lp->regmap, reg, data);
+}
+EXPORT_SYMBOL_GPL(lp8788_write_byte);
+
+int lp8788_update_bits(struct lp8788 *lp, u8 reg, u8 mask, u8 data)
+{
+        return regmap_update_bits(lp->regmap, reg, mask, data);
+}
+EXPORT_SYMBOL_GPL(lp8788_update_bits);
+
+static int lp8788_platform_init(struct lp8788 *lp)
+{
+        struct lp8788_platform_data *pdata = lp->pdata;
+
+        return (pdata && pdata->init_func) ? pdata->init_func(lp) : 0;
+}
+
+static const struct regmap_config lp8788_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = MAX_LP8788_REGISTERS,
+};
+
+static int lp8788_probe(struct i2c_client *cl, const struct i2c_device_id *id)
+{
+        struct lp8788 *lp;
+        struct lp8788_platform_data *pdata = cl->dev.platform_data;
+        int ret;
+
+        lp = devm_kzalloc(&cl->dev, sizeof(struct lp8788), GFP_KERNEL);
+        if (!lp)
+                return -ENOMEM;
+
+        lp->regmap = devm_regmap_init_i2c(cl, &lp8788_regmap_config);
+        if (IS_ERR(lp->regmap)) {
+                ret = PTR_ERR(lp->regmap);
+                dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
+                return ret;
+        }
+
+        lp->pdata = pdata;
+        lp->dev = &cl->dev;
+        i2c_set_clientdata(cl, lp);
+
+        ret = lp8788_platform_init(lp);
+        if (ret)
+                return ret;
+
+        ret = lp8788_irq_init(lp, cl->irq);
+        if (ret)
+                return ret;
+
+        return mfd_add_devices(lp->dev, -1, lp8788_devs,
+                               ARRAY_SIZE(lp8788_devs), NULL, 0, NULL);
+}
+
+static int __devexit lp8788_remove(struct i2c_client *cl)
+{
+        struct lp8788 *lp = i2c_get_clientdata(cl);
+
+        mfd_remove_devices(lp->dev);
+        lp8788_irq_exit(lp);
+        return 0;
+}
+
+static const struct i2c_device_id lp8788_ids[] = {
+        {"lp8788", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lp8788_ids);
+
+static struct i2c_driver lp8788_driver = {
+        .driver = {
+                .name = "lp8788",
+                .owner = THIS_MODULE,
+        },
+        .probe = lp8788_probe,
+        .remove = __devexit_p(lp8788_remove),
+        .id_table = lp8788_ids,
+};
+
+static int __init lp8788_init(void)
+{
+        return i2c_add_driver(&lp8788_driver);
+}
+subsys_initcall(lp8788_init);
+
+static void __exit lp8788_exit(void)
+{
+        i2c_del_driver(&lp8788_driver);
+}
+module_exit(lp8788_exit);
+
+MODULE_DESCRIPTION("TI LP8788 MFD Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");