4 files changed, 688 insertions, 0 deletions

diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 7df3bcf79490..b1d537053faf 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -174,6 +174,16 @@ config PMIC_DA903X
           individual components like LCD backlight, voltage regulators,
           LEDs and battery-charger under the corresponding menus.
 
+config PMIC_ADP5520
+        bool "Analog Devices ADP5520/01 MFD PMIC Core Support"
+        depends on I2C=y
+        help
+          Say yes here to add support for Analog Devices AD5520 and ADP5501,
+          Multifunction Power Management IC. This includes
+          the I2C driver and the core APIs _only_, you have to select
+          individual components like LCD backlight, LEDs, GPIOs and Kepad
+          under the corresponding menus.
+
 config MFD_WM8400
         tristate "Support Wolfson Microelectronics WM8400"
         select MFD_CORE
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 1792b1ff8ffc..24558574a737 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -54,3 +54,4 @@ obj-$(CONFIG_AB3100_CORE)	+= ab3100-core.o
 obj-$(CONFIG_AB3100_OTP)        += ab3100-otp.o
 obj-$(CONFIG_AB4500_CORE)       += ab4500-core.o
 obj-$(CONFIG_MFD_88PM8607)      += 88pm8607.o
+obj-$(CONFIG_PMIC_ADP5520)      += adp5520.o
\ No newline at end of file
diff --git a/drivers/mfd/adp5520.c b/drivers/mfd/adp5520.c
new file mode 100644
index 000000000000..401a9b6029e3
--- /dev/null
+++ b/drivers/mfd/adp5520.c
@@ -0,0 +1,378 @@
+/*
+ * Base driver for Analog Devices ADP5520/ADP5501 MFD PMICs
+ * LCD Backlight: drivers/video/backlight/adp5520_bl
+ * LEDs         : drivers/led/leds-adp5520
+ * GPIO         : drivers/gpio/adp5520-gpio (ADP5520 only)
+ * Keys         : drivers/input/keyboard/adp5520-keys (ADP5520 only)
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Derived from da903x:
+ * Copyright (C) 2008 Compulab, Ltd.
+ *      Mike Rapoport <mike@compulab.co.il>
+ *
+ * Copyright (C) 2006-2008 Marvell International Ltd.
+ *      Eric Miao <eric.miao@marvell.com>
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+
+#include <linux/mfd/adp5520.h>
+
+struct adp5520_chip {
+        struct i2c_client *client;
+        struct device *dev;
+        struct mutex lock;
+        struct blocking_notifier_head notifier_list;
+        int irq;
+        unsigned long id;
+};
+
+static int __adp5520_read(struct i2c_client *client,
+                                int reg, uint8_t *val)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
+                return ret;
+        }
+
+        *val = (uint8_t)ret;
+        return 0;
+}
+
+static int __adp5520_write(struct i2c_client *client,
+                                 int reg, uint8_t val)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, reg, val);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
+                                val, reg);
+                return ret;
+        }
+        return 0;
+}
+
+int __adp5520_ack_bits(struct i2c_client *client, int reg, uint8_t bit_mask)
+{
+        struct adp5520_chip *chip = i2c_get_clientdata(client);
+        uint8_t reg_val;
+        int ret;
+
+        mutex_lock(&chip->lock);
+
+        ret = __adp5520_read(client, reg, &reg_val);
+
+        if (!ret) {
+                reg_val |= bit_mask;
+                ret = __adp5520_write(client, reg, reg_val);
+        }
+
+        mutex_unlock(&chip->lock);
+        return ret;
+}
+
+int adp5520_write(struct device *dev, int reg, uint8_t val)
+{
+        return __adp5520_write(to_i2c_client(dev), reg, val);
+}
+EXPORT_SYMBOL_GPL(adp5520_write);
+
+int adp5520_read(struct device *dev, int reg, uint8_t *val)
+{
+        return __adp5520_read(to_i2c_client(dev), reg, val);
+}
+EXPORT_SYMBOL_GPL(adp5520_read);
+
+int adp5520_set_bits(struct device *dev, int reg, uint8_t bit_mask)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(dev);
+        uint8_t reg_val;
+        int ret;
+
+        mutex_lock(&chip->lock);
+
+        ret = __adp5520_read(chip->client, reg, &reg_val);
+
+        if (!ret && ((reg_val & bit_mask) == 0)) {
+                reg_val |= bit_mask;
+                ret = __adp5520_write(chip->client, reg, reg_val);
+        }
+
+        mutex_unlock(&chip->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(adp5520_set_bits);
+
+int adp5520_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(dev);
+        uint8_t reg_val;
+        int ret;
+
+        mutex_lock(&chip->lock);
+
+        ret = __adp5520_read(chip->client, reg, &reg_val);
+
+        if (!ret && (reg_val & bit_mask)) {
+                reg_val &= ~bit_mask;
+                ret = __adp5520_write(chip->client, reg, reg_val);
+        }
+
+        mutex_unlock(&chip->lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(adp5520_clr_bits);
+
+int adp5520_register_notifier(struct device *dev, struct notifier_block *nb,
+                                unsigned int events)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(dev);
+
+        if (chip->irq) {
+                adp5520_set_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
+                        events & (ADP5520_KP_IEN | ADP5520_KR_IEN |
+                        ADP5520_OVP_IEN | ADP5520_CMPR_IEN));
+
+                return blocking_notifier_chain_register(&chip->notifier_list,
+                         nb);
+        }
+
+        return -ENODEV;
+}
+EXPORT_SYMBOL_GPL(adp5520_register_notifier);
+
+int adp5520_unregister_notifier(struct device *dev, struct notifier_block *nb,
+                                unsigned int events)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(dev);
+
+        adp5520_clr_bits(chip->dev, ADP5520_INTERRUPT_ENABLE,
+                events & (ADP5520_KP_IEN | ADP5520_KR_IEN |
+                ADP5520_OVP_IEN | ADP5520_CMPR_IEN));
+
+        return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(adp5520_unregister_notifier);
+
+static irqreturn_t adp5520_irq_thread(int irq, void *data)
+{
+        struct adp5520_chip *chip = data;
+        unsigned int events;
+        uint8_t reg_val;
+        int ret;
+
+        ret = __adp5520_read(chip->client, ADP5520_MODE_STATUS, &reg_val);
+        if (ret)
+                goto out;
+
+        events =  reg_val & (ADP5520_OVP_INT | ADP5520_CMPR_INT |
+                ADP5520_GPI_INT | ADP5520_KR_INT | ADP5520_KP_INT);
+
+        blocking_notifier_call_chain(&chip->notifier_list, events, NULL);
+        /* ACK, Sticky bits are W1C */
+        __adp5520_ack_bits(chip->client, ADP5520_MODE_STATUS, events);
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int __remove_subdev(struct device *dev, void *unused)
+{
+        platform_device_unregister(to_platform_device(dev));
+        return 0;
+}
+
+static int adp5520_remove_subdevs(struct adp5520_chip *chip)
+{
+        return device_for_each_child(chip->dev, NULL, __remove_subdev);
+}
+
+static int __devinit adp5520_probe(struct i2c_client *client,
+                                        const struct i2c_device_id *id)
+{
+        struct adp5520_platform_data *pdata = client->dev.platform_data;
+        struct platform_device *pdev;
+        struct adp5520_chip *chip;
+        int ret;
+
+        if (!i2c_check_functionality(client->adapter,
+                                        I2C_FUNC_SMBUS_BYTE_DATA)) {
+                dev_err(&client->dev, "SMBUS Word Data not Supported\n");
+                return -EIO;
+        }
+
+        if (pdata == NULL) {
+                dev_err(&client->dev, "missing platform data\n");
+                return -ENODEV;
+        }
+
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+        if (!chip)
+                return -ENOMEM;
+
+        i2c_set_clientdata(client, chip);
+        chip->client = client;
+
+        chip->dev = &client->dev;
+        chip->irq = client->irq;
+        chip->id = id->driver_data;
+        mutex_init(&chip->lock);
+
+        if (chip->irq) {
+                BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);
+
+                ret = request_threaded_irq(chip->irq, NULL, adp5520_irq_thread,
+                                IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+                                "adp5520", chip);
+                if (ret) {
+                        dev_err(&client->dev, "failed to request irq %d\n",
+                                        chip->irq);
+                        goto out_free_chip;
+                }
+        }
+
+        ret = adp5520_write(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
+        if (ret) {
+                dev_err(&client->dev, "failed to write\n");
+                goto out_free_irq;
+        }
+
+        if (pdata->keys) {
+                pdev = platform_device_register_data(chip->dev, "adp5520-keys",
+                                chip->id, pdata->keys, sizeof(*pdata->keys));
+                if (IS_ERR(pdev)) {
+                        ret = PTR_ERR(pdev);
+                        goto out_remove_subdevs;
+                }
+        }
+
+        if (pdata->gpio) {
+                pdev = platform_device_register_data(chip->dev, "adp5520-gpio",
+                                chip->id, pdata->gpio, sizeof(*pdata->gpio));
+                if (IS_ERR(pdev)) {
+                        ret = PTR_ERR(pdev);
+                        goto out_remove_subdevs;
+                }
+        }
+
+        if (pdata->leds) {
+                pdev = platform_device_register_data(chip->dev, "adp5520-led",
+                                chip->id, pdata->leds, sizeof(*pdata->leds));
+                if (IS_ERR(pdev)) {
+                        ret = PTR_ERR(pdev);
+                        goto out_remove_subdevs;
+                }
+        }
+
+        if (pdata->backlight) {
+                pdev = platform_device_register_data(chip->dev,
+                                                "adp5520-backlight",
+                                                chip->id,
+                                                pdata->backlight,
+                                                sizeof(*pdata->backlight));
+                if (IS_ERR(pdev)) {
+                        ret = PTR_ERR(pdev);
+                        goto out_remove_subdevs;
+                }
+        }
+
+        return 0;
+
+out_remove_subdevs:
+        adp5520_remove_subdevs(chip);
+
+out_free_irq:
+        if (chip->irq)
+                free_irq(chip->irq, chip);
+
+out_free_chip:
+        i2c_set_clientdata(client, NULL);
+        kfree(chip);
+
+        return ret;
+}
+
+static int __devexit adp5520_remove(struct i2c_client *client)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(&client->dev);
+
+        if (chip->irq)
+                free_irq(chip->irq, chip);
+
+        adp5520_remove_subdevs(chip);
+        adp5520_write(chip->dev, ADP5520_MODE_STATUS, 0);
+        i2c_set_clientdata(client, NULL);
+        kfree(chip);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int adp5520_suspend(struct i2c_client *client,
+                                 pm_message_t state)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(&client->dev);
+
+        adp5520_clr_bits(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
+        return 0;
+}
+
+static int adp5520_resume(struct i2c_client *client)
+{
+        struct adp5520_chip *chip = dev_get_drvdata(&client->dev);
+
+        adp5520_set_bits(chip->dev, ADP5520_MODE_STATUS, ADP5520_nSTNBY);
+        return 0;
+}
+#else
+#define adp5520_suspend NULL
+#define adp5520_resume  NULL
+#endif
+
+static const struct i2c_device_id adp5520_id[] = {
+        { "pmic-adp5520", ID_ADP5520 },
+        { "pmic-adp5501", ID_ADP5501 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, adp5520_id);
+
+static struct i2c_driver adp5520_driver = {
+        .driver = {
+                .name   = "adp5520",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = adp5520_probe,
+        .remove         = __devexit_p(adp5520_remove),
+        .suspend        = adp5520_suspend,
+        .resume         = adp5520_resume,
+        .id_table       = adp5520_id,
+};
+
+static int __init adp5520_init(void)
+{
+        return i2c_add_driver(&adp5520_driver);
+}
+module_init(adp5520_init);
+
+static void __exit adp5520_exit(void)
+{
+        i2c_del_driver(&adp5520_driver);
+}
+module_exit(adp5520_exit);
+
+MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
+MODULE_DESCRIPTION("ADP5520(01) PMIC-MFD Driver");
+MODULE_LICENSE("GPL");
diff --git a/include/linux/mfd/adp5520.h b/include/linux/mfd/adp5520.h
new file mode 100644
index 000000000000..ac37558a4673
--- /dev/null
+++ b/include/linux/mfd/adp5520.h
@@ -0,0 +1,299 @@
+/*
+ * Definitions and platform data for Analog Devices
+ * ADP5520/ADP5501 MFD PMICs (Backlight, LED, GPIO and Keys)
+ *
+ * Copyright 2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+
+#ifndef __LINUX_MFD_ADP5520_H
+#define __LINUX_MFD_ADP5520_H
+
+#define ID_ADP5520              5520
+#define ID_ADP5501              5501
+
+/*
+ * ADP5520/ADP5501 Register Map
+ */
+
+#define ADP5520_MODE_STATUS             0x00
+#define ADP5520_INTERRUPT_ENABLE        0x01
+#define ADP5520_BL_CONTROL              0x02
+#define ADP5520_BL_TIME                 0x03
+#define ADP5520_BL_FADE                 0x04
+#define ADP5520_DAYLIGHT_MAX            0x05
+#define ADP5520_DAYLIGHT_DIM            0x06
+#define ADP5520_OFFICE_MAX              0x07
+#define ADP5520_OFFICE_DIM              0x08
+#define ADP5520_DARK_MAX                0x09
+#define ADP5520_DARK_DIM                0x0A
+#define ADP5520_BL_VALUE                0x0B
+#define ADP5520_ALS_CMPR_CFG            0x0C
+#define ADP5520_L2_TRIP                 0x0D
+#define ADP5520_L2_HYS                  0x0E
+#define ADP5520_L3_TRIP                 0x0F
+#define ADP5520_L3_HYS                  0x10
+#define ADP5520_LED_CONTROL             0x11
+#define ADP5520_LED_TIME                0x12
+#define ADP5520_LED_FADE                0x13
+#define ADP5520_LED1_CURRENT            0x14
+#define ADP5520_LED2_CURRENT            0x15
+#define ADP5520_LED3_CURRENT            0x16
+
+/*
+ * ADP5520 Register Map
+ */
+
+#define ADP5520_GPIO_CFG_1              0x17
+#define ADP5520_GPIO_CFG_2              0x18
+#define ADP5520_GPIO_IN                 0x19
+#define ADP5520_GPIO_OUT                0x1A
+#define ADP5520_GPIO_INT_EN             0x1B
+#define ADP5520_GPIO_INT_STAT           0x1C
+#define ADP5520_GPIO_INT_LVL            0x1D
+#define ADP5520_GPIO_DEBOUNCE           0x1E
+#define ADP5520_GPIO_PULLUP             0x1F
+#define ADP5520_KP_INT_STAT_1           0x20
+#define ADP5520_KP_INT_STAT_2           0x21
+#define ADP5520_KR_INT_STAT_1           0x22
+#define ADP5520_KR_INT_STAT_2           0x23
+#define ADP5520_KEY_STAT_1              0x24
+#define ADP5520_KEY_STAT_2              0x25
+
+/*
+ * MODE_STATUS bits
+ */
+
+#define ADP5520_nSTNBY          (1 << 7)
+#define ADP5520_BL_EN           (1 << 6)
+#define ADP5520_DIM_EN          (1 << 5)
+#define ADP5520_OVP_INT         (1 << 4)
+#define ADP5520_CMPR_INT        (1 << 3)
+#define ADP5520_GPI_INT         (1 << 2)
+#define ADP5520_KR_INT          (1 << 1)
+#define ADP5520_KP_INT          (1 << 0)
+
+/*
+ * INTERRUPT_ENABLE bits
+ */
+
+#define ADP5520_AUTO_LD_EN      (1 << 4)
+#define ADP5520_CMPR_IEN        (1 << 3)
+#define ADP5520_OVP_IEN         (1 << 2)
+#define ADP5520_KR_IEN          (1 << 1)
+#define ADP5520_KP_IEN          (1 << 0)
+
+/*
+ * BL_CONTROL bits
+ */
+
+#define ADP5520_BL_LVL          ((x) << 5)
+#define ADP5520_BL_LAW          ((x) << 4)
+#define ADP5520_BL_AUTO_ADJ     (1 << 3)
+#define ADP5520_OVP_EN          (1 << 2)
+#define ADP5520_FOVR            (1 << 1)
+#define ADP5520_KP_BL_EN        (1 << 0)
+
+/*
+ * ALS_CMPR_CFG bits
+ */
+
+#define ADP5520_L3_OUT          (1 << 3)
+#define ADP5520_L2_OUT          (1 << 2)
+#define ADP5520_L3_EN           (1 << 1)
+
+#define ADP5020_MAX_BRIGHTNESS  0x7F
+
+#define FADE_VAL(in, out)       ((0xF & (in)) | ((0xF & (out)) << 4))
+#define BL_CTRL_VAL(law, auto)  (((1 & (auto)) << 3) | ((0x3 & (law)) << 4))
+#define ALS_CMPR_CFG_VAL(filt, l3_en)   (((0x7 & filt) << 5) | l3_en)
+
+/*
+ * LEDs subdevice bits and masks
+ */
+
+#define ADP5520_01_MAXLEDS 3
+
+#define ADP5520_FLAG_LED_MASK           0x3
+#define ADP5520_FLAG_OFFT_SHIFT         8
+#define ADP5520_FLAG_OFFT_MASK          0x3
+
+#define ADP5520_R3_MODE         (1 << 5)
+#define ADP5520_C3_MODE         (1 << 4)
+#define ADP5520_LED_LAW         (1 << 3)
+#define ADP5520_LED3_EN         (1 << 2)
+#define ADP5520_LED2_EN         (1 << 1)
+#define ADP5520_LED1_EN         (1 << 0)
+
+/*
+ * GPIO subdevice bits and masks
+ */
+
+#define ADP5520_MAXGPIOS        8
+
+#define ADP5520_GPIO_C3         (1 << 7)        /* LED2 or GPIO7 aka C3 */
+#define ADP5520_GPIO_C2         (1 << 6)
+#define ADP5520_GPIO_C1         (1 << 5)
+#define ADP5520_GPIO_C0         (1 << 4)
+#define ADP5520_GPIO_R3         (1 << 3)        /* LED3 or GPIO3 aka R3 */
+#define ADP5520_GPIO_R2         (1 << 2)
+#define ADP5520_GPIO_R1         (1 << 1)
+#define ADP5520_GPIO_R0         (1 << 0)
+
+struct adp5520_gpio_platform_data {
+        unsigned gpio_start;
+        u8 gpio_en_mask;
+        u8 gpio_pullup_mask;
+};
+
+/*
+ * Keypad subdevice bits and masks
+ */
+
+#define ADP5520_MAXKEYS 16
+
+#define ADP5520_COL_C3          (1 << 7)        /* LED2 or GPIO7 aka C3 */
+#define ADP5520_COL_C2          (1 << 6)
+#define ADP5520_COL_C1          (1 << 5)
+#define ADP5520_COL_C0          (1 << 4)
+#define ADP5520_ROW_R3          (1 << 3)        /* LED3 or GPIO3 aka R3 */
+#define ADP5520_ROW_R2          (1 << 2)
+#define ADP5520_ROW_R1          (1 << 1)
+#define ADP5520_ROW_R0          (1 << 0)
+
+#define ADP5520_KEY(row, col) (col + row * 4)
+#define ADP5520_KEYMAPSIZE      ADP5520_MAXKEYS
+
+struct adp5520_keys_platform_data {
+        int rows_en_mask;               /* Number of rows */
+        int cols_en_mask;               /* Number of columns */
+        const unsigned short *keymap;   /* Pointer to keymap */
+        unsigned short keymapsize;      /* Keymap size */
+        unsigned repeat:1;              /* Enable key repeat */
+};
+
+
+/*
+ * LEDs subdevice platform data
+ */
+
+#define FLAG_ID_ADP5520_LED1_ADP5501_LED0       1       /* ADP5520 PIN ILED */
+#define FLAG_ID_ADP5520_LED2_ADP5501_LED1       2       /* ADP5520 PIN C3 */
+#define FLAG_ID_ADP5520_LED3_ADP5501_LED2       3       /* ADP5520 PIN R3 */
+
+#define ADP5520_LED_DIS_BLINK   (0 << ADP5520_FLAG_OFFT_SHIFT)
+#define ADP5520_LED_OFFT_600ms  (1 << ADP5520_FLAG_OFFT_SHIFT)
+#define ADP5520_LED_OFFT_800ms  (2 << ADP5520_FLAG_OFFT_SHIFT)
+#define ADP5520_LED_OFFT_1200ms (3 << ADP5520_FLAG_OFFT_SHIFT)
+
+#define ADP5520_LED_ONT_200ms   0
+#define ADP5520_LED_ONT_600ms   1
+#define ADP5520_LED_ONT_800ms   2
+#define ADP5520_LED_ONT_1200ms  3
+
+struct adp5520_leds_platform_data {
+        int num_leds;
+        struct led_info *leds;
+        u8 fade_in;             /* Backlight Fade-In Timer */
+        u8 fade_out;            /* Backlight Fade-Out Timer */
+        u8 led_on_time;
+};
+
+/*
+ * Backlight subdevice platform data
+ */
+
+#define ADP5520_FADE_T_DIS      0       /* Fade Timer Disabled */
+#define ADP5520_FADE_T_300ms    1       /* 0.3 Sec */
+#define ADP5520_FADE_T_600ms    2
+#define ADP5520_FADE_T_900ms    3
+#define ADP5520_FADE_T_1200ms   4
+#define ADP5520_FADE_T_1500ms   5
+#define ADP5520_FADE_T_1800ms   6
+#define ADP5520_FADE_T_2100ms   7
+#define ADP5520_FADE_T_2400ms   8
+#define ADP5520_FADE_T_2700ms   9
+#define ADP5520_FADE_T_3000ms   10
+#define ADP5520_FADE_T_3500ms   11
+#define ADP5520_FADE_T_4000ms   12
+#define ADP5520_FADE_T_4500ms   13
+#define ADP5520_FADE_T_5000ms   14
+#define ADP5520_FADE_T_5500ms   15      /* 5.5 Sec */
+
+#define ADP5520_BL_LAW_LINEAR   0
+#define ADP5520_BL_LAW_SQUARE   1
+#define ADP5520_BL_LAW_CUBIC1   2
+#define ADP5520_BL_LAW_CUBIC2   3
+
+#define ADP5520_BL_AMBL_FILT_80ms       0       /* Light sensor filter time */
+#define ADP5520_BL_AMBL_FILT_160ms      1
+#define ADP5520_BL_AMBL_FILT_320ms      2
+#define ADP5520_BL_AMBL_FILT_640ms      3
+#define ADP5520_BL_AMBL_FILT_1280ms     4
+#define ADP5520_BL_AMBL_FILT_2560ms     5
+#define ADP5520_BL_AMBL_FILT_5120ms     6
+#define ADP5520_BL_AMBL_FILT_10240ms    7       /* 10.24 sec */
+
+        /*
+         * Blacklight current 0..30mA
+         */
+#define ADP5520_BL_CUR_mA(I)            ((I * 127) / 30)
+
+        /*
+         * L2 comparator current 0..1000uA
+         */
+#define ADP5520_L2_COMP_CURR_uA(I)      ((I * 255) / 1000)
+
+        /*
+         * L3 comparator current 0..127uA
+         */
+#define ADP5520_L3_COMP_CURR_uA(I)      ((I * 255) / 127)
+
+struct adp5520_backlight_platform_data {
+        u8 fade_in;             /* Backlight Fade-In Timer */
+        u8 fade_out;            /* Backlight Fade-Out Timer */
+        u8 fade_led_law;        /* fade-on/fade-off transfer characteristic */
+
+        u8 en_ambl_sens;        /* 1 = enable ambient light sensor */
+        u8 abml_filt;           /* Light sensor filter time */
+        u8 l1_daylight_max;     /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l1_daylight_dim;     /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l2_office_max;       /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l2_office_dim;       /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l3_dark_max;         /* use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l3_dark_dim;         /* typ = 0, use BL_CUR_mA(I) 0 <= I <= 30 mA */
+        u8 l2_trip;             /* use L2_COMP_CURR_uA(I) 0 <= I <= 1000 uA */
+        u8 l2_hyst;             /* use L2_COMP_CURR_uA(I) 0 <= I <= 1000 uA */
+        u8 l3_trip;             /* use L3_COMP_CURR_uA(I) 0 <= I <= 127 uA */
+        u8 l3_hyst;             /* use L3_COMP_CURR_uA(I) 0 <= I <= 127 uA */
+};
+
+/*
+ * MFD chip platform data
+ */
+
+struct adp5520_platform_data {
+        struct adp5520_keys_platform_data *keys;
+        struct adp5520_gpio_platform_data *gpio;
+        struct adp5520_leds_platform_data *leds;
+        struct adp5520_backlight_platform_data *backlight;
+};
+
+/*
+ * MFD chip functions
+ */
+
+extern int adp5520_read(struct device *dev, int reg, uint8_t *val);
+extern int adp5520_write(struct device *dev, int reg, u8 val);
+extern int adp5520_clr_bits(struct device *dev, int reg, uint8_t bit_mask);
+extern int adp5520_set_bits(struct device *dev, int reg, uint8_t bit_mask);
+
+extern int adp5520_register_notifier(struct device *dev,
+                 struct notifier_block *nb, unsigned int events);
+
+extern int adp5520_unregister_notifier(struct device *dev,
+                struct notifier_block *nb, unsigned int events);
+
+#endif /* __LINUX_MFD_ADP5520_H */