1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
4 */
5
6 #include <linux/bitfield.h>
7 #include <linux/bits.h>
8 #include <linux/leds.h>
9 #include <linux/led-class-flash.h>
10 #include <linux/module.h>
11 #include <linux/platform_device.h>
12 #include <linux/property.h>
13 #include <linux/regmap.h>
14 #include <media/v4l2-flash-led-class.h>
15
16 /* registers definitions */
17 #define FLASH_TYPE_REG 0x04
18 #define FLASH_TYPE_VAL 0x18
19
20 #define FLASH_SUBTYPE_REG 0x05
21 #define FLASH_SUBTYPE_3CH_PM8150_VAL 0x04
22 #define FLASH_SUBTYPE_3CH_PMI8998_VAL 0x03
23 #define FLASH_SUBTYPE_4CH_VAL 0x07
24
25 #define FLASH_STS_3CH_OTST1 BIT(0)
26 #define FLASH_STS_3CH_OTST2 BIT(1)
27 #define FLASH_STS_3CH_OTST3 BIT(2)
28 #define FLASH_STS_3CH_BOB_THM_OVERLOAD BIT(3)
29 #define FLASH_STS_3CH_VPH_DROOP BIT(4)
30 #define FLASH_STS_3CH_BOB_ILIM_S1 BIT(5)
31 #define FLASH_STS_3CH_BOB_ILIM_S2 BIT(6)
32 #define FLASH_STS_3CH_BCL_IBAT BIT(7)
33
34 #define FLASH_STS_4CH_VPH_LOW BIT(0)
35 #define FLASH_STS_4CH_BCL_IBAT BIT(1)
36 #define FLASH_STS_4CH_BOB_ILIM_S1 BIT(2)
37 #define FLASH_STS_4CH_BOB_ILIM_S2 BIT(3)
38 #define FLASH_STS_4CH_OTST2 BIT(4)
39 #define FLASH_STS_4CH_OTST1 BIT(5)
40 #define FLASH_STS_4CHG_BOB_THM_OVERLOAD BIT(6)
41
42 #define FLASH_TIMER_EN_BIT BIT(7)
43 #define FLASH_TIMER_VAL_MASK GENMASK(6, 0)
44 #define FLASH_TIMER_STEP_MS 10
45
46 #define FLASH_STROBE_HW_SW_SEL_BIT BIT(2)
47 #define SW_STROBE_VAL 0
48 #define HW_STROBE_VAL 1
49 #define FLASH_HW_STROBE_TRIGGER_SEL_BIT BIT(1)
50 #define STROBE_LEVEL_TRIGGER_VAL 0
51 #define STROBE_EDGE_TRIGGER_VAL 1
52 #define FLASH_STROBE_POLARITY_BIT BIT(0)
53 #define STROBE_ACTIVE_HIGH_VAL 1
54
55 #define FLASH_IRES_MASK_4CH BIT(0)
56 #define FLASH_IRES_MASK_3CH GENMASK(1, 0)
57 #define FLASH_IRES_12P5MA_VAL 0
58 #define FLASH_IRES_5MA_VAL_4CH 1
59 #define FLASH_IRES_5MA_VAL_3CH 3
60
61 /* constants */
62 #define FLASH_CURRENT_MAX_UA 1500000
63 #define TORCH_CURRENT_MAX_UA 500000
64 #define FLASH_TOTAL_CURRENT_MAX_UA 2000000
65 #define FLASH_CURRENT_DEFAULT_UA 1000000
66 #define TORCH_CURRENT_DEFAULT_UA 200000
67
68 #define TORCH_IRES_UA 5000
69 #define FLASH_IRES_UA 12500
70
71 #define FLASH_TIMEOUT_MAX_US 1280000
72 #define FLASH_TIMEOUT_STEP_US 10000
73
74 #define UA_PER_MA 1000
75
76 enum hw_type {
77 QCOM_MVFLASH_3CH,
78 QCOM_MVFLASH_4CH,
79 };
80
81 enum led_mode {
82 FLASH_MODE,
83 TORCH_MODE,
84 };
85
86 enum led_strobe {
87 SW_STROBE,
88 HW_STROBE,
89 };
90
91 enum {
92 REG_STATUS1,
93 REG_STATUS2,
94 REG_STATUS3,
95 REG_CHAN_TIMER,
96 REG_ITARGET,
97 REG_MODULE_EN,
98 REG_IRESOLUTION,
99 REG_CHAN_STROBE,
100 REG_CHAN_EN,
101 REG_MAX_COUNT,
102 };
103
104 static struct reg_field mvflash_3ch_regs[REG_MAX_COUNT] = {
105 REG_FIELD(0x08, 0, 7), /* status1 */
106 REG_FIELD(0x09, 0, 7), /* status2 */
107 REG_FIELD(0x0a, 0, 7), /* status3 */
108 REG_FIELD_ID(0x40, 0, 7, 3, 1), /* chan_timer */
109 REG_FIELD_ID(0x43, 0, 6, 3, 1), /* itarget */
110 REG_FIELD(0x46, 7, 7), /* module_en */
111 REG_FIELD(0x47, 0, 5), /* iresolution */
112 REG_FIELD_ID(0x49, 0, 2, 3, 1), /* chan_strobe */
113 REG_FIELD(0x4c, 0, 2), /* chan_en */
114 };
115
116 static struct reg_field mvflash_4ch_regs[REG_MAX_COUNT] = {
117 REG_FIELD(0x06, 0, 7), /* status1 */
118 REG_FIELD(0x07, 0, 6), /* status2 */
119 REG_FIELD(0x09, 0, 7), /* status3 */
120 REG_FIELD_ID(0x3e, 0, 7, 4, 1), /* chan_timer */
121 REG_FIELD_ID(0x42, 0, 6, 4, 1), /* itarget */
122 REG_FIELD(0x46, 7, 7), /* module_en */
123 REG_FIELD(0x49, 0, 3), /* iresolution */
124 REG_FIELD_ID(0x4a, 0, 6, 4, 1), /* chan_strobe */
125 REG_FIELD(0x4e, 0, 3), /* chan_en */
126 };
127
128 struct qcom_flash_data {
129 struct v4l2_flash **v4l2_flash;
130 struct regmap_field *r_fields[REG_MAX_COUNT];
131 struct mutex lock;
132 enum hw_type hw_type;
133 u8 leds_count;
134 u8 max_channels;
135 u8 chan_en_bits;
136 };
137
138 struct qcom_flash_led {
139 struct qcom_flash_data *flash_data;
140 struct led_classdev_flash flash;
141 u32 max_flash_current_ma;
142 u32 max_torch_current_ma;
143 u32 max_timeout_ms;
144 u32 flash_current_ma;
145 u32 flash_timeout_ms;
146 u8 *chan_id;
147 u8 chan_count;
148 bool enabled;
149 };
150
set_flash_module_en(struct qcom_flash_led * led,bool en)151 static int set_flash_module_en(struct qcom_flash_led *led, bool en)
152 {
153 struct qcom_flash_data *flash_data = led->flash_data;
154 u8 led_mask = 0, enable;
155 int i, rc;
156
157 for (i = 0; i < led->chan_count; i++)
158 led_mask |= BIT(led->chan_id[i]);
159
160 mutex_lock(&flash_data->lock);
161 if (en)
162 flash_data->chan_en_bits |= led_mask;
163 else
164 flash_data->chan_en_bits &= ~led_mask;
165
166 enable = !!flash_data->chan_en_bits;
167 rc = regmap_field_write(flash_data->r_fields[REG_MODULE_EN], enable);
168 if (rc)
169 dev_err(led->flash.led_cdev.dev, "write module_en failed, rc=%d\n", rc);
170 mutex_unlock(&flash_data->lock);
171
172 return rc;
173 }
174
set_flash_current(struct qcom_flash_led * led,u32 current_ma,enum led_mode mode)175 static int set_flash_current(struct qcom_flash_led *led, u32 current_ma, enum led_mode mode)
176 {
177 struct qcom_flash_data *flash_data = led->flash_data;
178 u32 itarg_ua, ires_ua;
179 u8 shift, ires_mask = 0, ires_val = 0, chan_id;
180 int i, rc;
181
182 /*
183 * Split the current across the channels and set the
184 * IRESOLUTION and ITARGET registers accordingly.
185 */
186 itarg_ua = (current_ma * UA_PER_MA) / led->chan_count + 1;
187 ires_ua = (mode == FLASH_MODE) ? FLASH_IRES_UA : TORCH_IRES_UA;
188
189 for (i = 0; i < led->chan_count; i++) {
190 u8 itarget = 0;
191
192 if (itarg_ua > ires_ua)
193 itarget = itarg_ua / ires_ua - 1;
194
195 chan_id = led->chan_id[i];
196
197 rc = regmap_fields_write(flash_data->r_fields[REG_ITARGET], chan_id, itarget);
198 if (rc)
199 return rc;
200
201 if (flash_data->hw_type == QCOM_MVFLASH_3CH) {
202 shift = chan_id * 2;
203 ires_mask |= FLASH_IRES_MASK_3CH << shift;
204 ires_val |= ((mode == FLASH_MODE) ?
205 (FLASH_IRES_12P5MA_VAL << shift) :
206 (FLASH_IRES_5MA_VAL_3CH << shift));
207 } else if (flash_data->hw_type == QCOM_MVFLASH_4CH) {
208 shift = chan_id;
209 ires_mask |= FLASH_IRES_MASK_4CH << shift;
210 ires_val |= ((mode == FLASH_MODE) ?
211 (FLASH_IRES_12P5MA_VAL << shift) :
212 (FLASH_IRES_5MA_VAL_4CH << shift));
213 } else {
214 dev_err(led->flash.led_cdev.dev,
215 "HW type %d is not supported\n", flash_data->hw_type);
216 return -EOPNOTSUPP;
217 }
218 }
219
220 return regmap_field_update_bits(flash_data->r_fields[REG_IRESOLUTION], ires_mask, ires_val);
221 }
222
set_flash_timeout(struct qcom_flash_led * led,u32 timeout_ms)223 static int set_flash_timeout(struct qcom_flash_led *led, u32 timeout_ms)
224 {
225 struct qcom_flash_data *flash_data = led->flash_data;
226 u8 timer, chan_id;
227 int rc, i;
228
229 /* set SAFETY_TIMER for all the channels connected to the same LED */
230 timeout_ms = min_t(u32, timeout_ms, led->max_timeout_ms);
231
232 for (i = 0; i < led->chan_count; i++) {
233 chan_id = led->chan_id[i];
234
235 timer = timeout_ms / FLASH_TIMER_STEP_MS;
236 timer = clamp_t(u8, timer, 0, FLASH_TIMER_VAL_MASK);
237
238 if (timeout_ms)
239 timer |= FLASH_TIMER_EN_BIT;
240
241 rc = regmap_fields_write(flash_data->r_fields[REG_CHAN_TIMER], chan_id, timer);
242 if (rc)
243 return rc;
244 }
245
246 return 0;
247 }
248
set_flash_strobe(struct qcom_flash_led * led,enum led_strobe strobe,bool state)249 static int set_flash_strobe(struct qcom_flash_led *led, enum led_strobe strobe, bool state)
250 {
251 struct qcom_flash_data *flash_data = led->flash_data;
252 u8 strobe_sel, chan_en, chan_id, chan_mask = 0;
253 int rc, i;
254
255 /* Set SW strobe config for all channels connected to the LED */
256 for (i = 0; i < led->chan_count; i++) {
257 chan_id = led->chan_id[i];
258
259 if (strobe == SW_STROBE)
260 strobe_sel = FIELD_PREP(FLASH_STROBE_HW_SW_SEL_BIT, SW_STROBE_VAL);
261 else
262 strobe_sel = FIELD_PREP(FLASH_STROBE_HW_SW_SEL_BIT, HW_STROBE_VAL);
263
264 strobe_sel |=
265 FIELD_PREP(FLASH_HW_STROBE_TRIGGER_SEL_BIT, STROBE_LEVEL_TRIGGER_VAL) |
266 FIELD_PREP(FLASH_STROBE_POLARITY_BIT, STROBE_ACTIVE_HIGH_VAL);
267
268 rc = regmap_fields_write(
269 flash_data->r_fields[REG_CHAN_STROBE], chan_id, strobe_sel);
270 if (rc)
271 return rc;
272
273 chan_mask |= BIT(chan_id);
274 }
275
276 /* Enable/disable flash channels */
277 chan_en = state ? chan_mask : 0;
278 rc = regmap_field_update_bits(flash_data->r_fields[REG_CHAN_EN], chan_mask, chan_en);
279 if (rc)
280 return rc;
281
282 led->enabled = state;
283 return 0;
284 }
285
flcdev_to_qcom_fled(struct led_classdev_flash * flcdev)286 static inline struct qcom_flash_led *flcdev_to_qcom_fled(struct led_classdev_flash *flcdev)
287 {
288 return container_of(flcdev, struct qcom_flash_led, flash);
289 }
290
qcom_flash_brightness_set(struct led_classdev_flash * fled_cdev,u32 brightness)291 static int qcom_flash_brightness_set(struct led_classdev_flash *fled_cdev, u32 brightness)
292 {
293 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
294
295 led->flash_current_ma = min_t(u32, led->max_flash_current_ma, brightness / UA_PER_MA);
296 return 0;
297 }
298
qcom_flash_timeout_set(struct led_classdev_flash * fled_cdev,u32 timeout)299 static int qcom_flash_timeout_set(struct led_classdev_flash *fled_cdev, u32 timeout)
300 {
301 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
302
303 led->flash_timeout_ms = timeout / USEC_PER_MSEC;
304 return 0;
305 }
306
qcom_flash_strobe_set(struct led_classdev_flash * fled_cdev,bool state)307 static int qcom_flash_strobe_set(struct led_classdev_flash *fled_cdev, bool state)
308 {
309 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
310 int rc;
311
312 rc = set_flash_strobe(led, SW_STROBE, false);
313 if (rc)
314 return rc;
315
316 rc = set_flash_current(led, led->flash_current_ma, FLASH_MODE);
317 if (rc)
318 return rc;
319
320 rc = set_flash_timeout(led, led->flash_timeout_ms);
321 if (rc)
322 return rc;
323
324 rc = set_flash_module_en(led, state);
325 if (rc)
326 return rc;
327
328 return set_flash_strobe(led, SW_STROBE, state);
329 }
330
qcom_flash_strobe_get(struct led_classdev_flash * fled_cdev,bool * state)331 static int qcom_flash_strobe_get(struct led_classdev_flash *fled_cdev, bool *state)
332 {
333 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
334
335 *state = led->enabled;
336 return 0;
337 }
338
qcom_flash_fault_get(struct led_classdev_flash * fled_cdev,u32 * fault)339 static int qcom_flash_fault_get(struct led_classdev_flash *fled_cdev, u32 *fault)
340 {
341 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
342 struct qcom_flash_data *flash_data = led->flash_data;
343 u8 shift, chan_id, chan_mask = 0;
344 u8 ot_mask = 0, oc_mask = 0, uv_mask = 0;
345 u32 val, fault_sts = 0;
346 int i, rc;
347
348 rc = regmap_field_read(flash_data->r_fields[REG_STATUS1], &val);
349 if (rc)
350 return rc;
351
352 for (i = 0; i < led->chan_count; i++) {
353 chan_id = led->chan_id[i];
354 shift = chan_id * 2;
355
356 if (val & BIT(shift))
357 fault_sts |= LED_FAULT_SHORT_CIRCUIT;
358
359 chan_mask |= BIT(chan_id);
360 }
361
362 rc = regmap_field_read(flash_data->r_fields[REG_STATUS2], &val);
363 if (rc)
364 return rc;
365
366 if (flash_data->hw_type == QCOM_MVFLASH_3CH) {
367 ot_mask = FLASH_STS_3CH_OTST1 |
368 FLASH_STS_3CH_OTST2 |
369 FLASH_STS_3CH_OTST3 |
370 FLASH_STS_3CH_BOB_THM_OVERLOAD;
371 oc_mask = FLASH_STS_3CH_BOB_ILIM_S1 |
372 FLASH_STS_3CH_BOB_ILIM_S2 |
373 FLASH_STS_3CH_BCL_IBAT;
374 uv_mask = FLASH_STS_3CH_VPH_DROOP;
375 } else if (flash_data->hw_type == QCOM_MVFLASH_4CH) {
376 ot_mask = FLASH_STS_4CH_OTST2 |
377 FLASH_STS_4CH_OTST1 |
378 FLASH_STS_4CHG_BOB_THM_OVERLOAD;
379 oc_mask = FLASH_STS_4CH_BCL_IBAT |
380 FLASH_STS_4CH_BOB_ILIM_S1 |
381 FLASH_STS_4CH_BOB_ILIM_S2;
382 uv_mask = FLASH_STS_4CH_VPH_LOW;
383 }
384
385 if (val & ot_mask)
386 fault_sts |= LED_FAULT_OVER_TEMPERATURE;
387
388 if (val & oc_mask)
389 fault_sts |= LED_FAULT_OVER_CURRENT;
390
391 if (val & uv_mask)
392 fault_sts |= LED_FAULT_INPUT_VOLTAGE;
393
394 rc = regmap_field_read(flash_data->r_fields[REG_STATUS3], &val);
395 if (rc)
396 return rc;
397
398 if (flash_data->hw_type == QCOM_MVFLASH_3CH) {
399 if (val & chan_mask)
400 fault_sts |= LED_FAULT_TIMEOUT;
401 } else if (flash_data->hw_type == QCOM_MVFLASH_4CH) {
402 for (i = 0; i < led->chan_count; i++) {
403 chan_id = led->chan_id[i];
404 shift = chan_id * 2;
405
406 if (val & BIT(shift))
407 fault_sts |= LED_FAULT_TIMEOUT;
408 }
409 }
410
411 *fault = fault_sts;
412 return 0;
413 }
414
qcom_flash_led_brightness_set(struct led_classdev * led_cdev,enum led_brightness brightness)415 static int qcom_flash_led_brightness_set(struct led_classdev *led_cdev,
416 enum led_brightness brightness)
417 {
418 struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
419 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
420 u32 current_ma = brightness * led->max_torch_current_ma / LED_FULL;
421 bool enable = !!brightness;
422 int rc;
423
424 rc = set_flash_strobe(led, SW_STROBE, false);
425 if (rc)
426 return rc;
427
428 rc = set_flash_module_en(led, false);
429 if (rc)
430 return rc;
431
432 rc = set_flash_current(led, current_ma, TORCH_MODE);
433 if (rc)
434 return rc;
435
436 /* Disable flash timeout for torch LED */
437 rc = set_flash_timeout(led, 0);
438 if (rc)
439 return rc;
440
441 rc = set_flash_module_en(led, enable);
442 if (rc)
443 return rc;
444
445 return set_flash_strobe(led, SW_STROBE, enable);
446 }
447
448 static const struct led_flash_ops qcom_flash_ops = {
449 .flash_brightness_set = qcom_flash_brightness_set,
450 .strobe_set = qcom_flash_strobe_set,
451 .strobe_get = qcom_flash_strobe_get,
452 .timeout_set = qcom_flash_timeout_set,
453 .fault_get = qcom_flash_fault_get,
454 };
455
456 #if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
qcom_flash_external_strobe_set(struct v4l2_flash * v4l2_flash,bool enable)457 static int qcom_flash_external_strobe_set(struct v4l2_flash *v4l2_flash, bool enable)
458 {
459 struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
460 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
461 int rc;
462
463 rc = set_flash_module_en(led, enable);
464 if (rc)
465 return rc;
466
467 if (enable)
468 return set_flash_strobe(led, HW_STROBE, true);
469 else
470 return set_flash_strobe(led, SW_STROBE, false);
471 }
472
473 static enum led_brightness
qcom_flash_intensity_to_led_brightness(struct v4l2_flash * v4l2_flash,s32 intensity)474 qcom_flash_intensity_to_led_brightness(struct v4l2_flash *v4l2_flash, s32 intensity)
475 {
476 struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
477 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
478 u32 current_ma = intensity / UA_PER_MA;
479
480 current_ma = min_t(u32, current_ma, led->max_torch_current_ma);
481 if (!current_ma)
482 return LED_OFF;
483
484 return (current_ma * LED_FULL) / led->max_torch_current_ma;
485 }
486
qcom_flash_brightness_to_led_intensity(struct v4l2_flash * v4l2_flash,enum led_brightness brightness)487 static s32 qcom_flash_brightness_to_led_intensity(struct v4l2_flash *v4l2_flash,
488 enum led_brightness brightness)
489 {
490 struct led_classdev_flash *fled_cdev = v4l2_flash->fled_cdev;
491 struct qcom_flash_led *led = flcdev_to_qcom_fled(fled_cdev);
492
493 return (brightness * led->max_torch_current_ma * UA_PER_MA) / LED_FULL;
494 }
495
496 static const struct v4l2_flash_ops qcom_v4l2_flash_ops = {
497 .external_strobe_set = qcom_flash_external_strobe_set,
498 .intensity_to_led_brightness = qcom_flash_intensity_to_led_brightness,
499 .led_brightness_to_intensity = qcom_flash_brightness_to_led_intensity,
500 };
501
502 static int
qcom_flash_v4l2_init(struct device * dev,struct qcom_flash_led * led,struct fwnode_handle * fwnode)503 qcom_flash_v4l2_init(struct device *dev, struct qcom_flash_led *led, struct fwnode_handle *fwnode)
504 {
505 struct qcom_flash_data *flash_data = led->flash_data;
506 struct v4l2_flash_config v4l2_cfg = { 0 };
507 struct led_flash_setting *intensity = &v4l2_cfg.intensity;
508 struct v4l2_flash *v4l2_flash;
509
510 if (!(led->flash.led_cdev.flags & LED_DEV_CAP_FLASH))
511 return 0;
512
513 intensity->min = intensity->step = TORCH_IRES_UA * led->chan_count;
514 intensity->max = led->max_torch_current_ma * UA_PER_MA;
515 intensity->val = min_t(u32, intensity->max, TORCH_CURRENT_DEFAULT_UA);
516
517 strscpy(v4l2_cfg.dev_name, led->flash.led_cdev.dev->kobj.name,
518 sizeof(v4l2_cfg.dev_name));
519
520 v4l2_cfg.has_external_strobe = true;
521 v4l2_cfg.flash_faults = LED_FAULT_INPUT_VOLTAGE |
522 LED_FAULT_OVER_CURRENT |
523 LED_FAULT_SHORT_CIRCUIT |
524 LED_FAULT_OVER_TEMPERATURE |
525 LED_FAULT_TIMEOUT;
526
527 v4l2_flash = v4l2_flash_init(dev, fwnode, &led->flash, &qcom_v4l2_flash_ops, &v4l2_cfg);
528 if (IS_ERR(v4l2_flash))
529 return PTR_ERR(v4l2_flash);
530
531 flash_data->v4l2_flash[flash_data->leds_count] = v4l2_flash;
532 return 0;
533 }
534 # else
535 static int
qcom_flash_v4l2_init(struct device * dev,struct qcom_flash_led * led,struct fwnode_handle * fwnode)536 qcom_flash_v4l2_init(struct device *dev, struct qcom_flash_led *led, struct fwnode_handle *fwnode)
537 {
538 return 0;
539 }
540 #endif
541
qcom_flash_register_led_device(struct device * dev,struct fwnode_handle * node,struct qcom_flash_led * led)542 static int qcom_flash_register_led_device(struct device *dev,
543 struct fwnode_handle *node, struct qcom_flash_led *led)
544 {
545 struct qcom_flash_data *flash_data = led->flash_data;
546 struct led_init_data init_data;
547 struct led_classdev_flash *flash = &led->flash;
548 struct led_flash_setting *brightness, *timeout;
549 u32 current_ua, timeout_us;
550 u32 channels[4];
551 int i, rc, count;
552
553 count = fwnode_property_count_u32(node, "led-sources");
554 if (count <= 0) {
555 dev_err(dev, "No led-sources specified\n");
556 return -ENODEV;
557 }
558
559 if (count > flash_data->max_channels) {
560 dev_err(dev, "led-sources count %u exceeds maximum channel count %u\n",
561 count, flash_data->max_channels);
562 return -EINVAL;
563 }
564
565 rc = fwnode_property_read_u32_array(node, "led-sources", channels, count);
566 if (rc < 0) {
567 dev_err(dev, "Failed to read led-sources property, rc=%d\n", rc);
568 return rc;
569 }
570
571 led->chan_count = count;
572 led->chan_id = devm_kcalloc(dev, count, sizeof(u8), GFP_KERNEL);
573 if (!led->chan_id)
574 return -ENOMEM;
575
576 for (i = 0; i < count; i++) {
577 if ((channels[i] == 0) || (channels[i] > flash_data->max_channels)) {
578 dev_err(dev, "led-source out of HW support range [1-%u]\n",
579 flash_data->max_channels);
580 return -EINVAL;
581 }
582
583 /* Make chan_id indexing from 0 */
584 led->chan_id[i] = channels[i] - 1;
585 }
586
587 rc = fwnode_property_read_u32(node, "led-max-microamp", ¤t_ua);
588 if (rc < 0) {
589 dev_err(dev, "Failed to read led-max-microamp property, rc=%d\n", rc);
590 return rc;
591 }
592
593 if (current_ua == 0) {
594 dev_err(dev, "led-max-microamp shouldn't be 0\n");
595 return -EINVAL;
596 }
597
598 current_ua = min_t(u32, current_ua, TORCH_CURRENT_MAX_UA * led->chan_count);
599 led->max_torch_current_ma = current_ua / UA_PER_MA;
600
601 if (fwnode_property_present(node, "flash-max-microamp")) {
602 flash->led_cdev.flags |= LED_DEV_CAP_FLASH;
603
604 rc = fwnode_property_read_u32(node, "flash-max-microamp", ¤t_ua);
605 if (rc < 0) {
606 dev_err(dev, "Failed to read flash-max-microamp property, rc=%d\n",
607 rc);
608 return rc;
609 }
610
611 current_ua = min_t(u32, current_ua, FLASH_CURRENT_MAX_UA * led->chan_count);
612 current_ua = min_t(u32, current_ua, FLASH_TOTAL_CURRENT_MAX_UA);
613
614 /* Initialize flash class LED device brightness settings */
615 brightness = &flash->brightness;
616 brightness->min = brightness->step = FLASH_IRES_UA * led->chan_count;
617 brightness->max = current_ua;
618 brightness->val = min_t(u32, current_ua, FLASH_CURRENT_DEFAULT_UA);
619
620 led->max_flash_current_ma = current_ua / UA_PER_MA;
621 led->flash_current_ma = brightness->val / UA_PER_MA;
622
623 rc = fwnode_property_read_u32(node, "flash-max-timeout-us", &timeout_us);
624 if (rc < 0) {
625 dev_err(dev, "Failed to read flash-max-timeout-us property, rc=%d\n",
626 rc);
627 return rc;
628 }
629
630 timeout_us = min_t(u32, timeout_us, FLASH_TIMEOUT_MAX_US);
631
632 /* Initialize flash class LED device timeout settings */
633 timeout = &flash->timeout;
634 timeout->min = timeout->step = FLASH_TIMEOUT_STEP_US;
635 timeout->val = timeout->max = timeout_us;
636
637 led->max_timeout_ms = led->flash_timeout_ms = timeout_us / USEC_PER_MSEC;
638
639 flash->ops = &qcom_flash_ops;
640 }
641
642 flash->led_cdev.brightness_set_blocking = qcom_flash_led_brightness_set;
643
644 init_data.fwnode = node;
645 init_data.devicename = NULL;
646 init_data.default_label = NULL;
647 init_data.devname_mandatory = false;
648
649 rc = devm_led_classdev_flash_register_ext(dev, flash, &init_data);
650 if (rc < 0) {
651 dev_err(dev, "Register flash LED classdev failed, rc=%d\n", rc);
652 return rc;
653 }
654
655 return qcom_flash_v4l2_init(dev, led, node);
656 }
657
qcom_flash_led_probe(struct platform_device * pdev)658 static int qcom_flash_led_probe(struct platform_device *pdev)
659 {
660 struct qcom_flash_data *flash_data;
661 struct qcom_flash_led *led;
662 struct fwnode_handle *child;
663 struct device *dev = &pdev->dev;
664 struct regmap *regmap;
665 struct reg_field *regs;
666 int count, i, rc;
667 u32 val, reg_base;
668
669 flash_data = devm_kzalloc(dev, sizeof(*flash_data), GFP_KERNEL);
670 if (!flash_data)
671 return -ENOMEM;
672
673 regmap = dev_get_regmap(dev->parent, NULL);
674 if (!regmap) {
675 dev_err(dev, "Failed to get parent regmap\n");
676 return -EINVAL;
677 }
678
679 rc = fwnode_property_read_u32(dev->fwnode, "reg", ®_base);
680 if (rc < 0) {
681 dev_err(dev, "Failed to get register base address, rc=%d\n", rc);
682 return rc;
683 }
684
685 rc = regmap_read(regmap, reg_base + FLASH_TYPE_REG, &val);
686 if (rc < 0) {
687 dev_err(dev, "Read flash LED module type failed, rc=%d\n", rc);
688 return rc;
689 }
690
691 if (val != FLASH_TYPE_VAL) {
692 dev_err(dev, "type %#x is not a flash LED module\n", val);
693 return -ENODEV;
694 }
695
696 rc = regmap_read(regmap, reg_base + FLASH_SUBTYPE_REG, &val);
697 if (rc < 0) {
698 dev_err(dev, "Read flash LED module subtype failed, rc=%d\n", rc);
699 return rc;
700 }
701
702 if (val == FLASH_SUBTYPE_3CH_PM8150_VAL || val == FLASH_SUBTYPE_3CH_PMI8998_VAL) {
703 flash_data->hw_type = QCOM_MVFLASH_3CH;
704 flash_data->max_channels = 3;
705 regs = mvflash_3ch_regs;
706 } else if (val == FLASH_SUBTYPE_4CH_VAL) {
707 flash_data->hw_type = QCOM_MVFLASH_4CH;
708 flash_data->max_channels = 4;
709 regs = mvflash_4ch_regs;
710 } else {
711 dev_err(dev, "flash LED subtype %#x is not yet supported\n", val);
712 return -ENODEV;
713 }
714
715 for (i = 0; i < REG_MAX_COUNT; i++)
716 regs[i].reg += reg_base;
717
718 rc = devm_regmap_field_bulk_alloc(dev, regmap, flash_data->r_fields, regs, REG_MAX_COUNT);
719 if (rc < 0) {
720 dev_err(dev, "Failed to allocate regmap field, rc=%d\n", rc);
721 return rc;
722 }
723
724 platform_set_drvdata(pdev, flash_data);
725 mutex_init(&flash_data->lock);
726
727 count = device_get_child_node_count(dev);
728 if (count == 0 || count > flash_data->max_channels) {
729 dev_err(dev, "No child or child count exceeds %d\n", flash_data->max_channels);
730 return -EINVAL;
731 }
732
733 flash_data->v4l2_flash = devm_kcalloc(dev, count,
734 sizeof(*flash_data->v4l2_flash), GFP_KERNEL);
735 if (!flash_data->v4l2_flash)
736 return -ENOMEM;
737
738 device_for_each_child_node(dev, child) {
739 led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
740 if (!led) {
741 rc = -ENOMEM;
742 goto release;
743 }
744
745 led->flash_data = flash_data;
746 rc = qcom_flash_register_led_device(dev, child, led);
747 if (rc < 0)
748 goto release;
749
750 flash_data->leds_count++;
751 }
752
753 return 0;
754
755 release:
756 fwnode_handle_put(child);
757 while (flash_data->v4l2_flash[flash_data->leds_count] && flash_data->leds_count)
758 v4l2_flash_release(flash_data->v4l2_flash[flash_data->leds_count--]);
759 return rc;
760 }
761
qcom_flash_led_remove(struct platform_device * pdev)762 static int qcom_flash_led_remove(struct platform_device *pdev)
763 {
764 struct qcom_flash_data *flash_data = platform_get_drvdata(pdev);
765
766 while (flash_data->v4l2_flash[flash_data->leds_count] && flash_data->leds_count)
767 v4l2_flash_release(flash_data->v4l2_flash[flash_data->leds_count--]);
768
769 mutex_destroy(&flash_data->lock);
770 return 0;
771 }
772
773 static const struct of_device_id qcom_flash_led_match_table[] = {
774 { .compatible = "qcom,spmi-flash-led" },
775 { }
776 };
777
778 MODULE_DEVICE_TABLE(of, qcom_flash_led_match_table);
779 static struct platform_driver qcom_flash_led_driver = {
780 .driver = {
781 .name = "leds-qcom-flash",
782 .of_match_table = qcom_flash_led_match_table,
783 },
784 .probe = qcom_flash_led_probe,
785 .remove = qcom_flash_led_remove,
786 };
787
788 module_platform_driver(qcom_flash_led_driver);
789
790 MODULE_DESCRIPTION("QCOM Flash LED driver");
791 MODULE_LICENSE("GPL");
792