Commit | Line | Data |
---|---|---|
c942fddf | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
216ec6cc SW |
2 | /* |
3 | * LED driver for Mediatek MT6323 PMIC | |
4 | * | |
5 | * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com> | |
216ec6cc SW |
6 | */ |
7 | #include <linux/kernel.h> | |
8 | #include <linux/leds.h> | |
9 | #include <linux/mfd/mt6323/registers.h> | |
10 | #include <linux/mfd/mt6397/core.h> | |
11 | #include <linux/module.h> | |
12 | #include <linux/of.h> | |
13 | #include <linux/platform_device.h> | |
14 | #include <linux/regmap.h> | |
15 | ||
16 | /* | |
17 | * Register field for MT6323_TOP_CKPDN0 to enable | |
18 | * 32K clock common for LED device. | |
19 | */ | |
20 | #define MT6323_RG_DRV_32K_CK_PDN BIT(11) | |
21 | #define MT6323_RG_DRV_32K_CK_PDN_MASK BIT(11) | |
22 | ||
23 | /* | |
24 | * Register field for MT6323_TOP_CKPDN2 to enable | |
25 | * individual clock for LED device. | |
26 | */ | |
27 | #define MT6323_RG_ISINK_CK_PDN(i) BIT(i) | |
28 | #define MT6323_RG_ISINK_CK_PDN_MASK(i) BIT(i) | |
29 | ||
30 | /* | |
31 | * Register field for MT6323_TOP_CKCON1 to select | |
32 | * clock source. | |
33 | */ | |
34 | #define MT6323_RG_ISINK_CK_SEL_MASK(i) (BIT(10) << (i)) | |
35 | ||
36 | /* | |
37 | * Register for MT6323_ISINK_CON0 to setup the | |
38 | * duty cycle of the blink. | |
39 | */ | |
40 | #define MT6323_ISINK_CON0(i) (MT6323_ISINK0_CON0 + 0x8 * (i)) | |
41 | #define MT6323_ISINK_DIM_DUTY_MASK (0x1f << 8) | |
42 | #define MT6323_ISINK_DIM_DUTY(i) (((i) << 8) & \ | |
43 | MT6323_ISINK_DIM_DUTY_MASK) | |
44 | ||
45 | /* Register to setup the period of the blink. */ | |
46 | #define MT6323_ISINK_CON1(i) (MT6323_ISINK0_CON1 + 0x8 * (i)) | |
47 | #define MT6323_ISINK_DIM_FSEL_MASK (0xffff) | |
48 | #define MT6323_ISINK_DIM_FSEL(i) ((i) & MT6323_ISINK_DIM_FSEL_MASK) | |
49 | ||
50 | /* Register to control the brightness. */ | |
51 | #define MT6323_ISINK_CON2(i) (MT6323_ISINK0_CON2 + 0x8 * (i)) | |
52 | #define MT6323_ISINK_CH_STEP_SHIFT 12 | |
53 | #define MT6323_ISINK_CH_STEP_MASK (0x7 << 12) | |
54 | #define MT6323_ISINK_CH_STEP(i) (((i) << 12) & \ | |
55 | MT6323_ISINK_CH_STEP_MASK) | |
56 | #define MT6323_ISINK_SFSTR0_TC_MASK (0x3 << 1) | |
57 | #define MT6323_ISINK_SFSTR0_TC(i) (((i) << 1) & \ | |
58 | MT6323_ISINK_SFSTR0_TC_MASK) | |
59 | #define MT6323_ISINK_SFSTR0_EN_MASK BIT(0) | |
60 | #define MT6323_ISINK_SFSTR0_EN BIT(0) | |
61 | ||
62 | /* Register to LED channel enablement. */ | |
63 | #define MT6323_ISINK_CH_EN_MASK(i) BIT(i) | |
64 | #define MT6323_ISINK_CH_EN(i) BIT(i) | |
65 | ||
66 | #define MT6323_MAX_PERIOD 10000 | |
67 | #define MT6323_MAX_LEDS 4 | |
68 | #define MT6323_MAX_BRIGHTNESS 6 | |
69 | #define MT6323_UNIT_DUTY 3125 | |
70 | #define MT6323_CAL_HW_DUTY(o, p) DIV_ROUND_CLOSEST((o) * 100000ul,\ | |
71 | (p) * MT6323_UNIT_DUTY) | |
72 | ||
73 | struct mt6323_leds; | |
74 | ||
75 | /** | |
76 | * struct mt6323_led - state container for the LED device | |
77 | * @id: the identifier in MT6323 LED device | |
78 | * @parent: the pointer to MT6323 LED controller | |
79 | * @cdev: LED class device for this LED device | |
80 | * @current_brightness: current state of the LED device | |
81 | */ | |
82 | struct mt6323_led { | |
83 | int id; | |
84 | struct mt6323_leds *parent; | |
85 | struct led_classdev cdev; | |
86 | enum led_brightness current_brightness; | |
87 | }; | |
88 | ||
89 | /** | |
90 | * struct mt6323_leds - state container for holding LED controller | |
91 | * of the driver | |
92 | * @dev: the device pointer | |
93 | * @hw: the underlying hardware providing shared | |
94 | * bus for the register operations | |
95 | * @lock: the lock among process context | |
96 | * @led: the array that contains the state of individual | |
97 | * LED device | |
98 | */ | |
99 | struct mt6323_leds { | |
100 | struct device *dev; | |
101 | struct mt6397_chip *hw; | |
102 | /* protect among process context */ | |
103 | struct mutex lock; | |
104 | struct mt6323_led *led[MT6323_MAX_LEDS]; | |
105 | }; | |
106 | ||
107 | static int mt6323_led_hw_brightness(struct led_classdev *cdev, | |
108 | enum led_brightness brightness) | |
109 | { | |
110 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
111 | struct mt6323_leds *leds = led->parent; | |
112 | struct regmap *regmap = leds->hw->regmap; | |
113 | u32 con2_mask = 0, con2_val = 0; | |
114 | int ret; | |
115 | ||
116 | /* | |
117 | * Setup current output for the corresponding | |
118 | * brightness level. | |
119 | */ | |
120 | con2_mask |= MT6323_ISINK_CH_STEP_MASK | | |
121 | MT6323_ISINK_SFSTR0_TC_MASK | | |
122 | MT6323_ISINK_SFSTR0_EN_MASK; | |
123 | con2_val |= MT6323_ISINK_CH_STEP(brightness - 1) | | |
124 | MT6323_ISINK_SFSTR0_TC(2) | | |
125 | MT6323_ISINK_SFSTR0_EN; | |
126 | ||
127 | ret = regmap_update_bits(regmap, MT6323_ISINK_CON2(led->id), | |
128 | con2_mask, con2_val); | |
129 | return ret; | |
130 | } | |
131 | ||
132 | static int mt6323_led_hw_off(struct led_classdev *cdev) | |
133 | { | |
134 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
135 | struct mt6323_leds *leds = led->parent; | |
136 | struct regmap *regmap = leds->hw->regmap; | |
137 | unsigned int status; | |
138 | int ret; | |
139 | ||
140 | status = MT6323_ISINK_CH_EN(led->id); | |
141 | ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL, | |
142 | MT6323_ISINK_CH_EN_MASK(led->id), ~status); | |
143 | if (ret < 0) | |
144 | return ret; | |
145 | ||
146 | usleep_range(100, 300); | |
147 | ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2, | |
148 | MT6323_RG_ISINK_CK_PDN_MASK(led->id), | |
149 | MT6323_RG_ISINK_CK_PDN(led->id)); | |
150 | if (ret < 0) | |
151 | return ret; | |
152 | ||
153 | return 0; | |
154 | } | |
155 | ||
156 | static enum led_brightness | |
157 | mt6323_get_led_hw_brightness(struct led_classdev *cdev) | |
158 | { | |
159 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
160 | struct mt6323_leds *leds = led->parent; | |
161 | struct regmap *regmap = leds->hw->regmap; | |
162 | unsigned int status; | |
163 | int ret; | |
164 | ||
165 | ret = regmap_read(regmap, MT6323_TOP_CKPDN2, &status); | |
166 | if (ret < 0) | |
167 | return ret; | |
168 | ||
169 | if (status & MT6323_RG_ISINK_CK_PDN_MASK(led->id)) | |
170 | return 0; | |
171 | ||
172 | ret = regmap_read(regmap, MT6323_ISINK_EN_CTRL, &status); | |
173 | if (ret < 0) | |
174 | return ret; | |
175 | ||
176 | if (!(status & MT6323_ISINK_CH_EN(led->id))) | |
177 | return 0; | |
178 | ||
179 | ret = regmap_read(regmap, MT6323_ISINK_CON2(led->id), &status); | |
180 | if (ret < 0) | |
181 | return ret; | |
182 | ||
183 | return ((status & MT6323_ISINK_CH_STEP_MASK) | |
184 | >> MT6323_ISINK_CH_STEP_SHIFT) + 1; | |
185 | } | |
186 | ||
187 | static int mt6323_led_hw_on(struct led_classdev *cdev, | |
188 | enum led_brightness brightness) | |
189 | { | |
190 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
191 | struct mt6323_leds *leds = led->parent; | |
192 | struct regmap *regmap = leds->hw->regmap; | |
193 | unsigned int status; | |
194 | int ret; | |
195 | ||
196 | /* | |
197 | * Setup required clock source, enable the corresponding | |
198 | * clock and channel and let work with continuous blink as | |
199 | * the default. | |
200 | */ | |
201 | ret = regmap_update_bits(regmap, MT6323_TOP_CKCON1, | |
202 | MT6323_RG_ISINK_CK_SEL_MASK(led->id), 0); | |
203 | if (ret < 0) | |
204 | return ret; | |
205 | ||
206 | status = MT6323_RG_ISINK_CK_PDN(led->id); | |
207 | ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2, | |
208 | MT6323_RG_ISINK_CK_PDN_MASK(led->id), | |
209 | ~status); | |
210 | if (ret < 0) | |
211 | return ret; | |
212 | ||
213 | usleep_range(100, 300); | |
214 | ||
215 | ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL, | |
216 | MT6323_ISINK_CH_EN_MASK(led->id), | |
217 | MT6323_ISINK_CH_EN(led->id)); | |
218 | if (ret < 0) | |
219 | return ret; | |
220 | ||
221 | ret = mt6323_led_hw_brightness(cdev, brightness); | |
222 | if (ret < 0) | |
223 | return ret; | |
224 | ||
225 | ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id), | |
226 | MT6323_ISINK_DIM_DUTY_MASK, | |
227 | MT6323_ISINK_DIM_DUTY(31)); | |
228 | if (ret < 0) | |
229 | return ret; | |
230 | ||
231 | ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id), | |
232 | MT6323_ISINK_DIM_FSEL_MASK, | |
233 | MT6323_ISINK_DIM_FSEL(1000)); | |
234 | if (ret < 0) | |
235 | return ret; | |
236 | ||
237 | return 0; | |
238 | } | |
239 | ||
240 | static int mt6323_led_set_blink(struct led_classdev *cdev, | |
241 | unsigned long *delay_on, | |
242 | unsigned long *delay_off) | |
243 | { | |
244 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
245 | struct mt6323_leds *leds = led->parent; | |
246 | struct regmap *regmap = leds->hw->regmap; | |
247 | unsigned long period; | |
248 | u8 duty_hw; | |
249 | int ret; | |
250 | ||
251 | /* | |
252 | * Units are in ms, if over the hardware able | |
253 | * to support, fallback into software blink | |
254 | */ | |
255 | period = *delay_on + *delay_off; | |
256 | ||
257 | if (period > MT6323_MAX_PERIOD) | |
258 | return -EINVAL; | |
259 | ||
260 | /* | |
261 | * LED subsystem requires a default user | |
262 | * friendly blink pattern for the LED so using | |
263 | * 1Hz duty cycle 50% here if without specific | |
264 | * value delay_on and delay off being assigned. | |
265 | */ | |
266 | if (!*delay_on && !*delay_off) { | |
267 | *delay_on = 500; | |
268 | *delay_off = 500; | |
269 | } | |
270 | ||
271 | /* | |
272 | * Calculate duty_hw based on the percentage of period during | |
273 | * which the led is ON. | |
274 | */ | |
275 | duty_hw = MT6323_CAL_HW_DUTY(*delay_on, period); | |
276 | ||
277 | /* hardware doesn't support zero duty cycle. */ | |
278 | if (!duty_hw) | |
279 | return -EINVAL; | |
280 | ||
281 | mutex_lock(&leds->lock); | |
282 | /* | |
283 | * Set max_brightness as the software blink behavior | |
284 | * when no blink brightness. | |
285 | */ | |
286 | if (!led->current_brightness) { | |
287 | ret = mt6323_led_hw_on(cdev, cdev->max_brightness); | |
288 | if (ret < 0) | |
289 | goto out; | |
290 | led->current_brightness = cdev->max_brightness; | |
291 | } | |
292 | ||
293 | ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id), | |
294 | MT6323_ISINK_DIM_DUTY_MASK, | |
295 | MT6323_ISINK_DIM_DUTY(duty_hw - 1)); | |
296 | if (ret < 0) | |
297 | goto out; | |
298 | ||
299 | ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id), | |
300 | MT6323_ISINK_DIM_FSEL_MASK, | |
301 | MT6323_ISINK_DIM_FSEL(period - 1)); | |
302 | out: | |
303 | mutex_unlock(&leds->lock); | |
304 | ||
305 | return ret; | |
306 | } | |
307 | ||
308 | static int mt6323_led_set_brightness(struct led_classdev *cdev, | |
309 | enum led_brightness brightness) | |
310 | { | |
311 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
312 | struct mt6323_leds *leds = led->parent; | |
313 | int ret; | |
314 | ||
315 | mutex_lock(&leds->lock); | |
316 | ||
317 | if (!led->current_brightness && brightness) { | |
318 | ret = mt6323_led_hw_on(cdev, brightness); | |
319 | if (ret < 0) | |
320 | goto out; | |
321 | } else if (brightness) { | |
322 | ret = mt6323_led_hw_brightness(cdev, brightness); | |
323 | if (ret < 0) | |
324 | goto out; | |
325 | } else { | |
326 | ret = mt6323_led_hw_off(cdev); | |
327 | if (ret < 0) | |
328 | goto out; | |
329 | } | |
330 | ||
331 | led->current_brightness = brightness; | |
332 | out: | |
333 | mutex_unlock(&leds->lock); | |
334 | ||
335 | return ret; | |
336 | } | |
337 | ||
338 | static int mt6323_led_set_dt_default(struct led_classdev *cdev, | |
339 | struct device_node *np) | |
340 | { | |
341 | struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev); | |
342 | const char *state; | |
343 | int ret = 0; | |
344 | ||
345 | led->cdev.name = of_get_property(np, "label", NULL) ? : np->name; | |
346 | led->cdev.default_trigger = of_get_property(np, | |
347 | "linux,default-trigger", | |
348 | NULL); | |
349 | ||
350 | state = of_get_property(np, "default-state", NULL); | |
351 | if (state) { | |
352 | if (!strcmp(state, "keep")) { | |
353 | ret = mt6323_get_led_hw_brightness(cdev); | |
354 | if (ret < 0) | |
355 | return ret; | |
356 | led->current_brightness = ret; | |
357 | ret = 0; | |
358 | } else if (!strcmp(state, "on")) { | |
359 | ret = | |
360 | mt6323_led_set_brightness(cdev, cdev->max_brightness); | |
361 | } else { | |
362 | ret = mt6323_led_set_brightness(cdev, LED_OFF); | |
363 | } | |
364 | } | |
365 | ||
366 | return ret; | |
367 | } | |
368 | ||
369 | static int mt6323_led_probe(struct platform_device *pdev) | |
370 | { | |
371 | struct device *dev = &pdev->dev; | |
372 | struct device_node *np = pdev->dev.of_node; | |
373 | struct device_node *child; | |
374 | struct mt6397_chip *hw = dev_get_drvdata(pdev->dev.parent); | |
375 | struct mt6323_leds *leds; | |
376 | struct mt6323_led *led; | |
377 | int ret; | |
378 | unsigned int status; | |
379 | u32 reg; | |
380 | ||
381 | leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL); | |
382 | if (!leds) | |
383 | return -ENOMEM; | |
384 | ||
385 | platform_set_drvdata(pdev, leds); | |
386 | leds->dev = dev; | |
387 | ||
388 | /* | |
389 | * leds->hw points to the underlying bus for the register | |
390 | * controlled. | |
391 | */ | |
392 | leds->hw = hw; | |
393 | mutex_init(&leds->lock); | |
394 | ||
395 | status = MT6323_RG_DRV_32K_CK_PDN; | |
396 | ret = regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0, | |
397 | MT6323_RG_DRV_32K_CK_PDN_MASK, ~status); | |
398 | if (ret < 0) { | |
399 | dev_err(leds->dev, | |
400 | "Failed to update MT6323_TOP_CKPDN0 Register\n"); | |
401 | return ret; | |
402 | } | |
403 | ||
404 | for_each_available_child_of_node(np, child) { | |
405 | ret = of_property_read_u32(child, "reg", ®); | |
406 | if (ret) { | |
407 | dev_err(dev, "Failed to read led 'reg' property\n"); | |
408 | goto put_child_node; | |
409 | } | |
410 | ||
ac572452 | 411 | if (reg >= MT6323_MAX_LEDS || leds->led[reg]) { |
216ec6cc SW |
412 | dev_err(dev, "Invalid led reg %u\n", reg); |
413 | ret = -EINVAL; | |
414 | goto put_child_node; | |
415 | } | |
416 | ||
417 | led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL); | |
418 | if (!led) { | |
419 | ret = -ENOMEM; | |
420 | goto put_child_node; | |
421 | } | |
422 | ||
423 | leds->led[reg] = led; | |
424 | leds->led[reg]->id = reg; | |
425 | leds->led[reg]->cdev.max_brightness = MT6323_MAX_BRIGHTNESS; | |
426 | leds->led[reg]->cdev.brightness_set_blocking = | |
427 | mt6323_led_set_brightness; | |
428 | leds->led[reg]->cdev.blink_set = mt6323_led_set_blink; | |
429 | leds->led[reg]->cdev.brightness_get = | |
430 | mt6323_get_led_hw_brightness; | |
431 | leds->led[reg]->parent = leds; | |
432 | ||
433 | ret = mt6323_led_set_dt_default(&leds->led[reg]->cdev, child); | |
434 | if (ret < 0) { | |
435 | dev_err(leds->dev, | |
436 | "Failed to LED set default from devicetree\n"); | |
437 | goto put_child_node; | |
438 | } | |
439 | ||
440 | ret = devm_led_classdev_register(dev, &leds->led[reg]->cdev); | |
441 | if (ret) { | |
442 | dev_err(&pdev->dev, "Failed to register LED: %d\n", | |
443 | ret); | |
444 | goto put_child_node; | |
445 | } | |
446 | leds->led[reg]->cdev.dev->of_node = child; | |
447 | } | |
448 | ||
449 | return 0; | |
450 | ||
451 | put_child_node: | |
452 | of_node_put(child); | |
453 | return ret; | |
454 | } | |
455 | ||
456 | static int mt6323_led_remove(struct platform_device *pdev) | |
457 | { | |
458 | struct mt6323_leds *leds = platform_get_drvdata(pdev); | |
459 | int i; | |
460 | ||
461 | /* Turn the LEDs off on driver removal. */ | |
462 | for (i = 0 ; leds->led[i] ; i++) | |
463 | mt6323_led_hw_off(&leds->led[i]->cdev); | |
464 | ||
465 | regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0, | |
466 | MT6323_RG_DRV_32K_CK_PDN_MASK, | |
467 | MT6323_RG_DRV_32K_CK_PDN); | |
468 | ||
469 | mutex_destroy(&leds->lock); | |
470 | ||
471 | return 0; | |
472 | } | |
473 | ||
474 | static const struct of_device_id mt6323_led_dt_match[] = { | |
475 | { .compatible = "mediatek,mt6323-led" }, | |
476 | {}, | |
477 | }; | |
478 | MODULE_DEVICE_TABLE(of, mt6323_led_dt_match); | |
479 | ||
480 | static struct platform_driver mt6323_led_driver = { | |
481 | .probe = mt6323_led_probe, | |
482 | .remove = mt6323_led_remove, | |
483 | .driver = { | |
484 | .name = "mt6323-led", | |
485 | .of_match_table = mt6323_led_dt_match, | |
486 | }, | |
487 | }; | |
488 | ||
489 | module_platform_driver(mt6323_led_driver); | |
490 | ||
491 | MODULE_DESCRIPTION("LED driver for Mediatek MT6323 PMIC"); | |
492 | MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); | |
493 | MODULE_LICENSE("GPL"); |