[mirror_ubuntu-artful-kernel.git] / drivers / video / backlight / lm3639_bl.c

/*
* Simple driver for Texas Instruments LM3639 Backlight + Flash LED driver chip
* Copyright (C) 2012 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/leds.h>
#include <linux/backlight.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/uaccess.h>
#include <linux/interrupt.h>
#include <linux/regmap.h>
#include <linux/platform_data/lm3639_bl.h>

#define REG_DEV_ID	0x00
#define REG_CHECKSUM	0x01
#define REG_BL_CONF_1	0x02
#define REG_BL_CONF_2	0x03
#define REG_BL_CONF_3	0x04
#define REG_BL_CONF_4	0x05
#define REG_FL_CONF_1	0x06
#define REG_FL_CONF_2	0x07
#define REG_FL_CONF_3	0x08
#define REG_IO_CTRL	0x09
#define REG_ENABLE	0x0A
#define REG_FLAG	0x0B
#define REG_MAX		REG_FLAG

struct lm3639_chip_data {
	struct device *dev;
	struct lm3639_platform_data *pdata;

	struct backlight_device *bled;
	struct led_classdev cdev_flash;
	struct led_classdev cdev_torch;
	struct regmap *regmap;

	unsigned int bled_mode;
	unsigned int bled_map;
	unsigned int last_flag;
};

/* initialize chip */
static int lm3639_chip_init(struct lm3639_chip_data *pchip)
{
	int ret;
	unsigned int reg_val;
	struct lm3639_platform_data *pdata = pchip->pdata;

	/* input pins config. */
	ret =
	    regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x08,
			       pdata->pin_pwm);
	if (ret < 0)
		goto out;

	reg_val = (pdata->pin_pwm & 0x40) | pdata->pin_strobe | pdata->pin_tx;
	ret = regmap_update_bits(pchip->regmap, REG_IO_CTRL, 0x7C, reg_val);
	if (ret < 0)
		goto out;

	/* init brightness */
	ret = regmap_write(pchip->regmap, REG_BL_CONF_4, pdata->init_brt_led);
	if (ret < 0)
		goto out;

	ret = regmap_write(pchip->regmap, REG_BL_CONF_3, pdata->init_brt_led);
	if (ret < 0)
		goto out;

	/* output pins config. */
	if (!pdata->init_brt_led) {
		reg_val = pdata->fled_pins;
		reg_val |= pdata->bled_pins;
	} else {
		reg_val = pdata->fled_pins;
		reg_val |= pdata->bled_pins | 0x01;
	}

	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x79, reg_val);
	if (ret < 0)
		goto out;

	return ret;
out:
	dev_err(pchip->dev, "i2c failed to access register\n");
	return ret;
}

/* update and get brightness */
static int lm3639_bled_update_status(struct backlight_device *bl)
{
	int ret;
	unsigned int reg_val;
	struct lm3639_chip_data *pchip = bl_get_data(bl);
	struct lm3639_platform_data *pdata = pchip->pdata;

	ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
	if (ret < 0)
		goto out;

	if (reg_val != 0)
		dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);

	/* pwm control */
	if (pdata->pin_pwm) {
		if (pdata->pwm_set_intensity)
			pdata->pwm_set_intensity(bl->props.brightness,
						 pdata->max_brt_led);
		else
			dev_err(pchip->dev,
				"No pwm control func. in plat-data\n");
		return bl->props.brightness;
	}

	/* i2c control and set brigtness */
	ret = regmap_write(pchip->regmap, REG_BL_CONF_4, bl->props.brightness);
	if (ret < 0)
		goto out;
	ret = regmap_write(pchip->regmap, REG_BL_CONF_3, bl->props.brightness);
	if (ret < 0)
		goto out;

	if (!bl->props.brightness)
		ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x00);
	else
		ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x01);
	if (ret < 0)
		goto out;

	return bl->props.brightness;
out:
	dev_err(pchip->dev, "i2c failed to access registers\n");
	return bl->props.brightness;
}

static int lm3639_bled_get_brightness(struct backlight_device *bl)
{
	int ret;
	unsigned int reg_val;
	struct lm3639_chip_data *pchip = bl_get_data(bl);
	struct lm3639_platform_data *pdata = pchip->pdata;

	if (pdata->pin_pwm) {
		if (pdata->pwm_get_intensity)
			bl->props.brightness = pdata->pwm_get_intensity();
		else
			dev_err(pchip->dev,
				"No pwm control func. in plat-data\n");
		return bl->props.brightness;
	}

	ret = regmap_read(pchip->regmap, REG_BL_CONF_1, &reg_val);
	if (ret < 0)
		goto out;
	if (reg_val & 0x10)
		ret = regmap_read(pchip->regmap, REG_BL_CONF_4, &reg_val);
	else
		ret = regmap_read(pchip->regmap, REG_BL_CONF_3, &reg_val);
	if (ret < 0)
		goto out;
	bl->props.brightness = reg_val;

	return bl->props.brightness;
out:
	dev_err(pchip->dev, "i2c failed to access register\n");
	return bl->props.brightness;
}

static const struct backlight_ops lm3639_bled_ops = {
	.options = BL_CORE_SUSPENDRESUME,
	.update_status = lm3639_bled_update_status,
	.get_brightness = lm3639_bled_get_brightness,
};

/* backlight mapping mode */
static ssize_t lm3639_bled_mode_store(struct device *dev,
				      struct device_attribute *devAttr,
				      const char *buf, size_t size)
{
	ssize_t ret;
	struct lm3639_chip_data *pchip = dev_get_drvdata(dev);
	unsigned int state;

	ret = kstrtouint(buf, 10, &state);
	if (ret)
		goto out_input;

	if (!state)
		ret =
		    regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10,
				       0x00);
	else
		ret =
		    regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10,
				       0x10);

	if (ret < 0)
		goto out;

	return size;

out:
	dev_err(pchip->dev, "%s:i2c access fail to register\n", __func__);
	return ret;

out_input:
	dev_err(pchip->dev, "%s:input conversion fail\n", __func__);
	return ret;

}

static DEVICE_ATTR(bled_mode, S_IWUSR, NULL, lm3639_bled_mode_store);

/* torch */
static void lm3639_torch_brightness_set(struct led_classdev *cdev,
					enum led_brightness brightness)
{
	int ret;
	unsigned int reg_val;
	struct lm3639_chip_data *pchip;

	pchip = container_of(cdev, struct lm3639_chip_data, cdev_torch);

	ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
	if (ret < 0)
		goto out;
	if (reg_val != 0)
		dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);

	/* brightness 0 means off state */
	if (!brightness) {
		ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00);
		if (ret < 0)
			goto out;
		return;
	}

	ret = regmap_update_bits(pchip->regmap,
				 REG_FL_CONF_1, 0x70, (brightness - 1) << 4);
	if (ret < 0)
		goto out;
	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x02);
	if (ret < 0)
		goto out;

	return;
out:
	dev_err(pchip->dev, "i2c failed to access register\n");
}

/* flash */
static void lm3639_flash_brightness_set(struct led_classdev *cdev,
					enum led_brightness brightness)
{
	int ret;
	unsigned int reg_val;
	struct lm3639_chip_data *pchip;

	pchip = container_of(cdev, struct lm3639_chip_data, cdev_flash);

	ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
	if (ret < 0)
		goto out;
	if (reg_val != 0)
		dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);

	/* torch off before flash control */
	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00);
	if (ret < 0)
		goto out;

	/* brightness 0 means off state */
	if (!brightness)
		return;

	ret = regmap_update_bits(pchip->regmap,
				 REG_FL_CONF_1, 0x0F, brightness - 1);
	if (ret < 0)
		goto out;
	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x06);
	if (ret < 0)
		goto out;

	return;
out:
	dev_err(pchip->dev, "i2c failed to access register\n");
}

static const struct regmap_config lm3639_regmap = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = REG_MAX,
};

static int lm3639_probe(struct i2c_client *client,
				  const struct i2c_device_id *id)
{
	int ret;
	struct lm3639_chip_data *pchip;
	struct lm3639_platform_data *pdata = dev_get_platdata(&client->dev);
	struct backlight_properties props;

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		dev_err(&client->dev, "i2c functionality check fail.\n");
		return -EOPNOTSUPP;
	}

	if (pdata == NULL) {
		dev_err(&client->dev, "Needs Platform Data.\n");
		return -ENODATA;
	}

	pchip = devm_kzalloc(&client->dev,
			     sizeof(struct lm3639_chip_data), GFP_KERNEL);
	if (!pchip)
		return -ENOMEM;

	pchip->pdata = pdata;
	pchip->dev = &client->dev;

	pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap);
	if (IS_ERR(pchip->regmap)) {
		ret = PTR_ERR(pchip->regmap);
		dev_err(&client->dev, "fail : allocate register map: %d\n",
			ret);
		return ret;
	}
	i2c_set_clientdata(client, pchip);

	/* chip initialize */
	ret = lm3639_chip_init(pchip);
	if (ret < 0) {
		dev_err(&client->dev, "fail : chip init\n");
		goto err_out;
	}

	/* backlight */
	props.type = BACKLIGHT_RAW;
	props.brightness = pdata->init_brt_led;
	props.max_brightness = pdata->max_brt_led;
	pchip->bled =
	    devm_backlight_device_register(pchip->dev, "lm3639_bled",
					   pchip->dev, pchip, &lm3639_bled_ops,
					   &props);
	if (IS_ERR(pchip->bled)) {
		dev_err(&client->dev, "fail : backlight register\n");
		ret = PTR_ERR(pchip->bled);
		goto err_out;
	}

	ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode);
	if (ret < 0) {
		dev_err(&client->dev, "failed : add sysfs entries\n");
		goto err_out;
	}

	/* flash */
	pchip->cdev_flash.name = "lm3639_flash";
	pchip->cdev_flash.max_brightness = 16;
	pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set;
	ret = led_classdev_register((struct device *)
				    &client->dev, &pchip->cdev_flash);
	if (ret < 0) {
		dev_err(&client->dev, "fail : flash register\n");
		goto err_flash;
	}

	/* torch */
	pchip->cdev_torch.name = "lm3639_torch";
	pchip->cdev_torch.max_brightness = 8;
	pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set;
	ret = led_classdev_register((struct device *)
				    &client->dev, &pchip->cdev_torch);
	if (ret < 0) {
		dev_err(&client->dev, "fail : torch register\n");
		goto err_torch;
	}

	return 0;

err_torch:
	led_classdev_unregister(&pchip->cdev_flash);
err_flash:
	device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
err_out:
	return ret;
}

static int lm3639_remove(struct i2c_client *client)
{
	struct lm3639_chip_data *pchip = i2c_get_clientdata(client);

	regmap_write(pchip->regmap, REG_ENABLE, 0x00);

	if (&pchip->cdev_torch)
		led_classdev_unregister(&pchip->cdev_torch);
	if (&pchip->cdev_flash)
		led_classdev_unregister(&pchip->cdev_flash);
	if (pchip->bled)
		device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
	return 0;
}

static const struct i2c_device_id lm3639_id[] = {
	{LM3639_NAME, 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, lm3639_id);
static struct i2c_driver lm3639_i2c_driver = {
	.driver = {
		   .name = LM3639_NAME,
		   },
	.probe = lm3639_probe,
	.remove = lm3639_remove,
	.id_table = lm3639_id,
};

module_i2c_driver(lm3639_i2c_driver);

MODULE_DESCRIPTION("Texas Instruments Backlight+Flash LED driver for LM3639");
MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
MODULE_AUTHOR("Ldd Mlp <ldd-mlp@list.ti.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
0f59858d SJ	1	/*
	2	* Simple driver for Texas Instruments LM3639 Backlight + Flash LED driver chip
	3	* Copyright (C) 2012 Texas Instruments
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	*/
	10	#include <linux/module.h>
	11	#include <linux/slab.h>
	12	#include <linux/i2c.h>
	13	#include <linux/leds.h>
	14	#include <linux/backlight.h>
	15	#include <linux/err.h>
	16	#include <linux/delay.h>
	17	#include <linux/uaccess.h>
	18	#include <linux/interrupt.h>
	19	#include <linux/regmap.h>
	20	#include <linux/platform_data/lm3639_bl.h>
	21
	22	#define REG_DEV_ID 0x00
	23	#define REG_CHECKSUM 0x01
	24	#define REG_BL_CONF_1 0x02
	25	#define REG_BL_CONF_2 0x03
	26	#define REG_BL_CONF_3 0x04
	27	#define REG_BL_CONF_4 0x05
	28	#define REG_FL_CONF_1 0x06
	29	#define REG_FL_CONF_2 0x07
	30	#define REG_FL_CONF_3 0x08
	31	#define REG_IO_CTRL 0x09
	32	#define REG_ENABLE 0x0A
	33	#define REG_FLAG 0x0B
	34	#define REG_MAX REG_FLAG
	35
	36	struct lm3639_chip_data {
	37	struct device *dev;
	38	struct lm3639_platform_data *pdata;
	39
	40	struct backlight_device *bled;
	41	struct led_classdev cdev_flash;
	42	struct led_classdev cdev_torch;
	43	struct regmap *regmap;
	44
	45	unsigned int bled_mode;
	46	unsigned int bled_map;
	47	unsigned int last_flag;
	48	};
	49
	50	/* initialize chip */
1b9e450d	51	static int lm3639_chip_init(struct lm3639_chip_data *pchip)
0f59858d SJ	52	{
	53	int ret;
	54	unsigned int reg_val;
	55	struct lm3639_platform_data *pdata = pchip->pdata;
	56
	57	/* input pins config. */
	58	ret =
	59	regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x08,
	60	pdata->pin_pwm);
	61	if (ret < 0)
	62	goto out;
	63
	64	reg_val = (pdata->pin_pwm & 0x40) \| pdata->pin_strobe \| pdata->pin_tx;
	65	ret = regmap_update_bits(pchip->regmap, REG_IO_CTRL, 0x7C, reg_val);
	66	if (ret < 0)
	67	goto out;
	68
	69	/* init brightness */
	70	ret = regmap_write(pchip->regmap, REG_BL_CONF_4, pdata->init_brt_led);
	71	if (ret < 0)
	72	goto out;
	73
	74	ret = regmap_write(pchip->regmap, REG_BL_CONF_3, pdata->init_brt_led);
	75	if (ret < 0)
	76	goto out;
	77
	78	/* output pins config. */
0ab7b20f JH	79	if (!pdata->init_brt_led) {
	80	reg_val = pdata->fled_pins;
	81	reg_val \|= pdata->bled_pins;
	82	} else {
	83	reg_val = pdata->fled_pins;
	84	reg_val \|= pdata->bled_pins \| 0x01;
	85	}
0f59858d SJ	86
	87	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x79, reg_val);
	88	if (ret < 0)
	89	goto out;
	90
	91	return ret;
	92	out:
	93	dev_err(pchip->dev, "i2c failed to access register\n");
	94	return ret;
	95	}
	96
	97	/* update and get brightness */
	98	static int lm3639_bled_update_status(struct backlight_device *bl)
	99	{
	100	int ret;
	101	unsigned int reg_val;
	102	struct lm3639_chip_data *pchip = bl_get_data(bl);
	103	struct lm3639_platform_data *pdata = pchip->pdata;
	104
	105	ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
	106	if (ret < 0)
	107	goto out;
	108
	109	if (reg_val != 0)
	110	dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);
	111
	112	/* pwm control */
	113	if (pdata->pin_pwm) {
	114	if (pdata->pwm_set_intensity)
	115	pdata->pwm_set_intensity(bl->props.brightness,
	116	pdata->max_brt_led);
	117	else
	118	dev_err(pchip->dev,
	119	"No pwm control func. in plat-data\n");
	120	return bl->props.brightness;
	121	}
	122
	123	/* i2c control and set brigtness */
	124	ret = regmap_write(pchip->regmap, REG_BL_CONF_4, bl->props.brightness);
	125	if (ret < 0)
	126	goto out;
	127	ret = regmap_write(pchip->regmap, REG_BL_CONF_3, bl->props.brightness);
	128	if (ret < 0)
	129	goto out;
	130
	131	if (!bl->props.brightness)
	132	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x00);
	133	else
	134	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x01, 0x01);
	135	if (ret < 0)
	136	goto out;
	137
	138	return bl->props.brightness;
	139	out:
	140	dev_err(pchip->dev, "i2c failed to access registers\n");
	141	return bl->props.brightness;
	142	}
	143
	144	static int lm3639_bled_get_brightness(struct backlight_device *bl)
	145	{
	146	int ret;
	147	unsigned int reg_val;
	148	struct lm3639_chip_data *pchip = bl_get_data(bl);
	149	struct lm3639_platform_data *pdata = pchip->pdata;
150
151	if (pdata->pin_pwm) {
152	if (pdata->pwm_get_intensity)
153	bl->props.brightness = pdata->pwm_get_intensity();
154	else
155	dev_err(pchip->dev,
156	"No pwm control func. in plat-data\n");
157	return bl->props.brightness;
158	}
159
160	ret = regmap_read(pchip->regmap, REG_BL_CONF_1, &reg_val);
161	if (ret < 0)
162	goto out;
163	if (reg_val & 0x10)
164	ret = regmap_read(pchip->regmap, REG_BL_CONF_4, &reg_val);
165	else
166	ret = regmap_read(pchip->regmap, REG_BL_CONF_3, &reg_val);
167	if (ret < 0)
168	goto out;
169	bl->props.brightness = reg_val;
170
171	return bl->props.brightness;
172	out:
173	dev_err(pchip->dev, "i2c failed to access register\n");
174	return bl->props.brightness;
175	}
176
177	static const struct backlight_ops lm3639_bled_ops = {
178	.options = BL_CORE_SUSPENDRESUME,
179	.update_status = lm3639_bled_update_status,
180	.get_brightness = lm3639_bled_get_brightness,
181	};
182
183	/* backlight mapping mode */
184	static ssize_t lm3639_bled_mode_store(struct device *dev,
185	struct device_attribute *devAttr,
186	const char *buf, size_t size)
187	{
188	ssize_t ret;
189	struct lm3639_chip_data *pchip = dev_get_drvdata(dev);
190	unsigned int state;
191
192	ret = kstrtouint(buf, 10, &state);
193	if (ret)
194	goto out_input;
195
196	if (!state)
197	ret =
198	regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10,
199	0x00);
200	else
201	ret =
202	regmap_update_bits(pchip->regmap, REG_BL_CONF_1, 0x10,
203	0x10);
204
205	if (ret < 0)
206	goto out;
207
208	return size;
209
210	out:
211	dev_err(pchip->dev, "%s:i2c access fail to register\n", __func__);
dc36d7e7	212	return ret;
0f59858d SJ	213
	214	out_input:
	215	dev_err(pchip->dev, "%s:input conversion fail\n", __func__);
dc36d7e7	216	return ret;
0f59858d SJ	217
	218	}
	219
fb08cd9b	220	static DEVICE_ATTR(bled_mode, S_IWUSR, NULL, lm3639_bled_mode_store);
0f59858d SJ	221
	222	/* torch */
	223	static void lm3639_torch_brightness_set(struct led_classdev *cdev,
	224	enum led_brightness brightness)
	225	{
	226	int ret;
	227	unsigned int reg_val;
	228	struct lm3639_chip_data *pchip;
	229
	230	pchip = container_of(cdev, struct lm3639_chip_data, cdev_torch);
	231
	232	ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
	233	if (ret < 0)
	234	goto out;
	235	if (reg_val != 0)
	236	dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);
	237
	238	/* brightness 0 means off state */
	239	if (!brightness) {
	240	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00);
	241	if (ret < 0)
	242	goto out;
	243	return;
	244	}
	245
	246	ret = regmap_update_bits(pchip->regmap,
	247	REG_FL_CONF_1, 0x70, (brightness - 1) << 4);
	248	if (ret < 0)
	249	goto out;
	250	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x02);
	251	if (ret < 0)
	252	goto out;
	253
	254	return;
	255	out:
	256	dev_err(pchip->dev, "i2c failed to access register\n");
0f59858d SJ	257	}
	258
	259	/* flash */
	260	static void lm3639_flash_brightness_set(struct led_classdev *cdev,
	261	enum led_brightness brightness)
	262	{
	263	int ret;
	264	unsigned int reg_val;
	265	struct lm3639_chip_data *pchip;
	266
	267	pchip = container_of(cdev, struct lm3639_chip_data, cdev_flash);
	268
	269	ret = regmap_read(pchip->regmap, REG_FLAG, &reg_val);
	270	if (ret < 0)
	271	goto out;
	272	if (reg_val != 0)
	273	dev_info(pchip->dev, "last flag is 0x%x\n", reg_val);
	274
	275	/* torch off before flash control */
	276	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x00);
	277	if (ret < 0)
	278	goto out;
	279
	280	/* brightness 0 means off state */
	281	if (!brightness)
	282	return;
	283
	284	ret = regmap_update_bits(pchip->regmap,
	285	REG_FL_CONF_1, 0x0F, brightness - 1);
	286	if (ret < 0)
	287	goto out;
	288	ret = regmap_update_bits(pchip->regmap, REG_ENABLE, 0x06, 0x06);
	289	if (ret < 0)
	290	goto out;
	291
	292	return;
	293	out:
	294	dev_err(pchip->dev, "i2c failed to access register\n");
0f59858d SJ	295	}
	296
	297	static const struct regmap_config lm3639_regmap = {
	298	.reg_bits = 8,
	299	.val_bits = 8,
	300	.max_register = REG_MAX,
	301	};
	302
1b9e450d	303	static int lm3639_probe(struct i2c_client *client,
0f59858d SJ	304	const struct i2c_device_id *id)
	305	{
	306	int ret;
	307	struct lm3639_chip_data *pchip;
c512794c	308	struct lm3639_platform_data *pdata = dev_get_platdata(&client->dev);
0f59858d SJ	309	struct backlight_properties props;
	310
	311	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
	312	dev_err(&client->dev, "i2c functionality check fail.\n");
	313	return -EOPNOTSUPP;
	314	}
	315
	316	if (pdata == NULL) {
	317	dev_err(&client->dev, "Needs Platform Data.\n");
	318	return -ENODATA;
	319	}
	320
	321	pchip = devm_kzalloc(&client->dev,
	322	sizeof(struct lm3639_chip_data), GFP_KERNEL);
	323	if (!pchip)
	324	return -ENOMEM;
	325
	326	pchip->pdata = pdata;
	327	pchip->dev = &client->dev;
	328
	329	pchip->regmap = devm_regmap_init_i2c(client, &lm3639_regmap);
	330	if (IS_ERR(pchip->regmap)) {
	331	ret = PTR_ERR(pchip->regmap);
	332	dev_err(&client->dev, "fail : allocate register map: %d\n",
	333	ret);
	334	return ret;
	335	}
	336	i2c_set_clientdata(client, pchip);
	337
	338	/* chip initialize */
	339	ret = lm3639_chip_init(pchip);
	340	if (ret < 0) {
	341	dev_err(&client->dev, "fail : chip init\n");
	342	goto err_out;
	343	}
	344
	345	/* backlight */
	346	props.type = BACKLIGHT_RAW;
	347	props.brightness = pdata->init_brt_led;
	348	props.max_brightness = pdata->max_brt_led;
	349	pchip->bled =
f1740e4c DJ	350	devm_backlight_device_register(pchip->dev, "lm3639_bled",
	351	pchip->dev, pchip, &lm3639_bled_ops,
	352	&props);
0f59858d SJ	353	if (IS_ERR(pchip->bled)) {
0f59858d SJ	354	dev_err(&client->dev, "fail : backlight register\n");
aea00a6c	355	ret = PTR_ERR(pchip->bled);
0f59858d SJ	356	goto err_out;
	357	}
	358
	359	ret = device_create_file(&(pchip->bled->dev), &dev_attr_bled_mode);
	360	if (ret < 0) {
	361	dev_err(&client->dev, "failed : add sysfs entries\n");
f1740e4c	362	goto err_out;
0f59858d SJ	363	}
	364
	365	/* flash */
	366	pchip->cdev_flash.name = "lm3639_flash";
	367	pchip->cdev_flash.max_brightness = 16;
	368	pchip->cdev_flash.brightness_set = lm3639_flash_brightness_set;
	369	ret = led_classdev_register((struct device *)
	370	&client->dev, &pchip->cdev_flash);
	371	if (ret < 0) {
	372	dev_err(&client->dev, "fail : flash register\n");
0f59858d SJ	373	goto err_flash;
	374	}
	375
	376	/* torch */
	377	pchip->cdev_torch.name = "lm3639_torch";
	378	pchip->cdev_torch.max_brightness = 8;
	379	pchip->cdev_torch.brightness_set = lm3639_torch_brightness_set;
	380	ret = led_classdev_register((struct device *)
	381	&client->dev, &pchip->cdev_torch);
	382	if (ret < 0) {
	383	dev_err(&client->dev, "fail : torch register\n");
0f59858d SJ	384	goto err_torch;
	385	}
	386
	387	return 0;
	388
	389	err_torch:
	390	led_classdev_unregister(&pchip->cdev_flash);
	391	err_flash:
	392	device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
0f59858d SJ	393	err_out:
	394	return ret;
	395	}
	396
7e4b9d0b	397	static int lm3639_remove(struct i2c_client *client)
0f59858d SJ	398	{
	399	struct lm3639_chip_data *pchip = i2c_get_clientdata(client);
	400
	401	regmap_write(pchip->regmap, REG_ENABLE, 0x00);
	402
	403	if (&pchip->cdev_torch)
	404	led_classdev_unregister(&pchip->cdev_torch);
	405	if (&pchip->cdev_flash)
	406	led_classdev_unregister(&pchip->cdev_flash);
f1740e4c	407	if (pchip->bled)
0f59858d	408	device_remove_file(&(pchip->bled->dev), &dev_attr_bled_mode);
0f59858d SJ	409	return 0;
	410	}
	411
	412	static const struct i2c_device_id lm3639_id[] = {
	413	{LM3639_NAME, 0},
	414	{}
	415	};
	416
	417	MODULE_DEVICE_TABLE(i2c, lm3639_id);
	418	static struct i2c_driver lm3639_i2c_driver = {
	419	.driver = {
	420	.name = LM3639_NAME,
	421	},
	422	.probe = lm3639_probe,
d1723fa2	423	.remove = lm3639_remove,
0f59858d SJ	424	.id_table = lm3639_id,
	425	};
	426
	427	module_i2c_driver(lm3639_i2c_driver);
	428
	429	MODULE_DESCRIPTION("Texas Instruments Backlight+Flash LED driver for LM3639");
f1740e4c DJ	430	MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
f1740e4c DJ	431	MODULE_AUTHOR("Ldd Mlp <ldd-mlp@list.ti.com>");
0f59858d	432	MODULE_LICENSE("GPL v2");