1 // SPDX-License-Identifier: GPL-2.0-only
3 * drivers/media/i2c/adp1653.c
5 * Copyright (C) 2008--2011 Nokia Corporation
7 * Contact: Sakari Ailus <sakari.ailus@iki.fi>
10 * Sakari Ailus <sakari.ailus@iki.fi>
11 * Tuukka Toivonen <tuukkat76@gmail.com>
12 * Pavel Machek <pavel@ucw.cz>
15 * - fault interrupt handling
17 * - power doesn't need to be ON if all lights are off
20 #include <linux/delay.h>
21 #include <linux/module.h>
22 #include <linux/i2c.h>
23 #include <linux/slab.h>
25 #include <linux/gpio/consumer.h>
26 #include <media/i2c/adp1653.h>
27 #include <media/v4l2-device.h>
29 #define TIMEOUT_MAX 820000
30 #define TIMEOUT_STEP 54600
31 #define TIMEOUT_MIN (TIMEOUT_MAX - ADP1653_REG_CONFIG_TMR_SET_MAX \
33 #define TIMEOUT_US_TO_CODE(t) ((TIMEOUT_MAX + (TIMEOUT_STEP / 2) - (t)) \
35 #define TIMEOUT_CODE_TO_US(c) (TIMEOUT_MAX - (c) * TIMEOUT_STEP)
37 /* Write values into ADP1653 registers. */
38 static int adp1653_update_hw(struct adp1653_flash
*flash
)
40 struct i2c_client
*client
= v4l2_get_subdevdata(&flash
->subdev
);
45 out_sel
= ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
46 flash
->indicator_intensity
->val
)
47 << ADP1653_REG_OUT_SEL_ILED_SHIFT
;
49 switch (flash
->led_mode
->val
) {
50 case V4L2_FLASH_LED_MODE_NONE
:
52 case V4L2_FLASH_LED_MODE_FLASH
:
53 /* Flash mode, light on with strobe, duration from timer */
54 config
= ADP1653_REG_CONFIG_TMR_CFG
;
55 config
|= TIMEOUT_US_TO_CODE(flash
->flash_timeout
->val
)
56 << ADP1653_REG_CONFIG_TMR_SET_SHIFT
;
58 case V4L2_FLASH_LED_MODE_TORCH
:
59 /* Torch mode, light immediately on, duration indefinite */
60 out_sel
|= ADP1653_FLASH_INTENSITY_mA_TO_REG(
61 flash
->torch_intensity
->val
)
62 << ADP1653_REG_OUT_SEL_HPLED_SHIFT
;
66 rval
= i2c_smbus_write_byte_data(client
, ADP1653_REG_OUT_SEL
, out_sel
);
70 rval
= i2c_smbus_write_byte_data(client
, ADP1653_REG_CONFIG
, config
);
77 static int adp1653_get_fault(struct adp1653_flash
*flash
)
79 struct i2c_client
*client
= v4l2_get_subdevdata(&flash
->subdev
);
83 fault
= i2c_smbus_read_byte_data(client
, ADP1653_REG_FAULT
);
87 flash
->fault
|= fault
;
93 rval
= i2c_smbus_write_byte_data(client
, ADP1653_REG_OUT_SEL
, 0);
97 flash
->led_mode
->val
= V4L2_FLASH_LED_MODE_NONE
;
99 rval
= adp1653_update_hw(flash
);
106 static int adp1653_strobe(struct adp1653_flash
*flash
, int enable
)
108 struct i2c_client
*client
= v4l2_get_subdevdata(&flash
->subdev
);
109 u8 out_sel
= ADP1653_INDICATOR_INTENSITY_uA_TO_REG(
110 flash
->indicator_intensity
->val
)
111 << ADP1653_REG_OUT_SEL_ILED_SHIFT
;
114 if (flash
->led_mode
->val
!= V4L2_FLASH_LED_MODE_FLASH
)
118 return i2c_smbus_write_byte_data(client
, ADP1653_REG_OUT_SEL
,
121 out_sel
|= ADP1653_FLASH_INTENSITY_mA_TO_REG(
122 flash
->flash_intensity
->val
)
123 << ADP1653_REG_OUT_SEL_HPLED_SHIFT
;
124 rval
= i2c_smbus_write_byte_data(client
, ADP1653_REG_OUT_SEL
, out_sel
);
128 /* Software strobe using i2c */
129 rval
= i2c_smbus_write_byte_data(client
, ADP1653_REG_SW_STROBE
,
130 ADP1653_REG_SW_STROBE_SW_STROBE
);
133 return i2c_smbus_write_byte_data(client
, ADP1653_REG_SW_STROBE
, 0);
136 /* --------------------------------------------------------------------------
140 static int adp1653_get_ctrl(struct v4l2_ctrl
*ctrl
)
142 struct adp1653_flash
*flash
=
143 container_of(ctrl
->handler
, struct adp1653_flash
, ctrls
);
146 rval
= adp1653_get_fault(flash
);
152 if (flash
->fault
& ADP1653_REG_FAULT_FLT_SCP
)
153 ctrl
->cur
.val
|= V4L2_FLASH_FAULT_SHORT_CIRCUIT
;
154 if (flash
->fault
& ADP1653_REG_FAULT_FLT_OT
)
155 ctrl
->cur
.val
|= V4L2_FLASH_FAULT_OVER_TEMPERATURE
;
156 if (flash
->fault
& ADP1653_REG_FAULT_FLT_TMR
)
157 ctrl
->cur
.val
|= V4L2_FLASH_FAULT_TIMEOUT
;
158 if (flash
->fault
& ADP1653_REG_FAULT_FLT_OV
)
159 ctrl
->cur
.val
|= V4L2_FLASH_FAULT_OVER_VOLTAGE
;
166 static int adp1653_set_ctrl(struct v4l2_ctrl
*ctrl
)
168 struct adp1653_flash
*flash
=
169 container_of(ctrl
->handler
, struct adp1653_flash
, ctrls
);
172 rval
= adp1653_get_fault(flash
);
175 if ((rval
& (ADP1653_REG_FAULT_FLT_SCP
|
176 ADP1653_REG_FAULT_FLT_OT
|
177 ADP1653_REG_FAULT_FLT_OV
)) &&
178 (ctrl
->id
== V4L2_CID_FLASH_STROBE
||
179 ctrl
->id
== V4L2_CID_FLASH_TORCH_INTENSITY
||
180 ctrl
->id
== V4L2_CID_FLASH_LED_MODE
))
184 case V4L2_CID_FLASH_STROBE
:
185 return adp1653_strobe(flash
, 1);
186 case V4L2_CID_FLASH_STROBE_STOP
:
187 return adp1653_strobe(flash
, 0);
190 return adp1653_update_hw(flash
);
193 static const struct v4l2_ctrl_ops adp1653_ctrl_ops
= {
194 .g_volatile_ctrl
= adp1653_get_ctrl
,
195 .s_ctrl
= adp1653_set_ctrl
,
198 static int adp1653_init_controls(struct adp1653_flash
*flash
)
200 struct v4l2_ctrl
*fault
;
202 v4l2_ctrl_handler_init(&flash
->ctrls
, 9);
205 v4l2_ctrl_new_std_menu(&flash
->ctrls
, &adp1653_ctrl_ops
,
206 V4L2_CID_FLASH_LED_MODE
,
207 V4L2_FLASH_LED_MODE_TORCH
, ~0x7, 0);
208 v4l2_ctrl_new_std_menu(&flash
->ctrls
, &adp1653_ctrl_ops
,
209 V4L2_CID_FLASH_STROBE_SOURCE
,
210 V4L2_FLASH_STROBE_SOURCE_SOFTWARE
, ~0x1, 0);
211 v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
212 V4L2_CID_FLASH_STROBE
, 0, 0, 0, 0);
213 v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
214 V4L2_CID_FLASH_STROBE_STOP
, 0, 0, 0, 0);
215 flash
->flash_timeout
=
216 v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
217 V4L2_CID_FLASH_TIMEOUT
, TIMEOUT_MIN
,
218 flash
->platform_data
->max_flash_timeout
,
220 flash
->platform_data
->max_flash_timeout
);
221 flash
->flash_intensity
=
222 v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
223 V4L2_CID_FLASH_INTENSITY
,
224 ADP1653_FLASH_INTENSITY_MIN
,
225 flash
->platform_data
->max_flash_intensity
,
226 1, flash
->platform_data
->max_flash_intensity
);
227 flash
->torch_intensity
=
228 v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
229 V4L2_CID_FLASH_TORCH_INTENSITY
,
230 ADP1653_TORCH_INTENSITY_MIN
,
231 flash
->platform_data
->max_torch_intensity
,
232 ADP1653_FLASH_INTENSITY_STEP
,
233 flash
->platform_data
->max_torch_intensity
);
234 flash
->indicator_intensity
=
235 v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
236 V4L2_CID_FLASH_INDICATOR_INTENSITY
,
237 ADP1653_INDICATOR_INTENSITY_MIN
,
238 flash
->platform_data
->max_indicator_intensity
,
239 ADP1653_INDICATOR_INTENSITY_STEP
,
240 ADP1653_INDICATOR_INTENSITY_MIN
);
241 fault
= v4l2_ctrl_new_std(&flash
->ctrls
, &adp1653_ctrl_ops
,
242 V4L2_CID_FLASH_FAULT
, 0,
243 V4L2_FLASH_FAULT_OVER_VOLTAGE
244 | V4L2_FLASH_FAULT_OVER_TEMPERATURE
245 | V4L2_FLASH_FAULT_SHORT_CIRCUIT
, 0, 0);
247 if (flash
->ctrls
.error
)
248 return flash
->ctrls
.error
;
250 fault
->flags
|= V4L2_CTRL_FLAG_VOLATILE
;
252 flash
->subdev
.ctrl_handler
= &flash
->ctrls
;
256 /* --------------------------------------------------------------------------
257 * V4L2 subdev operations
261 adp1653_init_device(struct adp1653_flash
*flash
)
263 struct i2c_client
*client
= v4l2_get_subdevdata(&flash
->subdev
);
266 /* Clear FAULT register by writing zero to OUT_SEL */
267 rval
= i2c_smbus_write_byte_data(client
, ADP1653_REG_OUT_SEL
, 0);
269 dev_err(&client
->dev
, "failed writing fault register\n");
273 mutex_lock(flash
->ctrls
.lock
);
274 /* Reset faults before reading new ones. */
276 rval
= adp1653_get_fault(flash
);
277 mutex_unlock(flash
->ctrls
.lock
);
279 dev_err(&client
->dev
, "faults detected: 0x%1.1x\n", rval
);
283 mutex_lock(flash
->ctrls
.lock
);
284 rval
= adp1653_update_hw(flash
);
285 mutex_unlock(flash
->ctrls
.lock
);
287 dev_err(&client
->dev
,
288 "adp1653_update_hw failed at %s\n", __func__
);
296 __adp1653_set_power(struct adp1653_flash
*flash
, int on
)
300 if (flash
->platform_data
->power
) {
301 ret
= flash
->platform_data
->power(&flash
->subdev
, on
);
305 gpiod_set_value(flash
->platform_data
->enable_gpio
, on
);
307 /* Some delay is apparently required. */
314 ret
= adp1653_init_device(flash
);
318 if (flash
->platform_data
->power
)
319 flash
->platform_data
->power(&flash
->subdev
, 0);
321 gpiod_set_value(flash
->platform_data
->enable_gpio
, 0);
327 adp1653_set_power(struct v4l2_subdev
*subdev
, int on
)
329 struct adp1653_flash
*flash
= to_adp1653_flash(subdev
);
332 mutex_lock(&flash
->power_lock
);
334 /* If the power count is modified from 0 to != 0 or from != 0 to 0,
335 * update the power state.
337 if (flash
->power_count
== !on
) {
338 ret
= __adp1653_set_power(flash
, !!on
);
343 /* Update the power count. */
344 flash
->power_count
+= on
? 1 : -1;
345 WARN_ON(flash
->power_count
< 0);
348 mutex_unlock(&flash
->power_lock
);
352 static int adp1653_open(struct v4l2_subdev
*sd
, struct v4l2_subdev_fh
*fh
)
354 return adp1653_set_power(sd
, 1);
357 static int adp1653_close(struct v4l2_subdev
*sd
, struct v4l2_subdev_fh
*fh
)
359 return adp1653_set_power(sd
, 0);
362 static const struct v4l2_subdev_core_ops adp1653_core_ops
= {
363 .s_power
= adp1653_set_power
,
366 static const struct v4l2_subdev_ops adp1653_ops
= {
367 .core
= &adp1653_core_ops
,
370 static const struct v4l2_subdev_internal_ops adp1653_internal_ops
= {
371 .open
= adp1653_open
,
372 .close
= adp1653_close
,
375 /* --------------------------------------------------------------------------
380 static int adp1653_suspend(struct device
*dev
)
382 struct v4l2_subdev
*subdev
= dev_get_drvdata(dev
);
383 struct adp1653_flash
*flash
= to_adp1653_flash(subdev
);
385 if (!flash
->power_count
)
388 return __adp1653_set_power(flash
, 0);
391 static int adp1653_resume(struct device
*dev
)
393 struct v4l2_subdev
*subdev
= dev_get_drvdata(dev
);
394 struct adp1653_flash
*flash
= to_adp1653_flash(subdev
);
396 if (!flash
->power_count
)
399 return __adp1653_set_power(flash
, 1);
404 #define adp1653_suspend NULL
405 #define adp1653_resume NULL
407 #endif /* CONFIG_PM */
409 static int adp1653_of_init(struct i2c_client
*client
,
410 struct adp1653_flash
*flash
,
411 struct device_node
*node
)
413 struct adp1653_platform_data
*pd
;
414 struct device_node
*child
;
416 pd
= devm_kzalloc(&client
->dev
, sizeof(*pd
), GFP_KERNEL
);
419 flash
->platform_data
= pd
;
421 child
= of_get_child_by_name(node
, "flash");
425 if (of_property_read_u32(child
, "flash-timeout-us",
426 &pd
->max_flash_timeout
))
429 if (of_property_read_u32(child
, "flash-max-microamp",
430 &pd
->max_flash_intensity
))
433 pd
->max_flash_intensity
/= 1000;
435 if (of_property_read_u32(child
, "led-max-microamp",
436 &pd
->max_torch_intensity
))
439 pd
->max_torch_intensity
/= 1000;
442 child
= of_get_child_by_name(node
, "indicator");
446 if (of_property_read_u32(child
, "led-max-microamp",
447 &pd
->max_indicator_intensity
))
452 pd
->enable_gpio
= devm_gpiod_get(&client
->dev
, "enable", GPIOD_OUT_LOW
);
453 if (IS_ERR(pd
->enable_gpio
)) {
454 dev_err(&client
->dev
, "Error getting GPIO\n");
455 return PTR_ERR(pd
->enable_gpio
);
460 dev_err(&client
->dev
, "Required property not found\n");
466 static int adp1653_probe(struct i2c_client
*client
,
467 const struct i2c_device_id
*devid
)
469 struct adp1653_flash
*flash
;
472 flash
= devm_kzalloc(&client
->dev
, sizeof(*flash
), GFP_KERNEL
);
476 if (client
->dev
.of_node
) {
477 ret
= adp1653_of_init(client
, flash
, client
->dev
.of_node
);
481 if (!client
->dev
.platform_data
) {
482 dev_err(&client
->dev
,
483 "Neither DT not platform data provided\n");
486 flash
->platform_data
= client
->dev
.platform_data
;
489 mutex_init(&flash
->power_lock
);
491 v4l2_i2c_subdev_init(&flash
->subdev
, client
, &adp1653_ops
);
492 flash
->subdev
.internal_ops
= &adp1653_internal_ops
;
493 flash
->subdev
.flags
|= V4L2_SUBDEV_FL_HAS_DEVNODE
;
495 ret
= adp1653_init_controls(flash
);
499 ret
= media_entity_pads_init(&flash
->subdev
.entity
, 0, NULL
);
503 flash
->subdev
.entity
.function
= MEDIA_ENT_F_FLASH
;
508 dev_err(&client
->dev
, "adp1653: failed to register device\n");
509 v4l2_ctrl_handler_free(&flash
->ctrls
);
513 static int adp1653_remove(struct i2c_client
*client
)
515 struct v4l2_subdev
*subdev
= i2c_get_clientdata(client
);
516 struct adp1653_flash
*flash
= to_adp1653_flash(subdev
);
518 v4l2_device_unregister_subdev(&flash
->subdev
);
519 v4l2_ctrl_handler_free(&flash
->ctrls
);
520 media_entity_cleanup(&flash
->subdev
.entity
);
525 static const struct i2c_device_id adp1653_id_table
[] = {
529 MODULE_DEVICE_TABLE(i2c
, adp1653_id_table
);
531 static const struct dev_pm_ops adp1653_pm_ops
= {
532 .suspend
= adp1653_suspend
,
533 .resume
= adp1653_resume
,
536 static struct i2c_driver adp1653_i2c_driver
= {
538 .name
= ADP1653_NAME
,
539 .pm
= &adp1653_pm_ops
,
541 .probe
= adp1653_probe
,
542 .remove
= adp1653_remove
,
543 .id_table
= adp1653_id_table
,
546 module_i2c_driver(adp1653_i2c_driver
);
548 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@nokia.com>");
549 MODULE_DESCRIPTION("Analog Devices ADP1653 LED flash driver");
550 MODULE_LICENSE("GPL");