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