?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / video / backlight / qcom-wled.c
blob3d276b30a78c939bf3a7c9fd62a84e6de5364155
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (c) 2015, Sony Mobile Communications, AB.
3 */
4
5 #include <linux/delay.h>
6 #include <linux/interrupt.h>
7 #include <linux/ktime.h>
8 #include <linux/kernel.h>
9 #include <linux/backlight.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/of_device.h>
13 #include <linux/of_address.h>
14 #include <linux/regmap.h>
15
16 /* From DT binding */
17 #define WLED_MAX_STRINGS 4
18
19 #define WLED_DEFAULT_BRIGHTNESS 2048
20 #define WLED_SOFT_START_DLY_US 10000
21 #define WLED3_SINK_REG_BRIGHT_MAX 0xFFF
22
23 /* WLED3/WLED4 control registers */
24 #define WLED3_CTRL_REG_FAULT_STATUS 0x08
25 #define WLED3_CTRL_REG_ILIM_FAULT_BIT BIT(0)
26 #define WLED3_CTRL_REG_OVP_FAULT_BIT BIT(1)
27 #define WLED4_CTRL_REG_SC_FAULT_BIT BIT(2)
28
29 #define WLED3_CTRL_REG_INT_RT_STS 0x10
30 #define WLED3_CTRL_REG_OVP_FAULT_STATUS BIT(1)
31
32 #define WLED3_CTRL_REG_MOD_EN 0x46
33 #define WLED3_CTRL_REG_MOD_EN_MASK BIT(7)
34 #define WLED3_CTRL_REG_MOD_EN_SHIFT 7
35
36 #define WLED3_CTRL_REG_FEEDBACK_CONTROL 0x48
37
38 #define WLED3_CTRL_REG_FREQ 0x4c
39 #define WLED3_CTRL_REG_FREQ_MASK GENMASK(3, 0)
40
41 #define WLED3_CTRL_REG_OVP 0x4d
42 #define WLED3_CTRL_REG_OVP_MASK GENMASK(1, 0)
43
44 #define WLED3_CTRL_REG_ILIMIT 0x4e
45 #define WLED3_CTRL_REG_ILIMIT_MASK GENMASK(2, 0)
46
47 /* WLED3/WLED4 sink registers */
48 #define WLED3_SINK_REG_SYNC 0x47
49 #define WLED3_SINK_REG_SYNC_CLEAR 0x00
50
51 #define WLED3_SINK_REG_CURR_SINK 0x4f
52 #define WLED3_SINK_REG_CURR_SINK_MASK GENMASK(7, 5)
53 #define WLED3_SINK_REG_CURR_SINK_SHFT 5
54
55 /* WLED3 specific per-'string' registers below */
56 #define WLED3_SINK_REG_BRIGHT(n) (0x40 + n)
57
58 #define WLED3_SINK_REG_STR_MOD_EN(n) (0x60 + (n * 0x10))
59 #define WLED3_SINK_REG_STR_MOD_MASK BIT(7)
60
61 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR(n) (0x62 + (n * 0x10))
62 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(4, 0)
63
64 #define WLED3_SINK_REG_STR_MOD_SRC(n) (0x63 + (n * 0x10))
65 #define WLED3_SINK_REG_STR_MOD_SRC_MASK BIT(0)
66 #define WLED3_SINK_REG_STR_MOD_SRC_INT 0x00
67 #define WLED3_SINK_REG_STR_MOD_SRC_EXT 0x01
68
69 #define WLED3_SINK_REG_STR_CABC(n) (0x66 + (n * 0x10))
70 #define WLED3_SINK_REG_STR_CABC_MASK BIT(7)
71
72 /* WLED4 specific control registers */
73 #define WLED4_CTRL_REG_SHORT_PROTECT 0x5e
74 #define WLED4_CTRL_REG_SHORT_EN_MASK BIT(7)
75
76 #define WLED4_CTRL_REG_SEC_ACCESS 0xd0
77 #define WLED4_CTRL_REG_SEC_UNLOCK 0xa5
78
79 #define WLED4_CTRL_REG_TEST1 0xe2
80 #define WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2 0x09
81
82 /* WLED4 specific sink registers */
83 #define WLED4_SINK_REG_CURR_SINK 0x46
84 #define WLED4_SINK_REG_CURR_SINK_MASK GENMASK(7, 4)
85 #define WLED4_SINK_REG_CURR_SINK_SHFT 4
86
87 /* WLED4 specific per-'string' registers below */
88 #define WLED4_SINK_REG_STR_MOD_EN(n) (0x50 + (n * 0x10))
89 #define WLED4_SINK_REG_STR_MOD_MASK BIT(7)
90
91 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR(n) (0x52 + (n * 0x10))
92 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(3, 0)
93
94 #define WLED4_SINK_REG_STR_MOD_SRC(n) (0x53 + (n * 0x10))
95 #define WLED4_SINK_REG_STR_MOD_SRC_MASK BIT(0)
96 #define WLED4_SINK_REG_STR_MOD_SRC_INT 0x00
97 #define WLED4_SINK_REG_STR_MOD_SRC_EXT 0x01
98
99 #define WLED4_SINK_REG_STR_CABC(n) (0x56 + (n * 0x10))
100 #define WLED4_SINK_REG_STR_CABC_MASK BIT(7)
101
102 #define WLED4_SINK_REG_BRIGHT(n) (0x57 + (n * 0x10))
103
104 struct wled_var_cfg {
105 const u32 *values;
106 u32 (*fn)(u32);
107 int size;
108 };
109
110 struct wled_u32_opts {
111 const char *name;
112 u32 *val_ptr;
113 const struct wled_var_cfg *cfg;
114 };
115
116 struct wled_bool_opts {
117 const char *name;
118 bool *val_ptr;
119 };
120
121 struct wled_config {
122 u32 boost_i_limit;
123 u32 ovp;
124 u32 switch_freq;
125 u32 num_strings;
126 u32 string_i_limit;
127 u32 enabled_strings[WLED_MAX_STRINGS];
128 bool cs_out_en;
129 bool ext_gen;
130 bool cabc;
131 bool external_pfet;
132 bool auto_detection_enabled;
133 };
134
135 struct wled {
136 const char *name;
137 struct device *dev;
138 struct regmap *regmap;
139 struct mutex lock; /* Lock to avoid race from thread irq handler */
140 ktime_t last_short_event;
141 ktime_t start_ovp_fault_time;
142 u16 ctrl_addr;
143 u16 sink_addr;
144 u16 max_string_count;
145 u16 auto_detection_ovp_count;
146 u32 brightness;
147 u32 max_brightness;
148 u32 short_count;
149 u32 auto_detect_count;
150 bool disabled_by_short;
151 bool has_short_detect;
152 int short_irq;
153 int ovp_irq;
154
155 struct wled_config cfg;
156 struct delayed_work ovp_work;
157 int (*wled_set_brightness)(struct wled *wled, u16 brightness);
158 };
159
160 static int wled3_set_brightness(struct wled *wled, u16 brightness)
161 {
162 int rc, i;
163 u8 v[2];
164
165 v[0] = brightness & 0xff;
166 v[1] = (brightness >> 8) & 0xf;
167
168 for (i = 0; i < wled->cfg.num_strings; ++i) {
169 rc = regmap_bulk_write(wled->regmap, wled->ctrl_addr +
170 WLED3_SINK_REG_BRIGHT(i), v, 2);
171 if (rc < 0)
172 return rc;
173 }
174
175 return 0;
176 }
177
178 static int wled4_set_brightness(struct wled *wled, u16 brightness)
179 {
180 int rc, i;
181 u16 low_limit = wled->max_brightness * 4 / 1000;
182 u8 v[2];
183
184 /* WLED4's lower limit of operation is 0.4% */
185 if (brightness > 0 && brightness < low_limit)
186 brightness = low_limit;
187
188 v[0] = brightness & 0xff;
189 v[1] = (brightness >> 8) & 0xf;
190
191 for (i = 0; i < wled->cfg.num_strings; ++i) {
192 rc = regmap_bulk_write(wled->regmap, wled->sink_addr +
193 WLED4_SINK_REG_BRIGHT(i), v, 2);
194 if (rc < 0)
195 return rc;
196 }
197
198 return 0;
199 }
200
201 static void wled_ovp_work(struct work_struct *work)
202 {
203 struct wled *wled = container_of(work,
204 struct wled, ovp_work.work);
205 enable_irq(wled->ovp_irq);
206 }
207
208 static int wled_module_enable(struct wled *wled, int val)
209 {
210 int rc;
211
212 if (wled->disabled_by_short)
213 return -ENXIO;
214
215 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
216 WLED3_CTRL_REG_MOD_EN,
217 WLED3_CTRL_REG_MOD_EN_MASK,
218 val << WLED3_CTRL_REG_MOD_EN_SHIFT);
219 if (rc < 0)
220 return rc;
221
222 if (wled->ovp_irq > 0) {
223 if (val) {
224 /*
225 * The hardware generates a storm of spurious OVP
226 * interrupts during soft start operations. So defer
227 * enabling the IRQ for 10ms to ensure that the
228 * soft start is complete.
229 */
230 schedule_delayed_work(&wled->ovp_work, HZ / 100);
231 } else {
232 if (!cancel_delayed_work_sync(&wled->ovp_work))
233 disable_irq(wled->ovp_irq);
234 }
235 }
236
237 return 0;
238 }
239
240 static int wled_sync_toggle(struct wled *wled)
241 {
242 int rc;
243 unsigned int mask = GENMASK(wled->max_string_count - 1, 0);
244
245 rc = regmap_update_bits(wled->regmap,
246 wled->ctrl_addr + WLED3_SINK_REG_SYNC,
247 mask, mask);
248 if (rc < 0)
249 return rc;
250
251 rc = regmap_update_bits(wled->regmap,
252 wled->ctrl_addr + WLED3_SINK_REG_SYNC,
253 mask, WLED3_SINK_REG_SYNC_CLEAR);
254
255 return rc;
256 }
257
258 static int wled_update_status(struct backlight_device *bl)
259 {
260 struct wled *wled = bl_get_data(bl);
261 u16 brightness = bl->props.brightness;
262 int rc = 0;
263
264 if (bl->props.power != FB_BLANK_UNBLANK ||
265 bl->props.fb_blank != FB_BLANK_UNBLANK ||
266 bl->props.state & BL_CORE_FBBLANK)
267 brightness = 0;
268
269 mutex_lock(&wled->lock);
270 if (brightness) {
271 rc = wled->wled_set_brightness(wled, brightness);
272 if (rc < 0) {
273 dev_err(wled->dev, "wled failed to set brightness rc:%d\n",
274 rc);
275 goto unlock_mutex;
276 }
277
278 rc = wled_sync_toggle(wled);
279 if (rc < 0) {
280 dev_err(wled->dev, "wled sync failed rc:%d\n", rc);
281 goto unlock_mutex;
282 }
283 }
284
285 if (!!brightness != !!wled->brightness) {
286 rc = wled_module_enable(wled, !!brightness);
287 if (rc < 0) {
288 dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
289 goto unlock_mutex;
290 }
291 }
292
293 wled->brightness = brightness;
294
295 unlock_mutex:
296 mutex_unlock(&wled->lock);
297
298 return rc;
299 }
300
301 #define WLED_SHORT_DLY_MS 20
302 #define WLED_SHORT_CNT_MAX 5
303 #define WLED_SHORT_RESET_CNT_DLY_US USEC_PER_SEC
304
305 static irqreturn_t wled_short_irq_handler(int irq, void *_wled)
306 {
307 struct wled *wled = _wled;
308 int rc;
309 s64 elapsed_time;
310
311 wled->short_count++;
312 mutex_lock(&wled->lock);
313 rc = wled_module_enable(wled, false);
314 if (rc < 0) {
315 dev_err(wled->dev, "wled disable failed rc:%d\n", rc);
316 goto unlock_mutex;
317 }
318
319 elapsed_time = ktime_us_delta(ktime_get(),
320 wled->last_short_event);
321 if (elapsed_time > WLED_SHORT_RESET_CNT_DLY_US)
322 wled->short_count = 1;
323
324 if (wled->short_count > WLED_SHORT_CNT_MAX) {
325 dev_err(wled->dev, "Short triggered %d times, disabling WLED forever!\n",
326 wled->short_count);
327 wled->disabled_by_short = true;
328 goto unlock_mutex;
329 }
330
331 wled->last_short_event = ktime_get();
332
333 msleep(WLED_SHORT_DLY_MS);
334 rc = wled_module_enable(wled, true);
335 if (rc < 0)
336 dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
337
338 unlock_mutex:
339 mutex_unlock(&wled->lock);
340
341 return IRQ_HANDLED;
342 }
343
344 #define AUTO_DETECT_BRIGHTNESS 200
345
346 static void wled_auto_string_detection(struct wled *wled)
347 {
348 int rc = 0, i;
349 u32 sink_config = 0, int_sts;
350 u8 sink_test = 0, sink_valid = 0, val;
351
352 /* Read configured sink configuration */
353 rc = regmap_read(wled->regmap, wled->sink_addr +
354 WLED4_SINK_REG_CURR_SINK, &sink_config);
355 if (rc < 0) {
356 dev_err(wled->dev, "Failed to read SINK configuration rc=%d\n",
357 rc);
358 goto failed_detect;
359 }
360
361 /* Disable the module before starting detection */
362 rc = regmap_update_bits(wled->regmap,
363 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
364 WLED3_CTRL_REG_MOD_EN_MASK, 0);
365 if (rc < 0) {
366 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n", rc);
367 goto failed_detect;
368 }
369
370 /* Set low brightness across all sinks */
371 rc = wled4_set_brightness(wled, AUTO_DETECT_BRIGHTNESS);
372 if (rc < 0) {
373 dev_err(wled->dev, "Failed to set brightness for auto detection rc=%d\n",
374 rc);
375 goto failed_detect;
376 }
377
378 if (wled->cfg.cabc) {
379 for (i = 0; i < wled->cfg.num_strings; i++) {
380 rc = regmap_update_bits(wled->regmap, wled->sink_addr +
381 WLED4_SINK_REG_STR_CABC(i),
382 WLED4_SINK_REG_STR_CABC_MASK,
383 0);
384 if (rc < 0)
385 goto failed_detect;
386 }
387 }
388
389 /* Disable all sinks */
390 rc = regmap_write(wled->regmap,
391 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 0);
392 if (rc < 0) {
393 dev_err(wled->dev, "Failed to disable all sinks rc=%d\n", rc);
394 goto failed_detect;
395 }
396
397 /* Iterate through the strings one by one */
398 for (i = 0; i < wled->cfg.num_strings; i++) {
399 sink_test = BIT((WLED4_SINK_REG_CURR_SINK_SHFT + i));
400
401 /* Enable feedback control */
402 rc = regmap_write(wled->regmap, wled->ctrl_addr +
403 WLED3_CTRL_REG_FEEDBACK_CONTROL, i + 1);
404 if (rc < 0) {
405 dev_err(wled->dev, "Failed to enable feedback for SINK %d rc = %d\n",
406 i + 1, rc);
407 goto failed_detect;
408 }
409
410 /* Enable the sink */
411 rc = regmap_write(wled->regmap, wled->sink_addr +
412 WLED4_SINK_REG_CURR_SINK, sink_test);
413 if (rc < 0) {
414 dev_err(wled->dev, "Failed to configure SINK %d rc=%d\n",
415 i + 1, rc);
416 goto failed_detect;
417 }
418
419 /* Enable the module */
420 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
421 WLED3_CTRL_REG_MOD_EN,
422 WLED3_CTRL_REG_MOD_EN_MASK,
423 WLED3_CTRL_REG_MOD_EN_MASK);
424 if (rc < 0) {
425 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n",
426 rc);
427 goto failed_detect;
428 }
429
430 usleep_range(WLED_SOFT_START_DLY_US,
431 WLED_SOFT_START_DLY_US + 1000);
432
433 rc = regmap_read(wled->regmap, wled->ctrl_addr +
434 WLED3_CTRL_REG_INT_RT_STS, &int_sts);
435 if (rc < 0) {
436 dev_err(wled->dev, "Error in reading WLED3_CTRL_INT_RT_STS rc=%d\n",
437 rc);
438 goto failed_detect;
439 }
440
441 if (int_sts & WLED3_CTRL_REG_OVP_FAULT_STATUS)
442 dev_dbg(wled->dev, "WLED OVP fault detected with SINK %d\n",
443 i + 1);
444 else
445 sink_valid |= sink_test;
446
447 /* Disable the module */
448 rc = regmap_update_bits(wled->regmap,
449 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
450 WLED3_CTRL_REG_MOD_EN_MASK, 0);
451 if (rc < 0) {
452 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n",
453 rc);
454 goto failed_detect;
455 }
456 }
457
458 if (!sink_valid) {
459 dev_err(wled->dev, "No valid WLED sinks found\n");
460 wled->disabled_by_short = true;
461 goto failed_detect;
462 }
463
464 if (sink_valid != sink_config) {
465 dev_warn(wled->dev, "%x is not a valid sink configuration - using %x instead\n",
466 sink_config, sink_valid);
467 sink_config = sink_valid;
468 }
469
470 /* Write the new sink configuration */
471 rc = regmap_write(wled->regmap,
472 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
473 sink_config);
474 if (rc < 0) {
475 dev_err(wled->dev, "Failed to reconfigure the default sink rc=%d\n",
476 rc);
477 goto failed_detect;
478 }
479
480 /* Enable valid sinks */
481 for (i = 0; i < wled->cfg.num_strings; i++) {
482 if (wled->cfg.cabc) {
483 rc = regmap_update_bits(wled->regmap, wled->sink_addr +
484 WLED4_SINK_REG_STR_CABC(i),
485 WLED4_SINK_REG_STR_CABC_MASK,
486 WLED4_SINK_REG_STR_CABC_MASK);
487 if (rc < 0)
488 goto failed_detect;
489 }
490
491 if (sink_config & BIT(WLED4_SINK_REG_CURR_SINK_SHFT + i))
492 val = WLED4_SINK_REG_STR_MOD_MASK;
493 else
494 val = 0x0; /* Disable modulator_en for unused sink */
495
496 rc = regmap_write(wled->regmap, wled->sink_addr +
497 WLED4_SINK_REG_STR_MOD_EN(i), val);
498 if (rc < 0) {
499 dev_err(wled->dev, "Failed to configure MODULATOR_EN rc=%d\n",
500 rc);
501 goto failed_detect;
502 }
503 }
504
505 /* Restore the feedback setting */
506 rc = regmap_write(wled->regmap,
507 wled->ctrl_addr + WLED3_CTRL_REG_FEEDBACK_CONTROL, 0);
508 if (rc < 0) {
509 dev_err(wled->dev, "Failed to restore feedback setting rc=%d\n",
510 rc);
511 goto failed_detect;
512 }
513
514 /* Restore brightness */
515 rc = wled4_set_brightness(wled, wled->brightness);
516 if (rc < 0) {
517 dev_err(wled->dev, "Failed to set brightness after auto detection rc=%d\n",
518 rc);
519 goto failed_detect;
520 }
521
522 rc = regmap_update_bits(wled->regmap,
523 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
524 WLED3_CTRL_REG_MOD_EN_MASK,
525 WLED3_CTRL_REG_MOD_EN_MASK);
526 if (rc < 0) {
527 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n", rc);
528 goto failed_detect;
529 }
530
531 failed_detect:
532 return;
533 }
534
535 #define WLED_AUTO_DETECT_OVP_COUNT 5
536 #define WLED_AUTO_DETECT_CNT_DLY_US USEC_PER_SEC
537 static bool wled_auto_detection_required(struct wled *wled)
538 {
539 s64 elapsed_time_us;
540
541 if (!wled->cfg.auto_detection_enabled)
542 return false;
543
544 /*
545 * Check if the OVP fault was an occasional one
546 * or if it's firing continuously, the latter qualifies
547 * for an auto-detection check.
548 */
549 if (!wled->auto_detection_ovp_count) {
550 wled->start_ovp_fault_time = ktime_get();
551 wled->auto_detection_ovp_count++;
552 } else {
553 elapsed_time_us = ktime_us_delta(ktime_get(),
554 wled->start_ovp_fault_time);
555 if (elapsed_time_us > WLED_AUTO_DETECT_CNT_DLY_US)
556 wled->auto_detection_ovp_count = 0;
557 else
558 wled->auto_detection_ovp_count++;
559
560 if (wled->auto_detection_ovp_count >=
561 WLED_AUTO_DETECT_OVP_COUNT) {
562 wled->auto_detection_ovp_count = 0;
563 return true;
564 }
565 }
566
567 return false;
568 }
569
570 static int wled_auto_detection_at_init(struct wled *wled)
571 {
572 int rc;
573 u32 fault_status, rt_status;
574
575 if (!wled->cfg.auto_detection_enabled)
576 return 0;
577
578 rc = regmap_read(wled->regmap,
579 wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS,
580 &rt_status);
581 if (rc < 0) {
582 dev_err(wled->dev, "Failed to read RT status rc=%d\n", rc);
583 return rc;
584 }
585
586 rc = regmap_read(wled->regmap,
587 wled->ctrl_addr + WLED3_CTRL_REG_FAULT_STATUS,
588 &fault_status);
589 if (rc < 0) {
590 dev_err(wled->dev, "Failed to read fault status rc=%d\n", rc);
591 return rc;
592 }
593
594 if ((rt_status & WLED3_CTRL_REG_OVP_FAULT_STATUS) ||
595 (fault_status & WLED3_CTRL_REG_OVP_FAULT_BIT)) {
596 mutex_lock(&wled->lock);
597 wled_auto_string_detection(wled);
598 mutex_unlock(&wled->lock);
599 }
600
601 return rc;
602 }
603
604 static irqreturn_t wled_ovp_irq_handler(int irq, void *_wled)
605 {
606 struct wled *wled = _wled;
607 int rc;
608 u32 int_sts, fault_sts;
609
610 rc = regmap_read(wled->regmap,
611 wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS, &int_sts);
612 if (rc < 0) {
613 dev_err(wled->dev, "Error in reading WLED3_INT_RT_STS rc=%d\n",
614 rc);
615 return IRQ_HANDLED;
616 }
617
618 rc = regmap_read(wled->regmap, wled->ctrl_addr +
619 WLED3_CTRL_REG_FAULT_STATUS, &fault_sts);
620 if (rc < 0) {
621 dev_err(wled->dev, "Error in reading WLED_FAULT_STATUS rc=%d\n",
622 rc);
623 return IRQ_HANDLED;
624 }
625
626 if (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
627 WLED3_CTRL_REG_ILIM_FAULT_BIT))
628 dev_dbg(wled->dev, "WLED OVP fault detected, int_sts=%x fault_sts= %x\n",
629 int_sts, fault_sts);
630
631 if (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT) {
632 if (wled_auto_detection_required(wled)) {
633 mutex_lock(&wled->lock);
634 wled_auto_string_detection(wled);
635 mutex_unlock(&wled->lock);
636 }
637 }
638
639 return IRQ_HANDLED;
640 }
641
642 static int wled3_setup(struct wled *wled)
643 {
644 u16 addr;
645 u8 sink_en = 0;
646 int rc, i, j;
647
648 rc = regmap_update_bits(wled->regmap,
649 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
650 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
651 if (rc)
652 return rc;
653
654 rc = regmap_update_bits(wled->regmap,
655 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
656 WLED3_CTRL_REG_ILIMIT_MASK,
657 wled->cfg.boost_i_limit);
658 if (rc)
659 return rc;
660
661 rc = regmap_update_bits(wled->regmap,
662 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
663 WLED3_CTRL_REG_FREQ_MASK,
664 wled->cfg.switch_freq);
665 if (rc)
666 return rc;
667
668 for (i = 0; i < wled->cfg.num_strings; ++i) {
669 j = wled->cfg.enabled_strings[i];
670 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_EN(j);
671 rc = regmap_update_bits(wled->regmap, addr,
672 WLED3_SINK_REG_STR_MOD_MASK,
673 WLED3_SINK_REG_STR_MOD_MASK);
674 if (rc)
675 return rc;
676
677 if (wled->cfg.ext_gen) {
678 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_SRC(j);
679 rc = regmap_update_bits(wled->regmap, addr,
680 WLED3_SINK_REG_STR_MOD_SRC_MASK,
681 WLED3_SINK_REG_STR_MOD_SRC_EXT);
682 if (rc)
683 return rc;
684 }
685
686 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_FULL_SCALE_CURR(j);
687 rc = regmap_update_bits(wled->regmap, addr,
688 WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK,
689 wled->cfg.string_i_limit);
690 if (rc)
691 return rc;
692
693 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_CABC(j);
694 rc = regmap_update_bits(wled->regmap, addr,
695 WLED3_SINK_REG_STR_CABC_MASK,
696 wled->cfg.cabc ?
697 WLED3_SINK_REG_STR_CABC_MASK : 0);
698 if (rc)
699 return rc;
700
701 sink_en |= BIT(j + WLED3_SINK_REG_CURR_SINK_SHFT);
702 }
703
704 rc = regmap_update_bits(wled->regmap,
705 wled->ctrl_addr + WLED3_SINK_REG_CURR_SINK,
706 WLED3_SINK_REG_CURR_SINK_MASK, sink_en);
707 if (rc)
708 return rc;
709
710 return 0;
711 }
712
713 static const struct wled_config wled3_config_defaults = {
714 .boost_i_limit = 3,
715 .string_i_limit = 20,
716 .ovp = 2,
717 .num_strings = 3,
718 .switch_freq = 5,
719 .cs_out_en = false,
720 .ext_gen = false,
721 .cabc = false,
722 .enabled_strings = {0, 1, 2, 3},
723 };
724
725 static int wled4_setup(struct wled *wled)
726 {
727 int rc, temp, i, j;
728 u16 addr;
729 u8 sink_en = 0;
730 u32 sink_cfg;
731
732 rc = regmap_update_bits(wled->regmap,
733 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
734 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
735 if (rc < 0)
736 return rc;
737
738 rc = regmap_update_bits(wled->regmap,
739 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
740 WLED3_CTRL_REG_ILIMIT_MASK,
741 wled->cfg.boost_i_limit);
742 if (rc < 0)
743 return rc;
744
745 rc = regmap_update_bits(wled->regmap,
746 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
747 WLED3_CTRL_REG_FREQ_MASK,
748 wled->cfg.switch_freq);
749 if (rc < 0)
750 return rc;
751
752 if (wled->cfg.external_pfet) {
753 /* Unlock the secure register access */
754 rc = regmap_write(wled->regmap, wled->ctrl_addr +
755 WLED4_CTRL_REG_SEC_ACCESS,
756 WLED4_CTRL_REG_SEC_UNLOCK);
757 if (rc < 0)
758 return rc;
759
760 rc = regmap_write(wled->regmap,
761 wled->ctrl_addr + WLED4_CTRL_REG_TEST1,
762 WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2);
763 if (rc < 0)
764 return rc;
765 }
766
767 rc = regmap_read(wled->regmap, wled->sink_addr +
768 WLED4_SINK_REG_CURR_SINK, &sink_cfg);
769 if (rc < 0)
770 return rc;
771
772 for (i = 0; i < wled->cfg.num_strings; i++) {
773 j = wled->cfg.enabled_strings[i];
774 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
775 sink_en |= 1 << temp;
776 }
777
778 if (sink_cfg == sink_en) {
779 rc = wled_auto_detection_at_init(wled);
780 return rc;
781 }
782
783 rc = regmap_update_bits(wled->regmap,
784 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
785 WLED4_SINK_REG_CURR_SINK_MASK, 0);
786 if (rc < 0)
787 return rc;
788
789 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
790 WLED3_CTRL_REG_MOD_EN,
791 WLED3_CTRL_REG_MOD_EN_MASK, 0);
792 if (rc < 0)
793 return rc;
794
795 /* Per sink/string configuration */
796 for (i = 0; i < wled->cfg.num_strings; i++) {
797 j = wled->cfg.enabled_strings[i];
798
799 addr = wled->sink_addr +
800 WLED4_SINK_REG_STR_MOD_EN(j);
801 rc = regmap_update_bits(wled->regmap, addr,
802 WLED4_SINK_REG_STR_MOD_MASK,
803 WLED4_SINK_REG_STR_MOD_MASK);
804 if (rc < 0)
805 return rc;
806
807 addr = wled->sink_addr +
808 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
809 rc = regmap_update_bits(wled->regmap, addr,
810 WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
811 wled->cfg.string_i_limit);
812 if (rc < 0)
813 return rc;
814
815 addr = wled->sink_addr +
816 WLED4_SINK_REG_STR_CABC(j);
817 rc = regmap_update_bits(wled->regmap, addr,
818 WLED4_SINK_REG_STR_CABC_MASK,
819 wled->cfg.cabc ?
820 WLED4_SINK_REG_STR_CABC_MASK : 0);
821 if (rc < 0)
822 return rc;
823 }
824
825 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
826 WLED3_CTRL_REG_MOD_EN,
827 WLED3_CTRL_REG_MOD_EN_MASK,
828 WLED3_CTRL_REG_MOD_EN_MASK);
829 if (rc < 0)
830 return rc;
831
832 rc = regmap_update_bits(wled->regmap,
833 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
834 WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
835 if (rc < 0)
836 return rc;
837
838 rc = wled_sync_toggle(wled);
839 if (rc < 0) {
840 dev_err(wled->dev, "Failed to toggle sync reg rc:%d\n", rc);
841 return rc;
842 }
843
844 rc = wled_auto_detection_at_init(wled);
845
846 return rc;
847 }
848
849 static const struct wled_config wled4_config_defaults = {
850 .boost_i_limit = 4,
851 .string_i_limit = 10,
852 .ovp = 1,
853 .num_strings = 4,
854 .switch_freq = 11,
855 .cabc = false,
856 .external_pfet = false,
857 .auto_detection_enabled = false,
858 };
859
860 static const u32 wled3_boost_i_limit_values[] = {
861 105, 385, 525, 805, 980, 1260, 1400, 1680,
862 };
863
864 static const struct wled_var_cfg wled3_boost_i_limit_cfg = {
865 .values = wled3_boost_i_limit_values,
866 .size = ARRAY_SIZE(wled3_boost_i_limit_values),
867 };
868
869 static const u32 wled4_boost_i_limit_values[] = {
870 105, 280, 450, 620, 970, 1150, 1300, 1500,
871 };
872
873 static const struct wled_var_cfg wled4_boost_i_limit_cfg = {
874 .values = wled4_boost_i_limit_values,
875 .size = ARRAY_SIZE(wled4_boost_i_limit_values),
876 };
877
878 static const u32 wled3_ovp_values[] = {
879 35, 32, 29, 27,
880 };
881
882 static const struct wled_var_cfg wled3_ovp_cfg = {
883 .values = wled3_ovp_values,
884 .size = ARRAY_SIZE(wled3_ovp_values),
885 };
886
887 static const u32 wled4_ovp_values[] = {
888 31100, 29600, 19600, 18100,
889 };
890
891 static const struct wled_var_cfg wled4_ovp_cfg = {
892 .values = wled4_ovp_values,
893 .size = ARRAY_SIZE(wled4_ovp_values),
894 };
895
896 static u32 wled3_num_strings_values_fn(u32 idx)
897 {
898 return idx + 1;
899 }
900
901 static const struct wled_var_cfg wled3_num_strings_cfg = {
902 .fn = wled3_num_strings_values_fn,
903 .size = 3,
904 };
905
906 static const struct wled_var_cfg wled4_num_strings_cfg = {
907 .fn = wled3_num_strings_values_fn,
908 .size = 4,
909 };
910
911 static u32 wled3_switch_freq_values_fn(u32 idx)
912 {
913 return 19200 / (2 * (1 + idx));
914 }
915
916 static const struct wled_var_cfg wled3_switch_freq_cfg = {
917 .fn = wled3_switch_freq_values_fn,
918 .size = 16,
919 };
920
921 static const struct wled_var_cfg wled3_string_i_limit_cfg = {
922 .size = 26,
923 };
924
925 static const u32 wled4_string_i_limit_values[] = {
926 0, 2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000,
927 22500, 25000, 27500, 30000,
928 };
929
930 static const struct wled_var_cfg wled4_string_i_limit_cfg = {
931 .values = wled4_string_i_limit_values,
932 .size = ARRAY_SIZE(wled4_string_i_limit_values),
933 };
934
935 static const struct wled_var_cfg wled3_string_cfg = {
936 .size = 8,
937 };
938
939 static const struct wled_var_cfg wled4_string_cfg = {
940 .size = 16,
941 };
942
943 static u32 wled_values(const struct wled_var_cfg *cfg, u32 idx)
944 {
945 if (idx >= cfg->size)
946 return UINT_MAX;
947 if (cfg->fn)
948 return cfg->fn(idx);
949 if (cfg->values)
950 return cfg->values[idx];
951 return idx;
952 }
953
954 static int wled_configure(struct wled *wled, int version)
955 {
956 struct wled_config *cfg = &wled->cfg;
957 struct device *dev = wled->dev;
958 const __be32 *prop_addr;
959 u32 size, val, c;
960 int rc, i, j, string_len;
961
962 const struct wled_u32_opts *u32_opts = NULL;
963 const struct wled_u32_opts wled3_opts[] = {
964 {
965 .name = "qcom,current-boost-limit",
966 .val_ptr = &cfg->boost_i_limit,
967 .cfg = &wled3_boost_i_limit_cfg,
968 },
969 {
970 .name = "qcom,current-limit",
971 .val_ptr = &cfg->string_i_limit,
972 .cfg = &wled3_string_i_limit_cfg,
973 },
974 {
975 .name = "qcom,ovp",
976 .val_ptr = &cfg->ovp,
977 .cfg = &wled3_ovp_cfg,
978 },
979 {
980 .name = "qcom,switching-freq",
981 .val_ptr = &cfg->switch_freq,
982 .cfg = &wled3_switch_freq_cfg,
983 },
984 {
985 .name = "qcom,num-strings",
986 .val_ptr = &cfg->num_strings,
987 .cfg = &wled3_num_strings_cfg,
988 },
989 };
990
991 const struct wled_u32_opts wled4_opts[] = {
992 {
993 .name = "qcom,current-boost-limit",
994 .val_ptr = &cfg->boost_i_limit,
995 .cfg = &wled4_boost_i_limit_cfg,
996 },
997 {
998 .name = "qcom,current-limit-microamp",
999 .val_ptr = &cfg->string_i_limit,
1000 .cfg = &wled4_string_i_limit_cfg,
1001 },
1002 {
1003 .name = "qcom,ovp-millivolt",
1004 .val_ptr = &cfg->ovp,
1005 .cfg = &wled4_ovp_cfg,
1006 },
1007 {
1008 .name = "qcom,switching-freq",
1009 .val_ptr = &cfg->switch_freq,
1010 .cfg = &wled3_switch_freq_cfg,
1011 },
1012 {
1013 .name = "qcom,num-strings",
1014 .val_ptr = &cfg->num_strings,
1015 .cfg = &wled4_num_strings_cfg,
1016 },
1017 };
1018
1019 const struct wled_bool_opts bool_opts[] = {
1020 { "qcom,cs-out", &cfg->cs_out_en, },
1021 { "qcom,ext-gen", &cfg->ext_gen, },
1022 { "qcom,cabc", &cfg->cabc, },
1023 { "qcom,external-pfet", &cfg->external_pfet, },
1024 { "qcom,auto-string-detection", &cfg->auto_detection_enabled, },
1025 };
1026
1027 prop_addr = of_get_address(dev->of_node, 0, NULL, NULL);
1028 if (!prop_addr) {
1029 dev_err(wled->dev, "invalid IO resources\n");
1030 return -EINVAL;
1031 }
1032 wled->ctrl_addr = be32_to_cpu(*prop_addr);
1033
1034 rc = of_property_read_string(dev->of_node, "label", &wled->name);
1035 if (rc)
1036 wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node);
1037
1038 switch (version) {
1039 case 3:
1040 u32_opts = wled3_opts;
1041 size = ARRAY_SIZE(wled3_opts);
1042 *cfg = wled3_config_defaults;
1043 wled->wled_set_brightness = wled3_set_brightness;
1044 wled->max_string_count = 3;
1045 wled->sink_addr = wled->ctrl_addr;
1046 break;
1047
1048 case 4:
1049 u32_opts = wled4_opts;
1050 size = ARRAY_SIZE(wled4_opts);
1051 *cfg = wled4_config_defaults;
1052 wled->wled_set_brightness = wled4_set_brightness;
1053 wled->max_string_count = 4;
1054
1055 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1056 if (!prop_addr) {
1057 dev_err(wled->dev, "invalid IO resources\n");
1058 return -EINVAL;
1059 }
1060 wled->sink_addr = be32_to_cpu(*prop_addr);
1061 break;
1062
1063 default:
1064 dev_err(wled->dev, "Invalid WLED version\n");
1065 return -EINVAL;
1066 }
1067
1068 for (i = 0; i < size; ++i) {
1069 rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
1070 if (rc == -EINVAL) {
1071 continue;
1072 } else if (rc) {
1073 dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
1074 return rc;
1075 }
1076
1077 c = UINT_MAX;
1078 for (j = 0; c != val; j++) {
1079 c = wled_values(u32_opts[i].cfg, j);
1080 if (c == UINT_MAX) {
1081 dev_err(dev, "invalid value for '%s'\n",
1082 u32_opts[i].name);
1083 return -EINVAL;
1084 }
1085
1086 if (c == val)
1087 break;
1088 }
1089
1090 dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
1091 *u32_opts[i].val_ptr = j;
1092 }
1093
1094 for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
1095 if (of_property_read_bool(dev->of_node, bool_opts[i].name))
1096 *bool_opts[i].val_ptr = true;
1097 }
1098
1099 cfg->num_strings = cfg->num_strings + 1;
1100
1101 string_len = of_property_count_elems_of_size(dev->of_node,
1102 "qcom,enabled-strings",
1103 sizeof(u32));
1104 if (string_len > 0)
1105 of_property_read_u32_array(dev->of_node,
1106 "qcom,enabled-strings",
1107 wled->cfg.enabled_strings,
1108 sizeof(u32));
1109
1110 return 0;
1111 }
1112
1113 static int wled_configure_short_irq(struct wled *wled,
1114 struct platform_device *pdev)
1115 {
1116 int rc;
1117
1118 if (!wled->has_short_detect)
1119 return 0;
1120
1121 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1122 WLED4_CTRL_REG_SHORT_PROTECT,
1123 WLED4_CTRL_REG_SHORT_EN_MASK,
1124 WLED4_CTRL_REG_SHORT_EN_MASK);
1125 if (rc < 0)
1126 return rc;
1127
1128 wled->short_irq = platform_get_irq_byname(pdev, "short");
1129 if (wled->short_irq < 0) {
1130 dev_dbg(&pdev->dev, "short irq is not used\n");
1131 return 0;
1132 }
1133
1134 rc = devm_request_threaded_irq(wled->dev, wled->short_irq,
1135 NULL, wled_short_irq_handler,
1136 IRQF_ONESHOT,
1137 "wled_short_irq", wled);
1138 if (rc < 0)
1139 dev_err(wled->dev, "Unable to request short_irq (err:%d)\n",
1140 rc);
1141
1142 return rc;
1143 }
1144
1145 static int wled_configure_ovp_irq(struct wled *wled,
1146 struct platform_device *pdev)
1147 {
1148 int rc;
1149 u32 val;
1150
1151 wled->ovp_irq = platform_get_irq_byname(pdev, "ovp");
1152 if (wled->ovp_irq < 0) {
1153 dev_dbg(&pdev->dev, "OVP IRQ not found - disabling automatic string detection\n");
1154 return 0;
1155 }
1156
1157 rc = devm_request_threaded_irq(wled->dev, wled->ovp_irq, NULL,
1158 wled_ovp_irq_handler, IRQF_ONESHOT,
1159 "wled_ovp_irq", wled);
1160 if (rc < 0) {
1161 dev_err(wled->dev, "Unable to request ovp_irq (err:%d)\n",
1162 rc);
1163 wled->ovp_irq = 0;
1164 return 0;
1165 }
1166
1167 rc = regmap_read(wled->regmap, wled->ctrl_addr +
1168 WLED3_CTRL_REG_MOD_EN, &val);
1169 if (rc < 0)
1170 return rc;
1171
1172 /* Keep OVP irq disabled until module is enabled */
1173 if (!(val & WLED3_CTRL_REG_MOD_EN_MASK))
1174 disable_irq(wled->ovp_irq);
1175
1176 return 0;
1177 }
1178
1179 static const struct backlight_ops wled_ops = {
1180 .update_status = wled_update_status,
1181 };
1182
1183 static int wled_probe(struct platform_device *pdev)
1184 {
1185 struct backlight_properties props;
1186 struct backlight_device *bl;
1187 struct wled *wled;
1188 struct regmap *regmap;
1189 int version;
1190 u32 val;
1191 int rc;
1192
1193 regmap = dev_get_regmap(pdev->dev.parent, NULL);
1194 if (!regmap) {
1195 dev_err(&pdev->dev, "Unable to get regmap\n");
1196 return -EINVAL;
1197 }
1198
1199 wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL);
1200 if (!wled)
1201 return -ENOMEM;
1202
1203 wled->regmap = regmap;
1204 wled->dev = &pdev->dev;
1205
1206 version = (uintptr_t)of_device_get_match_data(&pdev->dev);
1207 if (!version) {
1208 dev_err(&pdev->dev, "Unknown device version\n");
1209 return -ENODEV;
1210 }
1211
1212 mutex_init(&wled->lock);
1213 rc = wled_configure(wled, version);
1214 if (rc)
1215 return rc;
1216
1217 switch (version) {
1218 case 3:
1219 wled->cfg.auto_detection_enabled = false;
1220 rc = wled3_setup(wled);
1221 if (rc) {
1222 dev_err(&pdev->dev, "wled3_setup failed\n");
1223 return rc;
1224 }
1225 break;
1226
1227 case 4:
1228 wled->has_short_detect = true;
1229 rc = wled4_setup(wled);
1230 if (rc) {
1231 dev_err(&pdev->dev, "wled4_setup failed\n");
1232 return rc;
1233 }
1234 break;
1235
1236 default:
1237 dev_err(wled->dev, "Invalid WLED version\n");
1238 break;
1239 }
1240
1241 INIT_DELAYED_WORK(&wled->ovp_work, wled_ovp_work);
1242
1243 rc = wled_configure_short_irq(wled, pdev);
1244 if (rc < 0)
1245 return rc;
1246
1247 rc = wled_configure_ovp_irq(wled, pdev);
1248 if (rc < 0)
1249 return rc;
1250
1251 val = WLED_DEFAULT_BRIGHTNESS;
1252 of_property_read_u32(pdev->dev.of_node, "default-brightness", &val);
1253
1254 memset(&props, 0, sizeof(struct backlight_properties));
1255 props.type = BACKLIGHT_RAW;
1256 props.brightness = val;
1257 props.max_brightness = WLED3_SINK_REG_BRIGHT_MAX;
1258 bl = devm_backlight_device_register(&pdev->dev, wled->name,
1259 &pdev->dev, wled,
1260 &wled_ops, &props);
1261 return PTR_ERR_OR_ZERO(bl);
1262 };
1263
1264 static int wled_remove(struct platform_device *pdev)
1265 {
1266 struct wled *wled = dev_get_drvdata(&pdev->dev);
1267
1268 mutex_destroy(&wled->lock);
1269 cancel_delayed_work_sync(&wled->ovp_work);
1270 disable_irq(wled->short_irq);
1271 disable_irq(wled->ovp_irq);
1272
1273 return 0;
1274 }
1275
1276 static const struct of_device_id wled_match_table[] = {
1277 { .compatible = "qcom,pm8941-wled", .data = (void *)3 },
1278 { .compatible = "qcom,pmi8998-wled", .data = (void *)4 },
1279 { .compatible = "qcom,pm660l-wled", .data = (void *)4 },
1280 {}
1281 };
1282 MODULE_DEVICE_TABLE(of, wled_match_table);
1283
1284 static struct platform_driver wled_driver = {
1285 .probe = wled_probe,
1286 .remove = wled_remove,
1287 .driver = {
1288 .name = "qcom,wled",
1289 .of_match_table = wled_match_table,
1290 },
1291 };
1292
1293 module_platform_driver(wled_driver);
1294
1295 MODULE_DESCRIPTION("Qualcomm WLED driver");
1296 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support