backlight: new backlight driver for LP855x devices

THis driver supports TI LP8550/LP8551/LP8552/LP8553/LP8556 backlight
devices.

The brightness can be controlled by the I2C or PWM input.  The lp855x
driver provides both modes.  For the PWM control, pwm-specific functions
can be defined in the platform data.  And some information can be read
via the sysfs(lp855x device attributes).

For details, please refer to Documentation/backlight/lp855x-driver.txt.

[axel.lin@gmail.com: add missing mutex_unlock in lp855x_read_byte() error path]
[axel.lin@gmail.com: check platform data in lp855x_probe()]
[axel.lin@gmail.com: small cleanups]
[dan.carpenter@oracle.com: silence a compiler warning]
[axel.lin@gmail.com: use id->driver_data to differentiate lp855x chips]
[akpm@linux-foundation.org: simplify boolean return expression]
Signed-off-by: Milo(Woogyom) Kim <milo.kim@ti.com>
Signed-off-by: Axel Lin <axel.lin@gmail.com>
Signed-off-by: Dan Carpenter <dan.carpenter@oracle.com>
Cc: Richard Purdie <rpurdie@rpsys.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

3 files changed, 339 insertions, 0 deletions

diff --git a/drivers/video/backlight/Kconfig b/drivers/video/backlight/Kconfig
index 681b36929fe4..49e7d83f869f 100644
--- a/drivers/video/backlight/Kconfig
+++ b/drivers/video/backlight/Kconfig
@@ -334,6 +334,13 @@ config BACKLIGHT_AAT2870
           If you have a AnalogicTech AAT2870 say Y to enable the
           backlight driver.
 
+config BACKLIGHT_LP855X
+        tristate "Backlight driver for TI LP855X"
+        depends on BACKLIGHT_CLASS_DEVICE && I2C
+        help
+          This supports TI LP8550, LP8551, LP8552, LP8553 and LP8556
+          backlight driver.
+
 endif # BACKLIGHT_CLASS_DEVICE
 
 endif # BACKLIGHT_LCD_SUPPORT
diff --git a/drivers/video/backlight/Makefile b/drivers/video/backlight/Makefile
index af5cf654ec7c..0ee06e0832bd 100644
--- a/drivers/video/backlight/Makefile
+++ b/drivers/video/backlight/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_BACKLIGHT_GENERIC)	+= generic_bl.o
 obj-$(CONFIG_BACKLIGHT_HP700)   += jornada720_bl.o
 obj-$(CONFIG_BACKLIGHT_HP680)   += hp680_bl.o
 obj-$(CONFIG_BACKLIGHT_LOCOMO)  += locomolcd.o
+obj-$(CONFIG_BACKLIGHT_LP855X)  += lp855x_bl.o
 obj-$(CONFIG_BACKLIGHT_OMAP1)   += omap1_bl.o
 obj-$(CONFIG_BACKLIGHT_PROGEAR) += progear_bl.o
 obj-$(CONFIG_BACKLIGHT_CARILLO_RANCH) += cr_bllcd.o
diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c
new file mode 100644
index 000000000000..72a0e0c917cf
--- /dev/null
+++ b/drivers/video/backlight/lp855x_bl.c
@@ -0,0 +1,331 @@
+/*
+ * TI LP855x Backlight Driver
+ *
+ *                      Copyright (C) 2011 Texas Instruments
+ *
+ * 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/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/backlight.h>
+#include <linux/err.h>
+#include <linux/lp855x.h>
+
+/* Registers */
+#define BRIGHTNESS_CTRL         (0x00)
+#define DEVICE_CTRL             (0x01)
+
+#define BUF_SIZE                20
+#define DEFAULT_BL_NAME         "lcd-backlight"
+#define MAX_BRIGHTNESS          255
+
+struct lp855x {
+        const char *chipname;
+        enum lp855x_chip_id chip_id;
+        struct i2c_client *client;
+        struct backlight_device *bl;
+        struct device *dev;
+        struct mutex xfer_lock;
+        struct lp855x_platform_data *pdata;
+};
+
+static int lp855x_read_byte(struct lp855x *lp, u8 reg, u8 *data)
+{
+        int ret;
+
+        mutex_lock(&lp->xfer_lock);
+        ret = i2c_smbus_read_byte_data(lp->client, reg);
+        if (ret < 0) {
+                mutex_unlock(&lp->xfer_lock);
+                dev_err(lp->dev, "failed to read 0x%.2x\n", reg);
+                return ret;
+        }
+        mutex_unlock(&lp->xfer_lock);
+
+        *data = (u8)ret;
+        return 0;
+}
+
+static int lp855x_write_byte(struct lp855x *lp, u8 reg, u8 data)
+{
+        int ret;
+
+        mutex_lock(&lp->xfer_lock);
+        ret = i2c_smbus_write_byte_data(lp->client, reg, data);
+        mutex_unlock(&lp->xfer_lock);
+
+        return ret;
+}
+
+static bool lp855x_is_valid_rom_area(struct lp855x *lp, u8 addr)
+{
+        u8 start, end;
+
+        switch (lp->chip_id) {
+        case LP8550:
+        case LP8551:
+        case LP8552:
+        case LP8553:
+                start = EEPROM_START;
+                end = EEPROM_END;
+                break;
+        case LP8556:
+                start = EPROM_START;
+                end = EPROM_END;
+                break;
+        default:
+                return false;
+        }
+
+        return (addr >= start && addr <= end);
+}
+
+static int lp855x_init_registers(struct lp855x *lp)
+{
+        u8 val, addr;
+        int i, ret;
+        struct lp855x_platform_data *pd = lp->pdata;
+
+        val = pd->initial_brightness;
+        ret = lp855x_write_byte(lp, BRIGHTNESS_CTRL, val);
+        if (ret)
+                return ret;
+
+        val = pd->device_control;
+        ret = lp855x_write_byte(lp, DEVICE_CTRL, val);
+        if (ret)
+                return ret;
+
+        if (pd->load_new_rom_data && pd->size_program) {
+                for (i = 0; i < pd->size_program; i++) {
+                        addr = pd->rom_data[i].addr;
+                        val = pd->rom_data[i].val;
+                        if (!lp855x_is_valid_rom_area(lp, addr))
+                                continue;
+
+                        ret = lp855x_write_byte(lp, addr, val);
+                        if (ret)
+                                return ret;
+                }
+        }
+
+        return ret;
+}
+
+static int lp855x_bl_update_status(struct backlight_device *bl)
+{
+        struct lp855x *lp = bl_get_data(bl);
+        enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode;
+
+        if (bl->props.state & BL_CORE_SUSPENDED)
+                bl->props.brightness = 0;
+
+        if (mode == PWM_BASED) {
+                struct lp855x_pwm_data *pd = &lp->pdata->pwm_data;
+                int br = bl->props.brightness;
+                int max_br = bl->props.max_brightness;
+
+                if (pd->pwm_set_intensity)
+                        pd->pwm_set_intensity(br, max_br);
+
+        } else if (mode == REGISTER_BASED) {
+                u8 val = bl->props.brightness;
+                lp855x_write_byte(lp, BRIGHTNESS_CTRL, val);
+        }
+
+        return 0;
+}
+
+static int lp855x_bl_get_brightness(struct backlight_device *bl)
+{
+        struct lp855x *lp = bl_get_data(bl);
+        enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode;
+
+        if (mode == PWM_BASED) {
+                struct lp855x_pwm_data *pd = &lp->pdata->pwm_data;
+                int max_br = bl->props.max_brightness;
+
+                if (pd->pwm_get_intensity)
+                        bl->props.brightness = pd->pwm_get_intensity(max_br);
+
+        } else if (mode == REGISTER_BASED) {
+                u8 val = 0;
+
+                lp855x_read_byte(lp, BRIGHTNESS_CTRL, &val);
+                bl->props.brightness = val;
+        }
+
+        return bl->props.brightness;
+}
+
+static const struct backlight_ops lp855x_bl_ops = {
+        .options = BL_CORE_SUSPENDRESUME,
+        .update_status = lp855x_bl_update_status,
+        .get_brightness = lp855x_bl_get_brightness,
+};
+
+static int lp855x_backlight_register(struct lp855x *lp)
+{
+        struct backlight_device *bl;
+        struct backlight_properties props;
+        struct lp855x_platform_data *pdata = lp->pdata;
+        char *name = pdata->name ? : DEFAULT_BL_NAME;
+
+        props.type = BACKLIGHT_PLATFORM;
+        props.max_brightness = MAX_BRIGHTNESS;
+
+        if (pdata->initial_brightness > props.max_brightness)
+                pdata->initial_brightness = props.max_brightness;
+
+        props.brightness = pdata->initial_brightness;
+
+        bl = backlight_device_register(name, lp->dev, lp,
+                                       &lp855x_bl_ops, &props);
+        if (IS_ERR(bl))
+                return PTR_ERR(bl);
+
+        lp->bl = bl;
+
+        return 0;
+}
+
+static void lp855x_backlight_unregister(struct lp855x *lp)
+{
+        if (lp->bl)
+                backlight_device_unregister(lp->bl);
+}
+
+static ssize_t lp855x_get_chip_id(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct lp855x *lp = dev_get_drvdata(dev);
+        return scnprintf(buf, BUF_SIZE, "%s\n", lp->chipname);
+}
+
+static ssize_t lp855x_get_bl_ctl_mode(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct lp855x *lp = dev_get_drvdata(dev);
+        enum lp855x_brightness_ctrl_mode mode = lp->pdata->mode;
+        char *strmode = NULL;
+
+        if (mode == PWM_BASED)
+                strmode = "pwm based";
+        else if (mode == REGISTER_BASED)
+                strmode = "register based";
+
+        return scnprintf(buf, BUF_SIZE, "%s\n", strmode);
+}
+
+static DEVICE_ATTR(chip_id, S_IRUGO, lp855x_get_chip_id, NULL);
+static DEVICE_ATTR(bl_ctl_mode, S_IRUGO, lp855x_get_bl_ctl_mode, NULL);
+
+static struct attribute *lp855x_attributes[] = {
+        &dev_attr_chip_id.attr,
+        &dev_attr_bl_ctl_mode.attr,
+        NULL,
+};
+
+static const struct attribute_group lp855x_attr_group = {
+        .attrs = lp855x_attributes,
+};
+
+static int lp855x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
+{
+        struct lp855x *lp;
+        struct lp855x_platform_data *pdata = cl->dev.platform_data;
+        enum lp855x_brightness_ctrl_mode mode;
+        int ret;
+
+        if (!pdata) {
+                dev_err(&cl->dev, "no platform data supplied\n");
+                return -EINVAL;
+        }
+
+        if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
+                return -EIO;
+
+        lp = devm_kzalloc(&cl->dev, sizeof(struct lp855x), GFP_KERNEL);
+        if (!lp)
+                return -ENOMEM;
+
+        mode = pdata->mode;
+        lp->client = cl;
+        lp->dev = &cl->dev;
+        lp->pdata = pdata;
+        lp->chipname = id->name;
+        lp->chip_id = id->driver_data;
+        i2c_set_clientdata(cl, lp);
+
+        mutex_init(&lp->xfer_lock);
+
+        ret = lp855x_init_registers(lp);
+        if (ret) {
+                dev_err(lp->dev, "i2c communication err: %d", ret);
+                if (mode == REGISTER_BASED)
+                        goto err_dev;
+        }
+
+        ret = lp855x_backlight_register(lp);
+        if (ret) {
+                dev_err(lp->dev,
+                        "failed to register backlight. err: %d\n", ret);
+                goto err_dev;
+        }
+
+        ret = sysfs_create_group(&lp->dev->kobj, &lp855x_attr_group);
+        if (ret) {
+                dev_err(lp->dev, "failed to register sysfs. err: %d\n", ret);
+                goto err_sysfs;
+        }
+
+        backlight_update_status(lp->bl);
+        return 0;
+
+err_sysfs:
+        lp855x_backlight_unregister(lp);
+err_dev:
+        return ret;
+}
+
+static int __devexit lp855x_remove(struct i2c_client *cl)
+{
+        struct lp855x *lp = i2c_get_clientdata(cl);
+
+        lp->bl->props.brightness = 0;
+        backlight_update_status(lp->bl);
+        sysfs_remove_group(&lp->dev->kobj, &lp855x_attr_group);
+        lp855x_backlight_unregister(lp);
+
+        return 0;
+}
+
+static const struct i2c_device_id lp855x_ids[] = {
+        {"lp8550", LP8550},
+        {"lp8551", LP8551},
+        {"lp8552", LP8552},
+        {"lp8553", LP8553},
+        {"lp8556", LP8556},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lp855x_ids);
+
+static struct i2c_driver lp855x_driver = {
+        .driver = {
+                   .name = "lp855x",
+                   },
+        .probe = lp855x_probe,
+        .remove = __devexit_p(lp855x_remove),
+        .id_table = lp855x_ids,
+};
+
+module_i2c_driver(lp855x_driver);
+
+MODULE_DESCRIPTION("Texas Instruments LP855x Backlight driver");
+MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>");
+MODULE_LICENSE("GPL");