Merge branch 'for-linus-4.5' of git://git.kernel.org/pub/scm/linux/kernel/git/mason...
[platform/kernel/linux-rpi.git] / drivers / leds / leds-ktd2692.c
1 /*
2  * LED driver : leds-ktd2692.c
3  *
4  * Copyright (C) 2015 Samsung Electronics
5  * Ingi Kim <ingi2.kim@samsung.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/delay.h>
13 #include <linux/err.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/led-class-flash.h>
16 #include <linux/module.h>
17 #include <linux/mutex.h>
18 #include <linux/of.h>
19 #include <linux/platform_device.h>
20 #include <linux/regulator/consumer.h>
21
22 /* Value related the movie mode */
23 #define KTD2692_MOVIE_MODE_CURRENT_LEVELS       16
24 #define KTD2692_MM_TO_FL_RATIO(x)               ((x) / 3)
25 #define KTD2962_MM_MIN_CURR_THRESHOLD_SCALE     8
26
27 /* Value related the flash mode */
28 #define KTD2692_FLASH_MODE_TIMEOUT_LEVELS       8
29 #define KTD2692_FLASH_MODE_TIMEOUT_DISABLE      0
30 #define KTD2692_FLASH_MODE_CURR_PERCENT(x)      (((x) * 16) / 100)
31
32 /* Macro for getting offset of flash timeout */
33 #define GET_TIMEOUT_OFFSET(timeout, step)       ((timeout) / (step))
34
35 /* Base register address */
36 #define KTD2692_REG_LVP_BASE                    0x00
37 #define KTD2692_REG_FLASH_TIMEOUT_BASE          0x20
38 #define KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE  0x40
39 #define KTD2692_REG_MOVIE_CURRENT_BASE          0x60
40 #define KTD2692_REG_FLASH_CURRENT_BASE          0x80
41 #define KTD2692_REG_MODE_BASE                   0xA0
42
43 /* Set bit coding time for expresswire interface */
44 #define KTD2692_TIME_RESET_US                   700
45 #define KTD2692_TIME_DATA_START_TIME_US         10
46 #define KTD2692_TIME_HIGH_END_OF_DATA_US        350
47 #define KTD2692_TIME_LOW_END_OF_DATA_US         10
48 #define KTD2692_TIME_SHORT_BITSET_US            4
49 #define KTD2692_TIME_LONG_BITSET_US             12
50
51 /* KTD2692 default length of name */
52 #define KTD2692_NAME_LENGTH                     20
53
54 enum ktd2692_bitset {
55         KTD2692_LOW = 0,
56         KTD2692_HIGH,
57 };
58
59 /* Movie / Flash Mode Control */
60 enum ktd2692_led_mode {
61         KTD2692_MODE_DISABLE = 0,       /* default */
62         KTD2692_MODE_MOVIE,
63         KTD2692_MODE_FLASH,
64 };
65
66 struct ktd2692_led_config_data {
67         /* maximum LED current in movie mode */
68         u32 movie_max_microamp;
69         /* maximum LED current in flash mode */
70         u32 flash_max_microamp;
71         /* maximum flash timeout */
72         u32 flash_max_timeout;
73         /* max LED brightness level */
74         enum led_brightness max_brightness;
75 };
76
77 struct ktd2692_context {
78         /* Related LED Flash class device */
79         struct led_classdev_flash fled_cdev;
80
81         /* secures access to the device */
82         struct mutex lock;
83         struct regulator *regulator;
84
85         struct gpio_desc *aux_gpio;
86         struct gpio_desc *ctrl_gpio;
87
88         enum ktd2692_led_mode mode;
89         enum led_brightness torch_brightness;
90 };
91
92 static struct ktd2692_context *fled_cdev_to_led(
93                                 struct led_classdev_flash *fled_cdev)
94 {
95         return container_of(fled_cdev, struct ktd2692_context, fled_cdev);
96 }
97
98 static void ktd2692_expresswire_start(struct ktd2692_context *led)
99 {
100         gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
101         udelay(KTD2692_TIME_DATA_START_TIME_US);
102 }
103
104 static void ktd2692_expresswire_reset(struct ktd2692_context *led)
105 {
106         gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
107         udelay(KTD2692_TIME_RESET_US);
108 }
109
110 static void ktd2692_expresswire_end(struct ktd2692_context *led)
111 {
112         gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
113         udelay(KTD2692_TIME_LOW_END_OF_DATA_US);
114         gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
115         udelay(KTD2692_TIME_HIGH_END_OF_DATA_US);
116 }
117
118 static void ktd2692_expresswire_set_bit(struct ktd2692_context *led, bool bit)
119 {
120         /*
121          * The Low Bit(0) and High Bit(1) is based on a time detection
122          * algorithm between time low and time high
123          * Time_(L_LB) : Low time of the Low Bit(0)
124          * Time_(H_LB) : High time of the LOW Bit(0)
125          * Time_(L_HB) : Low time of the High Bit(1)
126          * Time_(H_HB) : High time of the High Bit(1)
127          *
128          * It can be simplified to:
129          * Low Bit(0) : 2 * Time_(H_LB) < Time_(L_LB)
130          * High Bit(1) : 2 * Time_(L_HB) < Time_(H_HB)
131          * HIGH  ___           ____    _..     _________    ___
132          *          |_________|    |_..  |____|         |__|
133          * LOW        <L_LB>  <H_LB>     <L_HB>  <H_HB>
134          *          [  Low Bit (0) ]     [  High Bit(1) ]
135          */
136         if (bit) {
137                 gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
138                 udelay(KTD2692_TIME_SHORT_BITSET_US);
139                 gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
140                 udelay(KTD2692_TIME_LONG_BITSET_US);
141         } else {
142                 gpiod_direction_output(led->ctrl_gpio, KTD2692_LOW);
143                 udelay(KTD2692_TIME_LONG_BITSET_US);
144                 gpiod_direction_output(led->ctrl_gpio, KTD2692_HIGH);
145                 udelay(KTD2692_TIME_SHORT_BITSET_US);
146         }
147 }
148
149 static void ktd2692_expresswire_write(struct ktd2692_context *led, u8 value)
150 {
151         int i;
152
153         ktd2692_expresswire_start(led);
154         for (i = 7; i >= 0; i--)
155                 ktd2692_expresswire_set_bit(led, value & BIT(i));
156         ktd2692_expresswire_end(led);
157 }
158
159 static int ktd2692_led_brightness_set(struct led_classdev *led_cdev,
160                                        enum led_brightness brightness)
161 {
162         struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(led_cdev);
163         struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
164
165         mutex_lock(&led->lock);
166
167         if (brightness == LED_OFF) {
168                 led->mode = KTD2692_MODE_DISABLE;
169                 gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
170         } else {
171                 ktd2692_expresswire_write(led, brightness |
172                                         KTD2692_REG_MOVIE_CURRENT_BASE);
173                 led->mode = KTD2692_MODE_MOVIE;
174         }
175
176         ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
177         mutex_unlock(&led->lock);
178
179         return 0;
180 }
181
182 static int ktd2692_led_flash_strobe_set(struct led_classdev_flash *fled_cdev,
183                                         bool state)
184 {
185         struct ktd2692_context *led = fled_cdev_to_led(fled_cdev);
186         struct led_flash_setting *timeout = &fled_cdev->timeout;
187         u32 flash_tm_reg;
188
189         mutex_lock(&led->lock);
190
191         if (state) {
192                 flash_tm_reg = GET_TIMEOUT_OFFSET(timeout->val, timeout->step);
193                 ktd2692_expresswire_write(led, flash_tm_reg
194                                 | KTD2692_REG_FLASH_TIMEOUT_BASE);
195
196                 led->mode = KTD2692_MODE_FLASH;
197                 gpiod_direction_output(led->aux_gpio, KTD2692_HIGH);
198         } else {
199                 led->mode = KTD2692_MODE_DISABLE;
200                 gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
201         }
202
203         ktd2692_expresswire_write(led, led->mode | KTD2692_REG_MODE_BASE);
204
205         fled_cdev->led_cdev.brightness = LED_OFF;
206         led->mode = KTD2692_MODE_DISABLE;
207
208         mutex_unlock(&led->lock);
209
210         return 0;
211 }
212
213 static int ktd2692_led_flash_timeout_set(struct led_classdev_flash *fled_cdev,
214                                          u32 timeout)
215 {
216         return 0;
217 }
218
219 static void ktd2692_init_movie_current_max(struct ktd2692_led_config_data *cfg)
220 {
221         u32 offset, step;
222         u32 movie_current_microamp;
223
224         offset = KTD2692_MOVIE_MODE_CURRENT_LEVELS;
225         step = KTD2692_MM_TO_FL_RATIO(cfg->flash_max_microamp)
226                 / KTD2692_MOVIE_MODE_CURRENT_LEVELS;
227
228         do {
229                 movie_current_microamp = step * offset;
230                 offset--;
231         } while ((movie_current_microamp > cfg->movie_max_microamp) &&
232                 (offset > 0));
233
234         cfg->max_brightness = offset;
235 }
236
237 static void ktd2692_init_flash_timeout(struct led_classdev_flash *fled_cdev,
238                                        struct ktd2692_led_config_data *cfg)
239 {
240         struct led_flash_setting *setting;
241
242         setting = &fled_cdev->timeout;
243         setting->min = KTD2692_FLASH_MODE_TIMEOUT_DISABLE;
244         setting->max = cfg->flash_max_timeout;
245         setting->step = cfg->flash_max_timeout
246                         / (KTD2692_FLASH_MODE_TIMEOUT_LEVELS - 1);
247         setting->val = cfg->flash_max_timeout;
248 }
249
250 static void ktd2692_setup(struct ktd2692_context *led)
251 {
252         led->mode = KTD2692_MODE_DISABLE;
253         ktd2692_expresswire_reset(led);
254         gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
255
256         ktd2692_expresswire_write(led, (KTD2962_MM_MIN_CURR_THRESHOLD_SCALE - 1)
257                                  | KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
258         ktd2692_expresswire_write(led, KTD2692_FLASH_MODE_CURR_PERCENT(45)
259                                  | KTD2692_REG_FLASH_CURRENT_BASE);
260 }
261
262 static int ktd2692_parse_dt(struct ktd2692_context *led, struct device *dev,
263                             struct ktd2692_led_config_data *cfg)
264 {
265         struct device_node *np = dev->of_node;
266         struct device_node *child_node;
267         int ret;
268
269         if (!dev->of_node)
270                 return -ENXIO;
271
272         led->ctrl_gpio = devm_gpiod_get(dev, "ctrl", GPIOD_ASIS);
273         if (IS_ERR(led->ctrl_gpio)) {
274                 ret = PTR_ERR(led->ctrl_gpio);
275                 dev_err(dev, "cannot get ctrl-gpios %d\n", ret);
276                 return ret;
277         }
278
279         led->aux_gpio = devm_gpiod_get(dev, "aux", GPIOD_ASIS);
280         if (IS_ERR(led->aux_gpio)) {
281                 ret = PTR_ERR(led->aux_gpio);
282                 dev_err(dev, "cannot get aux-gpios %d\n", ret);
283                 return ret;
284         }
285
286         led->regulator = devm_regulator_get(dev, "vin");
287         if (IS_ERR(led->regulator))
288                 led->regulator = NULL;
289
290         if (led->regulator) {
291                 ret = regulator_enable(led->regulator);
292                 if (ret)
293                         dev_err(dev, "Failed to enable supply: %d\n", ret);
294         }
295
296         child_node = of_get_next_available_child(np, NULL);
297         if (!child_node) {
298                 dev_err(dev, "No DT child node found for connected LED.\n");
299                 return -EINVAL;
300         }
301
302         led->fled_cdev.led_cdev.name =
303                 of_get_property(child_node, "label", NULL) ? : child_node->name;
304
305         ret = of_property_read_u32(child_node, "led-max-microamp",
306                                    &cfg->movie_max_microamp);
307         if (ret) {
308                 dev_err(dev, "failed to parse led-max-microamp\n");
309                 goto err_parse_dt;
310         }
311
312         ret = of_property_read_u32(child_node, "flash-max-microamp",
313                                    &cfg->flash_max_microamp);
314         if (ret) {
315                 dev_err(dev, "failed to parse flash-max-microamp\n");
316                 goto err_parse_dt;
317         }
318
319         ret = of_property_read_u32(child_node, "flash-max-timeout-us",
320                                    &cfg->flash_max_timeout);
321         if (ret) {
322                 dev_err(dev, "failed to parse flash-max-timeout-us\n");
323                 goto err_parse_dt;
324         }
325
326 err_parse_dt:
327         of_node_put(child_node);
328         return ret;
329 }
330
331 static const struct led_flash_ops flash_ops = {
332         .strobe_set = ktd2692_led_flash_strobe_set,
333         .timeout_set = ktd2692_led_flash_timeout_set,
334 };
335
336 static int ktd2692_probe(struct platform_device *pdev)
337 {
338         struct ktd2692_context *led;
339         struct led_classdev *led_cdev;
340         struct led_classdev_flash *fled_cdev;
341         struct ktd2692_led_config_data led_cfg;
342         int ret;
343
344         led = devm_kzalloc(&pdev->dev, sizeof(*led), GFP_KERNEL);
345         if (!led)
346                 return -ENOMEM;
347
348         fled_cdev = &led->fled_cdev;
349         led_cdev = &fled_cdev->led_cdev;
350
351         ret = ktd2692_parse_dt(led, &pdev->dev, &led_cfg);
352         if (ret)
353                 return ret;
354
355         ktd2692_init_flash_timeout(fled_cdev, &led_cfg);
356         ktd2692_init_movie_current_max(&led_cfg);
357
358         fled_cdev->ops = &flash_ops;
359
360         led_cdev->max_brightness = led_cfg.max_brightness;
361         led_cdev->brightness_set_blocking = ktd2692_led_brightness_set;
362         led_cdev->flags |= LED_CORE_SUSPENDRESUME | LED_DEV_CAP_FLASH;
363
364         mutex_init(&led->lock);
365
366         platform_set_drvdata(pdev, led);
367
368         ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
369         if (ret) {
370                 dev_err(&pdev->dev, "can't register LED %s\n", led_cdev->name);
371                 mutex_destroy(&led->lock);
372                 return ret;
373         }
374
375         ktd2692_setup(led);
376
377         return 0;
378 }
379
380 static int ktd2692_remove(struct platform_device *pdev)
381 {
382         struct ktd2692_context *led = platform_get_drvdata(pdev);
383         int ret;
384
385         led_classdev_flash_unregister(&led->fled_cdev);
386
387         if (led->regulator) {
388                 ret = regulator_disable(led->regulator);
389                 if (ret)
390                         dev_err(&pdev->dev,
391                                 "Failed to disable supply: %d\n", ret);
392         }
393
394         mutex_destroy(&led->lock);
395
396         return 0;
397 }
398
399 static const struct of_device_id ktd2692_match[] = {
400         { .compatible = "kinetic,ktd2692", },
401         { /* sentinel */ },
402 };
403 MODULE_DEVICE_TABLE(of, ktd2692_match);
404
405 static struct platform_driver ktd2692_driver = {
406         .driver = {
407                 .name  = "ktd2692",
408                 .of_match_table = ktd2692_match,
409         },
410         .probe  = ktd2692_probe,
411         .remove = ktd2692_remove,
412 };
413
414 module_platform_driver(ktd2692_driver);
415
416 MODULE_AUTHOR("Ingi Kim <ingi2.kim@samsung.com>");
417 MODULE_DESCRIPTION("Kinetic KTD2692 LED driver");
418 MODULE_LICENSE("GPL v2");