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