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 #define MOD_A 0
19 #define MOD_B 1
20
21 #define WLED_DEFAULT_BRIGHTNESS 2048
22 #define WLED_SOFT_START_DLY_US 10000
23 #define WLED3_SINK_REG_BRIGHT_MAX 0xFFF
24 #define WLED5_SINK_REG_BRIGHT_MAX_12B 0xFFF
25 #define WLED5_SINK_REG_BRIGHT_MAX_15B 0x7FFF
26
27 /* WLED3/WLED4 control registers */
28 #define WLED3_CTRL_REG_FAULT_STATUS 0x08
29 #define WLED3_CTRL_REG_ILIM_FAULT_BIT BIT(0)
30 #define WLED3_CTRL_REG_OVP_FAULT_BIT BIT(1)
31 #define WLED4_CTRL_REG_SC_FAULT_BIT BIT(2)
32 #define WLED5_CTRL_REG_OVP_PRE_ALARM_BIT BIT(4)
33
34 #define WLED3_CTRL_REG_INT_RT_STS 0x10
35 #define WLED3_CTRL_REG_OVP_FAULT_STATUS BIT(1)
36
37 #define WLED3_CTRL_REG_MOD_EN 0x46
38 #define WLED3_CTRL_REG_MOD_EN_MASK BIT(7)
39 #define WLED3_CTRL_REG_MOD_EN_SHIFT 7
40
41 #define WLED3_CTRL_REG_FEEDBACK_CONTROL 0x48
42
43 #define WLED3_CTRL_REG_FREQ 0x4c
44 #define WLED3_CTRL_REG_FREQ_MASK GENMASK(3, 0)
45
46 #define WLED3_CTRL_REG_OVP 0x4d
47 #define WLED3_CTRL_REG_OVP_MASK GENMASK(1, 0)
48 #define WLED5_CTRL_REG_OVP_MASK GENMASK(3, 0)
49
50 #define WLED3_CTRL_REG_ILIMIT 0x4e
51 #define WLED3_CTRL_REG_ILIMIT_MASK GENMASK(2, 0)
52
53 /* WLED3/WLED4 sink registers */
54 #define WLED3_SINK_REG_SYNC 0x47
55 #define WLED3_SINK_REG_SYNC_CLEAR 0x00
56
57 #define WLED3_SINK_REG_CURR_SINK 0x4f
58 #define WLED3_SINK_REG_CURR_SINK_MASK GENMASK(7, 5)
59 #define WLED3_SINK_REG_CURR_SINK_SHFT 5
60
61 /* WLED3 specific per-'string' registers below */
62 #define WLED3_SINK_REG_BRIGHT(n) (0x40 + n)
63
64 #define WLED3_SINK_REG_STR_MOD_EN(n) (0x60 + (n * 0x10))
65 #define WLED3_SINK_REG_STR_MOD_MASK BIT(7)
66
67 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR(n) (0x62 + (n * 0x10))
68 #define WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(4, 0)
69
70 #define WLED3_SINK_REG_STR_MOD_SRC(n) (0x63 + (n * 0x10))
71 #define WLED3_SINK_REG_STR_MOD_SRC_MASK BIT(0)
72 #define WLED3_SINK_REG_STR_MOD_SRC_INT 0x00
73 #define WLED3_SINK_REG_STR_MOD_SRC_EXT 0x01
74
75 #define WLED3_SINK_REG_STR_CABC(n) (0x66 + (n * 0x10))
76 #define WLED3_SINK_REG_STR_CABC_MASK BIT(7)
77
78 /* WLED4 specific control registers */
79 #define WLED4_CTRL_REG_SHORT_PROTECT 0x5e
80 #define WLED4_CTRL_REG_SHORT_EN_MASK BIT(7)
81
82 #define WLED4_CTRL_REG_SEC_ACCESS 0xd0
83 #define WLED4_CTRL_REG_SEC_UNLOCK 0xa5
84
85 #define WLED4_CTRL_REG_TEST1 0xe2
86 #define WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2 0x09
87
88 /* WLED4 specific sink registers */
89 #define WLED4_SINK_REG_CURR_SINK 0x46
90 #define WLED4_SINK_REG_CURR_SINK_MASK GENMASK(7, 4)
91 #define WLED4_SINK_REG_CURR_SINK_SHFT 4
92
93 /* WLED4 specific per-'string' registers below */
94 #define WLED4_SINK_REG_STR_MOD_EN(n) (0x50 + (n * 0x10))
95 #define WLED4_SINK_REG_STR_MOD_MASK BIT(7)
96
97 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR(n) (0x52 + (n * 0x10))
98 #define WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK GENMASK(3, 0)
99
100 #define WLED4_SINK_REG_STR_MOD_SRC(n) (0x53 + (n * 0x10))
101 #define WLED4_SINK_REG_STR_MOD_SRC_MASK BIT(0)
102 #define WLED4_SINK_REG_STR_MOD_SRC_INT 0x00
103 #define WLED4_SINK_REG_STR_MOD_SRC_EXT 0x01
104
105 #define WLED4_SINK_REG_STR_CABC(n) (0x56 + (n * 0x10))
106 #define WLED4_SINK_REG_STR_CABC_MASK BIT(7)
107
108 #define WLED4_SINK_REG_BRIGHT(n) (0x57 + (n * 0x10))
109
110 /* WLED5 specific control registers */
111 #define WLED5_CTRL_REG_OVP_INT_CTL 0x5f
112 #define WLED5_CTRL_REG_OVP_INT_TIMER_MASK GENMASK(2, 0)
113
114 /* WLED5 specific sink registers */
115 #define WLED5_SINK_REG_MOD_A_EN 0x50
116 #define WLED5_SINK_REG_MOD_B_EN 0x60
117 #define WLED5_SINK_REG_MOD_EN_MASK BIT(7)
118
119 #define WLED5_SINK_REG_MOD_A_SRC_SEL 0x51
120 #define WLED5_SINK_REG_MOD_B_SRC_SEL 0x61
121 #define WLED5_SINK_REG_MOD_SRC_SEL_HIGH 0
122 #define WLED5_SINK_REG_MOD_SRC_SEL_EXT 0x03
123 #define WLED5_SINK_REG_MOD_SRC_SEL_MASK GENMASK(1, 0)
124
125 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL 0x52
126 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL 0x62
127 #define WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B 0
128 #define WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B 1
129
130 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB 0x53
131 #define WLED5_SINK_REG_MOD_A_BRIGHTNESS_MSB 0x54
132 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB 0x63
133 #define WLED5_SINK_REG_MOD_B_BRIGHTNESS_MSB 0x64
134
135 #define WLED5_SINK_REG_MOD_SYNC_BIT 0x65
136 #define WLED5_SINK_REG_SYNC_MOD_A_BIT BIT(0)
137 #define WLED5_SINK_REG_SYNC_MOD_B_BIT BIT(1)
138 #define WLED5_SINK_REG_SYNC_MASK GENMASK(1, 0)
139
140 /* WLED5 specific per-'string' registers below */
141 #define WLED5_SINK_REG_STR_FULL_SCALE_CURR(n) (0x72 + (n * 0x10))
142
143 #define WLED5_SINK_REG_STR_SRC_SEL(n) (0x73 + (n * 0x10))
144 #define WLED5_SINK_REG_SRC_SEL_MOD_A 0
145 #define WLED5_SINK_REG_SRC_SEL_MOD_B 1
146 #define WLED5_SINK_REG_SRC_SEL_MASK GENMASK(1, 0)
147
148 struct wled_var_cfg {
149 const u32 *values;
150 u32 (*fn)(u32);
151 int size;
152 };
153
154 struct wled_u32_opts {
155 const char *name;
156 u32 *val_ptr;
157 const struct wled_var_cfg *cfg;
158 };
159
160 struct wled_bool_opts {
161 const char *name;
162 bool *val_ptr;
163 };
164
165 struct wled_config {
166 u32 boost_i_limit;
167 u32 ovp;
168 u32 switch_freq;
169 u32 num_strings;
170 u32 string_i_limit;
171 u32 enabled_strings[WLED_MAX_STRINGS];
172 u32 mod_sel;
173 u32 cabc_sel;
174 bool cs_out_en;
175 bool ext_gen;
176 bool cabc;
177 bool external_pfet;
178 bool auto_detection_enabled;
179 };
180
181 struct wled {
182 const char *name;
183 struct device *dev;
184 struct regmap *regmap;
185 struct mutex lock; /* Lock to avoid race from thread irq handler */
186 ktime_t last_short_event;
187 ktime_t start_ovp_fault_time;
188 u16 ctrl_addr;
189 u16 sink_addr;
190 u16 max_string_count;
191 u16 auto_detection_ovp_count;
192 u32 brightness;
193 u32 max_brightness;
194 u32 short_count;
195 u32 auto_detect_count;
196 u32 version;
197 bool disabled_by_short;
198 bool has_short_detect;
199 bool cabc_disabled;
200 int short_irq;
201 int ovp_irq;
202
203 struct wled_config cfg;
204 struct delayed_work ovp_work;
205
206 /* Configures the brightness. Applicable for wled3, wled4 and wled5 */
207 int (*wled_set_brightness)(struct wled *wled, u16 brightness);
208
209 /* Configures the cabc register. Applicable for wled4 and wled5 */
210 int (*wled_cabc_config)(struct wled *wled, bool enable);
211
212 /*
213 * Toggles the sync bit for the brightness update to take place.
214 * Applicable for WLED3, WLED4 and WLED5.
215 */
216 int (*wled_sync_toggle)(struct wled *wled);
217
218 /*
219 * Time to wait before checking the OVP status after wled module enable.
220 * Applicable for WLED4 and WLED5.
221 */
222 int (*wled_ovp_delay)(struct wled *wled);
223
224 /*
225 * Determines if the auto string detection is required.
226 * Applicable for WLED4 and WLED5
227 */
228 bool (*wled_auto_detection_required)(struct wled *wled);
229 };
230
wled3_set_brightness(struct wled * wled,u16 brightness)231 static int wled3_set_brightness(struct wled *wled, u16 brightness)
232 {
233 int rc, i;
234 u8 v[2];
235
236 v[0] = brightness & 0xff;
237 v[1] = (brightness >> 8) & 0xf;
238
239 for (i = 0; i < wled->cfg.num_strings; ++i) {
240 rc = regmap_bulk_write(wled->regmap, wled->ctrl_addr +
241 WLED3_SINK_REG_BRIGHT(i), v, 2);
242 if (rc < 0)
243 return rc;
244 }
245
246 return 0;
247 }
248
wled4_set_brightness(struct wled * wled,u16 brightness)249 static int wled4_set_brightness(struct wled *wled, u16 brightness)
250 {
251 int rc, i;
252 u16 low_limit = wled->max_brightness * 4 / 1000;
253 u8 v[2];
254
255 /* WLED4's lower limit of operation is 0.4% */
256 if (brightness > 0 && brightness < low_limit)
257 brightness = low_limit;
258
259 v[0] = brightness & 0xff;
260 v[1] = (brightness >> 8) & 0xf;
261
262 for (i = 0; i < wled->cfg.num_strings; ++i) {
263 rc = regmap_bulk_write(wled->regmap, wled->sink_addr +
264 WLED4_SINK_REG_BRIGHT(i), v, 2);
265 if (rc < 0)
266 return rc;
267 }
268
269 return 0;
270 }
271
wled5_set_brightness(struct wled * wled,u16 brightness)272 static int wled5_set_brightness(struct wled *wled, u16 brightness)
273 {
274 int rc, offset;
275 u16 low_limit = wled->max_brightness * 1 / 1000;
276 u8 v[2];
277
278 /* WLED5's lower limit is 0.1% */
279 if (brightness < low_limit)
280 brightness = low_limit;
281
282 v[0] = brightness & 0xff;
283 v[1] = (brightness >> 8) & 0x7f;
284
285 offset = (wled->cfg.mod_sel == MOD_A) ?
286 WLED5_SINK_REG_MOD_A_BRIGHTNESS_LSB :
287 WLED5_SINK_REG_MOD_B_BRIGHTNESS_LSB;
288
289 rc = regmap_bulk_write(wled->regmap, wled->sink_addr + offset,
290 v, 2);
291 return rc;
292 }
293
wled_ovp_work(struct work_struct * work)294 static void wled_ovp_work(struct work_struct *work)
295 {
296 struct wled *wled = container_of(work,
297 struct wled, ovp_work.work);
298 enable_irq(wled->ovp_irq);
299 }
300
wled_module_enable(struct wled * wled,int val)301 static int wled_module_enable(struct wled *wled, int val)
302 {
303 int rc;
304
305 if (wled->disabled_by_short)
306 return -ENXIO;
307
308 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
309 WLED3_CTRL_REG_MOD_EN,
310 WLED3_CTRL_REG_MOD_EN_MASK,
311 val << WLED3_CTRL_REG_MOD_EN_SHIFT);
312 if (rc < 0)
313 return rc;
314
315 if (wled->ovp_irq > 0) {
316 if (val) {
317 /*
318 * The hardware generates a storm of spurious OVP
319 * interrupts during soft start operations. So defer
320 * enabling the IRQ for 10ms to ensure that the
321 * soft start is complete.
322 */
323 schedule_delayed_work(&wled->ovp_work, HZ / 100);
324 } else {
325 if (!cancel_delayed_work_sync(&wled->ovp_work))
326 disable_irq(wled->ovp_irq);
327 }
328 }
329
330 return 0;
331 }
332
wled3_sync_toggle(struct wled * wled)333 static int wled3_sync_toggle(struct wled *wled)
334 {
335 int rc;
336 unsigned int mask = GENMASK(wled->max_string_count - 1, 0);
337
338 rc = regmap_update_bits(wled->regmap,
339 wled->sink_addr + WLED3_SINK_REG_SYNC,
340 mask, WLED3_SINK_REG_SYNC_CLEAR);
341 if (rc < 0)
342 return rc;
343
344 rc = regmap_update_bits(wled->regmap,
345 wled->sink_addr + WLED3_SINK_REG_SYNC,
346 mask, mask);
347
348 return rc;
349 }
350
wled5_mod_sync_toggle(struct wled * wled)351 static int wled5_mod_sync_toggle(struct wled *wled)
352 {
353 int rc;
354 u8 val;
355
356 rc = regmap_update_bits(wled->regmap,
357 wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
358 WLED5_SINK_REG_SYNC_MASK, 0);
359 if (rc < 0)
360 return rc;
361
362 val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_SYNC_MOD_A_BIT :
363 WLED5_SINK_REG_SYNC_MOD_B_BIT;
364 return regmap_update_bits(wled->regmap,
365 wled->sink_addr + WLED5_SINK_REG_MOD_SYNC_BIT,
366 WLED5_SINK_REG_SYNC_MASK, val);
367 }
368
wled_ovp_fault_status(struct wled * wled,bool * fault_set)369 static int wled_ovp_fault_status(struct wled *wled, bool *fault_set)
370 {
371 int rc;
372 u32 int_rt_sts, fault_sts;
373
374 *fault_set = false;
375 rc = regmap_read(wled->regmap,
376 wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS,
377 &int_rt_sts);
378 if (rc < 0) {
379 dev_err(wled->dev, "Failed to read INT_RT_STS rc=%d\n", rc);
380 return rc;
381 }
382
383 rc = regmap_read(wled->regmap,
384 wled->ctrl_addr + WLED3_CTRL_REG_FAULT_STATUS,
385 &fault_sts);
386 if (rc < 0) {
387 dev_err(wled->dev, "Failed to read FAULT_STATUS rc=%d\n", rc);
388 return rc;
389 }
390
391 if (int_rt_sts & WLED3_CTRL_REG_OVP_FAULT_STATUS)
392 *fault_set = true;
393
394 if (wled->version == 4 && (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT))
395 *fault_set = true;
396
397 if (wled->version == 5 && (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
398 WLED5_CTRL_REG_OVP_PRE_ALARM_BIT)))
399 *fault_set = true;
400
401 if (*fault_set)
402 dev_dbg(wled->dev, "WLED OVP fault detected, int_rt_sts=0x%x fault_sts=0x%x\n",
403 int_rt_sts, fault_sts);
404
405 return rc;
406 }
407
wled4_ovp_delay(struct wled * wled)408 static int wled4_ovp_delay(struct wled *wled)
409 {
410 return WLED_SOFT_START_DLY_US;
411 }
412
wled5_ovp_delay(struct wled * wled)413 static int wled5_ovp_delay(struct wled *wled)
414 {
415 int rc, delay_us;
416 u32 val;
417 u8 ovp_timer_ms[8] = {1, 2, 4, 8, 12, 16, 20, 24};
418
419 /* For WLED5, get the delay based on OVP timer */
420 rc = regmap_read(wled->regmap, wled->ctrl_addr +
421 WLED5_CTRL_REG_OVP_INT_CTL, &val);
422 if (rc < 0)
423 delay_us =
424 ovp_timer_ms[val & WLED5_CTRL_REG_OVP_INT_TIMER_MASK] * 1000;
425 else
426 delay_us = 2 * WLED_SOFT_START_DLY_US;
427
428 dev_dbg(wled->dev, "delay_time_us: %d\n", delay_us);
429
430 return delay_us;
431 }
432
wled_update_status(struct backlight_device * bl)433 static int wled_update_status(struct backlight_device *bl)
434 {
435 struct wled *wled = bl_get_data(bl);
436 u16 brightness = backlight_get_brightness(bl);
437 int rc = 0;
438
439 mutex_lock(&wled->lock);
440 if (brightness) {
441 rc = wled->wled_set_brightness(wled, brightness);
442 if (rc < 0) {
443 dev_err(wled->dev, "wled failed to set brightness rc:%d\n",
444 rc);
445 goto unlock_mutex;
446 }
447
448 if (wled->version < 5) {
449 rc = wled->wled_sync_toggle(wled);
450 if (rc < 0) {
451 dev_err(wled->dev, "wled sync failed rc:%d\n", rc);
452 goto unlock_mutex;
453 }
454 } else {
455 /*
456 * For WLED5 toggling the MOD_SYNC_BIT updates the
457 * brightness
458 */
459 rc = wled5_mod_sync_toggle(wled);
460 if (rc < 0) {
461 dev_err(wled->dev, "wled mod sync failed rc:%d\n",
462 rc);
463 goto unlock_mutex;
464 }
465 }
466 }
467
468 if (!!brightness != !!wled->brightness) {
469 rc = wled_module_enable(wled, !!brightness);
470 if (rc < 0) {
471 dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
472 goto unlock_mutex;
473 }
474 }
475
476 wled->brightness = brightness;
477
478 unlock_mutex:
479 mutex_unlock(&wled->lock);
480
481 return rc;
482 }
483
wled4_cabc_config(struct wled * wled,bool enable)484 static int wled4_cabc_config(struct wled *wled, bool enable)
485 {
486 int i, j, rc;
487 u8 val;
488
489 for (i = 0; i < wled->cfg.num_strings; i++) {
490 j = wled->cfg.enabled_strings[i];
491
492 val = enable ? WLED4_SINK_REG_STR_CABC_MASK : 0;
493 rc = regmap_update_bits(wled->regmap, wled->sink_addr +
494 WLED4_SINK_REG_STR_CABC(j),
495 WLED4_SINK_REG_STR_CABC_MASK, val);
496 if (rc < 0)
497 return rc;
498 }
499
500 return 0;
501 }
502
wled5_cabc_config(struct wled * wled,bool enable)503 static int wled5_cabc_config(struct wled *wled, bool enable)
504 {
505 int rc, offset;
506 u8 reg;
507
508 if (wled->cabc_disabled)
509 return 0;
510
511 reg = enable ? wled->cfg.cabc_sel : 0;
512 offset = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_A_SRC_SEL :
513 WLED5_SINK_REG_MOD_B_SRC_SEL;
514
515 rc = regmap_update_bits(wled->regmap, wled->sink_addr + offset,
516 WLED5_SINK_REG_MOD_SRC_SEL_MASK, reg);
517 if (rc < 0) {
518 pr_err("Error in configuring CABC rc=%d\n", rc);
519 return rc;
520 }
521
522 if (!wled->cfg.cabc_sel)
523 wled->cabc_disabled = true;
524
525 return 0;
526 }
527
528 #define WLED_SHORT_DLY_MS 20
529 #define WLED_SHORT_CNT_MAX 5
530 #define WLED_SHORT_RESET_CNT_DLY_US USEC_PER_SEC
531
wled_short_irq_handler(int irq,void * _wled)532 static irqreturn_t wled_short_irq_handler(int irq, void *_wled)
533 {
534 struct wled *wled = _wled;
535 int rc;
536 s64 elapsed_time;
537
538 wled->short_count++;
539 mutex_lock(&wled->lock);
540 rc = wled_module_enable(wled, false);
541 if (rc < 0) {
542 dev_err(wled->dev, "wled disable failed rc:%d\n", rc);
543 goto unlock_mutex;
544 }
545
546 elapsed_time = ktime_us_delta(ktime_get(),
547 wled->last_short_event);
548 if (elapsed_time > WLED_SHORT_RESET_CNT_DLY_US)
549 wled->short_count = 1;
550
551 if (wled->short_count > WLED_SHORT_CNT_MAX) {
552 dev_err(wled->dev, "Short triggered %d times, disabling WLED forever!\n",
553 wled->short_count);
554 wled->disabled_by_short = true;
555 goto unlock_mutex;
556 }
557
558 wled->last_short_event = ktime_get();
559
560 msleep(WLED_SHORT_DLY_MS);
561 rc = wled_module_enable(wled, true);
562 if (rc < 0)
563 dev_err(wled->dev, "wled enable failed rc:%d\n", rc);
564
565 unlock_mutex:
566 mutex_unlock(&wled->lock);
567
568 return IRQ_HANDLED;
569 }
570
571 #define AUTO_DETECT_BRIGHTNESS 200
572
wled_auto_string_detection(struct wled * wled)573 static void wled_auto_string_detection(struct wled *wled)
574 {
575 int rc = 0, i, delay_time_us;
576 u32 sink_config = 0;
577 u8 sink_test = 0, sink_valid = 0, val;
578 bool fault_set;
579
580 /* Read configured sink configuration */
581 rc = regmap_read(wled->regmap, wled->sink_addr +
582 WLED4_SINK_REG_CURR_SINK, &sink_config);
583 if (rc < 0) {
584 dev_err(wled->dev, "Failed to read SINK configuration rc=%d\n",
585 rc);
586 goto failed_detect;
587 }
588
589 /* Disable the module before starting detection */
590 rc = regmap_update_bits(wled->regmap,
591 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
592 WLED3_CTRL_REG_MOD_EN_MASK, 0);
593 if (rc < 0) {
594 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n", rc);
595 goto failed_detect;
596 }
597
598 /* Set low brightness across all sinks */
599 rc = wled4_set_brightness(wled, AUTO_DETECT_BRIGHTNESS);
600 if (rc < 0) {
601 dev_err(wled->dev, "Failed to set brightness for auto detection rc=%d\n",
602 rc);
603 goto failed_detect;
604 }
605
606 if (wled->cfg.cabc) {
607 rc = wled->wled_cabc_config(wled, false);
608 if (rc < 0)
609 goto failed_detect;
610 }
611
612 /* Disable all sinks */
613 rc = regmap_write(wled->regmap,
614 wled->sink_addr + WLED4_SINK_REG_CURR_SINK, 0);
615 if (rc < 0) {
616 dev_err(wled->dev, "Failed to disable all sinks rc=%d\n", rc);
617 goto failed_detect;
618 }
619
620 /* Iterate through the strings one by one */
621 for (i = 0; i < wled->cfg.num_strings; i++) {
622 sink_test = BIT((WLED4_SINK_REG_CURR_SINK_SHFT + i));
623
624 /* Enable feedback control */
625 rc = regmap_write(wled->regmap, wled->ctrl_addr +
626 WLED3_CTRL_REG_FEEDBACK_CONTROL, i + 1);
627 if (rc < 0) {
628 dev_err(wled->dev, "Failed to enable feedback for SINK %d rc = %d\n",
629 i + 1, rc);
630 goto failed_detect;
631 }
632
633 /* Enable the sink */
634 rc = regmap_write(wled->regmap, wled->sink_addr +
635 WLED4_SINK_REG_CURR_SINK, sink_test);
636 if (rc < 0) {
637 dev_err(wled->dev, "Failed to configure SINK %d rc=%d\n",
638 i + 1, rc);
639 goto failed_detect;
640 }
641
642 /* Enable the module */
643 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
644 WLED3_CTRL_REG_MOD_EN,
645 WLED3_CTRL_REG_MOD_EN_MASK,
646 WLED3_CTRL_REG_MOD_EN_MASK);
647 if (rc < 0) {
648 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n",
649 rc);
650 goto failed_detect;
651 }
652
653 delay_time_us = wled->wled_ovp_delay(wled);
654 usleep_range(delay_time_us, delay_time_us + 1000);
655
656 rc = wled_ovp_fault_status(wled, &fault_set);
657 if (rc < 0) {
658 dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n",
659 rc);
660 goto failed_detect;
661 }
662
663 if (fault_set)
664 dev_dbg(wled->dev, "WLED OVP fault detected with SINK %d\n",
665 i + 1);
666 else
667 sink_valid |= sink_test;
668
669 /* Disable the module */
670 rc = regmap_update_bits(wled->regmap,
671 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
672 WLED3_CTRL_REG_MOD_EN_MASK, 0);
673 if (rc < 0) {
674 dev_err(wled->dev, "Failed to disable WLED module rc=%d\n",
675 rc);
676 goto failed_detect;
677 }
678 }
679
680 if (!sink_valid) {
681 dev_err(wled->dev, "No valid WLED sinks found\n");
682 wled->disabled_by_short = true;
683 goto failed_detect;
684 }
685
686 if (sink_valid != sink_config) {
687 dev_warn(wled->dev, "%x is not a valid sink configuration - using %x instead\n",
688 sink_config, sink_valid);
689 sink_config = sink_valid;
690 }
691
692 /* Write the new sink configuration */
693 rc = regmap_write(wled->regmap,
694 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
695 sink_config);
696 if (rc < 0) {
697 dev_err(wled->dev, "Failed to reconfigure the default sink rc=%d\n",
698 rc);
699 goto failed_detect;
700 }
701
702 /* Enable valid sinks */
703 if (wled->version == 4) {
704 for (i = 0; i < wled->cfg.num_strings; i++) {
705 if (sink_config &
706 BIT(WLED4_SINK_REG_CURR_SINK_SHFT + i))
707 val = WLED4_SINK_REG_STR_MOD_MASK;
708 else
709 /* Disable modulator_en for unused sink */
710 val = 0;
711
712 rc = regmap_write(wled->regmap, wled->sink_addr +
713 WLED4_SINK_REG_STR_MOD_EN(i), val);
714 if (rc < 0) {
715 dev_err(wled->dev, "Failed to configure MODULATOR_EN rc=%d\n",
716 rc);
717 goto failed_detect;
718 }
719 }
720 }
721
722 /* Enable CABC */
723 rc = wled->wled_cabc_config(wled, true);
724 if (rc < 0)
725 goto failed_detect;
726
727 /* Restore the feedback setting */
728 rc = regmap_write(wled->regmap,
729 wled->ctrl_addr + WLED3_CTRL_REG_FEEDBACK_CONTROL, 0);
730 if (rc < 0) {
731 dev_err(wled->dev, "Failed to restore feedback setting rc=%d\n",
732 rc);
733 goto failed_detect;
734 }
735
736 /* Restore brightness */
737 rc = wled4_set_brightness(wled, wled->brightness);
738 if (rc < 0) {
739 dev_err(wled->dev, "Failed to set brightness after auto detection rc=%d\n",
740 rc);
741 goto failed_detect;
742 }
743
744 rc = regmap_update_bits(wled->regmap,
745 wled->ctrl_addr + WLED3_CTRL_REG_MOD_EN,
746 WLED3_CTRL_REG_MOD_EN_MASK,
747 WLED3_CTRL_REG_MOD_EN_MASK);
748 if (rc < 0) {
749 dev_err(wled->dev, "Failed to enable WLED module rc=%d\n", rc);
750 goto failed_detect;
751 }
752
753 failed_detect:
754 return;
755 }
756
757 #define WLED_AUTO_DETECT_OVP_COUNT 5
758 #define WLED_AUTO_DETECT_CNT_DLY_US USEC_PER_SEC
759
wled4_auto_detection_required(struct wled * wled)760 static bool wled4_auto_detection_required(struct wled *wled)
761 {
762 s64 elapsed_time_us;
763
764 if (!wled->cfg.auto_detection_enabled)
765 return false;
766
767 /*
768 * Check if the OVP fault was an occasional one
769 * or if it's firing continuously, the latter qualifies
770 * for an auto-detection check.
771 */
772 if (!wled->auto_detection_ovp_count) {
773 wled->start_ovp_fault_time = ktime_get();
774 wled->auto_detection_ovp_count++;
775 } else {
776 elapsed_time_us = ktime_us_delta(ktime_get(),
777 wled->start_ovp_fault_time);
778 if (elapsed_time_us > WLED_AUTO_DETECT_CNT_DLY_US)
779 wled->auto_detection_ovp_count = 0;
780 else
781 wled->auto_detection_ovp_count++;
782
783 if (wled->auto_detection_ovp_count >=
784 WLED_AUTO_DETECT_OVP_COUNT) {
785 wled->auto_detection_ovp_count = 0;
786 return true;
787 }
788 }
789
790 return false;
791 }
792
wled5_auto_detection_required(struct wled * wled)793 static bool wled5_auto_detection_required(struct wled *wled)
794 {
795 if (!wled->cfg.auto_detection_enabled)
796 return false;
797
798 /*
799 * Unlike WLED4, WLED5 has OVP fault density interrupt configuration
800 * i.e. to count the number of OVP alarms for a certain duration before
801 * triggering OVP fault interrupt. By default, number of OVP fault
802 * events counted before an interrupt is fired is 32 and the time
803 * interval is 12 ms. If we see one OVP fault interrupt, then that
804 * should qualify for a real OVP fault condition to run auto detection
805 * algorithm.
806 */
807 return true;
808 }
809
wled_auto_detection_at_init(struct wled * wled)810 static int wled_auto_detection_at_init(struct wled *wled)
811 {
812 int rc;
813 bool fault_set;
814
815 if (!wled->cfg.auto_detection_enabled)
816 return 0;
817
818 rc = wled_ovp_fault_status(wled, &fault_set);
819 if (rc < 0) {
820 dev_err(wled->dev, "Error in getting OVP fault_sts, rc=%d\n",
821 rc);
822 return rc;
823 }
824
825 if (fault_set) {
826 mutex_lock(&wled->lock);
827 wled_auto_string_detection(wled);
828 mutex_unlock(&wled->lock);
829 }
830
831 return rc;
832 }
833
wled_ovp_irq_handler(int irq,void * _wled)834 static irqreturn_t wled_ovp_irq_handler(int irq, void *_wled)
835 {
836 struct wled *wled = _wled;
837 int rc;
838 u32 int_sts, fault_sts;
839
840 rc = regmap_read(wled->regmap,
841 wled->ctrl_addr + WLED3_CTRL_REG_INT_RT_STS, &int_sts);
842 if (rc < 0) {
843 dev_err(wled->dev, "Error in reading WLED3_INT_RT_STS rc=%d\n",
844 rc);
845 return IRQ_HANDLED;
846 }
847
848 rc = regmap_read(wled->regmap, wled->ctrl_addr +
849 WLED3_CTRL_REG_FAULT_STATUS, &fault_sts);
850 if (rc < 0) {
851 dev_err(wled->dev, "Error in reading WLED_FAULT_STATUS rc=%d\n",
852 rc);
853 return IRQ_HANDLED;
854 }
855
856 if (fault_sts & (WLED3_CTRL_REG_OVP_FAULT_BIT |
857 WLED3_CTRL_REG_ILIM_FAULT_BIT))
858 dev_dbg(wled->dev, "WLED OVP fault detected, int_sts=%x fault_sts= %x\n",
859 int_sts, fault_sts);
860
861 if (fault_sts & WLED3_CTRL_REG_OVP_FAULT_BIT) {
862 if (wled->wled_auto_detection_required(wled)) {
863 mutex_lock(&wled->lock);
864 wled_auto_string_detection(wled);
865 mutex_unlock(&wled->lock);
866 }
867 }
868
869 return IRQ_HANDLED;
870 }
871
wled3_setup(struct wled * wled)872 static int wled3_setup(struct wled *wled)
873 {
874 u16 addr;
875 u8 sink_en = 0;
876 int rc, i, j;
877
878 rc = regmap_update_bits(wled->regmap,
879 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
880 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
881 if (rc)
882 return rc;
883
884 rc = regmap_update_bits(wled->regmap,
885 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
886 WLED3_CTRL_REG_ILIMIT_MASK,
887 wled->cfg.boost_i_limit);
888 if (rc)
889 return rc;
890
891 rc = regmap_update_bits(wled->regmap,
892 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
893 WLED3_CTRL_REG_FREQ_MASK,
894 wled->cfg.switch_freq);
895 if (rc)
896 return rc;
897
898 for (i = 0; i < wled->cfg.num_strings; ++i) {
899 j = wled->cfg.enabled_strings[i];
900 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_EN(j);
901 rc = regmap_update_bits(wled->regmap, addr,
902 WLED3_SINK_REG_STR_MOD_MASK,
903 WLED3_SINK_REG_STR_MOD_MASK);
904 if (rc)
905 return rc;
906
907 if (wled->cfg.ext_gen) {
908 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_MOD_SRC(j);
909 rc = regmap_update_bits(wled->regmap, addr,
910 WLED3_SINK_REG_STR_MOD_SRC_MASK,
911 WLED3_SINK_REG_STR_MOD_SRC_EXT);
912 if (rc)
913 return rc;
914 }
915
916 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_FULL_SCALE_CURR(j);
917 rc = regmap_update_bits(wled->regmap, addr,
918 WLED3_SINK_REG_STR_FULL_SCALE_CURR_MASK,
919 wled->cfg.string_i_limit);
920 if (rc)
921 return rc;
922
923 addr = wled->ctrl_addr + WLED3_SINK_REG_STR_CABC(j);
924 rc = regmap_update_bits(wled->regmap, addr,
925 WLED3_SINK_REG_STR_CABC_MASK,
926 wled->cfg.cabc ?
927 WLED3_SINK_REG_STR_CABC_MASK : 0);
928 if (rc)
929 return rc;
930
931 sink_en |= BIT(j + WLED3_SINK_REG_CURR_SINK_SHFT);
932 }
933
934 rc = regmap_update_bits(wled->regmap,
935 wled->ctrl_addr + WLED3_SINK_REG_CURR_SINK,
936 WLED3_SINK_REG_CURR_SINK_MASK, sink_en);
937 if (rc)
938 return rc;
939
940 return 0;
941 }
942
943 static const struct wled_config wled3_config_defaults = {
944 .boost_i_limit = 3,
945 .string_i_limit = 20,
946 .ovp = 2,
947 .num_strings = 3,
948 .switch_freq = 5,
949 .cs_out_en = false,
950 .ext_gen = false,
951 .cabc = false,
952 .enabled_strings = {0, 1, 2, 3},
953 };
954
wled4_setup(struct wled * wled)955 static int wled4_setup(struct wled *wled)
956 {
957 int rc, temp, i, j;
958 u16 addr;
959 u8 sink_en = 0;
960 u32 sink_cfg;
961
962 rc = regmap_update_bits(wled->regmap,
963 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
964 WLED3_CTRL_REG_OVP_MASK, wled->cfg.ovp);
965 if (rc < 0)
966 return rc;
967
968 rc = regmap_update_bits(wled->regmap,
969 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
970 WLED3_CTRL_REG_ILIMIT_MASK,
971 wled->cfg.boost_i_limit);
972 if (rc < 0)
973 return rc;
974
975 rc = regmap_update_bits(wled->regmap,
976 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
977 WLED3_CTRL_REG_FREQ_MASK,
978 wled->cfg.switch_freq);
979 if (rc < 0)
980 return rc;
981
982 if (wled->cfg.external_pfet) {
983 /* Unlock the secure register access */
984 rc = regmap_write(wled->regmap, wled->ctrl_addr +
985 WLED4_CTRL_REG_SEC_ACCESS,
986 WLED4_CTRL_REG_SEC_UNLOCK);
987 if (rc < 0)
988 return rc;
989
990 rc = regmap_write(wled->regmap,
991 wled->ctrl_addr + WLED4_CTRL_REG_TEST1,
992 WLED4_CTRL_REG_TEST1_EXT_FET_DTEST2);
993 if (rc < 0)
994 return rc;
995 }
996
997 rc = regmap_read(wled->regmap, wled->sink_addr +
998 WLED4_SINK_REG_CURR_SINK, &sink_cfg);
999 if (rc < 0)
1000 return rc;
1001
1002 for (i = 0; i < wled->cfg.num_strings; i++) {
1003 j = wled->cfg.enabled_strings[i];
1004 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
1005 sink_en |= 1 << temp;
1006 }
1007
1008 if (sink_cfg == sink_en) {
1009 rc = wled_auto_detection_at_init(wled);
1010 return rc;
1011 }
1012
1013 rc = regmap_update_bits(wled->regmap,
1014 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1015 WLED4_SINK_REG_CURR_SINK_MASK, 0);
1016 if (rc < 0)
1017 return rc;
1018
1019 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1020 WLED3_CTRL_REG_MOD_EN,
1021 WLED3_CTRL_REG_MOD_EN_MASK, 0);
1022 if (rc < 0)
1023 return rc;
1024
1025 /* Per sink/string configuration */
1026 for (i = 0; i < wled->cfg.num_strings; i++) {
1027 j = wled->cfg.enabled_strings[i];
1028
1029 addr = wled->sink_addr +
1030 WLED4_SINK_REG_STR_MOD_EN(j);
1031 rc = regmap_update_bits(wled->regmap, addr,
1032 WLED4_SINK_REG_STR_MOD_MASK,
1033 WLED4_SINK_REG_STR_MOD_MASK);
1034 if (rc < 0)
1035 return rc;
1036
1037 addr = wled->sink_addr +
1038 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
1039 rc = regmap_update_bits(wled->regmap, addr,
1040 WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
1041 wled->cfg.string_i_limit);
1042 if (rc < 0)
1043 return rc;
1044 }
1045
1046 rc = wled4_cabc_config(wled, wled->cfg.cabc);
1047 if (rc < 0)
1048 return rc;
1049
1050 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1051 WLED3_CTRL_REG_MOD_EN,
1052 WLED3_CTRL_REG_MOD_EN_MASK,
1053 WLED3_CTRL_REG_MOD_EN_MASK);
1054 if (rc < 0)
1055 return rc;
1056
1057 rc = regmap_update_bits(wled->regmap,
1058 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1059 WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
1060 if (rc < 0)
1061 return rc;
1062
1063 rc = wled->wled_sync_toggle(wled);
1064 if (rc < 0) {
1065 dev_err(wled->dev, "Failed to toggle sync reg rc:%d\n", rc);
1066 return rc;
1067 }
1068
1069 rc = wled_auto_detection_at_init(wled);
1070
1071 return rc;
1072 }
1073
1074 static const struct wled_config wled4_config_defaults = {
1075 .boost_i_limit = 4,
1076 .string_i_limit = 10,
1077 .ovp = 1,
1078 .num_strings = 4,
1079 .switch_freq = 11,
1080 .cabc = false,
1081 .external_pfet = false,
1082 .auto_detection_enabled = false,
1083 };
1084
wled5_setup(struct wled * wled)1085 static int wled5_setup(struct wled *wled)
1086 {
1087 int rc, temp, i, j, offset;
1088 u8 sink_en = 0;
1089 u16 addr;
1090 u32 val;
1091
1092 rc = regmap_update_bits(wled->regmap,
1093 wled->ctrl_addr + WLED3_CTRL_REG_OVP,
1094 WLED5_CTRL_REG_OVP_MASK, wled->cfg.ovp);
1095 if (rc < 0)
1096 return rc;
1097
1098 rc = regmap_update_bits(wled->regmap,
1099 wled->ctrl_addr + WLED3_CTRL_REG_ILIMIT,
1100 WLED3_CTRL_REG_ILIMIT_MASK,
1101 wled->cfg.boost_i_limit);
1102 if (rc < 0)
1103 return rc;
1104
1105 rc = regmap_update_bits(wled->regmap,
1106 wled->ctrl_addr + WLED3_CTRL_REG_FREQ,
1107 WLED3_CTRL_REG_FREQ_MASK,
1108 wled->cfg.switch_freq);
1109 if (rc < 0)
1110 return rc;
1111
1112 /* Per sink/string configuration */
1113 for (i = 0; i < wled->cfg.num_strings; ++i) {
1114 j = wled->cfg.enabled_strings[i];
1115 addr = wled->sink_addr +
1116 WLED4_SINK_REG_STR_FULL_SCALE_CURR(j);
1117 rc = regmap_update_bits(wled->regmap, addr,
1118 WLED4_SINK_REG_STR_FULL_SCALE_CURR_MASK,
1119 wled->cfg.string_i_limit);
1120 if (rc < 0)
1121 return rc;
1122
1123 addr = wled->sink_addr + WLED5_SINK_REG_STR_SRC_SEL(j);
1124 rc = regmap_update_bits(wled->regmap, addr,
1125 WLED5_SINK_REG_SRC_SEL_MASK,
1126 wled->cfg.mod_sel == MOD_A ?
1127 WLED5_SINK_REG_SRC_SEL_MOD_A :
1128 WLED5_SINK_REG_SRC_SEL_MOD_B);
1129
1130 temp = j + WLED4_SINK_REG_CURR_SINK_SHFT;
1131 sink_en |= 1 << temp;
1132 }
1133
1134 rc = wled5_cabc_config(wled, wled->cfg.cabc_sel ? true : false);
1135 if (rc < 0)
1136 return rc;
1137
1138 /* Enable one of the modulators A or B based on mod_sel */
1139 addr = wled->sink_addr + WLED5_SINK_REG_MOD_A_EN;
1140 val = (wled->cfg.mod_sel == MOD_A) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
1141 rc = regmap_update_bits(wled->regmap, addr,
1142 WLED5_SINK_REG_MOD_EN_MASK, val);
1143 if (rc < 0)
1144 return rc;
1145
1146 addr = wled->sink_addr + WLED5_SINK_REG_MOD_B_EN;
1147 val = (wled->cfg.mod_sel == MOD_B) ? WLED5_SINK_REG_MOD_EN_MASK : 0;
1148 rc = regmap_update_bits(wled->regmap, addr,
1149 WLED5_SINK_REG_MOD_EN_MASK, val);
1150 if (rc < 0)
1151 return rc;
1152
1153 offset = (wled->cfg.mod_sel == MOD_A) ?
1154 WLED5_SINK_REG_MOD_A_BRIGHTNESS_WIDTH_SEL :
1155 WLED5_SINK_REG_MOD_B_BRIGHTNESS_WIDTH_SEL;
1156
1157 addr = wled->sink_addr + offset;
1158 val = (wled->max_brightness == WLED5_SINK_REG_BRIGHT_MAX_15B) ?
1159 WLED5_SINK_REG_BRIGHTNESS_WIDTH_15B :
1160 WLED5_SINK_REG_BRIGHTNESS_WIDTH_12B;
1161 rc = regmap_write(wled->regmap, addr, val);
1162 if (rc < 0)
1163 return rc;
1164
1165 rc = regmap_update_bits(wled->regmap,
1166 wled->sink_addr + WLED4_SINK_REG_CURR_SINK,
1167 WLED4_SINK_REG_CURR_SINK_MASK, sink_en);
1168 if (rc < 0)
1169 return rc;
1170
1171 /* This updates only FSC configuration in WLED5 */
1172 rc = wled->wled_sync_toggle(wled);
1173 if (rc < 0) {
1174 pr_err("Failed to toggle sync reg rc:%d\n", rc);
1175 return rc;
1176 }
1177
1178 rc = wled_auto_detection_at_init(wled);
1179 if (rc < 0)
1180 return rc;
1181
1182 return 0;
1183 }
1184
1185 static const struct wled_config wled5_config_defaults = {
1186 .boost_i_limit = 5,
1187 .string_i_limit = 10,
1188 .ovp = 4,
1189 .num_strings = 4,
1190 .switch_freq = 11,
1191 .mod_sel = 0,
1192 .cabc_sel = 0,
1193 .cabc = false,
1194 .external_pfet = false,
1195 .auto_detection_enabled = false,
1196 };
1197
1198 static const u32 wled3_boost_i_limit_values[] = {
1199 105, 385, 525, 805, 980, 1260, 1400, 1680,
1200 };
1201
1202 static const struct wled_var_cfg wled3_boost_i_limit_cfg = {
1203 .values = wled3_boost_i_limit_values,
1204 .size = ARRAY_SIZE(wled3_boost_i_limit_values),
1205 };
1206
1207 static const u32 wled4_boost_i_limit_values[] = {
1208 105, 280, 450, 620, 970, 1150, 1300, 1500,
1209 };
1210
1211 static const struct wled_var_cfg wled4_boost_i_limit_cfg = {
1212 .values = wled4_boost_i_limit_values,
1213 .size = ARRAY_SIZE(wled4_boost_i_limit_values),
1214 };
1215
wled5_boost_i_limit_values_fn(u32 idx)1216 static inline u32 wled5_boost_i_limit_values_fn(u32 idx)
1217 {
1218 return 525 + (idx * 175);
1219 }
1220
1221 static const struct wled_var_cfg wled5_boost_i_limit_cfg = {
1222 .fn = wled5_boost_i_limit_values_fn,
1223 .size = 8,
1224 };
1225
1226 static const u32 wled3_ovp_values[] = {
1227 35, 32, 29, 27,
1228 };
1229
1230 static const struct wled_var_cfg wled3_ovp_cfg = {
1231 .values = wled3_ovp_values,
1232 .size = ARRAY_SIZE(wled3_ovp_values),
1233 };
1234
1235 static const u32 wled4_ovp_values[] = {
1236 31100, 29600, 19600, 18100,
1237 };
1238
1239 static const struct wled_var_cfg wled4_ovp_cfg = {
1240 .values = wled4_ovp_values,
1241 .size = ARRAY_SIZE(wled4_ovp_values),
1242 };
1243
wled5_ovp_values_fn(u32 idx)1244 static inline u32 wled5_ovp_values_fn(u32 idx)
1245 {
1246 /*
1247 * 0000 - 38.5 V
1248 * 0001 - 37 V ..
1249 * 1111 - 16 V
1250 */
1251 return 38500 - (idx * 1500);
1252 }
1253
1254 static const struct wled_var_cfg wled5_ovp_cfg = {
1255 .fn = wled5_ovp_values_fn,
1256 .size = 16,
1257 };
1258
wled3_num_strings_values_fn(u32 idx)1259 static u32 wled3_num_strings_values_fn(u32 idx)
1260 {
1261 return idx + 1;
1262 }
1263
1264 static const struct wled_var_cfg wled3_num_strings_cfg = {
1265 .fn = wled3_num_strings_values_fn,
1266 .size = 3,
1267 };
1268
1269 static const struct wled_var_cfg wled4_num_strings_cfg = {
1270 .fn = wled3_num_strings_values_fn,
1271 .size = 4,
1272 };
1273
wled3_switch_freq_values_fn(u32 idx)1274 static u32 wled3_switch_freq_values_fn(u32 idx)
1275 {
1276 return 19200 / (2 * (1 + idx));
1277 }
1278
1279 static const struct wled_var_cfg wled3_switch_freq_cfg = {
1280 .fn = wled3_switch_freq_values_fn,
1281 .size = 16,
1282 };
1283
1284 static const struct wled_var_cfg wled3_string_i_limit_cfg = {
1285 .size = 26,
1286 };
1287
1288 static const u32 wled4_string_i_limit_values[] = {
1289 0, 2500, 5000, 7500, 10000, 12500, 15000, 17500, 20000,
1290 22500, 25000, 27500, 30000,
1291 };
1292
1293 static const struct wled_var_cfg wled4_string_i_limit_cfg = {
1294 .values = wled4_string_i_limit_values,
1295 .size = ARRAY_SIZE(wled4_string_i_limit_values),
1296 };
1297
1298 static const struct wled_var_cfg wled5_mod_sel_cfg = {
1299 .size = 2,
1300 };
1301
1302 static const struct wled_var_cfg wled5_cabc_sel_cfg = {
1303 .size = 4,
1304 };
1305
wled_values(const struct wled_var_cfg * cfg,u32 idx)1306 static u32 wled_values(const struct wled_var_cfg *cfg, u32 idx)
1307 {
1308 if (idx >= cfg->size)
1309 return UINT_MAX;
1310 if (cfg->fn)
1311 return cfg->fn(idx);
1312 if (cfg->values)
1313 return cfg->values[idx];
1314 return idx;
1315 }
1316
wled_configure(struct wled * wled)1317 static int wled_configure(struct wled *wled)
1318 {
1319 struct wled_config *cfg = &wled->cfg;
1320 struct device *dev = wled->dev;
1321 const __be32 *prop_addr;
1322 u32 size, val, c;
1323 int rc, i, j, string_len;
1324
1325 const struct wled_u32_opts *u32_opts = NULL;
1326 const struct wled_u32_opts wled3_opts[] = {
1327 {
1328 .name = "qcom,current-boost-limit",
1329 .val_ptr = &cfg->boost_i_limit,
1330 .cfg = &wled3_boost_i_limit_cfg,
1331 },
1332 {
1333 .name = "qcom,current-limit",
1334 .val_ptr = &cfg->string_i_limit,
1335 .cfg = &wled3_string_i_limit_cfg,
1336 },
1337 {
1338 .name = "qcom,ovp",
1339 .val_ptr = &cfg->ovp,
1340 .cfg = &wled3_ovp_cfg,
1341 },
1342 {
1343 .name = "qcom,switching-freq",
1344 .val_ptr = &cfg->switch_freq,
1345 .cfg = &wled3_switch_freq_cfg,
1346 },
1347 {
1348 .name = "qcom,num-strings",
1349 .val_ptr = &cfg->num_strings,
1350 .cfg = &wled3_num_strings_cfg,
1351 },
1352 };
1353
1354 const struct wled_u32_opts wled4_opts[] = {
1355 {
1356 .name = "qcom,current-boost-limit",
1357 .val_ptr = &cfg->boost_i_limit,
1358 .cfg = &wled4_boost_i_limit_cfg,
1359 },
1360 {
1361 .name = "qcom,current-limit-microamp",
1362 .val_ptr = &cfg->string_i_limit,
1363 .cfg = &wled4_string_i_limit_cfg,
1364 },
1365 {
1366 .name = "qcom,ovp-millivolt",
1367 .val_ptr = &cfg->ovp,
1368 .cfg = &wled4_ovp_cfg,
1369 },
1370 {
1371 .name = "qcom,switching-freq",
1372 .val_ptr = &cfg->switch_freq,
1373 .cfg = &wled3_switch_freq_cfg,
1374 },
1375 {
1376 .name = "qcom,num-strings",
1377 .val_ptr = &cfg->num_strings,
1378 .cfg = &wled4_num_strings_cfg,
1379 },
1380 };
1381
1382 const struct wled_u32_opts wled5_opts[] = {
1383 {
1384 .name = "qcom,current-boost-limit",
1385 .val_ptr = &cfg->boost_i_limit,
1386 .cfg = &wled5_boost_i_limit_cfg,
1387 },
1388 {
1389 .name = "qcom,current-limit-microamp",
1390 .val_ptr = &cfg->string_i_limit,
1391 .cfg = &wled4_string_i_limit_cfg,
1392 },
1393 {
1394 .name = "qcom,ovp-millivolt",
1395 .val_ptr = &cfg->ovp,
1396 .cfg = &wled5_ovp_cfg,
1397 },
1398 {
1399 .name = "qcom,switching-freq",
1400 .val_ptr = &cfg->switch_freq,
1401 .cfg = &wled3_switch_freq_cfg,
1402 },
1403 {
1404 .name = "qcom,num-strings",
1405 .val_ptr = &cfg->num_strings,
1406 .cfg = &wled4_num_strings_cfg,
1407 },
1408 {
1409 .name = "qcom,modulator-sel",
1410 .val_ptr = &cfg->mod_sel,
1411 .cfg = &wled5_mod_sel_cfg,
1412 },
1413 {
1414 .name = "qcom,cabc-sel",
1415 .val_ptr = &cfg->cabc_sel,
1416 .cfg = &wled5_cabc_sel_cfg,
1417 },
1418 };
1419
1420 const struct wled_bool_opts bool_opts[] = {
1421 { "qcom,cs-out", &cfg->cs_out_en, },
1422 { "qcom,ext-gen", &cfg->ext_gen, },
1423 { "qcom,cabc", &cfg->cabc, },
1424 { "qcom,external-pfet", &cfg->external_pfet, },
1425 { "qcom,auto-string-detection", &cfg->auto_detection_enabled, },
1426 };
1427
1428 prop_addr = of_get_address(dev->of_node, 0, NULL, NULL);
1429 if (!prop_addr) {
1430 dev_err(wled->dev, "invalid IO resources\n");
1431 return -EINVAL;
1432 }
1433 wled->ctrl_addr = be32_to_cpu(*prop_addr);
1434
1435 rc = of_property_read_string(dev->of_node, "label", &wled->name);
1436 if (rc)
1437 wled->name = devm_kasprintf(dev, GFP_KERNEL, "%pOFn", dev->of_node);
1438
1439 switch (wled->version) {
1440 case 3:
1441 u32_opts = wled3_opts;
1442 size = ARRAY_SIZE(wled3_opts);
1443 *cfg = wled3_config_defaults;
1444 wled->wled_set_brightness = wled3_set_brightness;
1445 wled->wled_sync_toggle = wled3_sync_toggle;
1446 wled->max_string_count = 3;
1447 wled->sink_addr = wled->ctrl_addr;
1448 break;
1449
1450 case 4:
1451 u32_opts = wled4_opts;
1452 size = ARRAY_SIZE(wled4_opts);
1453 *cfg = wled4_config_defaults;
1454 wled->wled_set_brightness = wled4_set_brightness;
1455 wled->wled_sync_toggle = wled3_sync_toggle;
1456 wled->wled_cabc_config = wled4_cabc_config;
1457 wled->wled_ovp_delay = wled4_ovp_delay;
1458 wled->wled_auto_detection_required =
1459 wled4_auto_detection_required;
1460 wled->max_string_count = 4;
1461
1462 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1463 if (!prop_addr) {
1464 dev_err(wled->dev, "invalid IO resources\n");
1465 return -EINVAL;
1466 }
1467 wled->sink_addr = be32_to_cpu(*prop_addr);
1468 break;
1469
1470 case 5:
1471 u32_opts = wled5_opts;
1472 size = ARRAY_SIZE(wled5_opts);
1473 *cfg = wled5_config_defaults;
1474 wled->wled_set_brightness = wled5_set_brightness;
1475 wled->wled_sync_toggle = wled3_sync_toggle;
1476 wled->wled_cabc_config = wled5_cabc_config;
1477 wled->wled_ovp_delay = wled5_ovp_delay;
1478 wled->wled_auto_detection_required =
1479 wled5_auto_detection_required;
1480 wled->max_string_count = 4;
1481
1482 prop_addr = of_get_address(dev->of_node, 1, NULL, NULL);
1483 if (!prop_addr) {
1484 dev_err(wled->dev, "invalid IO resources\n");
1485 return -EINVAL;
1486 }
1487 wled->sink_addr = be32_to_cpu(*prop_addr);
1488 break;
1489
1490 default:
1491 dev_err(wled->dev, "Invalid WLED version\n");
1492 return -EINVAL;
1493 }
1494
1495 for (i = 0; i < size; ++i) {
1496 rc = of_property_read_u32(dev->of_node, u32_opts[i].name, &val);
1497 if (rc == -EINVAL) {
1498 continue;
1499 } else if (rc) {
1500 dev_err(dev, "error reading '%s'\n", u32_opts[i].name);
1501 return rc;
1502 }
1503
1504 c = UINT_MAX;
1505 for (j = 0; c != val; j++) {
1506 c = wled_values(u32_opts[i].cfg, j);
1507 if (c == UINT_MAX) {
1508 dev_err(dev, "invalid value for '%s'\n",
1509 u32_opts[i].name);
1510 return -EINVAL;
1511 }
1512
1513 if (c == val)
1514 break;
1515 }
1516
1517 dev_dbg(dev, "'%s' = %u\n", u32_opts[i].name, c);
1518 *u32_opts[i].val_ptr = j;
1519 }
1520
1521 for (i = 0; i < ARRAY_SIZE(bool_opts); ++i) {
1522 if (of_property_read_bool(dev->of_node, bool_opts[i].name))
1523 *bool_opts[i].val_ptr = true;
1524 }
1525
1526 cfg->num_strings = cfg->num_strings + 1;
1527
1528 string_len = of_property_count_elems_of_size(dev->of_node,
1529 "qcom,enabled-strings",
1530 sizeof(u32));
1531 if (string_len > 0)
1532 of_property_read_u32_array(dev->of_node,
1533 "qcom,enabled-strings",
1534 wled->cfg.enabled_strings,
1535 sizeof(u32));
1536
1537 return 0;
1538 }
1539
wled_configure_short_irq(struct wled * wled,struct platform_device * pdev)1540 static int wled_configure_short_irq(struct wled *wled,
1541 struct platform_device *pdev)
1542 {
1543 int rc;
1544
1545 if (!wled->has_short_detect)
1546 return 0;
1547
1548 rc = regmap_update_bits(wled->regmap, wled->ctrl_addr +
1549 WLED4_CTRL_REG_SHORT_PROTECT,
1550 WLED4_CTRL_REG_SHORT_EN_MASK,
1551 WLED4_CTRL_REG_SHORT_EN_MASK);
1552 if (rc < 0)
1553 return rc;
1554
1555 wled->short_irq = platform_get_irq_byname(pdev, "short");
1556 if (wled->short_irq < 0) {
1557 dev_dbg(&pdev->dev, "short irq is not used\n");
1558 return 0;
1559 }
1560
1561 rc = devm_request_threaded_irq(wled->dev, wled->short_irq,
1562 NULL, wled_short_irq_handler,
1563 IRQF_ONESHOT,
1564 "wled_short_irq", wled);
1565 if (rc < 0)
1566 dev_err(wled->dev, "Unable to request short_irq (err:%d)\n",
1567 rc);
1568
1569 return rc;
1570 }
1571
wled_configure_ovp_irq(struct wled * wled,struct platform_device * pdev)1572 static int wled_configure_ovp_irq(struct wled *wled,
1573 struct platform_device *pdev)
1574 {
1575 int rc;
1576 u32 val;
1577
1578 wled->ovp_irq = platform_get_irq_byname(pdev, "ovp");
1579 if (wled->ovp_irq < 0) {
1580 dev_dbg(&pdev->dev, "OVP IRQ not found - disabling automatic string detection\n");
1581 return 0;
1582 }
1583
1584 rc = devm_request_threaded_irq(wled->dev, wled->ovp_irq, NULL,
1585 wled_ovp_irq_handler, IRQF_ONESHOT,
1586 "wled_ovp_irq", wled);
1587 if (rc < 0) {
1588 dev_err(wled->dev, "Unable to request ovp_irq (err:%d)\n",
1589 rc);
1590 wled->ovp_irq = 0;
1591 return 0;
1592 }
1593
1594 rc = regmap_read(wled->regmap, wled->ctrl_addr +
1595 WLED3_CTRL_REG_MOD_EN, &val);
1596 if (rc < 0)
1597 return rc;
1598
1599 /* Keep OVP irq disabled until module is enabled */
1600 if (!(val & WLED3_CTRL_REG_MOD_EN_MASK))
1601 disable_irq(wled->ovp_irq);
1602
1603 return 0;
1604 }
1605
1606 static const struct backlight_ops wled_ops = {
1607 .update_status = wled_update_status,
1608 };
1609
wled_probe(struct platform_device * pdev)1610 static int wled_probe(struct platform_device *pdev)
1611 {
1612 struct backlight_properties props;
1613 struct backlight_device *bl;
1614 struct wled *wled;
1615 struct regmap *regmap;
1616 u32 val;
1617 int rc;
1618
1619 regmap = dev_get_regmap(pdev->dev.parent, NULL);
1620 if (!regmap) {
1621 dev_err(&pdev->dev, "Unable to get regmap\n");
1622 return -EINVAL;
1623 }
1624
1625 wled = devm_kzalloc(&pdev->dev, sizeof(*wled), GFP_KERNEL);
1626 if (!wled)
1627 return -ENOMEM;
1628
1629 wled->regmap = regmap;
1630 wled->dev = &pdev->dev;
1631
1632 wled->version = (uintptr_t)of_device_get_match_data(&pdev->dev);
1633 if (!wled->version) {
1634 dev_err(&pdev->dev, "Unknown device version\n");
1635 return -ENODEV;
1636 }
1637
1638 mutex_init(&wled->lock);
1639 rc = wled_configure(wled);
1640 if (rc)
1641 return rc;
1642
1643 val = WLED3_SINK_REG_BRIGHT_MAX;
1644 of_property_read_u32(pdev->dev.of_node, "max-brightness", &val);
1645 wled->max_brightness = val;
1646
1647 switch (wled->version) {
1648 case 3:
1649 wled->cfg.auto_detection_enabled = false;
1650 rc = wled3_setup(wled);
1651 if (rc) {
1652 dev_err(&pdev->dev, "wled3_setup failed\n");
1653 return rc;
1654 }
1655 break;
1656
1657 case 4:
1658 wled->has_short_detect = true;
1659 rc = wled4_setup(wled);
1660 if (rc) {
1661 dev_err(&pdev->dev, "wled4_setup failed\n");
1662 return rc;
1663 }
1664 break;
1665
1666 case 5:
1667 wled->has_short_detect = true;
1668 if (wled->cfg.cabc_sel)
1669 wled->max_brightness = WLED5_SINK_REG_BRIGHT_MAX_12B;
1670
1671 rc = wled5_setup(wled);
1672 if (rc) {
1673 dev_err(&pdev->dev, "wled5_setup failed\n");
1674 return rc;
1675 }
1676 break;
1677
1678 default:
1679 dev_err(wled->dev, "Invalid WLED version\n");
1680 break;
1681 }
1682
1683 INIT_DELAYED_WORK(&wled->ovp_work, wled_ovp_work);
1684
1685 rc = wled_configure_short_irq(wled, pdev);
1686 if (rc < 0)
1687 return rc;
1688
1689 rc = wled_configure_ovp_irq(wled, pdev);
1690 if (rc < 0)
1691 return rc;
1692
1693 val = WLED_DEFAULT_BRIGHTNESS;
1694 of_property_read_u32(pdev->dev.of_node, "default-brightness", &val);
1695
1696 memset(&props, 0, sizeof(struct backlight_properties));
1697 props.type = BACKLIGHT_RAW;
1698 props.brightness = val;
1699 props.max_brightness = wled->max_brightness;
1700 bl = devm_backlight_device_register(&pdev->dev, wled->name,
1701 &pdev->dev, wled,
1702 &wled_ops, &props);
1703 return PTR_ERR_OR_ZERO(bl);
1704 };
1705
wled_remove(struct platform_device * pdev)1706 static int wled_remove(struct platform_device *pdev)
1707 {
1708 struct wled *wled = platform_get_drvdata(pdev);
1709
1710 mutex_destroy(&wled->lock);
1711 cancel_delayed_work_sync(&wled->ovp_work);
1712 disable_irq(wled->short_irq);
1713 disable_irq(wled->ovp_irq);
1714
1715 return 0;
1716 }
1717
1718 static const struct of_device_id wled_match_table[] = {
1719 { .compatible = "qcom,pm8941-wled", .data = (void *)3 },
1720 { .compatible = "qcom,pmi8998-wled", .data = (void *)4 },
1721 { .compatible = "qcom,pm660l-wled", .data = (void *)4 },
1722 { .compatible = "qcom,pm8150l-wled", .data = (void *)5 },
1723 {}
1724 };
1725 MODULE_DEVICE_TABLE(of, wled_match_table);
1726
1727 static struct platform_driver wled_driver = {
1728 .probe = wled_probe,
1729 .remove = wled_remove,
1730 .driver = {
1731 .name = "qcom,wled",
1732 .of_match_table = wled_match_table,
1733 },
1734 };
1735
1736 module_platform_driver(wled_driver);
1737
1738 MODULE_DESCRIPTION("Qualcomm WLED driver");
1739 MODULE_LICENSE("GPL v2");
1740