1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * LED Class Core
4 *
5 * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
6 * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
7 */
8
9 #include <linux/ctype.h>
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/leds.h>
15 #include <linux/list.h>
16 #include <linux/module.h>
17 #include <linux/property.h>
18 #include <linux/slab.h>
19 #include <linux/spinlock.h>
20 #include <linux/timer.h>
21 #include <uapi/linux/uleds.h>
22 #include <linux/of.h>
23 #include "leds.h"
24
25 static DEFINE_MUTEX(leds_lookup_lock);
26 static LIST_HEAD(leds_lookup_list);
27
brightness_show(struct device * dev,struct device_attribute * attr,char * buf)28 static ssize_t brightness_show(struct device *dev,
29 struct device_attribute *attr, char *buf)
30 {
31 struct led_classdev *led_cdev = dev_get_drvdata(dev);
32
33 /* no lock needed for this */
34 led_update_brightness(led_cdev);
35
36 return sprintf(buf, "%u\n", led_cdev->brightness);
37 }
38
brightness_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)39 static ssize_t brightness_store(struct device *dev,
40 struct device_attribute *attr, const char *buf, size_t size)
41 {
42 struct led_classdev *led_cdev = dev_get_drvdata(dev);
43 unsigned long state;
44 ssize_t ret;
45
46 mutex_lock(&led_cdev->led_access);
47
48 if (led_sysfs_is_disabled(led_cdev)) {
49 ret = -EBUSY;
50 goto unlock;
51 }
52
53 ret = kstrtoul(buf, 10, &state);
54 if (ret)
55 goto unlock;
56
57 if (state == LED_OFF)
58 led_trigger_remove(led_cdev);
59 /* flush out any request to disable blinking */
60 flush_work(&led_cdev->set_brightness_work);
61 led_set_brightness(led_cdev, state);
62 flush_work(&led_cdev->set_brightness_work);
63
64 ret = size;
65 unlock:
66 mutex_unlock(&led_cdev->led_access);
67 return ret;
68 }
69 static DEVICE_ATTR_RW(brightness);
70
max_brightness_show(struct device * dev,struct device_attribute * attr,char * buf)71 static ssize_t max_brightness_show(struct device *dev,
72 struct device_attribute *attr, char *buf)
73 {
74 struct led_classdev *led_cdev = dev_get_drvdata(dev);
75
76 return sprintf(buf, "%u\n", led_cdev->max_brightness);
77 }
78 static DEVICE_ATTR_RO(max_brightness);
79
80 #ifdef CONFIG_LEDS_TRIGGERS
81 static BIN_ATTR(trigger, 0644, led_trigger_read, led_trigger_write, 0);
82 static struct bin_attribute *led_trigger_bin_attrs[] = {
83 &bin_attr_trigger,
84 NULL,
85 };
86 static const struct attribute_group led_trigger_group = {
87 .bin_attrs = led_trigger_bin_attrs,
88 };
89 #endif
90
91 static struct attribute *led_class_attrs[] = {
92 &dev_attr_brightness.attr,
93 &dev_attr_max_brightness.attr,
94 NULL,
95 };
96
97 static const struct attribute_group led_group = {
98 .attrs = led_class_attrs,
99 };
100
101 static const struct attribute_group *led_groups[] = {
102 &led_group,
103 #ifdef CONFIG_LEDS_TRIGGERS
104 &led_trigger_group,
105 #endif
106 NULL,
107 };
108
109 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
brightness_hw_changed_show(struct device * dev,struct device_attribute * attr,char * buf)110 static ssize_t brightness_hw_changed_show(struct device *dev,
111 struct device_attribute *attr, char *buf)
112 {
113 struct led_classdev *led_cdev = dev_get_drvdata(dev);
114
115 if (led_cdev->brightness_hw_changed == -1)
116 return -ENODATA;
117
118 return sprintf(buf, "%u\n", led_cdev->brightness_hw_changed);
119 }
120
121 static DEVICE_ATTR_RO(brightness_hw_changed);
122
led_add_brightness_hw_changed(struct led_classdev * led_cdev)123 static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
124 {
125 struct device *dev = led_cdev->dev;
126 int ret;
127
128 ret = device_create_file(dev, &dev_attr_brightness_hw_changed);
129 if (ret) {
130 dev_err(dev, "Error creating brightness_hw_changed\n");
131 return ret;
132 }
133
134 led_cdev->brightness_hw_changed_kn =
135 sysfs_get_dirent(dev->kobj.sd, "brightness_hw_changed");
136 if (!led_cdev->brightness_hw_changed_kn) {
137 dev_err(dev, "Error getting brightness_hw_changed kn\n");
138 device_remove_file(dev, &dev_attr_brightness_hw_changed);
139 return -ENXIO;
140 }
141
142 return 0;
143 }
144
led_remove_brightness_hw_changed(struct led_classdev * led_cdev)145 static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
146 {
147 sysfs_put(led_cdev->brightness_hw_changed_kn);
148 device_remove_file(led_cdev->dev, &dev_attr_brightness_hw_changed);
149 }
150
led_classdev_notify_brightness_hw_changed(struct led_classdev * led_cdev,unsigned int brightness)151 void led_classdev_notify_brightness_hw_changed(struct led_classdev *led_cdev, unsigned int brightness)
152 {
153 if (WARN_ON(!led_cdev->brightness_hw_changed_kn))
154 return;
155
156 led_cdev->brightness_hw_changed = brightness;
157 sysfs_notify_dirent(led_cdev->brightness_hw_changed_kn);
158 }
159 EXPORT_SYMBOL_GPL(led_classdev_notify_brightness_hw_changed);
160 #else
led_add_brightness_hw_changed(struct led_classdev * led_cdev)161 static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
162 {
163 return 0;
164 }
led_remove_brightness_hw_changed(struct led_classdev * led_cdev)165 static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
166 {
167 }
168 #endif
169
170 /**
171 * led_classdev_suspend - suspend an led_classdev.
172 * @led_cdev: the led_classdev to suspend.
173 */
led_classdev_suspend(struct led_classdev * led_cdev)174 void led_classdev_suspend(struct led_classdev *led_cdev)
175 {
176 led_cdev->flags |= LED_SUSPENDED;
177 led_set_brightness_nopm(led_cdev, 0);
178 flush_work(&led_cdev->set_brightness_work);
179 }
180 EXPORT_SYMBOL_GPL(led_classdev_suspend);
181
182 /**
183 * led_classdev_resume - resume an led_classdev.
184 * @led_cdev: the led_classdev to resume.
185 */
led_classdev_resume(struct led_classdev * led_cdev)186 void led_classdev_resume(struct led_classdev *led_cdev)
187 {
188 led_set_brightness_nopm(led_cdev, led_cdev->brightness);
189
190 if (led_cdev->flash_resume)
191 led_cdev->flash_resume(led_cdev);
192
193 led_cdev->flags &= ~LED_SUSPENDED;
194 }
195 EXPORT_SYMBOL_GPL(led_classdev_resume);
196
197 #ifdef CONFIG_PM_SLEEP
led_suspend(struct device * dev)198 static int led_suspend(struct device *dev)
199 {
200 struct led_classdev *led_cdev = dev_get_drvdata(dev);
201
202 if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
203 led_classdev_suspend(led_cdev);
204
205 return 0;
206 }
207
led_resume(struct device * dev)208 static int led_resume(struct device *dev)
209 {
210 struct led_classdev *led_cdev = dev_get_drvdata(dev);
211
212 if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
213 led_classdev_resume(led_cdev);
214
215 return 0;
216 }
217 #endif
218
219 static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
220
led_module_get(struct device * led_dev)221 static struct led_classdev *led_module_get(struct device *led_dev)
222 {
223 struct led_classdev *led_cdev;
224
225 if (!led_dev)
226 return ERR_PTR(-EPROBE_DEFER);
227
228 led_cdev = dev_get_drvdata(led_dev);
229
230 if (!try_module_get(led_cdev->dev->parent->driver->owner)) {
231 put_device(led_cdev->dev);
232 return ERR_PTR(-ENODEV);
233 }
234
235 return led_cdev;
236 }
237
238 static const struct class leds_class = {
239 .name = "leds",
240 .dev_groups = led_groups,
241 .pm = &leds_class_dev_pm_ops,
242 };
243
244 /**
245 * of_led_get() - request a LED device via the LED framework
246 * @np: device node to get the LED device from
247 * @index: the index of the LED
248 *
249 * Returns the LED device parsed from the phandle specified in the "leds"
250 * property of a device tree node or a negative error-code on failure.
251 */
of_led_get(struct device_node * np,int index)252 struct led_classdev *of_led_get(struct device_node *np, int index)
253 {
254 struct device *led_dev;
255 struct device_node *led_node;
256
257 led_node = of_parse_phandle(np, "leds", index);
258 if (!led_node)
259 return ERR_PTR(-ENOENT);
260
261 led_dev = class_find_device_by_of_node(&leds_class, led_node);
262 of_node_put(led_node);
263 put_device(led_dev);
264
265 return led_module_get(led_dev);
266 }
267 EXPORT_SYMBOL_GPL(of_led_get);
268
269 /**
270 * led_put() - release a LED device
271 * @led_cdev: LED device
272 */
led_put(struct led_classdev * led_cdev)273 void led_put(struct led_classdev *led_cdev)
274 {
275 module_put(led_cdev->dev->parent->driver->owner);
276 put_device(led_cdev->dev);
277 }
278 EXPORT_SYMBOL_GPL(led_put);
279
devm_led_release(struct device * dev,void * res)280 static void devm_led_release(struct device *dev, void *res)
281 {
282 struct led_classdev **p = res;
283
284 led_put(*p);
285 }
286
__devm_led_get(struct device * dev,struct led_classdev * led)287 static struct led_classdev *__devm_led_get(struct device *dev, struct led_classdev *led)
288 {
289 struct led_classdev **dr;
290
291 dr = devres_alloc(devm_led_release, sizeof(struct led_classdev *), GFP_KERNEL);
292 if (!dr) {
293 led_put(led);
294 return ERR_PTR(-ENOMEM);
295 }
296
297 *dr = led;
298 devres_add(dev, dr);
299
300 return led;
301 }
302
303 /**
304 * devm_of_led_get - Resource-managed request of a LED device
305 * @dev: LED consumer
306 * @index: index of the LED to obtain in the consumer
307 *
308 * The device node of the device is parse to find the request LED device.
309 * The LED device returned from this function is automatically released
310 * on driver detach.
311 *
312 * @return a pointer to a LED device or ERR_PTR(errno) on failure.
313 */
devm_of_led_get(struct device * dev,int index)314 struct led_classdev *__must_check devm_of_led_get(struct device *dev,
315 int index)
316 {
317 struct led_classdev *led;
318
319 if (!dev)
320 return ERR_PTR(-EINVAL);
321
322 led = of_led_get(dev->of_node, index);
323 if (IS_ERR(led))
324 return led;
325
326 return __devm_led_get(dev, led);
327 }
328 EXPORT_SYMBOL_GPL(devm_of_led_get);
329
330 /**
331 * led_get() - request a LED device via the LED framework
332 * @dev: device for which to get the LED device
333 * @con_id: name of the LED from the device's point of view
334 *
335 * @return a pointer to a LED device or ERR_PTR(errno) on failure.
336 */
led_get(struct device * dev,char * con_id)337 struct led_classdev *led_get(struct device *dev, char *con_id)
338 {
339 struct led_lookup_data *lookup;
340 const char *provider = NULL;
341 struct device *led_dev;
342
343 mutex_lock(&leds_lookup_lock);
344 list_for_each_entry(lookup, &leds_lookup_list, list) {
345 if (!strcmp(lookup->dev_id, dev_name(dev)) &&
346 !strcmp(lookup->con_id, con_id)) {
347 provider = kstrdup_const(lookup->provider, GFP_KERNEL);
348 break;
349 }
350 }
351 mutex_unlock(&leds_lookup_lock);
352
353 if (!provider)
354 return ERR_PTR(-ENOENT);
355
356 led_dev = class_find_device_by_name(&leds_class, provider);
357 kfree_const(provider);
358
359 return led_module_get(led_dev);
360 }
361 EXPORT_SYMBOL_GPL(led_get);
362
363 /**
364 * devm_led_get() - request a LED device via the LED framework
365 * @dev: device for which to get the LED device
366 * @con_id: name of the LED from the device's point of view
367 *
368 * The LED device returned from this function is automatically released
369 * on driver detach.
370 *
371 * @return a pointer to a LED device or ERR_PTR(errno) on failure.
372 */
devm_led_get(struct device * dev,char * con_id)373 struct led_classdev *devm_led_get(struct device *dev, char *con_id)
374 {
375 struct led_classdev *led;
376
377 led = led_get(dev, con_id);
378 if (IS_ERR(led))
379 return led;
380
381 return __devm_led_get(dev, led);
382 }
383 EXPORT_SYMBOL_GPL(devm_led_get);
384
385 /**
386 * led_add_lookup() - Add a LED lookup table entry
387 * @led_lookup: the lookup table entry to add
388 *
389 * Add a LED lookup table entry. On systems without devicetree the lookup table
390 * is used by led_get() to find LEDs.
391 */
led_add_lookup(struct led_lookup_data * led_lookup)392 void led_add_lookup(struct led_lookup_data *led_lookup)
393 {
394 mutex_lock(&leds_lookup_lock);
395 list_add_tail(&led_lookup->list, &leds_lookup_list);
396 mutex_unlock(&leds_lookup_lock);
397 }
398 EXPORT_SYMBOL_GPL(led_add_lookup);
399
400 /**
401 * led_remove_lookup() - Remove a LED lookup table entry
402 * @led_lookup: the lookup table entry to remove
403 */
led_remove_lookup(struct led_lookup_data * led_lookup)404 void led_remove_lookup(struct led_lookup_data *led_lookup)
405 {
406 mutex_lock(&leds_lookup_lock);
407 list_del(&led_lookup->list);
408 mutex_unlock(&leds_lookup_lock);
409 }
410 EXPORT_SYMBOL_GPL(led_remove_lookup);
411
412 /**
413 * devm_of_led_get_optional - Resource-managed request of an optional LED device
414 * @dev: LED consumer
415 * @index: index of the LED to obtain in the consumer
416 *
417 * The device node of the device is parsed to find the requested LED device.
418 * The LED device returned from this function is automatically released
419 * on driver detach.
420 *
421 * @return a pointer to a LED device, ERR_PTR(errno) on failure and NULL if the
422 * led was not found.
423 */
devm_of_led_get_optional(struct device * dev,int index)424 struct led_classdev *__must_check devm_of_led_get_optional(struct device *dev,
425 int index)
426 {
427 struct led_classdev *led;
428
429 led = devm_of_led_get(dev, index);
430 if (IS_ERR(led) && PTR_ERR(led) == -ENOENT)
431 return NULL;
432
433 return led;
434 }
435 EXPORT_SYMBOL_GPL(devm_of_led_get_optional);
436
led_classdev_next_name(const char * init_name,char * name,size_t len)437 static int led_classdev_next_name(const char *init_name, char *name,
438 size_t len)
439 {
440 unsigned int i = 0;
441 int ret = 0;
442 struct device *dev;
443
444 strscpy(name, init_name, len);
445
446 while ((ret < len) &&
447 (dev = class_find_device_by_name(&leds_class, name))) {
448 put_device(dev);
449 ret = snprintf(name, len, "%s_%u", init_name, ++i);
450 }
451
452 if (ret >= len)
453 return -ENOMEM;
454
455 return i;
456 }
457
458 /**
459 * led_classdev_register_ext - register a new object of led_classdev class
460 * with init data.
461 *
462 * @parent: parent of LED device
463 * @led_cdev: the led_classdev structure for this device.
464 * @init_data: LED class device initialization data
465 */
led_classdev_register_ext(struct device * parent,struct led_classdev * led_cdev,struct led_init_data * init_data)466 int led_classdev_register_ext(struct device *parent,
467 struct led_classdev *led_cdev,
468 struct led_init_data *init_data)
469 {
470 char composed_name[LED_MAX_NAME_SIZE];
471 char final_name[LED_MAX_NAME_SIZE];
472 const char *proposed_name = composed_name;
473 int ret;
474
475 if (init_data) {
476 if (init_data->devname_mandatory && !init_data->devicename) {
477 dev_err(parent, "Mandatory device name is missing");
478 return -EINVAL;
479 }
480 ret = led_compose_name(parent, init_data, composed_name);
481 if (ret < 0)
482 return ret;
483
484 if (init_data->fwnode) {
485 fwnode_property_read_string(init_data->fwnode,
486 "linux,default-trigger",
487 &led_cdev->default_trigger);
488
489 if (fwnode_property_present(init_data->fwnode,
490 "retain-state-shutdown"))
491 led_cdev->flags |= LED_RETAIN_AT_SHUTDOWN;
492
493 fwnode_property_read_u32(init_data->fwnode,
494 "max-brightness",
495 &led_cdev->max_brightness);
496
497 if (fwnode_property_present(init_data->fwnode, "color"))
498 fwnode_property_read_u32(init_data->fwnode, "color",
499 &led_cdev->color);
500 }
501 } else {
502 proposed_name = led_cdev->name;
503 }
504
505 ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));
506 if (ret < 0)
507 return ret;
508
509 if (led_cdev->color >= LED_COLOR_ID_MAX)
510 dev_warn(parent, "LED %s color identifier out of range\n", final_name);
511
512 mutex_init(&led_cdev->led_access);
513 mutex_lock(&led_cdev->led_access);
514 led_cdev->dev = device_create_with_groups(&leds_class, parent, 0,
515 led_cdev, led_cdev->groups, "%s", final_name);
516 if (IS_ERR(led_cdev->dev)) {
517 mutex_unlock(&led_cdev->led_access);
518 return PTR_ERR(led_cdev->dev);
519 }
520 if (init_data && init_data->fwnode)
521 device_set_node(led_cdev->dev, init_data->fwnode);
522
523 if (ret)
524 dev_warn(parent, "Led %s renamed to %s due to name collision",
525 proposed_name, dev_name(led_cdev->dev));
526
527 if (led_cdev->flags & LED_BRIGHT_HW_CHANGED) {
528 ret = led_add_brightness_hw_changed(led_cdev);
529 if (ret) {
530 device_unregister(led_cdev->dev);
531 led_cdev->dev = NULL;
532 mutex_unlock(&led_cdev->led_access);
533 return ret;
534 }
535 }
536
537 led_cdev->work_flags = 0;
538 #ifdef CONFIG_LEDS_TRIGGERS
539 init_rwsem(&led_cdev->trigger_lock);
540 #endif
541 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
542 led_cdev->brightness_hw_changed = -1;
543 #endif
544 /* add to the list of leds */
545 down_write(&leds_list_lock);
546 list_add_tail(&led_cdev->node, &leds_list);
547 up_write(&leds_list_lock);
548
549 if (!led_cdev->max_brightness)
550 led_cdev->max_brightness = LED_FULL;
551
552 led_update_brightness(led_cdev);
553
554 led_init_core(led_cdev);
555
556 #ifdef CONFIG_LEDS_TRIGGERS
557 led_trigger_set_default(led_cdev);
558 #endif
559
560 mutex_unlock(&led_cdev->led_access);
561
562 dev_dbg(parent, "Registered led device: %s\n",
563 led_cdev->name);
564
565 return 0;
566 }
567 EXPORT_SYMBOL_GPL(led_classdev_register_ext);
568
569 /**
570 * led_classdev_unregister - unregisters a object of led_properties class.
571 * @led_cdev: the led device to unregister
572 *
573 * Unregisters a previously registered via led_classdev_register object.
574 */
led_classdev_unregister(struct led_classdev * led_cdev)575 void led_classdev_unregister(struct led_classdev *led_cdev)
576 {
577 if (IS_ERR_OR_NULL(led_cdev->dev))
578 return;
579
580 #ifdef CONFIG_LEDS_TRIGGERS
581 down_write(&led_cdev->trigger_lock);
582 if (led_cdev->trigger)
583 led_trigger_set(led_cdev, NULL);
584 up_write(&led_cdev->trigger_lock);
585 #endif
586
587 led_cdev->flags |= LED_UNREGISTERING;
588
589 /* Stop blinking */
590 led_stop_software_blink(led_cdev);
591
592 if (!(led_cdev->flags & LED_RETAIN_AT_SHUTDOWN))
593 led_set_brightness(led_cdev, LED_OFF);
594
595 flush_work(&led_cdev->set_brightness_work);
596
597 if (led_cdev->flags & LED_BRIGHT_HW_CHANGED)
598 led_remove_brightness_hw_changed(led_cdev);
599
600 device_unregister(led_cdev->dev);
601
602 down_write(&leds_list_lock);
603 list_del(&led_cdev->node);
604 up_write(&leds_list_lock);
605
606 mutex_destroy(&led_cdev->led_access);
607 }
608 EXPORT_SYMBOL_GPL(led_classdev_unregister);
609
devm_led_classdev_release(struct device * dev,void * res)610 static void devm_led_classdev_release(struct device *dev, void *res)
611 {
612 led_classdev_unregister(*(struct led_classdev **)res);
613 }
614
615 /**
616 * devm_led_classdev_register_ext - resource managed led_classdev_register_ext()
617 *
618 * @parent: parent of LED device
619 * @led_cdev: the led_classdev structure for this device.
620 * @init_data: LED class device initialization data
621 */
devm_led_classdev_register_ext(struct device * parent,struct led_classdev * led_cdev,struct led_init_data * init_data)622 int devm_led_classdev_register_ext(struct device *parent,
623 struct led_classdev *led_cdev,
624 struct led_init_data *init_data)
625 {
626 struct led_classdev **dr;
627 int rc;
628
629 dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL);
630 if (!dr)
631 return -ENOMEM;
632
633 rc = led_classdev_register_ext(parent, led_cdev, init_data);
634 if (rc) {
635 devres_free(dr);
636 return rc;
637 }
638
639 *dr = led_cdev;
640 devres_add(parent, dr);
641
642 return 0;
643 }
644 EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext);
645
devm_led_classdev_match(struct device * dev,void * res,void * data)646 static int devm_led_classdev_match(struct device *dev, void *res, void *data)
647 {
648 struct led_classdev **p = res;
649
650 if (WARN_ON(!p || !*p))
651 return 0;
652
653 return *p == data;
654 }
655
656 /**
657 * devm_led_classdev_unregister() - resource managed led_classdev_unregister()
658 * @dev: The device to unregister.
659 * @led_cdev: the led_classdev structure for this device.
660 */
devm_led_classdev_unregister(struct device * dev,struct led_classdev * led_cdev)661 void devm_led_classdev_unregister(struct device *dev,
662 struct led_classdev *led_cdev)
663 {
664 WARN_ON(devres_release(dev,
665 devm_led_classdev_release,
666 devm_led_classdev_match, led_cdev));
667 }
668 EXPORT_SYMBOL_GPL(devm_led_classdev_unregister);
669
leds_init(void)670 static int __init leds_init(void)
671 {
672 return class_register(&leds_class);
673 }
674
leds_exit(void)675 static void __exit leds_exit(void)
676 {
677 class_unregister(&leds_class);
678 }
679
680 subsys_initcall(leds_init);
681 module_exit(leds_exit);
682
683 MODULE_AUTHOR("John Lenz, Richard Purdie");
684 MODULE_LICENSE("GPL");
685 MODULE_DESCRIPTION("LED Class Interface");
686