treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / leds / leds-mt6323.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * LED driver for Mediatek MT6323 PMIC
4  *
5  * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com>
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", &reg);
406                 if (ret) {
407                         dev_err(dev, "Failed to read led 'reg' property\n");
408                         goto put_child_node;
409                 }
410
411                 if (reg >= MT6323_MAX_LEDS || leds->led[reg]) {
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");