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