GNU Linux-libre 5.13.14-gnu1
[releases.git] / drivers / leds / leds-netxbig.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs
4  *
5  * Copyright (C) 2010 LaCie
6  *
7  * Author: Simon Guinot <sguinot@lacie.com>
8  */
9
10 #include <linux/module.h>
11 #include <linux/irq.h>
12 #include <linux/slab.h>
13 #include <linux/spinlock.h>
14 #include <linux/platform_device.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/leds.h>
17 #include <linux/of.h>
18 #include <linux/of_platform.h>
19
20 struct netxbig_gpio_ext {
21         struct gpio_desc **addr;
22         int             num_addr;
23         struct gpio_desc **data;
24         int             num_data;
25         struct gpio_desc *enable;
26 };
27
28 enum netxbig_led_mode {
29         NETXBIG_LED_OFF,
30         NETXBIG_LED_ON,
31         NETXBIG_LED_SATA,
32         NETXBIG_LED_TIMER1,
33         NETXBIG_LED_TIMER2,
34         NETXBIG_LED_MODE_NUM,
35 };
36
37 #define NETXBIG_LED_INVALID_MODE NETXBIG_LED_MODE_NUM
38
39 struct netxbig_led_timer {
40         unsigned long           delay_on;
41         unsigned long           delay_off;
42         enum netxbig_led_mode   mode;
43 };
44
45 struct netxbig_led {
46         const char      *name;
47         const char      *default_trigger;
48         int             mode_addr;
49         int             *mode_val;
50         int             bright_addr;
51         int             bright_max;
52 };
53
54 struct netxbig_led_platform_data {
55         struct netxbig_gpio_ext *gpio_ext;
56         struct netxbig_led_timer *timer;
57         int                     num_timer;
58         struct netxbig_led      *leds;
59         int                     num_leds;
60 };
61
62 /*
63  * GPIO extension bus.
64  */
65
66 static DEFINE_SPINLOCK(gpio_ext_lock);
67
68 static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr)
69 {
70         int pin;
71
72         for (pin = 0; pin < gpio_ext->num_addr; pin++)
73                 gpiod_set_value(gpio_ext->addr[pin], (addr >> pin) & 1);
74 }
75
76 static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data)
77 {
78         int pin;
79
80         for (pin = 0; pin < gpio_ext->num_data; pin++)
81                 gpiod_set_value(gpio_ext->data[pin], (data >> pin) & 1);
82 }
83
84 static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext)
85 {
86         /* Enable select is done on the raising edge. */
87         gpiod_set_value(gpio_ext->enable, 0);
88         gpiod_set_value(gpio_ext->enable, 1);
89 }
90
91 static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext,
92                                int addr, int value)
93 {
94         unsigned long flags;
95
96         spin_lock_irqsave(&gpio_ext_lock, flags);
97         gpio_ext_set_addr(gpio_ext, addr);
98         gpio_ext_set_data(gpio_ext, value);
99         gpio_ext_enable_select(gpio_ext);
100         spin_unlock_irqrestore(&gpio_ext_lock, flags);
101 }
102
103 /*
104  * Class LED driver.
105  */
106
107 struct netxbig_led_data {
108         struct netxbig_gpio_ext *gpio_ext;
109         struct led_classdev     cdev;
110         int                     mode_addr;
111         int                     *mode_val;
112         int                     bright_addr;
113         struct                  netxbig_led_timer *timer;
114         int                     num_timer;
115         enum netxbig_led_mode   mode;
116         int                     sata;
117         spinlock_t              lock;
118 };
119
120 static int netxbig_led_get_timer_mode(enum netxbig_led_mode *mode,
121                                       unsigned long delay_on,
122                                       unsigned long delay_off,
123                                       struct netxbig_led_timer *timer,
124                                       int num_timer)
125 {
126         int i;
127
128         for (i = 0; i < num_timer; i++) {
129                 if (timer[i].delay_on == delay_on &&
130                     timer[i].delay_off == delay_off) {
131                         *mode = timer[i].mode;
132                         return 0;
133                 }
134         }
135         return -EINVAL;
136 }
137
138 static int netxbig_led_blink_set(struct led_classdev *led_cdev,
139                                  unsigned long *delay_on,
140                                  unsigned long *delay_off)
141 {
142         struct netxbig_led_data *led_dat =
143                 container_of(led_cdev, struct netxbig_led_data, cdev);
144         enum netxbig_led_mode mode;
145         int mode_val;
146         int ret;
147
148         /* Look for a LED mode with the requested timer frequency. */
149         ret = netxbig_led_get_timer_mode(&mode, *delay_on, *delay_off,
150                                          led_dat->timer, led_dat->num_timer);
151         if (ret < 0)
152                 return ret;
153
154         mode_val = led_dat->mode_val[mode];
155         if (mode_val == NETXBIG_LED_INVALID_MODE)
156                 return -EINVAL;
157
158         spin_lock_irq(&led_dat->lock);
159
160         gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
161         led_dat->mode = mode;
162
163         spin_unlock_irq(&led_dat->lock);
164
165         return 0;
166 }
167
168 static void netxbig_led_set(struct led_classdev *led_cdev,
169                             enum led_brightness value)
170 {
171         struct netxbig_led_data *led_dat =
172                 container_of(led_cdev, struct netxbig_led_data, cdev);
173         enum netxbig_led_mode mode;
174         int mode_val;
175         int set_brightness = 1;
176         unsigned long flags;
177
178         spin_lock_irqsave(&led_dat->lock, flags);
179
180         if (value == LED_OFF) {
181                 mode = NETXBIG_LED_OFF;
182                 set_brightness = 0;
183         } else {
184                 if (led_dat->sata)
185                         mode = NETXBIG_LED_SATA;
186                 else if (led_dat->mode == NETXBIG_LED_OFF)
187                         mode = NETXBIG_LED_ON;
188                 else /* Keep 'timer' mode. */
189                         mode = led_dat->mode;
190         }
191         mode_val = led_dat->mode_val[mode];
192
193         gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
194         led_dat->mode = mode;
195         /*
196          * Note that the brightness register is shared between all the
197          * SATA LEDs. So, change the brightness setting for a single
198          * SATA LED will affect all the others.
199          */
200         if (set_brightness)
201                 gpio_ext_set_value(led_dat->gpio_ext,
202                                    led_dat->bright_addr, value);
203
204         spin_unlock_irqrestore(&led_dat->lock, flags);
205 }
206
207 static ssize_t sata_store(struct device *dev,
208                           struct device_attribute *attr,
209                           const char *buff, size_t count)
210 {
211         struct led_classdev *led_cdev = dev_get_drvdata(dev);
212         struct netxbig_led_data *led_dat =
213                 container_of(led_cdev, struct netxbig_led_data, cdev);
214         unsigned long enable;
215         enum netxbig_led_mode mode;
216         int mode_val;
217         int ret;
218
219         ret = kstrtoul(buff, 10, &enable);
220         if (ret < 0)
221                 return ret;
222
223         enable = !!enable;
224
225         spin_lock_irq(&led_dat->lock);
226
227         if (led_dat->sata == enable) {
228                 ret = count;
229                 goto exit_unlock;
230         }
231
232         if (led_dat->mode != NETXBIG_LED_ON &&
233             led_dat->mode != NETXBIG_LED_SATA)
234                 mode = led_dat->mode; /* Keep modes 'off' and 'timer'. */
235         else if (enable)
236                 mode = NETXBIG_LED_SATA;
237         else
238                 mode = NETXBIG_LED_ON;
239
240         mode_val = led_dat->mode_val[mode];
241         if (mode_val == NETXBIG_LED_INVALID_MODE) {
242                 ret = -EINVAL;
243                 goto exit_unlock;
244         }
245
246         gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
247         led_dat->mode = mode;
248         led_dat->sata = enable;
249
250         ret = count;
251
252 exit_unlock:
253         spin_unlock_irq(&led_dat->lock);
254
255         return ret;
256 }
257
258 static ssize_t sata_show(struct device *dev,
259                          struct device_attribute *attr, char *buf)
260 {
261         struct led_classdev *led_cdev = dev_get_drvdata(dev);
262         struct netxbig_led_data *led_dat =
263                 container_of(led_cdev, struct netxbig_led_data, cdev);
264
265         return sprintf(buf, "%d\n", led_dat->sata);
266 }
267
268 static DEVICE_ATTR_RW(sata);
269
270 static struct attribute *netxbig_led_attrs[] = {
271         &dev_attr_sata.attr,
272         NULL
273 };
274 ATTRIBUTE_GROUPS(netxbig_led);
275
276 static int create_netxbig_led(struct platform_device *pdev,
277                               struct netxbig_led_platform_data *pdata,
278                               struct netxbig_led_data *led_dat,
279                               const struct netxbig_led *template)
280 {
281         spin_lock_init(&led_dat->lock);
282         led_dat->gpio_ext = pdata->gpio_ext;
283         led_dat->cdev.name = template->name;
284         led_dat->cdev.default_trigger = template->default_trigger;
285         led_dat->cdev.blink_set = netxbig_led_blink_set;
286         led_dat->cdev.brightness_set = netxbig_led_set;
287         /*
288          * Because the GPIO extension bus don't allow to read registers
289          * value, there is no way to probe the LED initial state.
290          * So, the initial sysfs LED value for the "brightness" and "sata"
291          * attributes are inconsistent.
292          *
293          * Note that the initial LED state can't be reconfigured.
294          * The reason is that the LED behaviour must stay uniform during
295          * the whole boot process (bootloader+linux).
296          */
297         led_dat->sata = 0;
298         led_dat->cdev.brightness = LED_OFF;
299         led_dat->cdev.max_brightness = template->bright_max;
300         led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
301         led_dat->mode_addr = template->mode_addr;
302         led_dat->mode_val = template->mode_val;
303         led_dat->bright_addr = template->bright_addr;
304         led_dat->timer = pdata->timer;
305         led_dat->num_timer = pdata->num_timer;
306         /*
307          * If available, expose the SATA activity blink capability through
308          * a "sata" sysfs attribute.
309          */
310         if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE)
311                 led_dat->cdev.groups = netxbig_led_groups;
312
313         return devm_led_classdev_register(&pdev->dev, &led_dat->cdev);
314 }
315
316 /**
317  * netxbig_gpio_ext_remove() - Clean up GPIO extension data
318  * @data: managed resource data to clean up
319  *
320  * Since we pick GPIO descriptors from another device than the device our
321  * driver is probing to, we need to register a specific callback to free
322  * these up using managed resources.
323  */
324 static void netxbig_gpio_ext_remove(void *data)
325 {
326         struct netxbig_gpio_ext *gpio_ext = data;
327         int i;
328
329         for (i = 0; i < gpio_ext->num_addr; i++)
330                 gpiod_put(gpio_ext->addr[i]);
331         for (i = 0; i < gpio_ext->num_data; i++)
332                 gpiod_put(gpio_ext->data[i]);
333         gpiod_put(gpio_ext->enable);
334 }
335
336 /**
337  * netxbig_gpio_ext_get() - Obtain GPIO extension device data
338  * @dev: main LED device
339  * @gpio_ext_dev: the GPIO extension device
340  * @gpio_ext: the data structure holding the GPIO extension data
341  *
342  * This function walks the subdevice that only contain GPIO line
343  * handles in the device tree and obtains the GPIO descriptors from that
344  * device.
345  */
346 static int netxbig_gpio_ext_get(struct device *dev,
347                                 struct device *gpio_ext_dev,
348                                 struct netxbig_gpio_ext *gpio_ext)
349 {
350         struct gpio_desc **addr, **data;
351         int num_addr, num_data;
352         struct gpio_desc *gpiod;
353         int ret;
354         int i;
355
356         ret = gpiod_count(gpio_ext_dev, "addr");
357         if (ret < 0) {
358                 dev_err(dev,
359                         "Failed to count GPIOs in DT property addr-gpios\n");
360                 return ret;
361         }
362         num_addr = ret;
363         addr = devm_kcalloc(dev, num_addr, sizeof(*addr), GFP_KERNEL);
364         if (!addr)
365                 return -ENOMEM;
366
367         /*
368          * We cannot use devm_ managed resources with these GPIO descriptors
369          * since they are associated with the "GPIO extension device" which
370          * does not probe any driver. The device tree parser will however
371          * populate a platform device for it so we can anyway obtain the
372          * GPIO descriptors from the device.
373          */
374         for (i = 0; i < num_addr; i++) {
375                 gpiod = gpiod_get_index(gpio_ext_dev, "addr", i,
376                                         GPIOD_OUT_LOW);
377                 if (IS_ERR(gpiod))
378                         return PTR_ERR(gpiod);
379                 gpiod_set_consumer_name(gpiod, "GPIO extension addr");
380                 addr[i] = gpiod;
381         }
382         gpio_ext->addr = addr;
383         gpio_ext->num_addr = num_addr;
384
385         ret = gpiod_count(gpio_ext_dev, "data");
386         if (ret < 0) {
387                 dev_err(dev,
388                         "Failed to count GPIOs in DT property data-gpios\n");
389                 return ret;
390         }
391         num_data = ret;
392         data = devm_kcalloc(dev, num_data, sizeof(*data), GFP_KERNEL);
393         if (!data)
394                 return -ENOMEM;
395
396         for (i = 0; i < num_data; i++) {
397                 gpiod = gpiod_get_index(gpio_ext_dev, "data", i,
398                                         GPIOD_OUT_LOW);
399                 if (IS_ERR(gpiod))
400                         return PTR_ERR(gpiod);
401                 gpiod_set_consumer_name(gpiod, "GPIO extension data");
402                 data[i] = gpiod;
403         }
404         gpio_ext->data = data;
405         gpio_ext->num_data = num_data;
406
407         gpiod = gpiod_get(gpio_ext_dev, "enable", GPIOD_OUT_LOW);
408         if (IS_ERR(gpiod)) {
409                 dev_err(dev,
410                         "Failed to get GPIO from DT property enable-gpio\n");
411                 return PTR_ERR(gpiod);
412         }
413         gpiod_set_consumer_name(gpiod, "GPIO extension enable");
414         gpio_ext->enable = gpiod;
415
416         return devm_add_action_or_reset(dev, netxbig_gpio_ext_remove, gpio_ext);
417 }
418
419 static int netxbig_leds_get_of_pdata(struct device *dev,
420                                      struct netxbig_led_platform_data *pdata)
421 {
422         struct device_node *np = dev_of_node(dev);
423         struct device_node *gpio_ext_np;
424         struct platform_device *gpio_ext_pdev;
425         struct device *gpio_ext_dev;
426         struct device_node *child;
427         struct netxbig_gpio_ext *gpio_ext;
428         struct netxbig_led_timer *timers;
429         struct netxbig_led *leds, *led;
430         int num_timers;
431         int num_leds = 0;
432         int ret;
433         int i;
434
435         /* GPIO extension */
436         gpio_ext_np = of_parse_phandle(np, "gpio-ext", 0);
437         if (!gpio_ext_np) {
438                 dev_err(dev, "Failed to get DT handle gpio-ext\n");
439                 return -EINVAL;
440         }
441         gpio_ext_pdev = of_find_device_by_node(gpio_ext_np);
442         if (!gpio_ext_pdev) {
443                 dev_err(dev, "Failed to find platform device for gpio-ext\n");
444                 return -ENODEV;
445         }
446         gpio_ext_dev = &gpio_ext_pdev->dev;
447
448         gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL);
449         if (!gpio_ext) {
450                 of_node_put(gpio_ext_np);
451                 ret = -ENOMEM;
452                 goto put_device;
453         }
454         ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext);
455         of_node_put(gpio_ext_np);
456         if (ret)
457                 goto put_device;
458         pdata->gpio_ext = gpio_ext;
459
460         /* Timers (optional) */
461         ret = of_property_count_u32_elems(np, "timers");
462         if (ret > 0) {
463                 if (ret % 3) {
464                         ret = -EINVAL;
465                         goto put_device;
466                 }
467
468                 num_timers = ret / 3;
469                 timers = devm_kcalloc(dev, num_timers, sizeof(*timers),
470                                       GFP_KERNEL);
471                 if (!timers) {
472                         ret = -ENOMEM;
473                         goto put_device;
474                 }
475                 for (i = 0; i < num_timers; i++) {
476                         u32 tmp;
477
478                         of_property_read_u32_index(np, "timers", 3 * i,
479                                                    &timers[i].mode);
480                         if (timers[i].mode >= NETXBIG_LED_MODE_NUM) {
481                                 ret = -EINVAL;
482                                 goto put_device;
483                         }
484                         of_property_read_u32_index(np, "timers",
485                                                    3 * i + 1, &tmp);
486                         timers[i].delay_on = tmp;
487                         of_property_read_u32_index(np, "timers",
488                                                    3 * i + 2, &tmp);
489                         timers[i].delay_off = tmp;
490                 }
491                 pdata->timer = timers;
492                 pdata->num_timer = num_timers;
493         }
494
495         /* LEDs */
496         num_leds = of_get_available_child_count(np);
497         if (!num_leds) {
498                 dev_err(dev, "No LED subnodes found in DT\n");
499                 ret = -ENODEV;
500                 goto put_device;
501         }
502
503         leds = devm_kcalloc(dev, num_leds, sizeof(*leds), GFP_KERNEL);
504         if (!leds) {
505                 ret = -ENOMEM;
506                 goto put_device;
507         }
508
509         led = leds;
510         for_each_available_child_of_node(np, child) {
511                 const char *string;
512                 int *mode_val;
513                 int num_modes;
514
515                 ret = of_property_read_u32(child, "mode-addr",
516                                            &led->mode_addr);
517                 if (ret)
518                         goto err_node_put;
519
520                 ret = of_property_read_u32(child, "bright-addr",
521                                            &led->bright_addr);
522                 if (ret)
523                         goto err_node_put;
524
525                 ret = of_property_read_u32(child, "max-brightness",
526                                            &led->bright_max);
527                 if (ret)
528                         goto err_node_put;
529
530                 mode_val =
531                         devm_kcalloc(dev,
532                                      NETXBIG_LED_MODE_NUM, sizeof(*mode_val),
533                                      GFP_KERNEL);
534                 if (!mode_val) {
535                         ret = -ENOMEM;
536                         goto err_node_put;
537                 }
538
539                 for (i = 0; i < NETXBIG_LED_MODE_NUM; i++)
540                         mode_val[i] = NETXBIG_LED_INVALID_MODE;
541
542                 ret = of_property_count_u32_elems(child, "mode-val");
543                 if (ret < 0 || ret % 2) {
544                         ret = -EINVAL;
545                         goto err_node_put;
546                 }
547                 num_modes = ret / 2;
548                 if (num_modes > NETXBIG_LED_MODE_NUM) {
549                         ret = -EINVAL;
550                         goto err_node_put;
551                 }
552
553                 for (i = 0; i < num_modes; i++) {
554                         int mode;
555                         int val;
556
557                         of_property_read_u32_index(child,
558                                                    "mode-val", 2 * i, &mode);
559                         of_property_read_u32_index(child,
560                                                    "mode-val", 2 * i + 1, &val);
561                         if (mode >= NETXBIG_LED_MODE_NUM) {
562                                 ret = -EINVAL;
563                                 goto err_node_put;
564                         }
565                         mode_val[mode] = val;
566                 }
567                 led->mode_val = mode_val;
568
569                 if (!of_property_read_string(child, "label", &string))
570                         led->name = string;
571                 else
572                         led->name = child->name;
573
574                 if (!of_property_read_string(child,
575                                              "linux,default-trigger", &string))
576                         led->default_trigger = string;
577
578                 led++;
579         }
580
581         pdata->leds = leds;
582         pdata->num_leds = num_leds;
583
584         return 0;
585
586 err_node_put:
587         of_node_put(child);
588 put_device:
589         put_device(gpio_ext_dev);
590         return ret;
591 }
592
593 static const struct of_device_id of_netxbig_leds_match[] = {
594         { .compatible = "lacie,netxbig-leds", },
595         {},
596 };
597 MODULE_DEVICE_TABLE(of, of_netxbig_leds_match);
598
599 static int netxbig_led_probe(struct platform_device *pdev)
600 {
601         struct netxbig_led_platform_data *pdata;
602         struct netxbig_led_data *leds_data;
603         int i;
604         int ret;
605
606         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
607         if (!pdata)
608                 return -ENOMEM;
609         ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata);
610         if (ret)
611                 return ret;
612
613         leds_data = devm_kcalloc(&pdev->dev,
614                                  pdata->num_leds, sizeof(*leds_data),
615                                  GFP_KERNEL);
616         if (!leds_data)
617                 return -ENOMEM;
618
619         for (i = 0; i < pdata->num_leds; i++) {
620                 ret = create_netxbig_led(pdev, pdata,
621                                          &leds_data[i], &pdata->leds[i]);
622                 if (ret < 0)
623                         return ret;
624         }
625
626         return 0;
627 }
628
629 static struct platform_driver netxbig_led_driver = {
630         .probe          = netxbig_led_probe,
631         .driver         = {
632                 .name           = "leds-netxbig",
633                 .of_match_table = of_netxbig_leds_match,
634         },
635 };
636
637 module_platform_driver(netxbig_led_driver);
638
639 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
640 MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards");
641 MODULE_LICENSE("GPL");
642 MODULE_ALIAS("platform:leds-netxbig");