2 * Copyright (c) 2017 Linaro Ltd
3 * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 and
7 * only version 2 as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 #include <linux/leds.h>
15 #include <linux/module.h>
17 #include <linux/of_device.h>
18 #include <linux/platform_device.h>
19 #include <linux/pwm.h>
20 #include <linux/regmap.h>
21 #include <linux/slab.h>
23 #define LPG_PATTERN_CONFIG_REG 0x40
24 #define LPG_SIZE_CLK_REG 0x41
25 #define LPG_PREDIV_CLK_REG 0x42
26 #define PWM_TYPE_CONFIG_REG 0x43
27 #define PWM_VALUE_REG 0x44
28 #define PWM_ENABLE_CONTROL_REG 0x46
29 #define PWM_SYNC_REG 0x47
30 #define LPG_RAMP_DURATION_REG 0x50
31 #define LPG_HI_PAUSE_REG 0x52
32 #define LPG_LO_PAUSE_REG 0x54
33 #define LPG_HI_IDX_REG 0x56
34 #define LPG_LO_IDX_REG 0x57
35 #define PWM_SEC_ACCESS_REG 0xd0
36 #define PWM_DTEST_REG(x) (0xe2 + (x) - 1)
38 #define TRI_LED_SRC_SEL 0x45
39 #define TRI_LED_EN_CTL 0x46
40 #define TRI_LED_ATC_CTL 0x47
42 #define LPG_LUT_REG(x) (0x40 + (x) * 2)
43 #define RAMP_CONTROL_REG 0xc8
49 * struct lpg - LPG device context
50 * @dev: struct device for LPG device
51 * @map: regmap for register access
52 * @pwm: PWM-chip object, if operating in PWM mode
53 * @pwm_9bit_mask: bitmask for enabling 9bit pwm
54 * @lut_base: base address of the LUT block (optional)
55 * @lut_size: number of entries in the LUT block
56 * @lut_bitmap: allocation bitmap for LUT entries
57 * @triled_base: base address of the TRILED block (optional)
58 * @triled_src: power-source for the TRILED
59 * @channels: list of PWM channels
60 * @num_channels: number of @channels
68 const struct lpg_data
*data
;
72 unsigned long *lut_bitmap
;
77 struct lpg_channel
*channels
;
78 unsigned int num_channels
;
82 * struct lpg_channel - per channel data
83 * @lpg: reference to parent lpg
84 * @base: base address of the PWM channel
85 * @triled_mask: mask in TRILED to enable this channel
86 * @lut_mask: mask in LUT to start pattern generator for this channel
87 * @in_use: channel is exposed to LED framework
88 * @dtest_line: DTEST line for output, or 0 if disabled
89 * @dtest_value: DTEST line configuration
90 * @pwm_value: duty (in microseconds) of the generated pulses, overriden by LUT
91 * @enabled: output enabled?
92 * @period_us: period (in microseconds) of the generated pulses
93 * @pwm_size: resolution of the @pwm_value, 6 or 9 bits
94 * @clk: base frequency of the clock generator
95 * @pre_div: divider of @clk
96 * @pre_div_exp: exponential divider of @clk
97 * @ramp_enabled: duty cycle is driven by iterating over lookup table
98 * @ramp_ping_pong: reverse through pattern, rather than wrapping to start
99 * @ramp_oneshot: perform only a single pass over the pattern
100 * @ramp_reverse: iterate over pattern backwards
101 * @ramp_duration_ms: length (in milliseconds) of one pattern run
102 * @ramp_lo_pause_ms: pause (in milliseconds) before iterating over pattern
103 * @ramp_hi_pause_ms: pause (in milliseconds) after iterating over pattern
104 * @pattern_lo_idx: start index of associated pattern
105 * @pattern_hi_idx: last index of associated pattern
111 unsigned int triled_mask
;
112 unsigned int lut_mask
;
122 unsigned int period_us
;
123 unsigned int pwm_size
;
125 unsigned int pre_div
;
126 unsigned int pre_div_exp
;
132 unsigned long ramp_duration_ms
;
133 unsigned long ramp_lo_pause_ms
;
134 unsigned long ramp_hi_pause_ms
;
136 unsigned int pattern_lo_idx
;
137 unsigned int pattern_hi_idx
;
141 * struct lpg_led - logical LED object
142 * @lpg: lpg context reference
143 * @cdev: LED class device
144 * @num_channels: number of @channels
145 * @channels: list of channels associated with the LED
150 struct led_classdev cdev
;
152 unsigned int num_channels
;
153 struct lpg_channel
*channels
[];
157 * struct lpg_channel_data - per channel initialization data
158 * @base: base address for PWM channel registers
159 * @triled_mask: bitmask for controlling this channel in TRILED
161 struct lpg_channel_data
{
167 * struct lpg_data - initialization data
168 * @lut_base: base address of LUT block
169 * @lut_size: number of entries in LUT
170 * @triled_base: base address of TRILED
171 * @pwm_9bit_mask: bitmask for switching from 6bit to 9bit pwm
172 * @num_channels: number of channels in LPG
173 * @channels: list of channel initialization data
176 unsigned int lut_base
;
177 unsigned int lut_size
;
178 unsigned int triled_base
;
179 unsigned int pwm_9bit_mask
;
181 struct lpg_channel_data
*channels
;
184 static int triled_set(struct lpg
*lpg
, unsigned int mask
, bool enable
)
186 /* Skip if we don't have a triled block */
187 if (!lpg
->triled_base
)
190 return regmap_update_bits(lpg
->map
, lpg
->triled_base
+ TRI_LED_EN_CTL
,
191 mask
, enable
? mask
: 0);
194 static int lpg_lut_store(struct lpg
*lpg
, const u16
*values
, size_t len
,
195 unsigned int *lo_idx
, unsigned int *hi_idx
)
201 /* Hardware does not behave when LO_IDX == HI_IDX */
205 idx
= bitmap_find_next_zero_area(lpg
->lut_bitmap
, lpg
->lut_size
,
207 if (idx
>= lpg
->lut_size
)
210 for (i
= 0; i
< len
; i
++) {
211 val
[0] = values
[i
] & 0xff;
212 val
[1] = values
[i
] >> 8;
214 regmap_bulk_write(lpg
->map
,
215 lpg
->lut_base
+ LPG_LUT_REG(idx
+ i
), val
, 2);
218 bitmap_set(lpg
->lut_bitmap
, idx
, len
);
221 *hi_idx
= idx
+ len
- 1;
226 static u16
*lpg_lut_read(struct lpg
*lpg
, unsigned int lo_idx
,
227 unsigned int hi_idx
, size_t *len
)
234 *len
= hi_idx
- lo_idx
+ 1;
236 values
= kcalloc(*len
, sizeof(u16
), GFP_KERNEL
);
238 return ERR_PTR(-ENOMEM
);
240 for (i
= 0; i
< *len
; i
++) {
241 ret
= regmap_bulk_read(lpg
->map
,
242 lpg
->lut_base
+ LPG_LUT_REG(lo_idx
+ i
),
249 values
[i
] = val
[0] | val
[1] << 8;
255 static void lpg_lut_free(struct lpg
*lpg
, unsigned int lo_idx
, unsigned int hi_idx
)
259 if (lo_idx
== hi_idx
)
262 len
= hi_idx
- lo_idx
+ 1;
263 bitmap_clear(lpg
->lut_bitmap
, lo_idx
, len
);
266 static int lpg_lut_sync(struct lpg
*lpg
, unsigned int mask
)
268 return regmap_update_bits(lpg
->map
, lpg
->lut_base
+ RAMP_CONTROL_REG
,
272 #define NUM_PWM_PREDIV 4
273 #define NUM_PWM_CLK 3
276 static const unsigned int lpg_clk_table
[NUM_PWM_PREDIV
][NUM_PWM_CLK
] = {
278 1 * (NSEC_PER_SEC
/ 1024),
279 1 * (NSEC_PER_SEC
/ 32768),
280 1 * (NSEC_PER_SEC
/ 19200000),
283 3 * (NSEC_PER_SEC
/ 1024),
284 3 * (NSEC_PER_SEC
/ 32768),
285 3 * (NSEC_PER_SEC
/ 19200000),
288 5 * (NSEC_PER_SEC
/ 1024),
289 5 * (NSEC_PER_SEC
/ 32768),
290 5 * (NSEC_PER_SEC
/ 19200000),
293 6 * (NSEC_PER_SEC
/ 1024),
294 6 * (NSEC_PER_SEC
/ 32768),
295 6 * (NSEC_PER_SEC
/ 19200000),
300 * PWM Frequency = Clock Frequency / (N * T)
302 * PWM Period = Clock Period * (N * T)
304 * N = 2^9 or 2^6 for 9-bit or 6-bit PWM size
305 * T = Pre-divide * 2^m, where m = 0..7 (exponent)
307 * This is the formula to figure out m for the best pre-divide and clock:
308 * (PWM Period / N) = (Pre-divide * Clock Period) * 2^m
310 static void lpg_calc_freq(struct lpg_channel
*chan
, unsigned int period_us
)
313 int best_m
, best_div
, best_clk
;
314 unsigned int last_err
, cur_err
, min_err
;
315 unsigned int tmp_p
, period_n
;
317 if (period_us
== chan
->period_us
)
321 if (period_us
< ((unsigned int)(-1) / NSEC_PER_USEC
)) {
322 period_n
= (period_us
* NSEC_PER_USEC
) >> 6;
325 period_n
= (period_us
>> 9) * NSEC_PER_USEC
;
329 min_err
= last_err
= (unsigned int)(-1);
333 for (clk
= 0; clk
< NUM_PWM_CLK
; clk
++) {
334 for (div
= 0; div
< NUM_PWM_PREDIV
; div
++) {
335 /* period_n = (PWM Period / N) */
336 /* tmp_p = (Pre-divide * Clock Period) * 2^m */
337 tmp_p
= lpg_clk_table
[div
][clk
];
338 for (m
= 0; m
<= NUM_EXP
; m
++) {
339 if (period_n
> tmp_p
)
340 cur_err
= period_n
- tmp_p
;
342 cur_err
= tmp_p
- period_n
;
344 if (cur_err
< min_err
) {
351 if (m
&& cur_err
> last_err
)
352 /* Break for bigger cur_err */
361 /* Use higher resolution */
362 if (best_m
>= 3 && n
== 6) {
367 chan
->clk
= best_clk
;
368 chan
->pre_div
= best_div
;
369 chan
->pre_div_exp
= best_m
;
372 chan
->period_us
= period_us
;
375 static void lpg_calc_duty(struct lpg_channel
*chan
, unsigned int duty_us
)
377 unsigned long max
= (1 << chan
->pwm_size
) - 1;
380 /* Figure out pwm_value with overflow handling */
381 if (duty_us
< 1 << (sizeof(val
) * 8 - chan
->pwm_size
))
382 val
= (duty_us
<< chan
->pwm_size
) / chan
->period_us
;
384 val
= duty_us
/ (chan
->period_us
>> chan
->pwm_size
);
389 chan
->pwm_value
= val
;
392 static void lpg_apply_freq(struct lpg_channel
*chan
)
395 struct lpg
*lpg
= chan
->lpg
;
400 /* Clock register values are off-by-one from lpg_clk_table */
403 if (chan
->pwm_size
== 9)
404 val
|= lpg
->data
->pwm_9bit_mask
;
406 regmap_write(lpg
->map
, chan
->base
+ LPG_SIZE_CLK_REG
, val
);
408 val
= chan
->pre_div
<< 5 | chan
->pre_div_exp
;
409 regmap_write(lpg
->map
, chan
->base
+ LPG_PREDIV_CLK_REG
, val
);
412 #define LPG_ENABLE_GLITCH_REMOVAL BIT(5)
414 static void lpg_enable_glitch(struct lpg_channel
*chan
)
416 struct lpg
*lpg
= chan
->lpg
;
418 regmap_update_bits(lpg
->map
, chan
->base
+ PWM_TYPE_CONFIG_REG
,
419 LPG_ENABLE_GLITCH_REMOVAL
, 0);
422 static void lpg_disable_glitch(struct lpg_channel
*chan
)
424 struct lpg
*lpg
= chan
->lpg
;
426 regmap_update_bits(lpg
->map
, chan
->base
+ PWM_TYPE_CONFIG_REG
,
427 LPG_ENABLE_GLITCH_REMOVAL
,
428 LPG_ENABLE_GLITCH_REMOVAL
);
431 static void lpg_apply_pwm_value(struct lpg_channel
*chan
)
433 u8 val
[] = { chan
->pwm_value
& 0xff, chan
->pwm_value
>> 8 };
434 struct lpg
*lpg
= chan
->lpg
;
439 regmap_bulk_write(lpg
->map
, chan
->base
+ PWM_VALUE_REG
, val
, 2);
442 #define LPG_PATTERN_CONFIG_LO_TO_HI BIT(4)
443 #define LPG_PATTERN_CONFIG_REPEAT BIT(3)
444 #define LPG_PATTERN_CONFIG_TOGGLE BIT(2)
445 #define LPG_PATTERN_CONFIG_PAUSE_HI BIT(1)
446 #define LPG_PATTERN_CONFIG_PAUSE_LO BIT(0)
448 static void lpg_apply_lut_control(struct lpg_channel
*chan
)
450 struct lpg
*lpg
= chan
->lpg
;
451 unsigned int hi_pause
;
452 unsigned int lo_pause
;
454 unsigned int conf
= 0;
455 unsigned int lo_idx
= chan
->pattern_lo_idx
;
456 unsigned int hi_idx
= chan
->pattern_hi_idx
;
459 if (!chan
->ramp_enabled
|| chan
->pattern_lo_idx
== chan
->pattern_hi_idx
)
462 pattern_len
= hi_idx
- lo_idx
+ 1;
464 step
= DIV_ROUND_UP(chan
->ramp_duration_ms
, pattern_len
);
465 hi_pause
= DIV_ROUND_UP(chan
->ramp_hi_pause_ms
, step
);
466 lo_pause
= DIV_ROUND_UP(chan
->ramp_lo_pause_ms
, step
);
468 if (!chan
->ramp_reverse
)
469 conf
|= LPG_PATTERN_CONFIG_LO_TO_HI
;
470 if (!chan
->ramp_oneshot
)
471 conf
|= LPG_PATTERN_CONFIG_REPEAT
;
472 if (chan
->ramp_ping_pong
)
473 conf
|= LPG_PATTERN_CONFIG_TOGGLE
;
474 if (chan
->ramp_hi_pause_ms
)
475 conf
|= LPG_PATTERN_CONFIG_PAUSE_HI
;
476 if (chan
->ramp_lo_pause_ms
)
477 conf
|= LPG_PATTERN_CONFIG_PAUSE_LO
;
479 regmap_write(lpg
->map
, chan
->base
+ LPG_PATTERN_CONFIG_REG
, conf
);
480 regmap_write(lpg
->map
, chan
->base
+ LPG_HI_IDX_REG
, hi_idx
);
481 regmap_write(lpg
->map
, chan
->base
+ LPG_LO_IDX_REG
, lo_idx
);
483 regmap_write(lpg
->map
, chan
->base
+ LPG_RAMP_DURATION_REG
, step
);
484 regmap_write(lpg
->map
, chan
->base
+ LPG_HI_PAUSE_REG
, hi_pause
);
485 regmap_write(lpg
->map
, chan
->base
+ LPG_LO_PAUSE_REG
, lo_pause
);
488 #define LPG_ENABLE_CONTROL_OUTPUT BIT(7)
489 #define LPG_ENABLE_CONTROL_BUFFER_TRISTATE BIT(5)
490 #define LPG_ENABLE_CONTROL_SRC_PWM BIT(2)
491 #define LPG_ENABLE_CONTROL_RAMP_GEN BIT(1)
493 static void lpg_apply_control(struct lpg_channel
*chan
)
496 struct lpg
*lpg
= chan
->lpg
;
498 ctrl
= LPG_ENABLE_CONTROL_BUFFER_TRISTATE
;
501 ctrl
|= LPG_ENABLE_CONTROL_OUTPUT
;
503 if (chan
->pattern_lo_idx
!= chan
->pattern_hi_idx
)
504 ctrl
|= LPG_ENABLE_CONTROL_RAMP_GEN
;
506 ctrl
|= LPG_ENABLE_CONTROL_SRC_PWM
;
508 regmap_write(lpg
->map
, chan
->base
+ PWM_ENABLE_CONTROL_REG
, ctrl
);
511 * Due to LPG hardware bug, in the PWM mode, having enabled PWM,
512 * We have to write PWM values one more time.
515 lpg_apply_pwm_value(chan
);
518 #define LPG_SYNC_PWM BIT(0)
520 static void lpg_apply_sync(struct lpg_channel
*chan
)
522 struct lpg
*lpg
= chan
->lpg
;
524 regmap_write(lpg
->map
, chan
->base
+ PWM_SYNC_REG
, LPG_SYNC_PWM
);
527 static void lpg_apply_dtest(struct lpg_channel
*chan
)
529 struct lpg
*lpg
= chan
->lpg
;
531 if (!chan
->dtest_line
)
534 regmap_write(lpg
->map
, chan
->base
+ PWM_SEC_ACCESS_REG
, 0xa5);
535 regmap_write(lpg
->map
, chan
->base
+ PWM_DTEST_REG(chan
->dtest_line
),
539 static void lpg_apply(struct lpg_channel
*chan
)
541 lpg_disable_glitch(chan
);
542 lpg_apply_freq(chan
);
543 lpg_apply_pwm_value(chan
);
544 lpg_apply_control(chan
);
545 lpg_apply_sync(chan
);
546 lpg_apply_lut_control(chan
);
547 lpg_enable_glitch(chan
);
550 static void lpg_brightness_set(struct led_classdev
*cdev
,
551 enum led_brightness value
)
553 struct lpg_led
*led
= container_of(cdev
, struct lpg_led
, cdev
);
554 struct lpg_channel
*chan
;
555 struct lpg
*lpg
= led
->lpg
;
556 unsigned int duty_us
;
557 unsigned int triled_mask
= 0;
558 unsigned int lut_mask
= 0;
561 for (i
= 0; i
< led
->num_channels
; i
++) {
562 chan
= led
->channels
[i
];
564 if (value
== LED_OFF
) {
565 chan
->enabled
= false;
566 chan
->ramp_enabled
= false;
567 } else if (chan
->pattern_lo_idx
!= chan
->pattern_hi_idx
) {
568 lpg_calc_freq(chan
, NSEC_PER_USEC
);
570 chan
->enabled
= true;
571 chan
->ramp_enabled
= true;
573 lut_mask
|= chan
->lut_mask
;
574 triled_mask
|= chan
->triled_mask
;
576 lpg_calc_freq(chan
, NSEC_PER_USEC
);
578 duty_us
= value
* chan
->period_us
/ cdev
->max_brightness
;
579 lpg_calc_duty(chan
, duty_us
);
580 chan
->enabled
= true;
581 chan
->ramp_enabled
= false;
583 triled_mask
|= chan
->triled_mask
;
589 /* Toggle triled lines */
591 triled_set(lpg
, triled_mask
, chan
->enabled
);
593 /* Trigger start of ramp generator(s) */
595 lpg_lut_sync(lpg
, lut_mask
);
598 static enum led_brightness
lpg_brightness_get(struct led_classdev
*cdev
)
600 struct lpg_led
*led
= container_of(cdev
, struct lpg_led
, cdev
);
601 struct lpg_channel
*chan
= led
->channels
[0];
602 unsigned long max
= (1 << chan
->pwm_size
) - 1;
606 else if (chan
->pattern_lo_idx
!= chan
->pattern_hi_idx
)
609 return chan
->pwm_value
* cdev
->max_brightness
/ max
;
612 static int lpg_blink_set(struct led_classdev
*cdev
,
613 unsigned long *delay_on
, unsigned long *delay_off
)
615 struct lpg_led
*led
= container_of(cdev
, struct lpg_led
, cdev
);
616 struct lpg_channel
*chan
= led
->channels
[0];
617 unsigned int period_us
;
618 unsigned int duty_us
;
620 if (!*delay_on
&& !*delay_off
) {
625 duty_us
= *delay_on
* USEC_PER_MSEC
;
626 period_us
= (*delay_on
+ *delay_off
) * USEC_PER_MSEC
;
628 lpg_calc_freq(chan
, period_us
);
629 lpg_calc_duty(chan
, duty_us
);
631 chan
->enabled
= true;
632 chan
->ramp_enabled
= false;
639 #define interpolate(x1, y1, x2, y2, x) \
640 ((y1) + ((y2) - (y1)) * ((x) - (x1)) / ((x2) - (x1)))
642 static int lpg_pattern_set(struct led_classdev
*led_cdev
,
643 struct led_pattern
*led_pattern
, int len
,
646 struct lpg_led
*led
= container_of(led_cdev
, struct lpg_led
, cdev
);
647 struct lpg_channel
*chan
= led
->channels
[0];
648 struct lpg
*lpg
= led
->lpg
;
649 unsigned int duration
= 0;
650 unsigned int min_delta
= (unsigned int)-1;
651 unsigned int hi_pause
;
652 unsigned int lo_pause
= 0;
655 unsigned int max
= (1 << chan
->pwm_size
) - 1;
656 bool ping_pong
= true;
671 * The led_pattern specifies brightness values, potentially distributed
672 * unevenly over the duration of the pattern. The LPG only support
673 * evenly distributed values, so we interpolate new values from the
677 /* Sum the duration over the inner delta_ts and the tail is hi_pause */
678 for (src_idx
= 0; src_idx
< len
- 1; src_idx
++)
679 duration
+= led_pattern
[src_idx
].delta_t
;
680 hi_pause
= led_pattern
[src_idx
].delta_t
;
682 for (src_idx
= 0; src_idx
< len
; src_idx
++) {
683 min_delta
= min_t(unsigned int, min_delta
,
684 led_pattern
[src_idx
].delta_t
);
687 steps
= duration
/ min_delta
+ 1;
688 pattern
= kcalloc(steps
, sizeof(*pattern
), GFP_KERNEL
);
693 for (src_idx
= 0, dst_idx
= 0; dst_idx
< steps
; dst_idx
++) {
694 /* The timestamp of this evenly distributed data point */
695 step_t
= dst_idx
* min_delta
;
698 * Find time_a - time_b interval from source pattern that spans
701 while (time_a
+ led_pattern
[src_idx
].delta_t
< step_t
) {
702 if (src_idx
>= len
- 1)
704 time_a
+= led_pattern
[++src_idx
].delta_t
;
707 if (src_idx
< len
- 1) {
708 time_b
= time_a
+ led_pattern
[src_idx
].delta_t
;
710 brightness_a
= led_pattern
[src_idx
].brightness
;
711 brightness_b
= led_pattern
[src_idx
+ 1].brightness
;
713 /* Interpolate over the source pattern segment */
714 value
= interpolate(time_a
, brightness_a
, time_b
,
715 brightness_b
, step_t
);
717 value
= led_pattern
[src_idx
].brightness
;
720 /* Scale calculated value to the hardware brightness value */
721 pattern
[dst_idx
] = value
* max
/ led_cdev
->max_brightness
;
724 /* Detect palindromes and use "ping pong" to reduce LUT usage */
725 for (dst_idx
= 0; dst_idx
< steps
/ 2; dst_idx
++) {
726 if (pattern
[dst_idx
] != pattern
[len
- dst_idx
- 1]) {
732 steps
= (steps
+ 1) / 2;
735 * When ping_pong is set the hi_pause will happen in the middle
736 * of the pattern, so we need to use lo_pause to delay between
745 ret
= lpg_lut_store(lpg
, pattern
, steps
, &lo_idx
, &hi_idx
);
749 chan
= led
->channels
[0];
751 lpg_lut_free(lpg
, chan
->pattern_lo_idx
, chan
->pattern_hi_idx
);
753 /* Update settings on each associated channel */
754 for (i
= 0; i
< led
->num_channels
; i
++) {
755 chan
= led
->channels
[i
];
757 chan
->ramp_duration_ms
= duration
;
758 chan
->ramp_ping_pong
= ping_pong
;
759 chan
->ramp_oneshot
= !repeat
;
761 chan
->pattern_lo_idx
= lo_idx
;
762 chan
->pattern_hi_idx
= hi_idx
;
771 static int lpg_pattern_clear(struct led_classdev
*cdev
)
773 struct lpg_led
*led
= container_of(cdev
, struct lpg_led
, cdev
);
774 struct lpg_channel
*chan
;
775 struct lpg
*lpg
= led
->lpg
;
778 chan
= led
->channels
[0];
780 lpg_lut_free(lpg
, chan
->pattern_lo_idx
, chan
->pattern_hi_idx
);
782 for (i
= 0; i
< led
->num_channels
; i
++) {
783 chan
= led
->channels
[i
];
784 chan
->pattern_lo_idx
= 0;
785 chan
->pattern_hi_idx
= 0;
791 static struct led_pattern
*lpg_pattern_get(struct led_classdev
*cdev
,
792 size_t *len
, bool *repeat
)
794 struct led_pattern
*led_pattern
;
795 struct lpg_led
*led
= container_of(cdev
, struct lpg_led
, cdev
);
796 struct lpg
*lpg
= led
->lpg
;
797 struct lpg_channel
*chan
= led
->channels
[0];
798 unsigned int delta_t
;
799 unsigned int max
= (1 << chan
->pwm_size
) - 1;
806 pattern
= lpg_lut_read(lpg
, chan
->pattern_lo_idx
, chan
->pattern_hi_idx
,
808 if (IS_ERR_OR_NULL(pattern
))
809 return ERR_CAST(pattern
);
811 all_steps
= chan
->ramp_ping_pong
? steps
* 2 - 1 : steps
;
813 delta_t
= (chan
->ramp_duration_ms
+ chan
->ramp_hi_pause_ms
) / all_steps
;
815 led_pattern
= kcalloc(all_steps
, sizeof(*pattern
), GFP_KERNEL
);
817 led_pattern
= ERR_PTR(-ENOMEM
);
821 for (i
= 0; i
< all_steps
; i
++) {
825 val
= pattern
[steps
- i
];
827 led_pattern
[i
].delta_t
= delta_t
;
828 led_pattern
[i
].brightness
= val
* cdev
->max_brightness
/ max
;
832 *repeat
= !chan
->ramp_oneshot
;
839 static int lpg_pwm_request(struct pwm_chip
*chip
, struct pwm_device
*pwm
)
841 struct lpg
*lpg
= container_of(chip
, struct lpg
, pwm
);
842 struct lpg_channel
*chan
= &lpg
->channels
[pwm
->hwpwm
];
844 return chan
->in_use
? -EBUSY
: 0;
847 static int lpg_pwm_apply(struct pwm_chip
*chip
, struct pwm_device
*pwm
,
848 struct pwm_state
*state
)
850 struct lpg
*lpg
= container_of(chip
, struct lpg
, pwm
);
851 struct lpg_channel
*chan
= &lpg
->channels
[pwm
->hwpwm
];
853 lpg_calc_freq(chan
, state
->period
/ NSEC_PER_USEC
);
854 lpg_calc_duty(chan
, state
->duty_cycle
/ NSEC_PER_USEC
);
855 chan
->enabled
= state
->enabled
;
859 triled_set(lpg
, chan
->triled_mask
, chan
->enabled
);
861 state
->polarity
= PWM_POLARITY_NORMAL
;
862 state
->period
= chan
->period_us
* NSEC_PER_USEC
;
867 static const struct pwm_ops lpg_pwm_ops
= {
868 .request
= lpg_pwm_request
,
869 .apply
= lpg_pwm_apply
,
870 .owner
= THIS_MODULE
,
873 static int lpg_add_pwm(struct lpg
*lpg
)
878 lpg
->pwm
.dev
= lpg
->dev
;
879 lpg
->pwm
.npwm
= lpg
->num_channels
;
880 lpg
->pwm
.ops
= &lpg_pwm_ops
;
882 ret
= pwmchip_add(&lpg
->pwm
);
884 dev_err(lpg
->dev
, "failed to add PWM chip: ret %d\n", ret
);
889 static int lpg_add_led(struct lpg
*lpg
, struct device_node
*np
)
899 sources
= of_property_count_u32_elems(np
, "led-sources");
901 dev_err(lpg
->dev
, "invalid led-sources of %s\n",
906 size
= sizeof(*led
) + sources
* sizeof(struct lpg_channel
*);
907 led
= devm_kzalloc(lpg
->dev
, size
, GFP_KERNEL
);
912 led
->num_channels
= sources
;
914 for (i
= 0; i
< sources
; i
++) {
915 ret
= of_property_read_u32_index(np
, "led-sources",
917 if (ret
|| !chan
|| chan
> lpg
->num_channels
) {
919 "invalid led-sources of %s\n",
924 led
->channels
[i
] = &lpg
->channels
[chan
- 1];
926 led
->channels
[i
]->in_use
= true;
929 /* Use label else node name */
930 led
->cdev
.name
= of_get_property(np
, "label", NULL
) ? : np
->name
;
931 led
->cdev
.default_trigger
= of_get_property(np
, "linux,default-trigger", NULL
);
932 led
->cdev
.brightness_set
= lpg_brightness_set
;
933 led
->cdev
.brightness_get
= lpg_brightness_get
;
934 led
->cdev
.blink_set
= lpg_blink_set
;
935 led
->cdev
.max_brightness
= 255;
937 /* Register pattern accessors only if we have a LUT block */
939 led
->cdev
.pattern_set
= lpg_pattern_set
;
940 led
->cdev
.pattern_clear
= lpg_pattern_clear
;
941 led
->cdev
.pattern_get
= lpg_pattern_get
;
944 if (!of_property_read_string(np
, "default-state", &state
) &&
945 !strcmp(state
, "on"))
946 led
->cdev
.brightness
= LED_FULL
;
948 led
->cdev
.brightness
= LED_OFF
;
950 lpg_brightness_set(&led
->cdev
, led
->cdev
.brightness
);
952 ret
= devm_led_classdev_register(lpg
->dev
, &led
->cdev
);
954 dev_err(lpg
->dev
, "unable to register %s\n", led
->cdev
.name
);
959 static int lpg_init_channels(struct lpg
*lpg
)
961 const struct lpg_data
*data
= lpg
->data
;
964 lpg
->num_channels
= data
->num_channels
;
965 lpg
->channels
= devm_kcalloc(lpg
->dev
, data
->num_channels
,
966 sizeof(struct lpg_channel
), GFP_KERNEL
);
970 for (i
= 0; i
< data
->num_channels
; i
++) {
971 lpg
->channels
[i
].lpg
= lpg
;
972 lpg
->channels
[i
].base
= data
->channels
[i
].base
;
973 lpg
->channels
[i
].triled_mask
= data
->channels
[i
].triled_mask
;
974 lpg
->channels
[i
].lut_mask
= BIT(i
);
980 static int lpg_init_triled(struct lpg
*lpg
)
982 struct device_node
*np
= lpg
->dev
->of_node
;
985 /* Skip initialization if we don't have a triled block */
986 if (!lpg
->data
->triled_base
)
989 lpg
->triled_base
= lpg
->data
->triled_base
;
991 ret
= of_property_read_u32(np
, "qcom,power-source", &lpg
->triled_src
);
992 if (ret
|| lpg
->triled_src
== 2 || lpg
->triled_src
> 3) {
993 dev_err(lpg
->dev
, "invalid power source\n");
997 /* Disable automatic trickle charge LED */
998 regmap_write(lpg
->map
, lpg
->triled_base
+ TRI_LED_ATC_CTL
, 0);
1000 /* Configure power source */
1001 regmap_write(lpg
->map
, lpg
->triled_base
+ TRI_LED_SRC_SEL
,
1004 /* Default all outputs to off */
1005 regmap_write(lpg
->map
, lpg
->triled_base
+ TRI_LED_EN_CTL
, 0);
1010 static int lpg_init_lut(struct lpg
*lpg
)
1012 const struct lpg_data
*data
= lpg
->data
;
1015 if (!data
->lut_base
)
1018 lpg
->lut_base
= data
->lut_base
;
1019 lpg
->lut_size
= data
->lut_size
;
1021 bitmap_size
= BITS_TO_LONGS(lpg
->lut_size
) / sizeof(unsigned long);
1022 lpg
->lut_bitmap
= devm_kzalloc(lpg
->dev
, bitmap_size
, GFP_KERNEL
);
1024 return lpg
->lut_bitmap
? 0 : -ENOMEM
;
1027 static int lpg_parse_dtest(struct lpg
*lpg
)
1029 struct lpg_channel
*chan
;
1030 struct device_node
*np
= lpg
->dev
->of_node
;
1035 count
= of_property_count_u32_elems(np
, "qcom,dtest");
1036 if (count
== -EINVAL
) {
1038 } else if (count
< 0 || count
!= lpg
->data
->num_channels
* 2) {
1043 for (i
= 0; i
< lpg
->data
->num_channels
; i
++) {
1044 chan
= &lpg
->channels
[i
];
1046 ret
= of_property_read_u32_index(np
, "qcom,dtest", i
* 2,
1051 ret
= of_property_read_u32_index(np
, "qcom,dtest", i
* 2 + 1,
1052 &chan
->dtest_value
);
1060 dev_err(lpg
->dev
, "malformed qcom,dtest\n");
1064 static int lpg_probe(struct platform_device
*pdev
)
1066 struct device_node
*np
;
1071 lpg
= devm_kzalloc(&pdev
->dev
, sizeof(*lpg
), GFP_KERNEL
);
1075 lpg
->data
= of_device_get_match_data(&pdev
->dev
);
1079 lpg
->dev
= &pdev
->dev
;
1081 lpg
->map
= dev_get_regmap(pdev
->dev
.parent
, NULL
);
1083 dev_err(&pdev
->dev
, "parent regmap unavailable\n");
1087 ret
= lpg_init_channels(lpg
);
1091 ret
= lpg_init_triled(lpg
);
1095 ret
= lpg_init_lut(lpg
);
1099 ret
= lpg_parse_dtest(lpg
);
1103 for_each_available_child_of_node(pdev
->dev
.of_node
, np
) {
1104 ret
= lpg_add_led(lpg
, np
);
1109 for (i
= 0; i
< lpg
->num_channels
; i
++)
1110 lpg_apply_dtest(&lpg
->channels
[i
]);
1112 ret
= lpg_add_pwm(lpg
);
1116 platform_set_drvdata(pdev
, lpg
);
1121 static int lpg_remove(struct platform_device
*pdev
)
1123 struct lpg
*lpg
= platform_get_drvdata(pdev
);
1125 pwmchip_remove(&lpg
->pwm
);
1130 static const struct lpg_data pm8916_pwm_data
= {
1131 .pwm_9bit_mask
= BIT(2),
1134 .channels
= (struct lpg_channel_data
[]) {
1139 static const struct lpg_data pm8941_lpg_data
= {
1143 .triled_base
= 0xd000,
1145 .pwm_9bit_mask
= 3 << 4,
1148 .channels
= (struct lpg_channel_data
[]) {
1153 { .base
= 0xb500, .triled_mask
= BIT(5) },
1154 { .base
= 0xb600, .triled_mask
= BIT(6) },
1155 { .base
= 0xb700, .triled_mask
= BIT(7) },
1160 static const struct lpg_data pm8994_lpg_data
= {
1164 .pwm_9bit_mask
= 3 << 4,
1167 .channels
= (struct lpg_channel_data
[]) {
1177 static const struct lpg_data pmi8994_lpg_data
= {
1181 .triled_base
= 0xd000,
1183 .pwm_9bit_mask
= BIT(4),
1186 .channels
= (struct lpg_channel_data
[]) {
1187 { .base
= 0xb100, .triled_mask
= BIT(5) },
1188 { .base
= 0xb200, .triled_mask
= BIT(6) },
1189 { .base
= 0xb300, .triled_mask
= BIT(7) },
1194 static const struct lpg_data pmi8998_lpg_data
= {
1198 .pwm_9bit_mask
= BIT(4),
1201 .channels
= (struct lpg_channel_data
[]) {
1204 { .base
= 0xb300, .triled_mask
= BIT(5) },
1205 { .base
= 0xb400, .triled_mask
= BIT(6) },
1206 { .base
= 0xb500, .triled_mask
= BIT(7) },
1211 static const struct of_device_id lpg_of_table
[] = {
1212 { .compatible
= "qcom,pm8916-pwm", .data
= &pm8916_pwm_data
},
1213 { .compatible
= "qcom,pm8941-lpg", .data
= &pm8941_lpg_data
},
1214 { .compatible
= "qcom,pm8994-lpg", .data
= &pm8994_lpg_data
},
1215 { .compatible
= "qcom,pmi8994-lpg", .data
= &pmi8994_lpg_data
},
1216 { .compatible
= "qcom,pmi8998-lpg", .data
= &pmi8998_lpg_data
},
1219 MODULE_DEVICE_TABLE(of
, lpg_of_table
);
1221 static struct platform_driver lpg_driver
= {
1223 .remove
= lpg_remove
,
1225 .name
= "qcom-spmi-lpg",
1226 .of_match_table
= lpg_of_table
,
1229 module_platform_driver(lpg_driver
);
1231 MODULE_DESCRIPTION("Qualcomm TRI LED driver");
1232 MODULE_LICENSE("GPL v2");