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