xref: /openbmc/linux/drivers/leds/flash/leds-mt6360.c (revision 04a4668b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 
3 #include <linux/bitops.h>
4 #include <linux/delay.h>
5 #include <linux/init.h>
6 #include <linux/interrupt.h>
7 #include <linux/kernel.h>
8 #include <linux/led-class-flash.h>
9 #include <linux/led-class-multicolor.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/platform_device.h>
13 #include <linux/property.h>
14 #include <linux/regmap.h>
15 #include <media/v4l2-flash-led-class.h>
16 
17 enum {
18 	MT6360_LED_ISNK1 = 0,
19 	MT6360_LED_ISNK2,
20 	MT6360_LED_ISNK3,
21 	MT6360_LED_ISNKML,
22 	MT6360_LED_FLASH1,
23 	MT6360_LED_FLASH2,
24 	MT6360_MAX_LEDS
25 };
26 
27 #define MT6360_REG_RGBEN		0x380
28 #define MT6360_REG_ISNK(_led_no)	(0x381 + (_led_no))
29 #define MT6360_ISNK_ENMASK(_led_no)	BIT(7 - (_led_no))
30 #define MT6360_ISNK_MASK		GENMASK(4, 0)
31 #define MT6360_CHRINDSEL_MASK		BIT(3)
32 
33 /* Virtual definition for multicolor */
34 #define MT6360_VIRTUAL_MULTICOLOR	(MT6360_MAX_LEDS + 1)
35 #define MULTICOLOR_NUM_CHANNELS		3
36 
37 #define MT6360_REG_FLEDEN		0x37E
38 #define MT6360_REG_STRBTO		0x373
39 #define MT6360_REG_FLEDBASE(_id)	(0x372 + 4 * (_id - MT6360_LED_FLASH1))
40 #define MT6360_REG_FLEDISTRB(_id)	(MT6360_REG_FLEDBASE(_id) + 2)
41 #define MT6360_REG_FLEDITOR(_id)	(MT6360_REG_FLEDBASE(_id) + 3)
42 #define MT6360_REG_CHGSTAT2		0x3E1
43 #define MT6360_REG_FLEDSTAT1		0x3E9
44 #define MT6360_ITORCH_MASK		GENMASK(4, 0)
45 #define MT6360_ISTROBE_MASK		GENMASK(6, 0)
46 #define MT6360_STRBTO_MASK		GENMASK(6, 0)
47 #define MT6360_TORCHEN_MASK		BIT(3)
48 #define MT6360_STROBEN_MASK		BIT(2)
49 #define MT6360_FLCSEN_MASK(_id)		BIT(MT6360_LED_FLASH2 - _id)
50 #define MT6360_FLEDCHGVINOVP_MASK	BIT(3)
51 #define MT6360_FLED1STRBTO_MASK		BIT(11)
52 #define MT6360_FLED2STRBTO_MASK		BIT(10)
53 #define MT6360_FLED1STRB_MASK		BIT(9)
54 #define MT6360_FLED2STRB_MASK		BIT(8)
55 #define MT6360_FLED1SHORT_MASK		BIT(7)
56 #define MT6360_FLED2SHORT_MASK		BIT(6)
57 #define MT6360_FLEDLVF_MASK		BIT(3)
58 
59 #define MT6360_ISNKRGB_STEPUA		2000
60 #define MT6360_ISNKRGB_MAXUA		24000
61 #define MT6360_ISNKML_STEPUA		5000
62 #define MT6360_ISNKML_MAXUA		150000
63 
64 #define MT6360_ITORCH_MINUA		25000
65 #define MT6360_ITORCH_STEPUA		12500
66 #define MT6360_ITORCH_MAXUA		400000
67 #define MT6360_ISTRB_MINUA		50000
68 #define MT6360_ISTRB_STEPUA		12500
69 #define MT6360_ISTRB_MAXUA		1500000
70 #define MT6360_STRBTO_MINUS		64000
71 #define MT6360_STRBTO_STEPUS		32000
72 #define MT6360_STRBTO_MAXUS		2432000
73 
74 struct mt6360_led {
75 	union {
76 		struct led_classdev isnk;
77 		struct led_classdev_mc mc;
78 		struct led_classdev_flash flash;
79 	};
80 	struct v4l2_flash *v4l2_flash;
81 	struct mt6360_priv *priv;
82 	u32 led_no;
83 	enum led_default_state default_state;
84 };
85 
86 struct mt6360_priv {
87 	struct device *dev;
88 	struct regmap *regmap;
89 	struct mutex lock;
90 	unsigned int fled_strobe_used;
91 	unsigned int fled_torch_used;
92 	unsigned int leds_active;
93 	unsigned int leds_count;
94 	struct mt6360_led leds[];
95 };
96 
mt6360_mc_brightness_set(struct led_classdev * lcdev,enum led_brightness level)97 static int mt6360_mc_brightness_set(struct led_classdev *lcdev,
98 				    enum led_brightness level)
99 {
100 	struct led_classdev_mc *mccdev = lcdev_to_mccdev(lcdev);
101 	struct mt6360_led *led = container_of(mccdev, struct mt6360_led, mc);
102 	struct mt6360_priv *priv = led->priv;
103 	u32 real_bright, enable_mask = 0, enable = 0;
104 	int i, ret;
105 
106 	mutex_lock(&priv->lock);
107 
108 	led_mc_calc_color_components(mccdev, level);
109 
110 	for (i = 0; i < mccdev->num_colors; i++) {
111 		struct mc_subled *subled = mccdev->subled_info + i;
112 
113 		real_bright = min(lcdev->max_brightness, subled->brightness);
114 		ret = regmap_update_bits(priv->regmap, MT6360_REG_ISNK(i),
115 					 MT6360_ISNK_MASK, real_bright);
116 		if (ret)
117 			goto out;
118 
119 		enable_mask |= MT6360_ISNK_ENMASK(subled->channel);
120 		if (real_bright)
121 			enable |= MT6360_ISNK_ENMASK(subled->channel);
122 	}
123 
124 	ret = regmap_update_bits(priv->regmap, MT6360_REG_RGBEN, enable_mask,
125 				 enable);
126 
127 out:
128 	mutex_unlock(&priv->lock);
129 	return ret;
130 }
131 
mt6360_isnk_brightness_set(struct led_classdev * lcdev,enum led_brightness level)132 static int mt6360_isnk_brightness_set(struct led_classdev *lcdev,
133 				      enum led_brightness level)
134 {
135 	struct mt6360_led *led = container_of(lcdev, struct mt6360_led, isnk);
136 	struct mt6360_priv *priv = led->priv;
137 	u32 enable_mask = MT6360_ISNK_ENMASK(led->led_no);
138 	u32 val = level ? MT6360_ISNK_ENMASK(led->led_no) : 0;
139 	int ret;
140 
141 	mutex_lock(&priv->lock);
142 
143 	ret = regmap_update_bits(priv->regmap, MT6360_REG_ISNK(led->led_no),
144 				 MT6360_ISNK_MASK, level);
145 	if (ret)
146 		goto out;
147 
148 	ret = regmap_update_bits(priv->regmap, MT6360_REG_RGBEN, enable_mask,
149 				 val);
150 
151 out:
152 	mutex_unlock(&priv->lock);
153 	return ret;
154 }
155 
mt6360_torch_brightness_set(struct led_classdev * lcdev,enum led_brightness level)156 static int mt6360_torch_brightness_set(struct led_classdev *lcdev,
157 				       enum led_brightness level)
158 {
159 	struct mt6360_led *led =
160 		container_of(lcdev, struct mt6360_led, flash.led_cdev);
161 	struct mt6360_priv *priv = led->priv;
162 	u32 enable_mask = MT6360_TORCHEN_MASK | MT6360_FLCSEN_MASK(led->led_no);
163 	u32 val = level ? MT6360_FLCSEN_MASK(led->led_no) : 0;
164 	u32 prev = priv->fled_torch_used, curr;
165 	int ret;
166 
167 	mutex_lock(&priv->lock);
168 
169 	/*
170 	 * Only one set of flash control logic, use the flag to avoid strobe is
171 	 * currently used.
172 	 */
173 	if (priv->fled_strobe_used) {
174 		dev_warn(lcdev->dev, "Please disable strobe first [%d]\n",
175 			 priv->fled_strobe_used);
176 		ret = -EBUSY;
177 		goto unlock;
178 	}
179 
180 	if (level)
181 		curr = prev | BIT(led->led_no);
182 	else
183 		curr = prev & ~BIT(led->led_no);
184 
185 	if (curr)
186 		val |= MT6360_TORCHEN_MASK;
187 
188 	if (level) {
189 		ret = regmap_update_bits(priv->regmap,
190 					 MT6360_REG_FLEDITOR(led->led_no),
191 					 MT6360_ITORCH_MASK, level - 1);
192 		if (ret)
193 			goto unlock;
194 	}
195 
196 	ret = regmap_update_bits(priv->regmap, MT6360_REG_FLEDEN, enable_mask,
197 				 val);
198 	if (ret)
199 		goto unlock;
200 
201 	priv->fled_torch_used = curr;
202 
203 unlock:
204 	mutex_unlock(&priv->lock);
205 	return ret;
206 }
207 
mt6360_flash_brightness_set(struct led_classdev_flash * fl_cdev,u32 brightness)208 static int mt6360_flash_brightness_set(struct led_classdev_flash *fl_cdev,
209 				       u32 brightness)
210 {
211 	/*
212 	 * Due to the current spike when turning on flash, let brightness to be
213 	 * kept by framework.
214 	 * This empty function is used to prevent led_classdev_flash register
215 	 * ops check failure.
216 	 */
217 	return 0;
218 }
219 
_mt6360_flash_brightness_set(struct led_classdev_flash * fl_cdev,u32 brightness)220 static int _mt6360_flash_brightness_set(struct led_classdev_flash *fl_cdev,
221 					u32 brightness)
222 {
223 	struct mt6360_led *led =
224 		container_of(fl_cdev, struct mt6360_led, flash);
225 	struct mt6360_priv *priv = led->priv;
226 	struct led_flash_setting *s = &fl_cdev->brightness;
227 	u32 val = (brightness - s->min) / s->step;
228 
229 	return regmap_update_bits(priv->regmap,
230 				  MT6360_REG_FLEDISTRB(led->led_no),
231 				  MT6360_ISTROBE_MASK, val);
232 }
233 
mt6360_strobe_set(struct led_classdev_flash * fl_cdev,bool state)234 static int mt6360_strobe_set(struct led_classdev_flash *fl_cdev, bool state)
235 {
236 	struct mt6360_led *led =
237 		container_of(fl_cdev, struct mt6360_led, flash);
238 	struct mt6360_priv *priv = led->priv;
239 	struct led_classdev *lcdev = &fl_cdev->led_cdev;
240 	struct led_flash_setting *s = &fl_cdev->brightness;
241 	u32 enable_mask = MT6360_STROBEN_MASK | MT6360_FLCSEN_MASK(led->led_no);
242 	u32 val = state ? MT6360_FLCSEN_MASK(led->led_no) : 0;
243 	u32 prev = priv->fled_strobe_used, curr;
244 	int ret;
245 
246 	mutex_lock(&priv->lock);
247 
248 	/*
249 	 * Only one set of flash control logic, use the flag to avoid torch is
250 	 * currently used
251 	 */
252 	if (priv->fled_torch_used) {
253 		dev_warn(lcdev->dev, "Please disable torch first [0x%x]\n",
254 			 priv->fled_torch_used);
255 		ret = -EBUSY;
256 		goto unlock;
257 	}
258 
259 	if (state)
260 		curr = prev | BIT(led->led_no);
261 	else
262 		curr = prev & ~BIT(led->led_no);
263 
264 	if (curr)
265 		val |= MT6360_STROBEN_MASK;
266 
267 	ret = regmap_update_bits(priv->regmap, MT6360_REG_FLEDEN, enable_mask,
268 				 val);
269 	if (ret) {
270 		dev_err(lcdev->dev, "[%d] control current source %d fail\n",
271 			led->led_no, state);
272 		goto unlock;
273 	}
274 
275 	/*
276 	 * If the flash need to be on, config the flash current ramping up to
277 	 * the setting value.
278 	 * Else, always recover back to the minimum one
279 	 */
280 	ret = _mt6360_flash_brightness_set(fl_cdev, state ? s->val : s->min);
281 	if (ret)
282 		goto unlock;
283 
284 	/*
285 	 * For the flash turn on/off, HW rampping up/down time is 5ms/500us,
286 	 * respectively.
287 	 */
288 	if (!prev && curr)
289 		usleep_range(5000, 6000);
290 	else if (prev && !curr)
291 		udelay(500);
292 
293 	priv->fled_strobe_used = curr;
294 
295 unlock:
296 	mutex_unlock(&priv->lock);
297 	return ret;
298 }
299 
mt6360_strobe_get(struct led_classdev_flash * fl_cdev,bool * state)300 static int mt6360_strobe_get(struct led_classdev_flash *fl_cdev, bool *state)
301 {
302 	struct mt6360_led *led =
303 		container_of(fl_cdev, struct mt6360_led, flash);
304 	struct mt6360_priv *priv = led->priv;
305 
306 	mutex_lock(&priv->lock);
307 	*state = !!(priv->fled_strobe_used & BIT(led->led_no));
308 	mutex_unlock(&priv->lock);
309 
310 	return 0;
311 }
312 
mt6360_timeout_set(struct led_classdev_flash * fl_cdev,u32 timeout)313 static int mt6360_timeout_set(struct led_classdev_flash *fl_cdev, u32 timeout)
314 {
315 	struct mt6360_led *led =
316 		container_of(fl_cdev, struct mt6360_led, flash);
317 	struct mt6360_priv *priv = led->priv;
318 	struct led_flash_setting *s = &fl_cdev->timeout;
319 	u32 val = (timeout - s->min) / s->step;
320 	int ret;
321 
322 	mutex_lock(&priv->lock);
323 	ret = regmap_update_bits(priv->regmap, MT6360_REG_STRBTO,
324 				 MT6360_STRBTO_MASK, val);
325 	mutex_unlock(&priv->lock);
326 
327 	return ret;
328 }
329 
mt6360_fault_get(struct led_classdev_flash * fl_cdev,u32 * fault)330 static int mt6360_fault_get(struct led_classdev_flash *fl_cdev, u32 *fault)
331 {
332 	struct mt6360_led *led =
333 		container_of(fl_cdev, struct mt6360_led, flash);
334 	struct mt6360_priv *priv = led->priv;
335 	u16 fled_stat;
336 	unsigned int chg_stat, strobe_timeout_mask, fled_short_mask;
337 	u32 rfault = 0;
338 	int ret;
339 
340 	mutex_lock(&priv->lock);
341 	ret = regmap_read(priv->regmap, MT6360_REG_CHGSTAT2, &chg_stat);
342 	if (ret)
343 		goto unlock;
344 
345 	ret = regmap_raw_read(priv->regmap, MT6360_REG_FLEDSTAT1, &fled_stat,
346 			      sizeof(fled_stat));
347 	if (ret)
348 		goto unlock;
349 
350 	if (led->led_no == MT6360_LED_FLASH1) {
351 		strobe_timeout_mask = MT6360_FLED1STRBTO_MASK;
352 		fled_short_mask = MT6360_FLED1SHORT_MASK;
353 	} else {
354 		strobe_timeout_mask = MT6360_FLED2STRBTO_MASK;
355 		fled_short_mask = MT6360_FLED2SHORT_MASK;
356 	}
357 
358 	if (chg_stat & MT6360_FLEDCHGVINOVP_MASK)
359 		rfault |= LED_FAULT_INPUT_VOLTAGE;
360 
361 	if (fled_stat & strobe_timeout_mask)
362 		rfault |= LED_FAULT_TIMEOUT;
363 
364 	if (fled_stat & fled_short_mask)
365 		rfault |= LED_FAULT_SHORT_CIRCUIT;
366 
367 	if (fled_stat & MT6360_FLEDLVF_MASK)
368 		rfault |= LED_FAULT_UNDER_VOLTAGE;
369 
370 	*fault = rfault;
371 unlock:
372 	mutex_unlock(&priv->lock);
373 	return ret;
374 }
375 
376 static const struct led_flash_ops mt6360_flash_ops = {
377 	.flash_brightness_set = mt6360_flash_brightness_set,
378 	.strobe_set = mt6360_strobe_set,
379 	.strobe_get = mt6360_strobe_get,
380 	.timeout_set = mt6360_timeout_set,
381 	.fault_get = mt6360_fault_get,
382 };
383 
mt6360_isnk_init_default_state(struct mt6360_led * led)384 static int mt6360_isnk_init_default_state(struct mt6360_led *led)
385 {
386 	struct mt6360_priv *priv = led->priv;
387 	unsigned int regval;
388 	u32 level;
389 	int ret;
390 
391 	ret = regmap_read(priv->regmap, MT6360_REG_ISNK(led->led_no), &regval);
392 	if (ret)
393 		return ret;
394 	level = regval & MT6360_ISNK_MASK;
395 
396 	ret = regmap_read(priv->regmap, MT6360_REG_RGBEN, &regval);
397 	if (ret)
398 		return ret;
399 
400 	if (!(regval & MT6360_ISNK_ENMASK(led->led_no)))
401 		level = LED_OFF;
402 
403 	switch (led->default_state) {
404 	case LEDS_DEFSTATE_ON:
405 		led->isnk.brightness = led->isnk.max_brightness;
406 		break;
407 	case LEDS_DEFSTATE_KEEP:
408 		led->isnk.brightness = min(level, led->isnk.max_brightness);
409 		break;
410 	default:
411 		led->isnk.brightness = LED_OFF;
412 	}
413 
414 	return mt6360_isnk_brightness_set(&led->isnk, led->isnk.brightness);
415 }
416 
mt6360_flash_init_default_state(struct mt6360_led * led)417 static int mt6360_flash_init_default_state(struct mt6360_led *led)
418 {
419 	struct led_classdev_flash *flash = &led->flash;
420 	struct mt6360_priv *priv = led->priv;
421 	u32 enable_mask = MT6360_TORCHEN_MASK | MT6360_FLCSEN_MASK(led->led_no);
422 	u32 level;
423 	unsigned int regval;
424 	int ret;
425 
426 	ret = regmap_read(priv->regmap, MT6360_REG_FLEDITOR(led->led_no),
427 			  &regval);
428 	if (ret)
429 		return ret;
430 	level = regval & MT6360_ITORCH_MASK;
431 
432 	ret = regmap_read(priv->regmap, MT6360_REG_FLEDEN, &regval);
433 	if (ret)
434 		return ret;
435 
436 	if ((regval & enable_mask) == enable_mask)
437 		level += 1;
438 	else
439 		level = LED_OFF;
440 
441 	switch (led->default_state) {
442 	case LEDS_DEFSTATE_ON:
443 		flash->led_cdev.brightness = flash->led_cdev.max_brightness;
444 		break;
445 	case LEDS_DEFSTATE_KEEP:
446 		flash->led_cdev.brightness =
447 			min(level, flash->led_cdev.max_brightness);
448 		break;
449 	default:
450 		flash->led_cdev.brightness = LED_OFF;
451 	}
452 
453 	return mt6360_torch_brightness_set(&flash->led_cdev,
454 					   flash->led_cdev.brightness);
455 }
456 
457 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
mt6360_flash_external_strobe_set(struct v4l2_flash * v4l2_flash,bool enable)458 static int mt6360_flash_external_strobe_set(struct v4l2_flash *v4l2_flash,
459 					    bool enable)
460 {
461 	struct led_classdev_flash *flash = v4l2_flash->fled_cdev;
462 	struct mt6360_led *led = container_of(flash, struct mt6360_led, flash);
463 	struct mt6360_priv *priv = led->priv;
464 	u32 mask = MT6360_FLCSEN_MASK(led->led_no);
465 	u32 val = enable ? mask : 0;
466 	int ret;
467 
468 	mutex_lock(&priv->lock);
469 
470 	ret = regmap_update_bits(priv->regmap, MT6360_REG_FLEDEN, mask, val);
471 	if (ret)
472 		goto unlock;
473 
474 	if (enable)
475 		priv->fled_strobe_used |= BIT(led->led_no);
476 	else
477 		priv->fled_strobe_used &= ~BIT(led->led_no);
478 
479 unlock:
480 	mutex_unlock(&priv->lock);
481 	return ret;
482 }
483 
484 static const struct v4l2_flash_ops v4l2_flash_ops = {
485 	.external_strobe_set = mt6360_flash_external_strobe_set,
486 };
487 
mt6360_init_v4l2_flash_config(struct mt6360_led * led,struct v4l2_flash_config * config)488 static void mt6360_init_v4l2_flash_config(struct mt6360_led *led,
489 					  struct v4l2_flash_config *config)
490 {
491 	struct led_classdev *lcdev;
492 	struct led_flash_setting *s = &config->intensity;
493 
494 	lcdev = &led->flash.led_cdev;
495 
496 	s->min = MT6360_ITORCH_MINUA;
497 	s->step = MT6360_ITORCH_STEPUA;
498 	s->val = s->max = s->min + (lcdev->max_brightness - 1) * s->step;
499 
500 	config->has_external_strobe = 1;
501 	strscpy(config->dev_name, lcdev->dev->kobj.name,
502 		sizeof(config->dev_name));
503 
504 	config->flash_faults = LED_FAULT_SHORT_CIRCUIT | LED_FAULT_TIMEOUT |
505 			       LED_FAULT_INPUT_VOLTAGE |
506 			       LED_FAULT_UNDER_VOLTAGE;
507 }
508 #else
509 static const struct v4l2_flash_ops v4l2_flash_ops;
mt6360_init_v4l2_flash_config(struct mt6360_led * led,struct v4l2_flash_config * config)510 static void mt6360_init_v4l2_flash_config(struct mt6360_led *led,
511 					  struct v4l2_flash_config *config)
512 {
513 }
514 #endif
515 
mt6360_led_register(struct device * parent,struct mt6360_led * led,struct led_init_data * init_data)516 static int mt6360_led_register(struct device *parent, struct mt6360_led *led,
517 				struct led_init_data *init_data)
518 {
519 	struct mt6360_priv *priv = led->priv;
520 	struct v4l2_flash_config v4l2_config = {0};
521 	int ret;
522 
523 	if ((led->led_no == MT6360_LED_ISNK1 ||
524 	     led->led_no == MT6360_VIRTUAL_MULTICOLOR) &&
525 	     (priv->leds_active & BIT(MT6360_LED_ISNK1))) {
526 		/*
527 		 * Change isink1 to SW control mode, disconnect it with
528 		 * charger state
529 		 */
530 		ret = regmap_update_bits(priv->regmap, MT6360_REG_RGBEN,
531 					 MT6360_CHRINDSEL_MASK,
532 					 MT6360_CHRINDSEL_MASK);
533 		if (ret) {
534 			dev_err(parent, "Failed to config ISNK1 to SW mode\n");
535 			return ret;
536 		}
537 	}
538 
539 	switch (led->led_no) {
540 	case MT6360_VIRTUAL_MULTICOLOR:
541 		ret = mt6360_mc_brightness_set(&led->mc.led_cdev, LED_OFF);
542 		if (ret) {
543 			dev_err(parent,
544 				"Failed to init multicolor brightness\n");
545 			return ret;
546 		}
547 
548 		ret = devm_led_classdev_multicolor_register_ext(parent,
549 							   &led->mc, init_data);
550 		if (ret) {
551 			dev_err(parent, "Couldn't register multicolor\n");
552 			return ret;
553 		}
554 		break;
555 	case MT6360_LED_ISNK1 ... MT6360_LED_ISNKML:
556 		ret = mt6360_isnk_init_default_state(led);
557 		if (ret) {
558 			dev_err(parent, "Failed to init %d isnk state\n",
559 				led->led_no);
560 			return ret;
561 		}
562 
563 		ret = devm_led_classdev_register_ext(parent, &led->isnk,
564 						     init_data);
565 		if (ret) {
566 			dev_err(parent, "Couldn't register isink %d\n",
567 				led->led_no);
568 			return ret;
569 		}
570 		break;
571 	default:
572 		ret = mt6360_flash_init_default_state(led);
573 		if (ret) {
574 			dev_err(parent, "Failed to init %d flash state\n",
575 				led->led_no);
576 			return ret;
577 		}
578 
579 		ret = devm_led_classdev_flash_register_ext(parent, &led->flash,
580 							   init_data);
581 		if (ret) {
582 			dev_err(parent, "Couldn't register flash %d\n",
583 				led->led_no);
584 			return ret;
585 		}
586 
587 		mt6360_init_v4l2_flash_config(led, &v4l2_config);
588 		led->v4l2_flash = v4l2_flash_init(parent, init_data->fwnode,
589 						  &led->flash,
590 						  &v4l2_flash_ops,
591 						  &v4l2_config);
592 		if (IS_ERR(led->v4l2_flash)) {
593 			dev_err(parent, "Failed to register %d v4l2 sd\n",
594 				led->led_no);
595 			return PTR_ERR(led->v4l2_flash);
596 		}
597 	}
598 
599 	return 0;
600 }
601 
clamp_align(u32 val,u32 min,u32 max,u32 step)602 static u32 clamp_align(u32 val, u32 min, u32 max, u32 step)
603 {
604 	u32 retval;
605 
606 	retval = clamp_val(val, min, max);
607 	if (step > 1)
608 		retval = rounddown(retval - min, step) + min;
609 
610 	return retval;
611 }
612 
mt6360_init_isnk_properties(struct mt6360_led * led,struct led_init_data * init_data)613 static int mt6360_init_isnk_properties(struct mt6360_led *led,
614 				       struct led_init_data *init_data)
615 {
616 	struct led_classdev *lcdev;
617 	struct mt6360_priv *priv = led->priv;
618 	struct fwnode_handle *child;
619 	u32 step_uA = MT6360_ISNKRGB_STEPUA, max_uA = MT6360_ISNKRGB_MAXUA;
620 	u32 val;
621 	int num_color = 0, ret;
622 
623 	if (led->led_no == MT6360_VIRTUAL_MULTICOLOR) {
624 		struct mc_subled *sub_led;
625 
626 		sub_led = devm_kzalloc(priv->dev,
627 			sizeof(*sub_led) * MULTICOLOR_NUM_CHANNELS, GFP_KERNEL);
628 		if (!sub_led)
629 			return -ENOMEM;
630 
631 		fwnode_for_each_child_node(init_data->fwnode, child) {
632 			u32 reg, color;
633 
634 			ret = fwnode_property_read_u32(child, "reg", &reg);
635 			if (ret || reg > MT6360_LED_ISNK3 ||
636 			    priv->leds_active & BIT(reg)) {
637 				fwnode_handle_put(child);
638 				return -EINVAL;
639 			}
640 
641 			ret = fwnode_property_read_u32(child, "color", &color);
642 			if (ret) {
643 				dev_err(priv->dev,
644 					"led %d, no color specified\n",
645 					led->led_no);
646 				fwnode_handle_put(child);
647 				return ret;
648 			}
649 
650 			priv->leds_active |= BIT(reg);
651 			sub_led[num_color].color_index = color;
652 			sub_led[num_color].channel = reg;
653 			num_color++;
654 		}
655 
656 		if (num_color < 2) {
657 			dev_err(priv->dev,
658 			     "Multicolor must include 2 or more led channel\n");
659 			return -EINVAL;
660 		}
661 
662 		led->mc.num_colors = num_color;
663 		led->mc.subled_info = sub_led;
664 
665 		lcdev = &led->mc.led_cdev;
666 		lcdev->brightness_set_blocking = mt6360_mc_brightness_set;
667 	} else {
668 		if (led->led_no == MT6360_LED_ISNKML) {
669 			step_uA = MT6360_ISNKML_STEPUA;
670 			max_uA = MT6360_ISNKML_MAXUA;
671 		}
672 
673 		lcdev = &led->isnk;
674 		lcdev->brightness_set_blocking = mt6360_isnk_brightness_set;
675 	}
676 
677 	ret = fwnode_property_read_u32(init_data->fwnode, "led-max-microamp",
678 				       &val);
679 	if (ret) {
680 		dev_warn(priv->dev,
681 		     "Not specified led-max-microamp, config to the minimum\n");
682 		val = step_uA;
683 	} else
684 		val = clamp_align(val, 0, max_uA, step_uA);
685 
686 	lcdev->max_brightness = val / step_uA;
687 
688 	fwnode_property_read_string(init_data->fwnode, "linux,default-trigger",
689 				    &lcdev->default_trigger);
690 
691 	return 0;
692 }
693 
mt6360_init_flash_properties(struct mt6360_led * led,struct led_init_data * init_data)694 static int mt6360_init_flash_properties(struct mt6360_led *led,
695 					struct led_init_data *init_data)
696 {
697 	struct led_classdev_flash *flash = &led->flash;
698 	struct led_classdev *lcdev = &flash->led_cdev;
699 	struct mt6360_priv *priv = led->priv;
700 	struct led_flash_setting *s;
701 	u32 val;
702 	int ret;
703 
704 	ret = fwnode_property_read_u32(init_data->fwnode, "led-max-microamp",
705 				       &val);
706 	if (ret) {
707 		dev_warn(priv->dev,
708 		     "Not specified led-max-microamp, config to the minimum\n");
709 		val = MT6360_ITORCH_MINUA;
710 	} else
711 		val = clamp_align(val, MT6360_ITORCH_MINUA, MT6360_ITORCH_MAXUA,
712 				  MT6360_ITORCH_STEPUA);
713 
714 	lcdev->max_brightness =
715 		(val - MT6360_ITORCH_MINUA) / MT6360_ITORCH_STEPUA + 1;
716 	lcdev->brightness_set_blocking = mt6360_torch_brightness_set;
717 	lcdev->flags |= LED_DEV_CAP_FLASH;
718 
719 	ret = fwnode_property_read_u32(init_data->fwnode, "flash-max-microamp",
720 				       &val);
721 	if (ret) {
722 		dev_warn(priv->dev,
723 		   "Not specified flash-max-microamp, config to the minimum\n");
724 		val = MT6360_ISTRB_MINUA;
725 	} else
726 		val = clamp_align(val, MT6360_ISTRB_MINUA, MT6360_ISTRB_MAXUA,
727 				  MT6360_ISTRB_STEPUA);
728 
729 	s = &flash->brightness;
730 	s->min = MT6360_ISTRB_MINUA;
731 	s->step = MT6360_ISTRB_STEPUA;
732 	s->val = s->max = val;
733 
734 	/*
735 	 * Always configure as min level when off to prevent flash current
736 	 * spike.
737 	 */
738 	ret = _mt6360_flash_brightness_set(flash, s->min);
739 	if (ret)
740 		return ret;
741 
742 	ret = fwnode_property_read_u32(init_data->fwnode,
743 				       "flash-max-timeout-us", &val);
744 	if (ret) {
745 		dev_warn(priv->dev,
746 		 "Not specified flash-max-timeout-us, config to the minimum\n");
747 		val = MT6360_STRBTO_MINUS;
748 	} else
749 		val = clamp_align(val, MT6360_STRBTO_MINUS, MT6360_STRBTO_MAXUS,
750 				  MT6360_STRBTO_STEPUS);
751 
752 	s = &flash->timeout;
753 	s->min = MT6360_STRBTO_MINUS;
754 	s->step = MT6360_STRBTO_STEPUS;
755 	s->val = s->max = val;
756 
757 	flash->ops = &mt6360_flash_ops;
758 
759 	return 0;
760 }
761 
mt6360_v4l2_flash_release(struct mt6360_priv * priv)762 static void mt6360_v4l2_flash_release(struct mt6360_priv *priv)
763 {
764 	int i;
765 
766 	for (i = 0; i < priv->leds_count; i++) {
767 		struct mt6360_led *led = priv->leds + i;
768 
769 		if (led->v4l2_flash)
770 			v4l2_flash_release(led->v4l2_flash);
771 	}
772 }
773 
mt6360_led_probe(struct platform_device * pdev)774 static int mt6360_led_probe(struct platform_device *pdev)
775 {
776 	struct mt6360_priv *priv;
777 	struct fwnode_handle *child;
778 	size_t count;
779 	int i = 0, ret;
780 
781 	count = device_get_child_node_count(&pdev->dev);
782 	if (!count || count > MT6360_MAX_LEDS) {
783 		dev_err(&pdev->dev,
784 			"No child node or node count over max led number %zu\n",
785 			count);
786 		return -EINVAL;
787 	}
788 
789 	priv = devm_kzalloc(&pdev->dev,
790 			    struct_size(priv, leds, count), GFP_KERNEL);
791 	if (!priv)
792 		return -ENOMEM;
793 
794 	priv->leds_count = count;
795 	priv->dev = &pdev->dev;
796 	mutex_init(&priv->lock);
797 
798 	priv->regmap = dev_get_regmap(pdev->dev.parent, NULL);
799 	if (!priv->regmap) {
800 		dev_err(&pdev->dev, "Failed to get parent regmap\n");
801 		return -ENODEV;
802 	}
803 
804 	device_for_each_child_node(&pdev->dev, child) {
805 		struct mt6360_led *led = priv->leds + i;
806 		struct led_init_data init_data = { .fwnode = child, };
807 		u32 reg, led_color;
808 
809 		ret = fwnode_property_read_u32(child, "color", &led_color);
810 		if (ret)
811 			goto out_flash_release;
812 
813 		if (led_color == LED_COLOR_ID_RGB ||
814 		    led_color == LED_COLOR_ID_MULTI)
815 			reg = MT6360_VIRTUAL_MULTICOLOR;
816 		else {
817 			ret = fwnode_property_read_u32(child, "reg", &reg);
818 			if (ret)
819 				goto out_flash_release;
820 
821 			if (reg >= MT6360_MAX_LEDS) {
822 				ret = -EINVAL;
823 				goto out_flash_release;
824 			}
825 		}
826 
827 		if (priv->leds_active & BIT(reg)) {
828 			ret = -EINVAL;
829 			goto out_flash_release;
830 		}
831 		priv->leds_active |= BIT(reg);
832 
833 		led->led_no = reg;
834 		led->priv = priv;
835 		led->default_state = led_init_default_state_get(child);
836 
837 		if (reg == MT6360_VIRTUAL_MULTICOLOR ||
838 		    reg <= MT6360_LED_ISNKML)
839 			ret = mt6360_init_isnk_properties(led, &init_data);
840 		else
841 			ret = mt6360_init_flash_properties(led, &init_data);
842 
843 		if (ret)
844 			goto out_flash_release;
845 
846 		ret = mt6360_led_register(&pdev->dev, led, &init_data);
847 		if (ret)
848 			goto out_flash_release;
849 
850 		i++;
851 	}
852 
853 	platform_set_drvdata(pdev, priv);
854 	return 0;
855 
856 out_flash_release:
857 	mt6360_v4l2_flash_release(priv);
858 	return ret;
859 }
860 
mt6360_led_remove(struct platform_device * pdev)861 static int mt6360_led_remove(struct platform_device *pdev)
862 {
863 	struct mt6360_priv *priv = platform_get_drvdata(pdev);
864 
865 	mt6360_v4l2_flash_release(priv);
866 	return 0;
867 }
868 
869 static const struct of_device_id __maybe_unused mt6360_led_of_id[] = {
870 	{ .compatible = "mediatek,mt6360-led", },
871 	{}
872 };
873 MODULE_DEVICE_TABLE(of, mt6360_led_of_id);
874 
875 static struct platform_driver mt6360_led_driver = {
876 	.driver = {
877 		.name = "mt6360-led",
878 		.of_match_table = mt6360_led_of_id,
879 	},
880 	.probe = mt6360_led_probe,
881 	.remove = mt6360_led_remove,
882 };
883 module_platform_driver(mt6360_led_driver);
884 
885 MODULE_AUTHOR("Gene Chen <gene_chen@richtek.com>");
886 MODULE_DESCRIPTION("MT6360 LED Driver");
887 MODULE_LICENSE("GPL v2");
888