[deliverable/linux.git] / drivers / media / i2c / lm3560.c

/*
 * drivers/media/i2c/lm3560.c
 * General device driver for TI lm3560, FLASH LED Driver
 *
 * Copyright (C) 2013 Texas Instruments
 *
 * Contact: Daniel Jeong <gshark.jeong@gmail.com>
 *			Ldd-Mlp <ldd-mlp@list.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.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#include <linux/delay.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/regmap.h>
#include <linux/videodev2.h>
#include <media/i2c/lm3560.h>
#include <media/v4l2-ctrls.h>
#include <media/v4l2-device.h>

/* registers definitions */
#define REG_ENABLE		0x10
#define REG_TORCH_BR	0xa0
#define REG_FLASH_BR	0xb0
#define REG_FLASH_TOUT	0xc0
#define REG_FLAG		0xd0
#define REG_CONFIG1		0xe0

/* fault mask */
#define FAULT_TIMEOUT	(1<<0)
#define FAULT_OVERTEMP	(1<<1)
#define FAULT_SHORT_CIRCUIT	(1<<2)

enum led_enable {
	MODE_SHDN = 0x0,
	MODE_TORCH = 0x2,
	MODE_FLASH = 0x3,
};

/**
 * struct lm3560_flash
 *
 * @pdata: platform data
 * @regmap: reg. map for i2c
 * @lock: muxtex for serial access.
 * @led_mode: V4L2 LED mode
 * @ctrls_led: V4L2 contols
 * @subdev_led: V4L2 subdev
 */
struct lm3560_flash {
	struct device *dev;
	struct lm3560_platform_data *pdata;
	struct regmap *regmap;
	struct mutex lock;

	enum v4l2_flash_led_mode led_mode;
	struct v4l2_ctrl_handler ctrls_led[LM3560_LED_MAX];
	struct v4l2_subdev subdev_led[LM3560_LED_MAX];
};

#define to_lm3560_flash(_ctrl, _no)	\
	container_of(_ctrl->handler, struct lm3560_flash, ctrls_led[_no])

/* enable mode control */
static int lm3560_mode_ctrl(struct lm3560_flash *flash)
{
	int rval = -EINVAL;

	switch (flash->led_mode) {
	case V4L2_FLASH_LED_MODE_NONE:
		rval = regmap_update_bits(flash->regmap,
					  REG_ENABLE, 0x03, MODE_SHDN);
		break;
	case V4L2_FLASH_LED_MODE_TORCH:
		rval = regmap_update_bits(flash->regmap,
					  REG_ENABLE, 0x03, MODE_TORCH);
		break;
	case V4L2_FLASH_LED_MODE_FLASH:
		rval = regmap_update_bits(flash->regmap,
					  REG_ENABLE, 0x03, MODE_FLASH);
		break;
	}
	return rval;
}

/* led1/2 enable/disable */
static int lm3560_enable_ctrl(struct lm3560_flash *flash,
			      enum lm3560_led_id led_no, bool on)
{
	int rval;

	if (led_no == LM3560_LED0) {
		if (on)
			rval = regmap_update_bits(flash->regmap,
						  REG_ENABLE, 0x08, 0x08);
		else
			rval = regmap_update_bits(flash->regmap,
						  REG_ENABLE, 0x08, 0x00);
	} else {
		if (on)
			rval = regmap_update_bits(flash->regmap,
						  REG_ENABLE, 0x10, 0x10);
		else
			rval = regmap_update_bits(flash->regmap,
						  REG_ENABLE, 0x10, 0x00);
	}
	return rval;
}

/* torch1/2 brightness control */
static int lm3560_torch_brt_ctrl(struct lm3560_flash *flash,
				 enum lm3560_led_id led_no, unsigned int brt)
{
	int rval;
	u8 br_bits;

	if (brt < LM3560_TORCH_BRT_MIN)
		return lm3560_enable_ctrl(flash, led_no, false);
	else
		rval = lm3560_enable_ctrl(flash, led_no, true);

	br_bits = LM3560_TORCH_BRT_uA_TO_REG(brt);
	if (led_no == LM3560_LED0)
		rval = regmap_update_bits(flash->regmap,
					  REG_TORCH_BR, 0x07, br_bits);
	else
		rval = regmap_update_bits(flash->regmap,
					  REG_TORCH_BR, 0x38, br_bits << 3);

	return rval;
}

/* flash1/2 brightness control */
static int lm3560_flash_brt_ctrl(struct lm3560_flash *flash,
				 enum lm3560_led_id led_no, unsigned int brt)
{
	int rval;
	u8 br_bits;

	if (brt < LM3560_FLASH_BRT_MIN)
		return lm3560_enable_ctrl(flash, led_no, false);
	else
		rval = lm3560_enable_ctrl(flash, led_no, true);

	br_bits = LM3560_FLASH_BRT_uA_TO_REG(brt);
	if (led_no == LM3560_LED0)
		rval = regmap_update_bits(flash->regmap,
					  REG_FLASH_BR, 0x0f, br_bits);
	else
		rval = regmap_update_bits(flash->regmap,
					  REG_FLASH_BR, 0xf0, br_bits << 4);

	return rval;
}

/* v4l2 controls  */
static int lm3560_get_ctrl(struct v4l2_ctrl *ctrl, enum lm3560_led_id led_no)
{
	struct lm3560_flash *flash = to_lm3560_flash(ctrl, led_no);
	int rval = -EINVAL;

	mutex_lock(&flash->lock);

	if (ctrl->id == V4L2_CID_FLASH_FAULT) {
		s32 fault = 0;
		unsigned int reg_val;
		rval = regmap_read(flash->regmap, REG_FLAG, &reg_val);
		if (rval < 0)
			goto out;
		if (reg_val & FAULT_SHORT_CIRCUIT)
			fault |= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
		if (reg_val & FAULT_OVERTEMP)
			fault |= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
		if (reg_val & FAULT_TIMEOUT)
			fault |= V4L2_FLASH_FAULT_TIMEOUT;
		ctrl->cur.val = fault;
	}

out:
	mutex_unlock(&flash->lock);
	return rval;
}

static int lm3560_set_ctrl(struct v4l2_ctrl *ctrl, enum lm3560_led_id led_no)
{
	struct lm3560_flash *flash = to_lm3560_flash(ctrl, led_no);
	u8 tout_bits;
	int rval = -EINVAL;

	mutex_lock(&flash->lock);

	switch (ctrl->id) {
	case V4L2_CID_FLASH_LED_MODE:
		flash->led_mode = ctrl->val;
		if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
			rval = lm3560_mode_ctrl(flash);
		break;

	case V4L2_CID_FLASH_STROBE_SOURCE:
		rval = regmap_update_bits(flash->regmap,
					  REG_CONFIG1, 0x04, (ctrl->val) << 2);
		if (rval < 0)
			goto err_out;
		break;

	case V4L2_CID_FLASH_STROBE:
		if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
			rval = -EBUSY;
			goto err_out;
		}
		flash->led_mode = V4L2_FLASH_LED_MODE_FLASH;
		rval = lm3560_mode_ctrl(flash);
		break;

	case V4L2_CID_FLASH_STROBE_STOP:
		if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
			rval = -EBUSY;
			goto err_out;
		}
		flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
		rval = lm3560_mode_ctrl(flash);
		break;

	case V4L2_CID_FLASH_TIMEOUT:
		tout_bits = LM3560_FLASH_TOUT_ms_TO_REG(ctrl->val);
		rval = regmap_update_bits(flash->regmap,
					  REG_FLASH_TOUT, 0x1f, tout_bits);
		break;

	case V4L2_CID_FLASH_INTENSITY:
		rval = lm3560_flash_brt_ctrl(flash, led_no, ctrl->val);
		break;

	case V4L2_CID_FLASH_TORCH_INTENSITY:
		rval = lm3560_torch_brt_ctrl(flash, led_no, ctrl->val);
		break;
	}

err_out:
	mutex_unlock(&flash->lock);
	return rval;
}

static int lm3560_led1_get_ctrl(struct v4l2_ctrl *ctrl)
{
	return lm3560_get_ctrl(ctrl, LM3560_LED1);
}

static int lm3560_led1_set_ctrl(struct v4l2_ctrl *ctrl)
{
	return lm3560_set_ctrl(ctrl, LM3560_LED1);
}

static int lm3560_led0_get_ctrl(struct v4l2_ctrl *ctrl)
{
	return lm3560_get_ctrl(ctrl, LM3560_LED0);
}

static int lm3560_led0_set_ctrl(struct v4l2_ctrl *ctrl)
{
	return lm3560_set_ctrl(ctrl, LM3560_LED0);
}

static const struct v4l2_ctrl_ops lm3560_led_ctrl_ops[LM3560_LED_MAX] = {
	[LM3560_LED0] = {
			 .g_volatile_ctrl = lm3560_led0_get_ctrl,
			 .s_ctrl = lm3560_led0_set_ctrl,
			 },
	[LM3560_LED1] = {
			 .g_volatile_ctrl = lm3560_led1_get_ctrl,
			 .s_ctrl = lm3560_led1_set_ctrl,
			 }
};

static int lm3560_init_controls(struct lm3560_flash *flash,
				enum lm3560_led_id led_no)
{
	struct v4l2_ctrl *fault;
	u32 max_flash_brt = flash->pdata->max_flash_brt[led_no];
	u32 max_torch_brt = flash->pdata->max_torch_brt[led_no];
	struct v4l2_ctrl_handler *hdl = &flash->ctrls_led[led_no];
	const struct v4l2_ctrl_ops *ops = &lm3560_led_ctrl_ops[led_no];

	v4l2_ctrl_handler_init(hdl, 8);

	/* flash mode */
	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,
			       V4L2_FLASH_LED_MODE_TORCH, ~0x7,
			       V4L2_FLASH_LED_MODE_NONE);
	flash->led_mode = V4L2_FLASH_LED_MODE_NONE;

	/* flash source */
	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_STROBE_SOURCE,
			       0x1, ~0x3, V4L2_FLASH_STROBE_SOURCE_SOFTWARE);

	/* flash strobe */
	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);

	/* flash strobe stop */
	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);

	/* flash strobe timeout */
	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TIMEOUT,
			  LM3560_FLASH_TOUT_MIN,
			  flash->pdata->max_flash_timeout,
			  LM3560_FLASH_TOUT_STEP,
			  flash->pdata->max_flash_timeout);

	/* flash brt */
	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_INTENSITY,
			  LM3560_FLASH_BRT_MIN, max_flash_brt,
			  LM3560_FLASH_BRT_STEP, max_flash_brt);

	/* torch brt */
	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TORCH_INTENSITY,
			  LM3560_TORCH_BRT_MIN, max_torch_brt,
			  LM3560_TORCH_BRT_STEP, max_torch_brt);

	/* fault */
	fault = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_FAULT, 0,
				  V4L2_FLASH_FAULT_OVER_VOLTAGE
				  | V4L2_FLASH_FAULT_OVER_TEMPERATURE
				  | V4L2_FLASH_FAULT_SHORT_CIRCUIT
				  | V4L2_FLASH_FAULT_TIMEOUT, 0, 0);
	if (fault != NULL)
		fault->flags |= V4L2_CTRL_FLAG_VOLATILE;

	if (hdl->error)
		return hdl->error;

	flash->subdev_led[led_no].ctrl_handler = hdl;
	return 0;
}

/* initialize device */
static const struct v4l2_subdev_ops lm3560_ops = {
	.core = NULL,
};

static const struct regmap_config lm3560_regmap = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = 0xFF,
};

static int lm3560_subdev_init(struct lm3560_flash *flash,
			      enum lm3560_led_id led_no, char *led_name)
{
	struct i2c_client *client = to_i2c_client(flash->dev);
	int rval;

	v4l2_i2c_subdev_init(&flash->subdev_led[led_no], client, &lm3560_ops);
	flash->subdev_led[led_no].flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
	strcpy(flash->subdev_led[led_no].name, led_name);
	rval = lm3560_init_controls(flash, led_no);
	if (rval)
		goto err_out;
	rval = media_entity_pads_init(&flash->subdev_led[led_no].entity, 0, NULL);
	if (rval < 0)
		goto err_out;
	flash->subdev_led[led_no].entity.function = MEDIA_ENT_F_FLASH;

	return rval;

err_out:
	v4l2_ctrl_handler_free(&flash->ctrls_led[led_no]);
	return rval;
}

static int lm3560_init_device(struct lm3560_flash *flash)
{
	int rval;
	unsigned int reg_val;

	/* set peak current */
	rval = regmap_update_bits(flash->regmap,
				  REG_FLASH_TOUT, 0x60, flash->pdata->peak);
	if (rval < 0)
		return rval;
	/* output disable */
	flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
	rval = lm3560_mode_ctrl(flash);
	if (rval < 0)
		return rval;
	/* reset faults */
	rval = regmap_read(flash->regmap, REG_FLAG, &reg_val);
	return rval;
}

static int lm3560_probe(struct i2c_client *client,
			const struct i2c_device_id *devid)
{
	struct lm3560_flash *flash;
	struct lm3560_platform_data *pdata = dev_get_platdata(&client->dev);
	int rval;

	flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL);
	if (flash == NULL)
		return -ENOMEM;

	flash->regmap = devm_regmap_init_i2c(client, &lm3560_regmap);
	if (IS_ERR(flash->regmap)) {
		rval = PTR_ERR(flash->regmap);
		return rval;
	}

	/* if there is no platform data, use chip default value */
	if (pdata == NULL) {
		pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
		if (pdata == NULL)
			return -ENODEV;
		pdata->peak = LM3560_PEAK_3600mA;
		pdata->max_flash_timeout = LM3560_FLASH_TOUT_MAX;
		/* led 1 */
		pdata->max_flash_brt[LM3560_LED0] = LM3560_FLASH_BRT_MAX;
		pdata->max_torch_brt[LM3560_LED0] = LM3560_TORCH_BRT_MAX;
		/* led 2 */
		pdata->max_flash_brt[LM3560_LED1] = LM3560_FLASH_BRT_MAX;
		pdata->max_torch_brt[LM3560_LED1] = LM3560_TORCH_BRT_MAX;
	}
	flash->pdata = pdata;
	flash->dev = &client->dev;
	mutex_init(&flash->lock);

	rval = lm3560_subdev_init(flash, LM3560_LED0, "lm3560-led0");
	if (rval < 0)
		return rval;

	rval = lm3560_subdev_init(flash, LM3560_LED1, "lm3560-led1");
	if (rval < 0)
		return rval;

	rval = lm3560_init_device(flash);
	if (rval < 0)
		return rval;

	i2c_set_clientdata(client, flash);

	return 0;
}

static int lm3560_remove(struct i2c_client *client)
{
	struct lm3560_flash *flash = i2c_get_clientdata(client);
	unsigned int i;

	for (i = LM3560_LED0; i < LM3560_LED_MAX; i++) {
		v4l2_device_unregister_subdev(&flash->subdev_led[i]);
		v4l2_ctrl_handler_free(&flash->ctrls_led[i]);
		media_entity_cleanup(&flash->subdev_led[i].entity);
	}

	return 0;
}

static const struct i2c_device_id lm3560_id_table[] = {
	{LM3560_NAME, 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, lm3560_id_table);

static struct i2c_driver lm3560_i2c_driver = {
	.driver = {
		   .name = LM3560_NAME,
		   .pm = NULL,
		   },
	.probe = lm3560_probe,
	.remove = lm3560_remove,
	.id_table = lm3560_id_table,
};

module_i2c_driver(lm3560_i2c_driver);

MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
MODULE_AUTHOR("Ldd Mlp <ldd-mlp@list.ti.com>");
MODULE_DESCRIPTION("Texas Instruments LM3560 LED flash driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
7f6b11a1 DJ	1	/*
	2	* drivers/media/i2c/lm3560.c
	3	* General device driver for TI lm3560, FLASH LED Driver
	4	*
	5	* Copyright (C) 2013 Texas Instruments
	6	*
	7	* Contact: Daniel Jeong <gshark.jeong@gmail.com>
	8	* Ldd-Mlp <ldd-mlp@list.ti.com>
	9	*
	10	* This program is free software; you can redistribute it and/or
	11	* modify it under the terms of the GNU General Public License
	12	* version 2 as published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
7f6b11a1 DJ	18	*/
	19
	20	#include <linux/delay.h>
	21	#include <linux/module.h>
	22	#include <linux/i2c.h>
	23	#include <linux/slab.h>
	24	#include <linux/mutex.h>
	25	#include <linux/regmap.h>
	26	#include <linux/videodev2.h>
b5dcee22	27	#include <media/i2c/lm3560.h>
7f6b11a1 DJ	28	#include <media/v4l2-ctrls.h>
	29	#include <media/v4l2-device.h>
	30
	31	/* registers definitions */
	32	#define REG_ENABLE 0x10
	33	#define REG_TORCH_BR 0xa0
	34	#define REG_FLASH_BR 0xb0
	35	#define REG_FLASH_TOUT 0xc0
	36	#define REG_FLAG 0xd0
	37	#define REG_CONFIG1 0xe0
	38
d1166b0f	39	/* fault mask */
7f6b11a1 DJ	40	#define FAULT_TIMEOUT (1<<0)
	41	#define FAULT_OVERTEMP (1<<1)
	42	#define FAULT_SHORT_CIRCUIT (1<<2)
	43
	44	enum led_enable {
	45	MODE_SHDN = 0x0,
	46	MODE_TORCH = 0x2,
	47	MODE_FLASH = 0x3,
	48	};
	49
d1166b0f AS	50	/**
d1166b0f AS	51	* struct lm3560_flash
7f6b11a1 DJ	52	*
	53	* @pdata: platform data
	54	* @regmap: reg. map for i2c
	55	* @lock: muxtex for serial access.
	56	* @led_mode: V4L2 LED mode
	57	* @ctrls_led: V4L2 contols
	58	* @subdev_led: V4L2 subdev
	59	*/
	60	struct lm3560_flash {
	61	struct device *dev;
	62	struct lm3560_platform_data *pdata;
	63	struct regmap *regmap;
	64	struct mutex lock;
	65
	66	enum v4l2_flash_led_mode led_mode;
	67	struct v4l2_ctrl_handler ctrls_led[LM3560_LED_MAX];
	68	struct v4l2_subdev subdev_led[LM3560_LED_MAX];
	69	};
	70
	71	#define to_lm3560_flash(_ctrl, _no) \
	72	container_of(_ctrl->handler, struct lm3560_flash, ctrls_led[_no])
	73
	74	/* enable mode control */
	75	static int lm3560_mode_ctrl(struct lm3560_flash *flash)
	76	{
	77	int rval = -EINVAL;
	78
	79	switch (flash->led_mode) {
	80	case V4L2_FLASH_LED_MODE_NONE:
	81	rval = regmap_update_bits(flash->regmap,
	82	REG_ENABLE, 0x03, MODE_SHDN);
	83	break;
	84	case V4L2_FLASH_LED_MODE_TORCH:
	85	rval = regmap_update_bits(flash->regmap,
	86	REG_ENABLE, 0x03, MODE_TORCH);
	87	break;
	88	case V4L2_FLASH_LED_MODE_FLASH:
	89	rval = regmap_update_bits(flash->regmap,
	90	REG_ENABLE, 0x03, MODE_FLASH);
	91	break;
	92	}
	93	return rval;
	94	}
	95
d1166b0f	96	/* led1/2 enable/disable */
7f6b11a1 DJ	97	static int lm3560_enable_ctrl(struct lm3560_flash *flash,
	98	enum lm3560_led_id led_no, bool on)
	99	{
	100	int rval;
	101
	102	if (led_no == LM3560_LED0) {
afb666d1	103	if (on)
7f6b11a1 DJ	104	rval = regmap_update_bits(flash->regmap,
	105	REG_ENABLE, 0x08, 0x08);
	106	else
	107	rval = regmap_update_bits(flash->regmap,
	108	REG_ENABLE, 0x08, 0x00);
	109	} else {
afb666d1	110	if (on)
7f6b11a1 DJ	111	rval = regmap_update_bits(flash->regmap,
	112	REG_ENABLE, 0x10, 0x10);
	113	else
	114	rval = regmap_update_bits(flash->regmap,
	115	REG_ENABLE, 0x10, 0x00);
	116	}
	117	return rval;
	118	}
	119
	120	/* torch1/2 brightness control */
	121	static int lm3560_torch_brt_ctrl(struct lm3560_flash *flash,
	122	enum lm3560_led_id led_no, unsigned int brt)
	123	{
	124	int rval;
	125	u8 br_bits;
	126
	127	if (brt < LM3560_TORCH_BRT_MIN)
	128	return lm3560_enable_ctrl(flash, led_no, false);
	129	else
	130	rval = lm3560_enable_ctrl(flash, led_no, true);
	131
	132	br_bits = LM3560_TORCH_BRT_uA_TO_REG(brt);
	133	if (led_no == LM3560_LED0)
	134	rval = regmap_update_bits(flash->regmap,
	135	REG_TORCH_BR, 0x07, br_bits);
	136	else
	137	rval = regmap_update_bits(flash->regmap,
	138	REG_TORCH_BR, 0x38, br_bits << 3);
	139
	140	return rval;
	141	}
	142
	143	/* flash1/2 brightness control */
	144	static int lm3560_flash_brt_ctrl(struct lm3560_flash *flash,
	145	enum lm3560_led_id led_no, unsigned int brt)
	146	{
	147	int rval;
	148	u8 br_bits;
	149
	150	if (brt < LM3560_FLASH_BRT_MIN)
	151	return lm3560_enable_ctrl(flash, led_no, false);
	152	else
	153	rval = lm3560_enable_ctrl(flash, led_no, true);
	154
	155	br_bits = LM3560_FLASH_BRT_uA_TO_REG(brt);
	156	if (led_no == LM3560_LED0)
	157	rval = regmap_update_bits(flash->regmap,
	158	REG_FLASH_BR, 0x0f, br_bits);
	159	else
	160	rval = regmap_update_bits(flash->regmap,
	161	REG_FLASH_BR, 0xf0, br_bits << 4);
	162
	163	return rval;
	164	}
	165
d1166b0f	166	/* v4l2 controls */
7f6b11a1 DJ	167	static int lm3560_get_ctrl(struct v4l2_ctrl *ctrl, enum lm3560_led_id led_no)
	168	{
	169	struct lm3560_flash *flash = to_lm3560_flash(ctrl, led_no);
e1c759bd	170	int rval = -EINVAL;
7f6b11a1 DJ	171
	172	mutex_lock(&flash->lock);
	173
	174	if (ctrl->id == V4L2_CID_FLASH_FAULT) {
7f6b11a1 DJ	175	s32 fault = 0;
	176	unsigned int reg_val;
	177	rval = regmap_read(flash->regmap, REG_FLAG, &reg_val);
	178	if (rval < 0)
e1c759bd DJ	179	goto out;
e1c759bd DJ	180	if (reg_val & FAULT_SHORT_CIRCUIT)
7f6b11a1	181	fault \|= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
e1c759bd	182	if (reg_val & FAULT_OVERTEMP)
7f6b11a1	183	fault \|= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
e1c759bd	184	if (reg_val & FAULT_TIMEOUT)
7f6b11a1 DJ	185	fault \|= V4L2_FLASH_FAULT_TIMEOUT;
7f6b11a1 DJ	186	ctrl->cur.val = fault;
7f6b11a1 DJ	187	}
7f6b11a1 DJ	188
e1c759bd	189	out:
7f6b11a1	190	mutex_unlock(&flash->lock);
e1c759bd	191	return rval;
7f6b11a1 DJ	192	}
	193
	194	static int lm3560_set_ctrl(struct v4l2_ctrl *ctrl, enum lm3560_led_id led_no)
	195	{
	196	struct lm3560_flash *flash = to_lm3560_flash(ctrl, led_no);
	197	u8 tout_bits;
	198	int rval = -EINVAL;
	199
	200	mutex_lock(&flash->lock);
	201
	202	switch (ctrl->id) {
	203	case V4L2_CID_FLASH_LED_MODE:
	204	flash->led_mode = ctrl->val;
	205	if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH)
	206	rval = lm3560_mode_ctrl(flash);
	207	break;
	208
	209	case V4L2_CID_FLASH_STROBE_SOURCE:
	210	rval = regmap_update_bits(flash->regmap,
	211	REG_CONFIG1, 0x04, (ctrl->val) << 2);
	212	if (rval < 0)
	213	goto err_out;
	214	break;
	215
	216	case V4L2_CID_FLASH_STROBE:
eed8c3ee WY	217	if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
	218	rval = -EBUSY;
	219	goto err_out;
	220	}
7f6b11a1 DJ	221	flash->led_mode = V4L2_FLASH_LED_MODE_FLASH;
	222	rval = lm3560_mode_ctrl(flash);
	223	break;
	224
	225	case V4L2_CID_FLASH_STROBE_STOP:
eed8c3ee WY	226	if (flash->led_mode != V4L2_FLASH_LED_MODE_FLASH) {
	227	rval = -EBUSY;
	228	goto err_out;
	229	}
7f6b11a1 DJ	230	flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
	231	rval = lm3560_mode_ctrl(flash);
	232	break;
	233
	234	case V4L2_CID_FLASH_TIMEOUT:
	235	tout_bits = LM3560_FLASH_TOUT_ms_TO_REG(ctrl->val);
	236	rval = regmap_update_bits(flash->regmap,
	237	REG_FLASH_TOUT, 0x1f, tout_bits);
	238	break;
	239
	240	case V4L2_CID_FLASH_INTENSITY:
	241	rval = lm3560_flash_brt_ctrl(flash, led_no, ctrl->val);
	242	break;
	243
	244	case V4L2_CID_FLASH_TORCH_INTENSITY:
	245	rval = lm3560_torch_brt_ctrl(flash, led_no, ctrl->val);
	246	break;
	247	}
	248
7f6b11a1	249	err_out:
eed8c3ee	250	mutex_unlock(&flash->lock);
7f6b11a1 DJ	251	return rval;
	252	}
	253
	254	static int lm3560_led1_get_ctrl(struct v4l2_ctrl *ctrl)
	255	{
	256	return lm3560_get_ctrl(ctrl, LM3560_LED1);
	257	}
	258
	259	static int lm3560_led1_set_ctrl(struct v4l2_ctrl *ctrl)
	260	{
	261	return lm3560_set_ctrl(ctrl, LM3560_LED1);
	262	}
	263
	264	static int lm3560_led0_get_ctrl(struct v4l2_ctrl *ctrl)
	265	{
	266	return lm3560_get_ctrl(ctrl, LM3560_LED0);
	267	}
	268
	269	static int lm3560_led0_set_ctrl(struct v4l2_ctrl *ctrl)
	270	{
	271	return lm3560_set_ctrl(ctrl, LM3560_LED0);
	272	}
	273
	274	static const struct v4l2_ctrl_ops lm3560_led_ctrl_ops[LM3560_LED_MAX] = {
	275	[LM3560_LED0] = {
	276	.g_volatile_ctrl = lm3560_led0_get_ctrl,
	277	.s_ctrl = lm3560_led0_set_ctrl,
	278	},
	279	[LM3560_LED1] = {
	280	.g_volatile_ctrl = lm3560_led1_get_ctrl,
	281	.s_ctrl = lm3560_led1_set_ctrl,
	282	}
	283	};
	284
	285	static int lm3560_init_controls(struct lm3560_flash *flash,
	286	enum lm3560_led_id led_no)
	287	{
	288	struct v4l2_ctrl *fault;
	289	u32 max_flash_brt = flash->pdata->max_flash_brt[led_no];
	290	u32 max_torch_brt = flash->pdata->max_torch_brt[led_no];
	291	struct v4l2_ctrl_handler *hdl = &flash->ctrls_led[led_no];
	292	const struct v4l2_ctrl_ops *ops = &lm3560_led_ctrl_ops[led_no];
	293
	294	v4l2_ctrl_handler_init(hdl, 8);
d1166b0f	295
7f6b11a1 DJ	296	/* flash mode */
	297	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,
	298	V4L2_FLASH_LED_MODE_TORCH, ~0x7,
	299	V4L2_FLASH_LED_MODE_NONE);
	300	flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
	301
	302	/* flash source */
	303	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_STROBE_SOURCE,
	304	0x1, ~0x3, V4L2_FLASH_STROBE_SOURCE_SOFTWARE);
	305
	306	/* flash strobe */
	307	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
d1166b0f	308
7f6b11a1 DJ	309	/* flash strobe stop */
	310	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
	311
	312	/* flash strobe timeout */
	313	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TIMEOUT,
	314	LM3560_FLASH_TOUT_MIN,
	315	flash->pdata->max_flash_timeout,
	316	LM3560_FLASH_TOUT_STEP,
	317	flash->pdata->max_flash_timeout);
	318
	319	/* flash brt */
	320	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_INTENSITY,
	321	LM3560_FLASH_BRT_MIN, max_flash_brt,
	322	LM3560_FLASH_BRT_STEP, max_flash_brt);
	323
	324	/* torch brt */
	325	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TORCH_INTENSITY,
	326	LM3560_TORCH_BRT_MIN, max_torch_brt,
	327	LM3560_TORCH_BRT_STEP, max_torch_brt);
	328
	329	/* fault */
	330	fault = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_FAULT, 0,
	331	V4L2_FLASH_FAULT_OVER_VOLTAGE
	332	\| V4L2_FLASH_FAULT_OVER_TEMPERATURE
	333	\| V4L2_FLASH_FAULT_SHORT_CIRCUIT
	334	\| V4L2_FLASH_FAULT_TIMEOUT, 0, 0);
	335	if (fault != NULL)
	336	fault->flags \|= V4L2_CTRL_FLAG_VOLATILE;
	337
	338	if (hdl->error)
	339	return hdl->error;
	340
	341	flash->subdev_led[led_no].ctrl_handler = hdl;
	342	return 0;
	343	}
	344
	345	/* initialize device */
	346	static const struct v4l2_subdev_ops lm3560_ops = {
	347	.core = NULL,
	348	};
	349
	350	static const struct regmap_config lm3560_regmap = {
	351	.reg_bits = 8,
	352	.val_bits = 8,
	353	.max_register = 0xFF,
	354	};
	355
	356	static int lm3560_subdev_init(struct lm3560_flash *flash,
	357	enum lm3560_led_id led_no, char *led_name)
	358	{
	359	struct i2c_client *client = to_i2c_client(flash->dev);
	360	int rval;
	361
	362	v4l2_i2c_subdev_init(&flash->subdev_led[led_no], client, &lm3560_ops);
	363	flash->subdev_led[led_no].flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;
	364	strcpy(flash->subdev_led[led_no].name, led_name);
	365	rval = lm3560_init_controls(flash, led_no);
	366	if (rval)
	367	goto err_out;
ab22e77c	368	rval = media_entity_pads_init(&flash->subdev_led[led_no].entity, 0, NULL);
7f6b11a1 DJ	369	if (rval < 0)
7f6b11a1 DJ	370	goto err_out;
4ca72efa	371	flash->subdev_led[led_no].entity.function = MEDIA_ENT_F_FLASH;
7f6b11a1 DJ	372
	373	return rval;
	374
	375	err_out:
	376	v4l2_ctrl_handler_free(&flash->ctrls_led[led_no]);
	377	return rval;
	378	}
	379
	380	static int lm3560_init_device(struct lm3560_flash *flash)
	381	{
	382	int rval;
	383	unsigned int reg_val;
	384
	385	/* set peak current */
	386	rval = regmap_update_bits(flash->regmap,
	387	REG_FLASH_TOUT, 0x60, flash->pdata->peak);
	388	if (rval < 0)
	389	return rval;
	390	/* output disable */
	391	flash->led_mode = V4L2_FLASH_LED_MODE_NONE;
	392	rval = lm3560_mode_ctrl(flash);
	393	if (rval < 0)
	394	return rval;
d1166b0f	395	/* reset faults */
7f6b11a1 DJ	396	rval = regmap_read(flash->regmap, REG_FLAG, &reg_val);
	397	return rval;
	398	}
	399
	400	static int lm3560_probe(struct i2c_client *client,
	401	const struct i2c_device_id *devid)
	402	{
	403	struct lm3560_flash *flash;
	404	struct lm3560_platform_data *pdata = dev_get_platdata(&client->dev);
	405	int rval;
	406
	407	flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL);
	408	if (flash == NULL)
	409	return -ENOMEM;
	410
	411	flash->regmap = devm_regmap_init_i2c(client, &lm3560_regmap);
	412	if (IS_ERR(flash->regmap)) {
	413	rval = PTR_ERR(flash->regmap);
	414	return rval;
	415	}
	416
	417	/* if there is no platform data, use chip default value */
	418	if (pdata == NULL) {
341ef565	419	pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
7f6b11a1 DJ	420	if (pdata == NULL)
	421	return -ENODEV;
	422	pdata->peak = LM3560_PEAK_3600mA;
	423	pdata->max_flash_timeout = LM3560_FLASH_TOUT_MAX;
	424	/* led 1 */
	425	pdata->max_flash_brt[LM3560_LED0] = LM3560_FLASH_BRT_MAX;
	426	pdata->max_torch_brt[LM3560_LED0] = LM3560_TORCH_BRT_MAX;
	427	/* led 2 */
	428	pdata->max_flash_brt[LM3560_LED1] = LM3560_FLASH_BRT_MAX;
	429	pdata->max_torch_brt[LM3560_LED1] = LM3560_TORCH_BRT_MAX;
	430	}
	431	flash->pdata = pdata;
	432	flash->dev = &client->dev;
	433	mutex_init(&flash->lock);
	434
	435	rval = lm3560_subdev_init(flash, LM3560_LED0, "lm3560-led0");
	436	if (rval < 0)
	437	return rval;
	438
	439	rval = lm3560_subdev_init(flash, LM3560_LED1, "lm3560-led1");
	440	if (rval < 0)
	441	return rval;
	442
	443	rval = lm3560_init_device(flash);
	444	if (rval < 0)
	445	return rval;
	446
cc58f4db WY	447	i2c_set_clientdata(client, flash);
cc58f4db WY	448
7f6b11a1 DJ	449	return 0;
	450	}
	451
	452	static int lm3560_remove(struct i2c_client *client)
	453	{
cc58f4db	454	struct lm3560_flash *flash = i2c_get_clientdata(client);
7f6b11a1 DJ	455	unsigned int i;
	456
	457	for (i = LM3560_LED0; i < LM3560_LED_MAX; i++) {
	458	v4l2_device_unregister_subdev(&flash->subdev_led[i]);
	459	v4l2_ctrl_handler_free(&flash->ctrls_led[i]);
	460	media_entity_cleanup(&flash->subdev_led[i].entity);
	461	}
	462
	463	return 0;
	464	}
	465
	466	static const struct i2c_device_id lm3560_id_table[] = {
	467	{LM3560_NAME, 0},
	468	{}
	469	};
	470
	471	MODULE_DEVICE_TABLE(i2c, lm3560_id_table);
	472
	473	static struct i2c_driver lm3560_i2c_driver = {
	474	.driver = {
	475	.name = LM3560_NAME,
	476	.pm = NULL,
	477	},
	478	.probe = lm3560_probe,
	479	.remove = lm3560_remove,
	480	.id_table = lm3560_id_table,
	481	};
	482
	483	module_i2c_driver(lm3560_i2c_driver);
	484
	485	MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
	486	MODULE_AUTHOR("Ldd Mlp <ldd-mlp@list.ti.com>");
	487	MODULE_DESCRIPTION("Texas Instruments LM3560 LED flash driver");
	488	MODULE_LICENSE("GPL");