Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7be865ab authored by Kim, Milo's avatar Kim, Milo Committed by Linus Torvalds
Browse files

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: default avatarMilo(Woogyom) Kim <milo.kim@ti.com>
Signed-off-by: default avatarAxel Lin <axel.lin@gmail.com>
Signed-off-by: default avatarDan Carpenter <dan.carpenter@oracle.com>
Cc: Richard Purdie <rpurdie@rpsys.net>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 050ea48b

Documentation/backlight/lp855x-driver.txt

0 → 100644
+78 −0
Original line number Diff line number Diff line 
Kernel driver lp855x

====================



Backlight driver for LP855x ICs



Supported chips:

	Texas Instruments LP8550, LP8551, LP8552, LP8553 and LP8556



Author: Milo(Woogyom) Kim <milo.kim@ti.com>



Description

-----------



* Brightness control



Brightness can be controlled by the pwm input or the i2c command.

The lp855x driver supports both cases.



* Device attributes



1) bl_ctl_mode

Backlight control mode.

Value : pwm based or register based



2) chip_id

The lp855x chip id.

Value : lp8550/lp8551/lp8552/lp8553/lp8556



Platform data for lp855x

------------------------



For supporting platform specific data, the lp855x platform data can be used.



* name : Backlight driver name. If it is not defined, default name is set.

* mode : Brightness control mode. PWM or register based.

* device_control : Value of DEVICE CONTROL register.

* initial_brightness : Initial value of backlight brightness.

* pwm_data : Platform specific pwm generation functions.

	     Only valid when brightness is pwm input mode.

	     Functions should be implemented by PWM driver.

	     - pwm_set_intensity() : set duty of PWM

	     - pwm_get_intensity() : get current duty of PWM

* load_new_rom_data :

	0 : use default configuration data

	1 : update values of eeprom or eprom registers on loading driver

* size_program : Total size of lp855x_rom_data.

* rom_data : List of new eeprom/eprom registers.



example 1) lp8552 platform data : i2c register mode with new eeprom data



#define EEPROM_A5_ADDR	0xA5

#define EEPROM_A5_VAL	0x4f	/* EN_VSYNC=0 */



static struct lp855x_rom_data lp8552_eeprom_arr[] = {

	{EEPROM_A5_ADDR, EEPROM_A5_VAL},

};



static struct lp855x_platform_data lp8552_pdata = {

	.name = "lcd-bl",

	.mode = REGISTER_BASED,

	.device_control = I2C_CONFIG(LP8552),

	.initial_brightness = INITIAL_BRT,

	.load_new_rom_data = 1,

	.size_program = ARRAY_SIZE(lp8552_eeprom_arr),

	.rom_data = lp8552_eeprom_arr,

};



example 2) lp8556 platform data : pwm input mode with default rom data



static struct lp855x_platform_data lp8556_pdata = {

	.mode = PWM_BASED,

	.device_control = PWM_CONFIG(LP8556),

	.initial_brightness = INITIAL_BRT,

	.pwm_data = {

		     .pwm_set_intensity = platform_pwm_set_intensity,

		     .pwm_get_intensity = platform_pwm_get_intensity,

		     },

};

drivers/video/backlight/Kconfig

+7 −0
Original line number Diff line number Diff line
@@ -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

drivers/video/backlight/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -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

drivers/video/backlight/lp855x_bl.c

0 → 100644
+331 −0
Original line number Diff line number Diff line 
/*

 * 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");

include/linux/lp855x.h

0 → 100644
+131 −0
Original line number Diff line number Diff line 
/*

 * 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.

 *

 */



#ifndef _LP855X_H

#define _LP855X_H



#define BL_CTL_SHFT	(0)

#define BRT_MODE_SHFT	(1)

#define BRT_MODE_MASK	(0x06)



/* Enable backlight. Only valid when BRT_MODE=10(I2C only) */

#define ENABLE_BL	(1)

#define DISABLE_BL	(0)



#define I2C_CONFIG(id)	id ## _I2C_CONFIG

#define PWM_CONFIG(id)	id ## _PWM_CONFIG



/* DEVICE CONTROL register - LP8550 */

#define LP8550_PWM_CONFIG	(LP8550_PWM_ONLY << BRT_MODE_SHFT)

#define LP8550_I2C_CONFIG	((ENABLE_BL << BL_CTL_SHFT) | \

				(LP8550_I2C_ONLY << BRT_MODE_SHFT))



/* DEVICE CONTROL register - LP8551 */

#define LP8551_PWM_CONFIG	LP8550_PWM_CONFIG

#define LP8551_I2C_CONFIG	LP8550_I2C_CONFIG



/* DEVICE CONTROL register - LP8552 */

#define LP8552_PWM_CONFIG	LP8550_PWM_CONFIG

#define LP8552_I2C_CONFIG	LP8550_I2C_CONFIG



/* DEVICE CONTROL register - LP8553 */

#define LP8553_PWM_CONFIG	LP8550_PWM_CONFIG

#define LP8553_I2C_CONFIG	LP8550_I2C_CONFIG



/* DEVICE CONTROL register - LP8556 */

#define LP8556_PWM_CONFIG	(LP8556_PWM_ONLY << BRT_MODE_SHFT)

#define LP8556_COMB1_CONFIG	(LP8556_COMBINED1 << BRT_MODE_SHFT)

#define LP8556_I2C_CONFIG	((ENABLE_BL << BL_CTL_SHFT) | \

				(LP8556_I2C_ONLY << BRT_MODE_SHFT))

#define LP8556_COMB2_CONFIG	(LP8556_COMBINED2 << BRT_MODE_SHFT)



/* ROM area boundary */

#define EEPROM_START	(0xA0)

#define EEPROM_END	(0xA7)

#define EPROM_START	(0xA0)

#define EPROM_END	(0xAF)



enum lp855x_chip_id {

	LP8550,

	LP8551,

	LP8552,

	LP8553,

	LP8556,

};



enum lp855x_brightness_ctrl_mode {

	PWM_BASED = 1,

	REGISTER_BASED,

};



enum lp8550_brighntess_source {

	LP8550_PWM_ONLY,

	LP8550_I2C_ONLY = 2,

};



enum lp8551_brighntess_source {

	LP8551_PWM_ONLY = LP8550_PWM_ONLY,

	LP8551_I2C_ONLY = LP8550_I2C_ONLY,

};



enum lp8552_brighntess_source {

	LP8552_PWM_ONLY = LP8550_PWM_ONLY,

	LP8552_I2C_ONLY = LP8550_I2C_ONLY,

};



enum lp8553_brighntess_source {

	LP8553_PWM_ONLY = LP8550_PWM_ONLY,

	LP8553_I2C_ONLY = LP8550_I2C_ONLY,

};



enum lp8556_brightness_source {

	LP8556_PWM_ONLY,

	LP8556_COMBINED1,	/* pwm + i2c before the shaper block */

	LP8556_I2C_ONLY,

	LP8556_COMBINED2,	/* pwm + i2c after the shaper block */

};



struct lp855x_pwm_data {

	void (*pwm_set_intensity) (int brightness, int max_brightness);

	int (*pwm_get_intensity) (int max_brightness);

};



struct lp855x_rom_data {

	u8 addr;

	u8 val;

};



/**

 * struct lp855x_platform_data

 * @name : Backlight driver name. If it is not defined, default name is set.

 * @mode : brightness control by pwm or lp855x register

 * @device_control : value of DEVICE CONTROL register

 * @initial_brightness : initial value of backlight brightness

 * @pwm_data : platform specific pwm generation functions.

		Only valid when mode is PWM_BASED.

 * @load_new_rom_data :

	0 : use default configuration data

	1 : update values of eeprom or eprom registers on loading driver

 * @size_program : total size of lp855x_rom_data

 * @rom_data : list of new eeprom/eprom registers

 */

struct lp855x_platform_data {

	char *name;

	enum lp855x_brightness_ctrl_mode mode;

	u8 device_control;

	int initial_brightness;

	struct lp855x_pwm_data pwm_data;

	u8 load_new_rom_data;

	int size_program;

	struct lp855x_rom_data *rom_data;

};



#endif