xref: /openbmc/linux/drivers/leds/led-class.c (revision fa7f32422ea1ac276b45b96a540ed5981caaa61f)
1 /*
2  * LED Class Core
3  *
4  * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
5  * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 
12 #include <linux/ctype.h>
13 #include <linux/device.h>
14 #include <linux/err.h>
15 #include <linux/init.h>
16 #include <linux/kernel.h>
17 #include <linux/leds.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/slab.h>
21 #include <linux/spinlock.h>
22 #include <linux/timer.h>
23 #include <uapi/linux/uleds.h>
24 #include "leds.h"
25 
26 static struct class *leds_class;
27 
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 
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 	led_set_brightness(led_cdev, state);
60 
61 	ret = size;
62 unlock:
63 	mutex_unlock(&led_cdev->led_access);
64 	return ret;
65 }
66 static DEVICE_ATTR_RW(brightness);
67 
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 DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
79 static struct attribute *led_trigger_attrs[] = {
80 	&dev_attr_trigger.attr,
81 	NULL,
82 };
83 static const struct attribute_group led_trigger_group = {
84 	.attrs = led_trigger_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 /**
107  * led_classdev_suspend - suspend an led_classdev.
108  * @led_cdev: the led_classdev to suspend.
109  */
110 void led_classdev_suspend(struct led_classdev *led_cdev)
111 {
112 	led_cdev->flags |= LED_SUSPENDED;
113 	led_set_brightness_nopm(led_cdev, 0);
114 }
115 EXPORT_SYMBOL_GPL(led_classdev_suspend);
116 
117 /**
118  * led_classdev_resume - resume an led_classdev.
119  * @led_cdev: the led_classdev to resume.
120  */
121 void led_classdev_resume(struct led_classdev *led_cdev)
122 {
123 	led_set_brightness_nopm(led_cdev, led_cdev->brightness);
124 
125 	if (led_cdev->flash_resume)
126 		led_cdev->flash_resume(led_cdev);
127 
128 	led_cdev->flags &= ~LED_SUSPENDED;
129 }
130 EXPORT_SYMBOL_GPL(led_classdev_resume);
131 
132 #ifdef CONFIG_PM_SLEEP
133 static int led_suspend(struct device *dev)
134 {
135 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
136 
137 	if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
138 		led_classdev_suspend(led_cdev);
139 
140 	return 0;
141 }
142 
143 static int led_resume(struct device *dev)
144 {
145 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
146 
147 	if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
148 		led_classdev_resume(led_cdev);
149 
150 	return 0;
151 }
152 #endif
153 
154 static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
155 
156 static int match_name(struct device *dev, const void *data)
157 {
158 	if (!dev_name(dev))
159 		return 0;
160 	return !strcmp(dev_name(dev), (char *)data);
161 }
162 
163 static int led_classdev_next_name(const char *init_name, char *name,
164 				  size_t len)
165 {
166 	unsigned int i = 0;
167 	int ret = 0;
168 	struct device *dev;
169 
170 	strlcpy(name, init_name, len);
171 
172 	while ((ret < len) &&
173 	       (dev = class_find_device(leds_class, NULL, name, match_name))) {
174 		put_device(dev);
175 		ret = snprintf(name, len, "%s_%u", init_name, ++i);
176 	}
177 
178 	if (ret >= len)
179 		return -ENOMEM;
180 
181 	return i;
182 }
183 
184 /**
185  * led_classdev_register - register a new object of led_classdev class.
186  * @parent: The device to register.
187  * @led_cdev: the led_classdev structure for this device.
188  */
189 int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
190 {
191 	char name[LED_MAX_NAME_SIZE];
192 	int ret;
193 
194 	ret = led_classdev_next_name(led_cdev->name, name, sizeof(name));
195 	if (ret < 0)
196 		return ret;
197 
198 	led_cdev->dev = device_create_with_groups(leds_class, parent, 0,
199 				led_cdev, led_cdev->groups, "%s", name);
200 	if (IS_ERR(led_cdev->dev))
201 		return PTR_ERR(led_cdev->dev);
202 
203 	if (ret)
204 		dev_warn(parent, "Led %s renamed to %s due to name collision",
205 				led_cdev->name, dev_name(led_cdev->dev));
206 
207 #ifdef CONFIG_LEDS_TRIGGERS
208 	init_rwsem(&led_cdev->trigger_lock);
209 #endif
210 	mutex_init(&led_cdev->led_access);
211 	/* add to the list of leds */
212 	down_write(&leds_list_lock);
213 	list_add_tail(&led_cdev->node, &leds_list);
214 	up_write(&leds_list_lock);
215 
216 	if (!led_cdev->max_brightness)
217 		led_cdev->max_brightness = LED_FULL;
218 
219 	led_update_brightness(led_cdev);
220 
221 	led_init_core(led_cdev);
222 
223 #ifdef CONFIG_LEDS_TRIGGERS
224 	led_trigger_set_default(led_cdev);
225 #endif
226 
227 	dev_dbg(parent, "Registered led device: %s\n",
228 			led_cdev->name);
229 
230 	return 0;
231 }
232 EXPORT_SYMBOL_GPL(led_classdev_register);
233 
234 /**
235  * led_classdev_unregister - unregisters a object of led_properties class.
236  * @led_cdev: the led device to unregister
237  *
238  * Unregisters a previously registered via led_classdev_register object.
239  */
240 void led_classdev_unregister(struct led_classdev *led_cdev)
241 {
242 #ifdef CONFIG_LEDS_TRIGGERS
243 	down_write(&led_cdev->trigger_lock);
244 	if (led_cdev->trigger)
245 		led_trigger_set(led_cdev, NULL);
246 	up_write(&led_cdev->trigger_lock);
247 #endif
248 
249 	led_cdev->flags |= LED_UNREGISTERING;
250 
251 	/* Stop blinking */
252 	led_stop_software_blink(led_cdev);
253 
254 	led_set_brightness(led_cdev, LED_OFF);
255 
256 	flush_work(&led_cdev->set_brightness_work);
257 
258 	device_unregister(led_cdev->dev);
259 
260 	down_write(&leds_list_lock);
261 	list_del(&led_cdev->node);
262 	up_write(&leds_list_lock);
263 
264 	mutex_destroy(&led_cdev->led_access);
265 }
266 EXPORT_SYMBOL_GPL(led_classdev_unregister);
267 
268 static void devm_led_classdev_release(struct device *dev, void *res)
269 {
270 	led_classdev_unregister(*(struct led_classdev **)res);
271 }
272 
273 /**
274  * devm_led_classdev_register - resource managed led_classdev_register()
275  * @parent: The device to register.
276  * @led_cdev: the led_classdev structure for this device.
277  */
278 int devm_led_classdev_register(struct device *parent,
279 			       struct led_classdev *led_cdev)
280 {
281 	struct led_classdev **dr;
282 	int rc;
283 
284 	dr = devres_alloc(devm_led_classdev_release, sizeof(*dr), GFP_KERNEL);
285 	if (!dr)
286 		return -ENOMEM;
287 
288 	rc = led_classdev_register(parent, led_cdev);
289 	if (rc) {
290 		devres_free(dr);
291 		return rc;
292 	}
293 
294 	*dr = led_cdev;
295 	devres_add(parent, dr);
296 
297 	return 0;
298 }
299 EXPORT_SYMBOL_GPL(devm_led_classdev_register);
300 
301 static int devm_led_classdev_match(struct device *dev, void *res, void *data)
302 {
303 	struct led_cdev **p = res;
304 
305 	if (WARN_ON(!p || !*p))
306 		return 0;
307 
308 	return *p == data;
309 }
310 
311 /**
312  * devm_led_classdev_unregister() - resource managed led_classdev_unregister()
313  * @parent: The device to unregister.
314  * @led_cdev: the led_classdev structure for this device.
315  */
316 void devm_led_classdev_unregister(struct device *dev,
317 				  struct led_classdev *led_cdev)
318 {
319 	WARN_ON(devres_release(dev,
320 			       devm_led_classdev_release,
321 			       devm_led_classdev_match, led_cdev));
322 }
323 EXPORT_SYMBOL_GPL(devm_led_classdev_unregister);
324 
325 static int __init leds_init(void)
326 {
327 	leds_class = class_create(THIS_MODULE, "leds");
328 	if (IS_ERR(leds_class))
329 		return PTR_ERR(leds_class);
330 	leds_class->pm = &leds_class_dev_pm_ops;
331 	leds_class->dev_groups = led_groups;
332 	return 0;
333 }
334 
335 static void __exit leds_exit(void)
336 {
337 	class_destroy(leds_class);
338 }
339 
340 subsys_initcall(leds_init);
341 module_exit(leds_exit);
342 
343 MODULE_AUTHOR("John Lenz, Richard Purdie");
344 MODULE_LICENSE("GPL");
345 MODULE_DESCRIPTION("LED Class Interface");
346