[mirror_ubuntu-artful-kernel.git] / drivers / media / i2c / adp1653.c

/*
 * drivers/media/i2c/adp1653.c
 *
 * Copyright (C) 2008--2011 Nokia Corporation
 *
 * Contact: Sakari Ailus <sakari.ailus@iki.fi>
 *
 * Contributors:
 *	Sakari Ailus <sakari.ailus@iki.fi>
 *	Tuukka Toivonen <tuukkat76@gmail.com>
 *	Pavel Machek <pavel@ucw.cz>
 *
 * 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.
 *
 * TODO:
 * - fault interrupt handling
 * - hardware strobe
 * - power doesn't need to be ON if all lights are off
 *
 */

#include <linux/delay.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/gpio/consumer.h>
#include <media/i2c/adp1653.h>
#include <media/v4l2-device.h>

#define TIMEOUT_MAX		820000
#define TIMEOUT_STEP		54600
#define TIMEOUT_MIN		(TIMEOUT_MAX - ADP1653_REG_CONFIG_TMR_SET_MAX \
				 * TIMEOUT_STEP)
#define TIMEOUT_US_TO_CODE(t)	((TIMEOUT_MAX + (TIMEOUT_STEP / 2) - (t)) \
				 / TIMEOUT_STEP)
#define TIMEOUT_CODE_TO_US(c)	(TIMEOUT_MAX - (c) * TIMEOUT_STEP)

/* Write values into ADP1653 registers. */
static int adp1653_update_hw(struct adp1653_flash *flash)
{
	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	u8 out_sel;
	u8 config = 0;
	int rval;

	out_sel = ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
		flash->indicator_intensity->val)
		<< ADP1653_REG_OUT_SEL_ILED_SHIFT;

	switch (flash->led_mode->val) {
	case V4L2_FLASH_LED_MODE_NONE:
		break;
	case V4L2_FLASH_LED_MODE_FLASH:
		/* Flash mode, light on with strobe, duration from timer */
		config = ADP1653_REG_CONFIG_TMR_CFG;
		config |= TIMEOUT_US_TO_CODE(flash->flash_timeout->val)
			  << ADP1653_REG_CONFIG_TMR_SET_SHIFT;
		break;
	case V4L2_FLASH_LED_MODE_TORCH:
		/* Torch mode, light immediately on, duration indefinite */
		out_sel |= ADP1653_FLASH_INTENSITY_mA_TO_REG(
			flash->torch_intensity->val)
			<< ADP1653_REG_OUT_SEL_HPLED_SHIFT;
		break;
	}

	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, out_sel);
	if (rval < 0)
		return rval;

	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_CONFIG, config);
	if (rval < 0)
		return rval;

	return 0;
}

static int adp1653_get_fault(struct adp1653_flash *flash)
{
	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	int fault;
	int rval;

	fault = i2c_smbus_read_byte_data(client, ADP1653_REG_FAULT);
	if (fault < 0)
		return fault;

	flash->fault |= fault;

	if (!flash->fault)
		return 0;

	/* Clear faults. */
	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, 0);
	if (rval < 0)
		return rval;

	flash->led_mode->val = V4L2_FLASH_LED_MODE_NONE;

	rval = adp1653_update_hw(flash);
	if (rval)
		return rval;

	return flash->fault;
}

static int adp1653_strobe(struct adp1653_flash *flash, int enable)
{
	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	u8 out_sel = ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
		flash->indicator_intensity->val)
		<< ADP1653_REG_OUT_SEL_ILED_SHIFT;
	int rval;

	if (flash->led_mode->val != V4L2_FLASH_LED_MODE_FLASH)
		return -EBUSY;

	if (!enable)
		return i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL,
						 out_sel);

	out_sel |= ADP1653_FLASH_INTENSITY_mA_TO_REG(
		flash->flash_intensity->val)
		<< ADP1653_REG_OUT_SEL_HPLED_SHIFT;
	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, out_sel);
	if (rval)
		return rval;

	/* Software strobe using i2c */
	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_SW_STROBE,
		ADP1653_REG_SW_STROBE_SW_STROBE);
	if (rval)
		return rval;
	return i2c_smbus_write_byte_data(client, ADP1653_REG_SW_STROBE, 0);
}

/* --------------------------------------------------------------------------
 * V4L2 controls
 */

static int adp1653_get_ctrl(struct v4l2_ctrl *ctrl)
{
	struct adp1653_flash *flash =
		container_of(ctrl->handler, struct adp1653_flash, ctrls);
	int rval;

	rval = adp1653_get_fault(flash);
	if (rval)
		return rval;

	ctrl->cur.val = 0;

	if (flash->fault & ADP1653_REG_FAULT_FLT_SCP)
		ctrl->cur.val |= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
	if (flash->fault & ADP1653_REG_FAULT_FLT_OT)
		ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
	if (flash->fault & ADP1653_REG_FAULT_FLT_TMR)
		ctrl->cur.val |= V4L2_FLASH_FAULT_TIMEOUT;
	if (flash->fault & ADP1653_REG_FAULT_FLT_OV)
		ctrl->cur.val |= V4L2_FLASH_FAULT_OVER_VOLTAGE;

	flash->fault = 0;

	return 0;
}

static int adp1653_set_ctrl(struct v4l2_ctrl *ctrl)
{
	struct adp1653_flash *flash =
		container_of(ctrl->handler, struct adp1653_flash, ctrls);
	int rval;

	rval = adp1653_get_fault(flash);
	if (rval)
		return rval;
	if ((rval & (ADP1653_REG_FAULT_FLT_SCP |
		     ADP1653_REG_FAULT_FLT_OT |
		     ADP1653_REG_FAULT_FLT_OV)) &&
	    (ctrl->id == V4L2_CID_FLASH_STROBE ||
	     ctrl->id == V4L2_CID_FLASH_TORCH_INTENSITY ||
	     ctrl->id == V4L2_CID_FLASH_LED_MODE))
		return -EBUSY;

	switch (ctrl->id) {
	case V4L2_CID_FLASH_STROBE:
		return adp1653_strobe(flash, 1);
	case V4L2_CID_FLASH_STROBE_STOP:
		return adp1653_strobe(flash, 0);
	}

	return adp1653_update_hw(flash);
}

static const struct v4l2_ctrl_ops adp1653_ctrl_ops = {
	.g_volatile_ctrl = adp1653_get_ctrl,
	.s_ctrl = adp1653_set_ctrl,
};

static int adp1653_init_controls(struct adp1653_flash *flash)
{
	struct v4l2_ctrl *fault;

	v4l2_ctrl_handler_init(&flash->ctrls, 9);

	flash->led_mode =
		v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,
				       V4L2_CID_FLASH_LED_MODE,
				       V4L2_FLASH_LED_MODE_TORCH, ~0x7, 0);
	v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,
			       V4L2_CID_FLASH_STROBE_SOURCE,
			       V4L2_FLASH_STROBE_SOURCE_SOFTWARE, ~0x1, 0);
	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
			  V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
			  V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
	flash->flash_timeout =
		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
				  V4L2_CID_FLASH_TIMEOUT, TIMEOUT_MIN,
				  flash->platform_data->max_flash_timeout,
				  TIMEOUT_STEP,
				  flash->platform_data->max_flash_timeout);
	flash->flash_intensity =
		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
				  V4L2_CID_FLASH_INTENSITY,
				  ADP1653_FLASH_INTENSITY_MIN,
				  flash->platform_data->max_flash_intensity,
				  1, flash->platform_data->max_flash_intensity);
	flash->torch_intensity =
		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
				  V4L2_CID_FLASH_TORCH_INTENSITY,
				  ADP1653_TORCH_INTENSITY_MIN,
				  flash->platform_data->max_torch_intensity,
				  ADP1653_FLASH_INTENSITY_STEP,
				  flash->platform_data->max_torch_intensity);
	flash->indicator_intensity =
		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
				  V4L2_CID_FLASH_INDICATOR_INTENSITY,
				  ADP1653_INDICATOR_INTENSITY_MIN,
				  flash->platform_data->max_indicator_intensity,
				  ADP1653_INDICATOR_INTENSITY_STEP,
				  ADP1653_INDICATOR_INTENSITY_MIN);
	fault = v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
				  V4L2_CID_FLASH_FAULT, 0,
				  V4L2_FLASH_FAULT_OVER_VOLTAGE
				  | V4L2_FLASH_FAULT_OVER_TEMPERATURE
				  | V4L2_FLASH_FAULT_SHORT_CIRCUIT, 0, 0);

	if (flash->ctrls.error)
		return flash->ctrls.error;

	fault->flags |= V4L2_CTRL_FLAG_VOLATILE;

	flash->subdev.ctrl_handler = &flash->ctrls;
	return 0;
}

/* --------------------------------------------------------------------------
 * V4L2 subdev operations
 */

static int
adp1653_init_device(struct adp1653_flash *flash)
{
	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	int rval;

	/* Clear FAULT register by writing zero to OUT_SEL */
	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, 0);
	if (rval < 0) {
		dev_err(&client->dev, "failed writing fault register\n");
		return -EIO;
	}

	mutex_lock(flash->ctrls.lock);
	/* Reset faults before reading new ones. */
	flash->fault = 0;
	rval = adp1653_get_fault(flash);
	mutex_unlock(flash->ctrls.lock);
	if (rval > 0) {
		dev_err(&client->dev, "faults detected: 0x%1.1x\n", rval);
		return -EIO;
	}

	mutex_lock(flash->ctrls.lock);
	rval = adp1653_update_hw(flash);
	mutex_unlock(flash->ctrls.lock);
	if (rval) {
		dev_err(&client->dev,
			"adp1653_update_hw failed at %s\n", __func__);
		return -EIO;
	}

	return 0;
}

static int
__adp1653_set_power(struct adp1653_flash *flash, int on)
{
	int ret;

	if (flash->platform_data->power) {
		ret = flash->platform_data->power(&flash->subdev, on);
		if (ret < 0)
			return ret;
	} else {
		gpiod_set_value(flash->platform_data->enable_gpio, on);
		if (on)
			/* Some delay is apparently required. */
			udelay(20);
	}

	if (!on)
		return 0;

	ret = adp1653_init_device(flash);
	if (ret >= 0)
		return ret;

	if (flash->platform_data->power)
		flash->platform_data->power(&flash->subdev, 0);
	else
		gpiod_set_value(flash->platform_data->enable_gpio, 0);

	return ret;
}

static int
adp1653_set_power(struct v4l2_subdev *subdev, int on)
{
	struct adp1653_flash *flash = to_adp1653_flash(subdev);
	int ret = 0;

	mutex_lock(&flash->power_lock);

	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
	 * update the power state.
	 */
	if (flash->power_count == !on) {
		ret = __adp1653_set_power(flash, !!on);
		if (ret < 0)
			goto done;
	}

	/* Update the power count. */
	flash->power_count += on ? 1 : -1;
	WARN_ON(flash->power_count < 0);

done:
	mutex_unlock(&flash->power_lock);
	return ret;
}

static int adp1653_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
{
	return adp1653_set_power(sd, 1);
}

static int adp1653_close(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
{
	return adp1653_set_power(sd, 0);
}

static const struct v4l2_subdev_core_ops adp1653_core_ops = {
	.s_power = adp1653_set_power,
};

static const struct v4l2_subdev_ops adp1653_ops = {
	.core = &adp1653_core_ops,
};

static const struct v4l2_subdev_internal_ops adp1653_internal_ops = {
	.open = adp1653_open,
	.close = adp1653_close,
};

/* --------------------------------------------------------------------------
 * I2C driver
 */
#ifdef CONFIG_PM

static int adp1653_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
	struct adp1653_flash *flash = to_adp1653_flash(subdev);

	if (!flash->power_count)
		return 0;

	return __adp1653_set_power(flash, 0);
}

static int adp1653_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
	struct adp1653_flash *flash = to_adp1653_flash(subdev);

	if (!flash->power_count)
		return 0;

	return __adp1653_set_power(flash, 1);
}

#else

#define adp1653_suspend	NULL
#define adp1653_resume	NULL

#endif /* CONFIG_PM */

static int adp1653_of_init(struct i2c_client *client,
			   struct adp1653_flash *flash,
			   struct device_node *node)
{
	struct adp1653_platform_data *pd;
	struct device_node *child;

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

	child = of_get_child_by_name(node, "flash");
	if (!child)
		return -EINVAL;

	if (of_property_read_u32(child, "flash-timeout-us",
				 &pd->max_flash_timeout))
		goto err;

	if (of_property_read_u32(child, "flash-max-microamp",
				 &pd->max_flash_intensity))
		goto err;

	pd->max_flash_intensity /= 1000;

	if (of_property_read_u32(child, "led-max-microamp",
				 &pd->max_torch_intensity))
		goto err;

	pd->max_torch_intensity /= 1000;
	of_node_put(child);

	child = of_get_child_by_name(node, "indicator");
	if (!child)
		return -EINVAL;

	if (of_property_read_u32(child, "led-max-microamp",
				 &pd->max_indicator_intensity))
		goto err;

	of_node_put(child);

	pd->enable_gpio = devm_gpiod_get(&client->dev, "enable", GPIOD_OUT_LOW);
	if (IS_ERR(pd->enable_gpio)) {
		dev_err(&client->dev, "Error getting GPIO\n");
		return PTR_ERR(pd->enable_gpio);
	}

	return 0;
err:
	dev_err(&client->dev, "Required property not found\n");
	of_node_put(child);
	return -EINVAL;
}


static int adp1653_probe(struct i2c_client *client,
			 const struct i2c_device_id *devid)
{
	struct adp1653_flash *flash;
	int ret;

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

	if (client->dev.of_node) {
		ret = adp1653_of_init(client, flash, client->dev.of_node);
		if (ret)
			return ret;
	} else {
		if (!client->dev.platform_data) {
			dev_err(&client->dev,
				"Neither DT not platform data provided\n");
			return -EINVAL;
		}
		flash->platform_data = client->dev.platform_data;
	}

	mutex_init(&flash->power_lock);

	v4l2_i2c_subdev_init(&flash->subdev, client, &adp1653_ops);
	flash->subdev.internal_ops = &adp1653_internal_ops;
	flash->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;

	ret = adp1653_init_controls(flash);
	if (ret)
		goto free_and_quit;

	ret = media_entity_pads_init(&flash->subdev.entity, 0, NULL);
	if (ret < 0)
		goto free_and_quit;

	flash->subdev.entity.function = MEDIA_ENT_F_FLASH;

	return 0;

free_and_quit:
	dev_err(&client->dev, "adp1653: failed to register device\n");
	v4l2_ctrl_handler_free(&flash->ctrls);
	return ret;
}

static int adp1653_remove(struct i2c_client *client)
{
	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
	struct adp1653_flash *flash = to_adp1653_flash(subdev);

	v4l2_device_unregister_subdev(&flash->subdev);
	v4l2_ctrl_handler_free(&flash->ctrls);
	media_entity_cleanup(&flash->subdev.entity);

	return 0;
}

static const struct i2c_device_id adp1653_id_table[] = {
	{ ADP1653_NAME, 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, adp1653_id_table);

static const struct dev_pm_ops adp1653_pm_ops = {
	.suspend	= adp1653_suspend,
	.resume		= adp1653_resume,
};

static struct i2c_driver adp1653_i2c_driver = {
	.driver		= {
		.name	= ADP1653_NAME,
		.pm	= &adp1653_pm_ops,
	},
	.probe		= adp1653_probe,
	.remove		= adp1653_remove,
	.id_table	= adp1653_id_table,
};

module_i2c_driver(adp1653_i2c_driver);

MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
MODULE_DESCRIPTION("Analog Devices ADP1653 LED flash driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
13abadad	1	/*
cb7a01ac	2	* drivers/media/i2c/adp1653.c
13abadad SA	3	*
	4	* Copyright (C) 2008--2011 Nokia Corporation
	5	*
8c5dff90	6	* Contact: Sakari Ailus <sakari.ailus@iki.fi>
13abadad SA	7	*
13abadad SA	8	* Contributors:
8c5dff90	9	* Sakari Ailus <sakari.ailus@iki.fi>
13abadad	10	* Tuukka Toivonen <tuukkat76@gmail.com>
074c57a2	11	* Pavel Machek <pavel@ucw.cz>
13abadad SA	12	*
	13	* This program is free software; you can redistribute it and/or
	14	* modify it under the terms of the GNU General Public License
	15	* version 2 as published by the Free Software Foundation.
	16	*
	17	* This program is distributed in the hope that it will be useful, but
	18	* WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	20	* General Public License for more details.
	21	*
13abadad SA	22	* TODO:
	23	* - fault interrupt handling
	24	* - hardware strobe
	25	* - power doesn't need to be ON if all lights are off
	26	*
	27	*/
	28
	29	#include <linux/delay.h>
7a707b89	30	#include <linux/module.h>
13abadad SA	31	#include <linux/i2c.h>
13abadad SA	32	#include <linux/slab.h>
074c57a2 PM	33	#include <linux/of.h>
074c57a2 PM	34	#include <linux/gpio/consumer.h>
b5dcee22	35	#include <media/i2c/adp1653.h>
13abadad SA	36	#include <media/v4l2-device.h>
	37
	38	#define TIMEOUT_MAX 820000
	39	#define TIMEOUT_STEP 54600
	40	#define TIMEOUT_MIN (TIMEOUT_MAX - ADP1653_REG_CONFIG_TMR_SET_MAX \
	41	* TIMEOUT_STEP)
	42	#define TIMEOUT_US_TO_CODE(t) ((TIMEOUT_MAX + (TIMEOUT_STEP / 2) - (t)) \
	43	/ TIMEOUT_STEP)
	44	#define TIMEOUT_CODE_TO_US(c) (TIMEOUT_MAX - (c) * TIMEOUT_STEP)
	45
	46	/* Write values into ADP1653 registers. */
	47	static int adp1653_update_hw(struct adp1653_flash *flash)
	48	{
	49	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	50	u8 out_sel;
	51	u8 config = 0;
	52	int rval;
	53
	54	out_sel = ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
	55	flash->indicator_intensity->val)
	56	<< ADP1653_REG_OUT_SEL_ILED_SHIFT;
	57
	58	switch (flash->led_mode->val) {
	59	case V4L2_FLASH_LED_MODE_NONE:
	60	break;
	61	case V4L2_FLASH_LED_MODE_FLASH:
	62	/* Flash mode, light on with strobe, duration from timer */
	63	config = ADP1653_REG_CONFIG_TMR_CFG;
	64	config \|= TIMEOUT_US_TO_CODE(flash->flash_timeout->val)
	65	<< ADP1653_REG_CONFIG_TMR_SET_SHIFT;
	66	break;
	67	case V4L2_FLASH_LED_MODE_TORCH:
	68	/* Torch mode, light immediately on, duration indefinite */
	69	out_sel \|= ADP1653_FLASH_INTENSITY_mA_TO_REG(
	70	flash->torch_intensity->val)
	71	<< ADP1653_REG_OUT_SEL_HPLED_SHIFT;
	72	break;
	73	}
	74
	75	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, out_sel);
	76	if (rval < 0)
	77	return rval;
	78
	79	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_CONFIG, config);
	80	if (rval < 0)
	81	return rval;
	82
	83	return 0;
	84	}
	85
	86	static int adp1653_get_fault(struct adp1653_flash *flash)
	87	{
	88	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	89	int fault;
	90	int rval;
	91
	92	fault = i2c_smbus_read_byte_data(client, ADP1653_REG_FAULT);
287980e4	93	if (fault < 0)
13abadad SA	94	return fault;
	95
	96	flash->fault \|= fault;
	97
	98	if (!flash->fault)
	99	return 0;
	100
	101	/* Clear faults. */
	102	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, 0);
287980e4	103	if (rval < 0)
13abadad SA	104	return rval;
	105
	106	flash->led_mode->val = V4L2_FLASH_LED_MODE_NONE;
	107
	108	rval = adp1653_update_hw(flash);
287980e4	109	if (rval)
13abadad SA	110	return rval;
	111
	112	return flash->fault;
	113	}
	114
	115	static int adp1653_strobe(struct adp1653_flash *flash, int enable)
	116	{
	117	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	118	u8 out_sel = ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
	119	flash->indicator_intensity->val)
	120	<< ADP1653_REG_OUT_SEL_ILED_SHIFT;
	121	int rval;
	122
	123	if (flash->led_mode->val != V4L2_FLASH_LED_MODE_FLASH)
	124	return -EBUSY;
	125
	126	if (!enable)
	127	return i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL,
	128	out_sel);
	129
	130	out_sel \|= ADP1653_FLASH_INTENSITY_mA_TO_REG(
	131	flash->flash_intensity->val)
	132	<< ADP1653_REG_OUT_SEL_HPLED_SHIFT;
	133	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, out_sel);
	134	if (rval)
	135	return rval;
	136
	137	/* Software strobe using i2c */
	138	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_SW_STROBE,
	139	ADP1653_REG_SW_STROBE_SW_STROBE);
	140	if (rval)
	141	return rval;
	142	return i2c_smbus_write_byte_data(client, ADP1653_REG_SW_STROBE, 0);
	143	}
	144
	145	/* --------------------------------------------------------------------------
	146	* V4L2 controls
	147	*/
	148
	149	static int adp1653_get_ctrl(struct v4l2_ctrl *ctrl)
	150	{
	151	struct adp1653_flash *flash =
	152	container_of(ctrl->handler, struct adp1653_flash, ctrls);
	153	int rval;
	154
	155	rval = adp1653_get_fault(flash);
287980e4	156	if (rval)
13abadad SA	157	return rval;
	158
	159	ctrl->cur.val = 0;
	160
	161	if (flash->fault & ADP1653_REG_FAULT_FLT_SCP)
	162	ctrl->cur.val \|= V4L2_FLASH_FAULT_SHORT_CIRCUIT;
	163	if (flash->fault & ADP1653_REG_FAULT_FLT_OT)
	164	ctrl->cur.val \|= V4L2_FLASH_FAULT_OVER_TEMPERATURE;
	165	if (flash->fault & ADP1653_REG_FAULT_FLT_TMR)
	166	ctrl->cur.val \|= V4L2_FLASH_FAULT_TIMEOUT;
	167	if (flash->fault & ADP1653_REG_FAULT_FLT_OV)
	168	ctrl->cur.val \|= V4L2_FLASH_FAULT_OVER_VOLTAGE;
	169
	170	flash->fault = 0;
	171
	172	return 0;
	173	}
	174
	175	static int adp1653_set_ctrl(struct v4l2_ctrl *ctrl)
	176	{
	177	struct adp1653_flash *flash =
	178	container_of(ctrl->handler, struct adp1653_flash, ctrls);
	179	int rval;
	180
	181	rval = adp1653_get_fault(flash);
287980e4	182	if (rval)
13abadad SA	183	return rval;
	184	if ((rval & (ADP1653_REG_FAULT_FLT_SCP \|
	185	ADP1653_REG_FAULT_FLT_OT \|
	186	ADP1653_REG_FAULT_FLT_OV)) &&
	187	(ctrl->id == V4L2_CID_FLASH_STROBE \|\|
	188	ctrl->id == V4L2_CID_FLASH_TORCH_INTENSITY \|\|
	189	ctrl->id == V4L2_CID_FLASH_LED_MODE))
	190	return -EBUSY;
	191
	192	switch (ctrl->id) {
	193	case V4L2_CID_FLASH_STROBE:
	194	return adp1653_strobe(flash, 1);
	195	case V4L2_CID_FLASH_STROBE_STOP:
	196	return adp1653_strobe(flash, 0);
	197	}
	198
	199	return adp1653_update_hw(flash);
	200	}
	201
	202	static const struct v4l2_ctrl_ops adp1653_ctrl_ops = {
	203	.g_volatile_ctrl = adp1653_get_ctrl,
	204	.s_ctrl = adp1653_set_ctrl,
	205	};
	206
	207	static int adp1653_init_controls(struct adp1653_flash *flash)
	208	{
	209	struct v4l2_ctrl *fault;
	210
	211	v4l2_ctrl_handler_init(&flash->ctrls, 9);
	212
	213	flash->led_mode =
	214	v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,
	215	V4L2_CID_FLASH_LED_MODE,
	216	V4L2_FLASH_LED_MODE_TORCH, ~0x7, 0);
	217	v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,
	218	V4L2_CID_FLASH_STROBE_SOURCE,
	219	V4L2_FLASH_STROBE_SOURCE_SOFTWARE, ~0x1, 0);
	220	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
	221	V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);
	222	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
	223	V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);
	224	flash->flash_timeout =
	225	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
	226	V4L2_CID_FLASH_TIMEOUT, TIMEOUT_MIN,
	227	flash->platform_data->max_flash_timeout,
	228	TIMEOUT_STEP,
	229	flash->platform_data->max_flash_timeout);
	230	flash->flash_intensity =
	231	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
	232	V4L2_CID_FLASH_INTENSITY,
	233	ADP1653_FLASH_INTENSITY_MIN,
	234	flash->platform_data->max_flash_intensity,
	235	1, flash->platform_data->max_flash_intensity);
	236	flash->torch_intensity =
	237	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
	238	V4L2_CID_FLASH_TORCH_INTENSITY,
	239	ADP1653_TORCH_INTENSITY_MIN,
	240	flash->platform_data->max_torch_intensity,
	241	ADP1653_FLASH_INTENSITY_STEP,
	242	flash->platform_data->max_torch_intensity);
	243	flash->indicator_intensity =
	244	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
	245	V4L2_CID_FLASH_INDICATOR_INTENSITY,
	246	ADP1653_INDICATOR_INTENSITY_MIN,
247	flash->platform_data->max_indicator_intensity,
248	ADP1653_INDICATOR_INTENSITY_STEP,
249	ADP1653_INDICATOR_INTENSITY_MIN);
250	fault = v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,
251	V4L2_CID_FLASH_FAULT, 0,
252	V4L2_FLASH_FAULT_OVER_VOLTAGE
253	\| V4L2_FLASH_FAULT_OVER_TEMPERATURE
254	\| V4L2_FLASH_FAULT_SHORT_CIRCUIT, 0, 0);
255
256	if (flash->ctrls.error)
257	return flash->ctrls.error;
258
88365105	259	fault->flags \|= V4L2_CTRL_FLAG_VOLATILE;
13abadad SA	260
	261	flash->subdev.ctrl_handler = &flash->ctrls;
	262	return 0;
	263	}
	264
	265	/* --------------------------------------------------------------------------
	266	* V4L2 subdev operations
	267	*/
	268
	269	static int
	270	adp1653_init_device(struct adp1653_flash *flash)
	271	{
	272	struct i2c_client *client = v4l2_get_subdevdata(&flash->subdev);
	273	int rval;
	274
	275	/* Clear FAULT register by writing zero to OUT_SEL */
	276	rval = i2c_smbus_write_byte_data(client, ADP1653_REG_OUT_SEL, 0);
	277	if (rval < 0) {
	278	dev_err(&client->dev, "failed writing fault register\n");
	279	return -EIO;
	280	}
	281
77e7c4e6	282	mutex_lock(flash->ctrls.lock);
13abadad SA	283	/* Reset faults before reading new ones. */
	284	flash->fault = 0;
	285	rval = adp1653_get_fault(flash);
77e7c4e6	286	mutex_unlock(flash->ctrls.lock);
13abadad SA	287	if (rval > 0) {
	288	dev_err(&client->dev, "faults detected: 0x%1.1x\n", rval);
	289	return -EIO;
	290	}
	291
77e7c4e6	292	mutex_lock(flash->ctrls.lock);
13abadad	293	rval = adp1653_update_hw(flash);
77e7c4e6	294	mutex_unlock(flash->ctrls.lock);
13abadad SA	295	if (rval) {
	296	dev_err(&client->dev,
	297	"adp1653_update_hw failed at %s\n", __func__);
	298	return -EIO;
	299	}
	300
	301	return 0;
	302	}
	303
	304	static int
	305	__adp1653_set_power(struct adp1653_flash *flash, int on)
	306	{
be8e58d9	307	int ret;
13abadad	308
074c57a2 PM	309	if (flash->platform_data->power) {
	310	ret = flash->platform_data->power(&flash->subdev, on);
	311	if (ret < 0)
	312	return ret;
	313	} else {
	314	gpiod_set_value(flash->platform_data->enable_gpio, on);
	315	if (on)
	316	/* Some delay is apparently required. */
	317	udelay(20);
	318	}
13abadad SA	319
	320	if (!on)
	321	return 0;
	322
	323	ret = adp1653_init_device(flash);
074c57a2 PM	324	if (ret >= 0)
	325	return ret;
	326
	327	if (flash->platform_data->power)
13abadad	328	flash->platform_data->power(&flash->subdev, 0);
074c57a2 PM	329	else
074c57a2 PM	330	gpiod_set_value(flash->platform_data->enable_gpio, 0);
13abadad SA	331
	332	return ret;
	333	}
	334
	335	static int
	336	adp1653_set_power(struct v4l2_subdev *subdev, int on)
	337	{
	338	struct adp1653_flash *flash = to_adp1653_flash(subdev);
	339	int ret = 0;
	340
	341	mutex_lock(&flash->power_lock);
	342
	343	/* If the power count is modified from 0 to != 0 or from != 0 to 0,
	344	* update the power state.
	345	*/
	346	if (flash->power_count == !on) {
	347	ret = __adp1653_set_power(flash, !!on);
	348	if (ret < 0)
	349	goto done;
	350	}
	351
	352	/* Update the power count. */
	353	flash->power_count += on ? 1 : -1;
	354	WARN_ON(flash->power_count < 0);
	355
	356	done:
	357	mutex_unlock(&flash->power_lock);
	358	return ret;
	359	}
	360
	361	static int adp1653_open(struct v4l2_subdev sd, struct v4l2_subdev_fh fh)
	362	{
	363	return adp1653_set_power(sd, 1);
	364	}
	365
	366	static int adp1653_close(struct v4l2_subdev sd, struct v4l2_subdev_fh fh)
	367	{
	368	return adp1653_set_power(sd, 0);
	369	}
	370
	371	static const struct v4l2_subdev_core_ops adp1653_core_ops = {
	372	.s_power = adp1653_set_power,
	373	};
	374
	375	static const struct v4l2_subdev_ops adp1653_ops = {
	376	.core = &adp1653_core_ops,
	377	};
	378
	379	static const struct v4l2_subdev_internal_ops adp1653_internal_ops = {
	380	.open = adp1653_open,
	381	.close = adp1653_close,
	382	};
	383
	384	/* --------------------------------------------------------------------------
	385	* I2C driver
	386	*/
	387	#ifdef CONFIG_PM
	388
	389	static int adp1653_suspend(struct device *dev)
	390	{
	391	struct i2c_client *client = to_i2c_client(dev);
	392	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
	393	struct adp1653_flash *flash = to_adp1653_flash(subdev);
	394
395	if (!flash->power_count)
396	return 0;
397
398	return __adp1653_set_power(flash, 0);
399	}
400
401	static int adp1653_resume(struct device *dev)
402	{
403	struct i2c_client *client = to_i2c_client(dev);
404	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
405	struct adp1653_flash *flash = to_adp1653_flash(subdev);
406
407	if (!flash->power_count)
408	return 0;
409
410	return __adp1653_set_power(flash, 1);
411	}
412
413	#else
414
415	#define adp1653_suspend NULL
416	#define adp1653_resume NULL
417
418	#endif /* CONFIG_PM */
419
074c57a2 PM	420	static int adp1653_of_init(struct i2c_client *client,
	421	struct adp1653_flash *flash,
	422	struct device_node *node)
	423	{
	424	struct adp1653_platform_data *pd;
	425	struct device_node *child;
	426
	427	pd = devm_kzalloc(&client->dev, sizeof(*pd), GFP_KERNEL);
	428	if (!pd)
	429	return -ENOMEM;
	430	flash->platform_data = pd;
	431
	432	child = of_get_child_by_name(node, "flash");
	433	if (!child)
	434	return -EINVAL;
	435
	436	if (of_property_read_u32(child, "flash-timeout-us",
	437	&pd->max_flash_timeout))
	438	goto err;
	439
	440	if (of_property_read_u32(child, "flash-max-microamp",
	441	&pd->max_flash_intensity))
	442	goto err;
	443
	444	pd->max_flash_intensity /= 1000;
	445
	446	if (of_property_read_u32(child, "led-max-microamp",
	447	&pd->max_torch_intensity))
	448	goto err;
	449
	450	pd->max_torch_intensity /= 1000;
	451	of_node_put(child);
	452
	453	child = of_get_child_by_name(node, "indicator");
	454	if (!child)
	455	return -EINVAL;
	456
	457	if (of_property_read_u32(child, "led-max-microamp",
	458	&pd->max_indicator_intensity))
	459	goto err;
	460
	461	of_node_put(child);
	462
a33c380e	463	pd->enable_gpio = devm_gpiod_get(&client->dev, "enable", GPIOD_OUT_LOW);
806f8ffa	464	if (IS_ERR(pd->enable_gpio)) {
074c57a2	465	dev_err(&client->dev, "Error getting GPIO\n");
806f8ffa	466	return PTR_ERR(pd->enable_gpio);
074c57a2 PM	467	}
	468
	469	return 0;
	470	err:
	471	dev_err(&client->dev, "Required property not found\n");
	472	of_node_put(child);
	473	return -EINVAL;
	474	}
	475
	476
13abadad SA	477	static int adp1653_probe(struct i2c_client *client,
	478	const struct i2c_device_id *devid)
	479	{
	480	struct adp1653_flash *flash;
	481	int ret;
	482
c02b211d	483	flash = devm_kzalloc(&client->dev, sizeof(*flash), GFP_KERNEL);
13abadad SA	484	if (flash == NULL)
	485	return -ENOMEM;
	486
074c57a2 PM	487	if (client->dev.of_node) {
	488	ret = adp1653_of_init(client, flash, client->dev.of_node);
	489	if (ret)
	490	return ret;
	491	} else {
	492	if (!client->dev.platform_data) {
	493	dev_err(&client->dev,
	494	"Neither DT not platform data provided\n");
b888d232	495	return -EINVAL;
074c57a2 PM	496	}
	497	flash->platform_data = client->dev.platform_data;
	498	}
13abadad SA	499
	500	mutex_init(&flash->power_lock);
	501
	502	v4l2_i2c_subdev_init(&flash->subdev, client, &adp1653_ops);
	503	flash->subdev.internal_ops = &adp1653_internal_ops;
	504	flash->subdev.flags \|= V4L2_SUBDEV_FL_HAS_DEVNODE;
	505
31ee95ec AS	506	ret = adp1653_init_controls(flash);
	507	if (ret)
	508	goto free_and_quit;
13abadad	509
ab22e77c	510	ret = media_entity_pads_init(&flash->subdev.entity, 0, NULL);
13abadad	511	if (ret < 0)
31ee95ec	512	goto free_and_quit;
13abadad	513
4ca72efa	514	flash->subdev.entity.function = MEDIA_ENT_F_FLASH;
be8e58d9	515
31ee95ec AS	516	return 0;
	517
	518	free_and_quit:
074c57a2	519	dev_err(&client->dev, "adp1653: failed to register device\n");
31ee95ec	520	v4l2_ctrl_handler_free(&flash->ctrls);
13abadad SA	521	return ret;
	522	}
	523
bf306900	524	static int adp1653_remove(struct i2c_client *client)
13abadad SA	525	{
	526	struct v4l2_subdev *subdev = i2c_get_clientdata(client);
	527	struct adp1653_flash *flash = to_adp1653_flash(subdev);
	528
	529	v4l2_device_unregister_subdev(&flash->subdev);
	530	v4l2_ctrl_handler_free(&flash->ctrls);
	531	media_entity_cleanup(&flash->subdev.entity);
c02b211d	532
13abadad SA	533	return 0;
	534	}
	535
	536	static const struct i2c_device_id adp1653_id_table[] = {
	537	{ ADP1653_NAME, 0 },
	538	{ }
	539	};
	540	MODULE_DEVICE_TABLE(i2c, adp1653_id_table);
	541
074c57a2	542	static const struct dev_pm_ops adp1653_pm_ops = {
13abadad SA	543	.suspend = adp1653_suspend,
	544	.resume = adp1653_resume,
	545	};
	546
	547	static struct i2c_driver adp1653_i2c_driver = {
	548	.driver = {
	549	.name = ADP1653_NAME,
	550	.pm = &adp1653_pm_ops,
	551	},
	552	.probe = adp1653_probe,
bf306900	553	.remove = adp1653_remove,
13abadad SA	554	.id_table = adp1653_id_table,
	555	};
	556
c6e8d86f	557	module_i2c_driver(adp1653_i2c_driver);
13abadad SA	558
	559	MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
	560	MODULE_DESCRIPTION("Analog Devices ADP1653 LED flash driver");
	561	MODULE_LICENSE("GPL");