led-class.c

  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(&led_cdev->led_access);
 37	led_update_brightness(led_cdev);
 38	brightness = led_cdev->brightness;
 39	mutex_unlock(&led_cdev->led_access);
 40
 41	return sysfs_emit(buf, "%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(&led_cdev->led_access);
 52
 53	if (led_sysfs_is_disabled(led_cdev)) {
 54		ret = -EBUSY;
 55		goto unlock;
 56	}
 57
 58	ret = kstrtoul(buf, 10, &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, state);
 65
 66	ret = size;
 67unlock:
 68	mutex_unlock(&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(&led_cdev->led_access);
 80	max_brightness = led_cdev->max_brightness;
 81	mutex_unlock(&led_cdev->led_access);
 82
 83	return sysfs_emit(buf, "%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 sysfs_emit(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, 0);
185	flush_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, 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(-EPROBE_DEFER);
234
235	led_cdev = dev_get_drvdata(led_dev);
236
237	if (!try_module_get(led_cdev->dev->parent->driver->owner)) {
238		put_device(led_cdev->dev);
239		return ERR_PTR(-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, "led-names", name);
272	led_node = of_parse_phandle(np, "leds", index);
273	if (!led_node)
274		return ERR_PTR(-ENOENT);
275
276	led_dev = class_find_device_by_of_node(&leds_class, led_node);
277	of_node_put(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(led_cdev->dev->parent->driver->owner);
289	put_device(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(-ENOMEM);
308	}
309
310	*dr = led;
311	devres_add(dev, 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(-EINVAL);
334
335	led = of_led_get(dev->of_node, index, NULL);
336	if (IS_ERR(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(dev->of_node, -1, con_id);
358	if (!IS_ERR(led_cdev) || PTR_ERR(led_cdev) != -ENOENT)
359		return led_cdev;
360
361	mutex_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(lookup->provider, GFP_KERNEL);
366			break;
367		}
368	}
369	mutex_unlock(&leds_lookup_lock);
370
371	if (!provider)
372		return ERR_PTR(-ENOENT);
373
374	led_dev = class_find_device_by_name(&leds_class, provider);
375	kfree_const(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(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(&leds_lookup_lock);
413	list_add_tail(&led_lookup->list, &leds_lookup_list);
414	mutex_unlock(&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(&leds_lookup_lock);
425	list_del(&led_lookup->list);
426	mutex_unlock(&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(led) && PTR_ERR(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(&leds_class, name))) {
466		put_device(dev);
467		ret = snprintf(name, len, "%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(parent, init_data, composed_name);
499		if (ret < 0)
500			return ret;
501
502		if (init_data->fwnode) {
503			fwnode_property_read_string(init_data->fwnode,
504				"linux,default-trigger",
505				&led_cdev->default_trigger);
506
507			if (fwnode_property_present(init_data->fwnode,
508						    "retain-state-shutdown"))
509				led_cdev->flags |= LED_RETAIN_AT_SHUTDOWN;
510
511			fwnode_property_read_u32(init_data->fwnode,
512				"max-brightness",
513				&led_cdev->max_brightness);
514
515			if (fwnode_property_present(init_data->fwnode, "color"))
516				fwnode_property_read_u32(init_data->fwnode, "color",
517							 &led_cdev->color);
518		}
519	} else {
520		proposed_name = led_cdev->name;
521	}
522
523	ret = led_classdev_next_name(proposed_name, final_name, 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(&led_cdev->led_access);
537	led_cdev->dev = device_create_with_groups(&leds_class, parent, 0,
538						  led_cdev, led_cdev->groups, "%s", final_name);
539	if (IS_ERR(led_cdev->dev)) {
540		mutex_unlock(&led_cdev->led_access);
541		return PTR_ERR(led_cdev->dev);
542	}
543	if (init_data && init_data->fwnode)
544		device_set_node(led_cdev->dev, 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(led_cdev->dev);
550			led_cdev->dev = NULL;
551			mutex_unlock(&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	if (!led_cdev->max_brightness)
564		led_cdev->max_brightness = LED_FULL;
565
566	led_update_brightness(led_cdev);
567
568	led_cdev->wq = leds_wq;
569
570	led_init_core(led_cdev);
571
572	/* add to the list of leds */
573	down_write(&leds_list_lock);
574	list_add_tail(&led_cdev->node, &leds_list);
575	up_write(&leds_list_lock);
576
577#ifdef CONFIG_LEDS_TRIGGERS
578	led_trigger_set_default(led_cdev);
579#endif
580
581	mutex_unlock(&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(led_cdev->dev))
599		return;
600
601#ifdef CONFIG_LEDS_TRIGGERS
602	down_write(&led_cdev->trigger_lock);
603	if (led_cdev->trigger)
604		led_trigger_set(led_cdev, NULL);
605	up_write(&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, LED_OFF);
615
616	flush_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(led_cdev->dev);
622
623	down_write(&leds_list_lock);
624	list_del(&led_cdev->node);
625	up_write(&leds_list_lock);
626
627	mutex_destroy(&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(dr);
657		return rc;
658	}
659
660	*dr = led_cdev;
661	devres_add(parent, 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(&leds_class);
700}
701
702static void __exit leds_exit(void)
703{
704	class_unregister(&leds_class);
705	destroy_workqueue(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");