• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 struct class *leds_class;
26 
brightness_show(struct device * dev,struct device_attribute * attr,char * buf)27 static ssize_t brightness_show(struct device *dev,
28 		struct device_attribute *attr, char *buf)
29 {
30 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
31 
32 	/* no lock needed for this */
33 	led_update_brightness(led_cdev);
34 
35 	return sprintf(buf, "%u\n", led_cdev->brightness);
36 }
37 
brightness_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)38 static ssize_t brightness_store(struct device *dev,
39 		struct device_attribute *attr, const char *buf, size_t size)
40 {
41 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
42 	unsigned long state;
43 	ssize_t ret;
44 
45 	mutex_lock(&led_cdev->led_access);
46 
47 	if (led_sysfs_is_disabled(led_cdev)) {
48 		ret = -EBUSY;
49 		goto unlock;
50 	}
51 
52 	ret = kstrtoul(buf, 10, &state);
53 	if (ret)
54 		goto unlock;
55 
56 	if (state == LED_OFF)
57 		led_trigger_remove(led_cdev);
58 	led_set_brightness(led_cdev, state);
59 	flush_work(&led_cdev->set_brightness_work);
60 
61 	ret = size;
62 unlock:
63 	mutex_unlock(&led_cdev->led_access);
64 	return ret;
65 }
66 static DEVICE_ATTR_RW(brightness);
67 
max_brightness_show(struct device * dev,struct device_attribute * attr,char * buf)68 static ssize_t max_brightness_show(struct device *dev,
69 		struct device_attribute *attr, char *buf)
70 {
71 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
72 
73 	return sprintf(buf, "%u\n", led_cdev->max_brightness);
74 }
75 static DEVICE_ATTR_RO(max_brightness);
76 
77 #ifdef CONFIG_LEDS_TRIGGERS
78 static BIN_ATTR(trigger, 0644, led_trigger_read, led_trigger_write, 0);
79 static struct bin_attribute *led_trigger_bin_attrs[] = {
80 	&bin_attr_trigger,
81 	NULL,
82 };
83 static const struct attribute_group led_trigger_group = {
84 	.bin_attrs = led_trigger_bin_attrs,
85 };
86 #endif
87 
88 static struct attribute *led_class_attrs[] = {
89 	&dev_attr_brightness.attr,
90 	&dev_attr_max_brightness.attr,
91 	NULL,
92 };
93 
94 static const struct attribute_group led_group = {
95 	.attrs = led_class_attrs,
96 };
97 
98 static const struct attribute_group *led_groups[] = {
99 	&led_group,
100 #ifdef CONFIG_LEDS_TRIGGERS
101 	&led_trigger_group,
102 #endif
103 	NULL,
104 };
105 
106 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
brightness_hw_changed_show(struct device * dev,struct device_attribute * attr,char * buf)107 static ssize_t brightness_hw_changed_show(struct device *dev,
108 		struct device_attribute *attr, char *buf)
109 {
110 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
111 
112 	if (led_cdev->brightness_hw_changed == -1)
113 		return -ENODATA;
114 
115 	return sprintf(buf, "%u\n", led_cdev->brightness_hw_changed);
116 }
117 
118 static DEVICE_ATTR_RO(brightness_hw_changed);
119 
led_add_brightness_hw_changed(struct led_classdev * led_cdev)120 static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
121 {
122 	struct device *dev = led_cdev->dev;
123 	int ret;
124 
125 	ret = device_create_file(dev, &dev_attr_brightness_hw_changed);
126 	if (ret) {
127 		dev_err(dev, "Error creating brightness_hw_changed\n");
128 		return ret;
129 	}
130 
131 	led_cdev->brightness_hw_changed_kn =
132 		sysfs_get_dirent(dev->kobj.sd, "brightness_hw_changed");
133 	if (!led_cdev->brightness_hw_changed_kn) {
134 		dev_err(dev, "Error getting brightness_hw_changed kn\n");
135 		device_remove_file(dev, &dev_attr_brightness_hw_changed);
136 		return -ENXIO;
137 	}
138 
139 	return 0;
140 }
141 
led_remove_brightness_hw_changed(struct led_classdev * led_cdev)142 static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
143 {
144 	sysfs_put(led_cdev->brightness_hw_changed_kn);
145 	device_remove_file(led_cdev->dev, &dev_attr_brightness_hw_changed);
146 }
147 
led_classdev_notify_brightness_hw_changed(struct led_classdev * led_cdev,enum led_brightness brightness)148 void led_classdev_notify_brightness_hw_changed(struct led_classdev *led_cdev,
149 					       enum led_brightness brightness)
150 {
151 	if (WARN_ON(!led_cdev->brightness_hw_changed_kn))
152 		return;
153 
154 	led_cdev->brightness_hw_changed = brightness;
155 	sysfs_notify_dirent(led_cdev->brightness_hw_changed_kn);
156 }
157 EXPORT_SYMBOL_GPL(led_classdev_notify_brightness_hw_changed);
158 #else
led_add_brightness_hw_changed(struct led_classdev * led_cdev)159 static int led_add_brightness_hw_changed(struct led_classdev *led_cdev)
160 {
161 	return 0;
162 }
led_remove_brightness_hw_changed(struct led_classdev * led_cdev)163 static void led_remove_brightness_hw_changed(struct led_classdev *led_cdev)
164 {
165 }
166 #endif
167 
168 /**
169  * led_classdev_suspend - suspend an led_classdev.
170  * @led_cdev: the led_classdev to suspend.
171  */
led_classdev_suspend(struct led_classdev * led_cdev)172 void led_classdev_suspend(struct led_classdev *led_cdev)
173 {
174 	led_cdev->flags |= LED_SUSPENDED;
175 	led_set_brightness_nopm(led_cdev, 0);
176 	flush_work(&led_cdev->set_brightness_work);
177 }
178 EXPORT_SYMBOL_GPL(led_classdev_suspend);
179 
180 /**
181  * led_classdev_resume - resume an led_classdev.
182  * @led_cdev: the led_classdev to resume.
183  */
led_classdev_resume(struct led_classdev * led_cdev)184 void led_classdev_resume(struct led_classdev *led_cdev)
185 {
186 	led_set_brightness_nopm(led_cdev, led_cdev->brightness);
187 
188 	if (led_cdev->flash_resume)
189 		led_cdev->flash_resume(led_cdev);
190 
191 	led_cdev->flags &= ~LED_SUSPENDED;
192 }
193 EXPORT_SYMBOL_GPL(led_classdev_resume);
194 
195 #ifdef CONFIG_PM_SLEEP
led_suspend(struct device * dev)196 static int led_suspend(struct device *dev)
197 {
198 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
199 
200 	if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
201 		led_classdev_suspend(led_cdev);
202 
203 	return 0;
204 }
205 
led_resume(struct device * dev)206 static int led_resume(struct device *dev)
207 {
208 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
209 
210 	if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
211 		led_classdev_resume(led_cdev);
212 
213 	return 0;
214 }
215 #endif
216 
217 static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
218 
219 /**
220  * of_led_get() - request a LED device via the LED framework
221  * @np: device node to get the LED device from
222  * @index: the index of the LED
223  *
224  * Returns the LED device parsed from the phandle specified in the "leds"
225  * property of a device tree node or a negative error-code on failure.
226  */
of_led_get(struct device_node * np,int index)227 struct led_classdev *of_led_get(struct device_node *np, int index)
228 {
229 	struct device *led_dev;
230 	struct led_classdev *led_cdev;
231 	struct device_node *led_node;
232 
233 	led_node = of_parse_phandle(np, "leds", index);
234 	if (!led_node)
235 		return ERR_PTR(-ENOENT);
236 
237 	led_dev = class_find_device_by_of_node(leds_class, led_node);
238 	of_node_put(led_node);
239 
240 	if (!led_dev)
241 		return ERR_PTR(-EPROBE_DEFER);
242 
243 	led_cdev = dev_get_drvdata(led_dev);
244 
245 	if (!try_module_get(led_cdev->dev->parent->driver->owner))
246 		return ERR_PTR(-ENODEV);
247 
248 	return led_cdev;
249 }
250 EXPORT_SYMBOL_GPL(of_led_get);
251 
252 /**
253  * led_put() - release a LED device
254  * @led_cdev: LED device
255  */
led_put(struct led_classdev * led_cdev)256 void led_put(struct led_classdev *led_cdev)
257 {
258 	module_put(led_cdev->dev->parent->driver->owner);
259 }
260 EXPORT_SYMBOL_GPL(led_put);
261 
devm_led_release(struct device * dev,void * res)262 static void devm_led_release(struct device *dev, void *res)
263 {
264 	struct led_classdev **p = res;
265 
266 	led_put(*p);
267 }
268 
269 /**
270  * devm_of_led_get - Resource-managed request of a LED device
271  * @dev:	LED consumer
272  * @index:	index of the LED to obtain in the consumer
273  *
274  * The device node of the device is parse to find the request LED device.
275  * The LED device returned from this function is automatically released
276  * on driver detach.
277  *
278  * @return a pointer to a LED device or ERR_PTR(errno) on failure.
279  */
devm_of_led_get(struct device * dev,int index)280 struct led_classdev *__must_check devm_of_led_get(struct device *dev,
281 						  int index)
282 {
283 	struct led_classdev *led;
284 	struct led_classdev **dr;
285 
286 	if (!dev)
287 		return ERR_PTR(-EINVAL);
288 
289 	led = of_led_get(dev->of_node, index);
290 	if (IS_ERR(led))
291 		return led;
292 
293 	dr = devres_alloc(devm_led_release, sizeof(struct led_classdev *),
294 			  GFP_KERNEL);
295 	if (!dr) {
296 		led_put(led);
297 		return ERR_PTR(-ENOMEM);
298 	}
299 
300 	*dr = led;
301 	devres_add(dev, dr);
302 
303 	return led;
304 }
305 EXPORT_SYMBOL_GPL(devm_of_led_get);
306 
led_classdev_next_name(const char * init_name,char * name,size_t len)307 static int led_classdev_next_name(const char *init_name, char *name,
308 				  size_t len)
309 {
310 	unsigned int i = 0;
311 	int ret = 0;
312 	struct device *dev;
313 
314 	strlcpy(name, init_name, len);
315 
316 	while ((ret < len) &&
317 	       (dev = class_find_device_by_name(leds_class, name))) {
318 		put_device(dev);
319 		ret = snprintf(name, len, "%s_%u", init_name, ++i);
320 	}
321 
322 	if (ret >= len)
323 		return -ENOMEM;
324 
325 	return i;
326 }
327 
328 /**
329  * led_classdev_register_ext - register a new object of led_classdev class
330  *			       with init data.
331  *
332  * @parent: parent of LED device
333  * @led_cdev: the led_classdev structure for this device.
334  * @init_data: LED class device initialization data
335  */
led_classdev_register_ext(struct device * parent,struct led_classdev * led_cdev,struct led_init_data * init_data)336 int led_classdev_register_ext(struct device *parent,
337 			      struct led_classdev *led_cdev,
338 			      struct led_init_data *init_data)
339 {
340 	char composed_name[LED_MAX_NAME_SIZE];
341 	char final_name[LED_MAX_NAME_SIZE];
342 	const char *proposed_name = composed_name;
343 	int ret;
344 
345 	if (init_data) {
346 		if (init_data->devname_mandatory && !init_data->devicename) {
347 			dev_err(parent, "Mandatory device name is missing");
348 			return -EINVAL;
349 		}
350 		ret = led_compose_name(parent, init_data, composed_name);
351 		if (ret < 0)
352 			return ret;
353 
354 		if (init_data->fwnode)
355 			fwnode_property_read_string(init_data->fwnode,
356 				"linux,default-trigger",
357 				&led_cdev->default_trigger);
358 	} else {
359 		proposed_name = led_cdev->name;
360 	}
361 
362 	ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));
363 	if (ret < 0)
364 		return ret;
365 
366 	mutex_init(&led_cdev->led_access);
367 	mutex_lock(&led_cdev->led_access);
368 	led_cdev->dev = device_create_with_groups(leds_class, parent, 0,
369 				led_cdev, led_cdev->groups, "%s", final_name);
370 	if (IS_ERR(led_cdev->dev)) {
371 		mutex_unlock(&led_cdev->led_access);
372 		return PTR_ERR(led_cdev->dev);
373 	}
374 	if (init_data && init_data->fwnode) {
375 		led_cdev->dev->fwnode = init_data->fwnode;
376 		led_cdev->dev->of_node = to_of_node(init_data->fwnode);
377 	}
378 
379 	if (ret)
380 		dev_warn(parent, "Led %s renamed to %s due to name collision",
381 				proposed_name, dev_name(led_cdev->dev));
382 
383 	if (led_cdev->flags & LED_BRIGHT_HW_CHANGED) {
384 		ret = led_add_brightness_hw_changed(led_cdev);
385 		if (ret) {
386 			device_unregister(led_cdev->dev);
387 			led_cdev->dev = NULL;
388 			mutex_unlock(&led_cdev->led_access);
389 			return ret;
390 		}
391 	}
392 
393 	led_cdev->work_flags = 0;
394 #ifdef CONFIG_LEDS_TRIGGERS
395 	init_rwsem(&led_cdev->trigger_lock);
396 #endif
397 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
398 	led_cdev->brightness_hw_changed = -1;
399 #endif
400 	/* add to the list of leds */
401 	down_write(&leds_list_lock);
402 	list_add_tail(&led_cdev->node, &leds_list);
403 	up_write(&leds_list_lock);
404 
405 	if (!led_cdev->max_brightness)
406 		led_cdev->max_brightness = LED_FULL;
407 
408 	led_update_brightness(led_cdev);
409 
410 	led_init_core(led_cdev);
411 
412 #ifdef CONFIG_LEDS_TRIGGERS
413 	led_trigger_set_default(led_cdev);
414 #endif
415 
416 	mutex_unlock(&led_cdev->led_access);
417 
418 	dev_dbg(parent, "Registered led device: %s\n",
419 			led_cdev->name);
420 
421 	return 0;
422 }
423 EXPORT_SYMBOL_GPL(led_classdev_register_ext);
424 
425 /**
426  * led_classdev_unregister - unregisters a object of led_properties class.
427  * @led_cdev: the led device to unregister
428  *
429  * Unregisters a previously registered via led_classdev_register object.
430  */
led_classdev_unregister(struct led_classdev * led_cdev)431 void led_classdev_unregister(struct led_classdev *led_cdev)
432 {
433 	if (IS_ERR_OR_NULL(led_cdev->dev))
434 		return;
435 
436 #ifdef CONFIG_LEDS_TRIGGERS
437 	down_write(&led_cdev->trigger_lock);
438 	if (led_cdev->trigger)
439 		led_trigger_set(led_cdev, NULL);
440 	up_write(&led_cdev->trigger_lock);
441 #endif
442 
443 	led_cdev->flags |= LED_UNREGISTERING;
444 
445 	/* Stop blinking */
446 	led_stop_software_blink(led_cdev);
447 
448 	led_set_brightness(led_cdev, LED_OFF);
449 
450 	flush_work(&led_cdev->set_brightness_work);
451 
452 	if (led_cdev->flags & LED_BRIGHT_HW_CHANGED)
453 		led_remove_brightness_hw_changed(led_cdev);
454 
455 	device_unregister(led_cdev->dev);
456 
457 	down_write(&leds_list_lock);
458 	list_del(&led_cdev->node);
459 	up_write(&leds_list_lock);
460 
461 	mutex_destroy(&led_cdev->led_access);
462 }
463 EXPORT_SYMBOL_GPL(led_classdev_unregister);
464 
devm_led_classdev_release(struct device * dev,void * res)465 static void devm_led_classdev_release(struct device *dev, void *res)
466 {
467 	led_classdev_unregister(*(struct led_classdev **)res);
468 }
469 
470 /**
471  * devm_led_classdev_register_ext - resource managed led_classdev_register_ext()
472  *
473  * @parent: parent of LED device
474  * @led_cdev: the led_classdev structure for this device.
475  * @init_data: LED class device initialization data
476  */
devm_led_classdev_register_ext(struct device * parent,struct led_classdev * led_cdev,struct led_init_data * init_data)477 int devm_led_classdev_register_ext(struct device *parent,
478 				   struct led_classdev *led_cdev,
479 				   struct led_init_data *init_data)
480 {
481 	struct led_classdev **dr;
482 	int rc;
483 
484 	dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL);
485 	if (!dr)
486 		return -ENOMEM;
487 
488 	rc = led_classdev_register_ext(parent, led_cdev, init_data);
489 	if (rc) {
490 		devres_free(dr);
491 		return rc;
492 	}
493 
494 	*dr = led_cdev;
495 	devres_add(parent, dr);
496 
497 	return 0;
498 }
499 EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext);
500 
devm_led_classdev_match(struct device * dev,void * res,void * data)501 static int devm_led_classdev_match(struct device *dev, void *res, void *data)
502 {
503 	struct led_classdev **p = res;
504 
505 	if (WARN_ON(!p || !*p))
506 		return 0;
507 
508 	return *p == data;
509 }
510 
511 /**
512  * devm_led_classdev_unregister() - resource managed led_classdev_unregister()
513  * @parent: The device to unregister.
514  * @led_cdev: the led_classdev structure for this device.
515  */
devm_led_classdev_unregister(struct device * dev,struct led_classdev * led_cdev)516 void devm_led_classdev_unregister(struct device *dev,
517 				  struct led_classdev *led_cdev)
518 {
519 	WARN_ON(devres_release(dev,
520 			       devm_led_classdev_release,
521 			       devm_led_classdev_match, led_cdev));
522 }
523 EXPORT_SYMBOL_GPL(devm_led_classdev_unregister);
524 
leds_init(void)525 static int __init leds_init(void)
526 {
527 	leds_class = class_create(THIS_MODULE, "leds");
528 	if (IS_ERR(leds_class))
529 		return PTR_ERR(leds_class);
530 	leds_class->pm = &leds_class_dev_pm_ops;
531 	leds_class->dev_groups = led_groups;
532 	return 0;
533 }
534 
leds_exit(void)535 static void __exit leds_exit(void)
536 {
537 	class_destroy(leds_class);
538 }
539 
540 subsys_initcall(leds_init);
541 module_exit(leds_exit);
542 
543 MODULE_AUTHOR("John Lenz, Richard Purdie");
544 MODULE_LICENSE("GPL");
545 MODULE_DESCRIPTION("LED Class Interface");
546