xref: /openbmc/linux/drivers/leds/led-class.c (revision c819e2cf)
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 "leds.h"
24 
25 static struct class *leds_class;
26 
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 
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 
60 	ret = size;
61 unlock:
62 	mutex_unlock(&led_cdev->led_access);
63 	return ret;
64 }
65 static DEVICE_ATTR_RW(brightness);
66 
67 static ssize_t max_brightness_show(struct device *dev,
68 		struct device_attribute *attr, char *buf)
69 {
70 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
71 
72 	return sprintf(buf, "%u\n", led_cdev->max_brightness);
73 }
74 static DEVICE_ATTR_RO(max_brightness);
75 
76 #ifdef CONFIG_LEDS_TRIGGERS
77 static DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
78 static struct attribute *led_trigger_attrs[] = {
79 	&dev_attr_trigger.attr,
80 	NULL,
81 };
82 static const struct attribute_group led_trigger_group = {
83 	.attrs = led_trigger_attrs,
84 };
85 #endif
86 
87 static struct attribute *led_class_attrs[] = {
88 	&dev_attr_brightness.attr,
89 	&dev_attr_max_brightness.attr,
90 	NULL,
91 };
92 
93 static const struct attribute_group led_group = {
94 	.attrs = led_class_attrs,
95 };
96 
97 static const struct attribute_group *led_groups[] = {
98 	&led_group,
99 #ifdef CONFIG_LEDS_TRIGGERS
100 	&led_trigger_group,
101 #endif
102 	NULL,
103 };
104 
105 static void led_timer_function(unsigned long data)
106 {
107 	struct led_classdev *led_cdev = (void *)data;
108 	unsigned long brightness;
109 	unsigned long delay;
110 
111 	if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
112 		led_set_brightness_async(led_cdev, LED_OFF);
113 		return;
114 	}
115 
116 	if (led_cdev->flags & LED_BLINK_ONESHOT_STOP) {
117 		led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
118 		return;
119 	}
120 
121 	brightness = led_get_brightness(led_cdev);
122 	if (!brightness) {
123 		/* Time to switch the LED on. */
124 		brightness = led_cdev->blink_brightness;
125 		delay = led_cdev->blink_delay_on;
126 	} else {
127 		/* Store the current brightness value to be able
128 		 * to restore it when the delay_off period is over.
129 		 */
130 		led_cdev->blink_brightness = brightness;
131 		brightness = LED_OFF;
132 		delay = led_cdev->blink_delay_off;
133 	}
134 
135 	led_set_brightness_async(led_cdev, brightness);
136 
137 	/* Return in next iteration if led is in one-shot mode and we are in
138 	 * the final blink state so that the led is toggled each delay_on +
139 	 * delay_off milliseconds in worst case.
140 	 */
141 	if (led_cdev->flags & LED_BLINK_ONESHOT) {
142 		if (led_cdev->flags & LED_BLINK_INVERT) {
143 			if (brightness)
144 				led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
145 		} else {
146 			if (!brightness)
147 				led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
148 		}
149 	}
150 
151 	mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
152 }
153 
154 static void set_brightness_delayed(struct work_struct *ws)
155 {
156 	struct led_classdev *led_cdev =
157 		container_of(ws, struct led_classdev, set_brightness_work);
158 
159 	led_stop_software_blink(led_cdev);
160 
161 	led_set_brightness_async(led_cdev, led_cdev->delayed_set_value);
162 }
163 
164 /**
165  * led_classdev_suspend - suspend an led_classdev.
166  * @led_cdev: the led_classdev to suspend.
167  */
168 void led_classdev_suspend(struct led_classdev *led_cdev)
169 {
170 	led_cdev->flags |= LED_SUSPENDED;
171 	led_cdev->brightness_set(led_cdev, 0);
172 }
173 EXPORT_SYMBOL_GPL(led_classdev_suspend);
174 
175 /**
176  * led_classdev_resume - resume an led_classdev.
177  * @led_cdev: the led_classdev to resume.
178  */
179 void led_classdev_resume(struct led_classdev *led_cdev)
180 {
181 	led_cdev->brightness_set(led_cdev, led_cdev->brightness);
182 	led_cdev->flags &= ~LED_SUSPENDED;
183 }
184 EXPORT_SYMBOL_GPL(led_classdev_resume);
185 
186 static int led_suspend(struct device *dev)
187 {
188 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
189 
190 	if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
191 		led_classdev_suspend(led_cdev);
192 
193 	return 0;
194 }
195 
196 static int led_resume(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_resume(led_cdev);
202 
203 	return 0;
204 }
205 
206 static const struct dev_pm_ops leds_class_dev_pm_ops = {
207 	.suspend        = led_suspend,
208 	.resume         = led_resume,
209 };
210 
211 /**
212  * led_classdev_register - register a new object of led_classdev class.
213  * @parent: The device to register.
214  * @led_cdev: the led_classdev structure for this device.
215  */
216 int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
217 {
218 	led_cdev->dev = device_create_with_groups(leds_class, parent, 0,
219 					led_cdev, led_cdev->groups,
220 					"%s", led_cdev->name);
221 	if (IS_ERR(led_cdev->dev))
222 		return PTR_ERR(led_cdev->dev);
223 
224 #ifdef CONFIG_LEDS_TRIGGERS
225 	init_rwsem(&led_cdev->trigger_lock);
226 #endif
227 	mutex_init(&led_cdev->led_access);
228 	/* add to the list of leds */
229 	down_write(&leds_list_lock);
230 	list_add_tail(&led_cdev->node, &leds_list);
231 	up_write(&leds_list_lock);
232 
233 	if (!led_cdev->max_brightness)
234 		led_cdev->max_brightness = LED_FULL;
235 
236 	led_cdev->flags |= SET_BRIGHTNESS_ASYNC;
237 
238 	led_update_brightness(led_cdev);
239 
240 	INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed);
241 
242 	init_timer(&led_cdev->blink_timer);
243 	led_cdev->blink_timer.function = led_timer_function;
244 	led_cdev->blink_timer.data = (unsigned long)led_cdev;
245 
246 #ifdef CONFIG_LEDS_TRIGGERS
247 	led_trigger_set_default(led_cdev);
248 #endif
249 
250 	dev_dbg(parent, "Registered led device: %s\n",
251 			led_cdev->name);
252 
253 	return 0;
254 }
255 EXPORT_SYMBOL_GPL(led_classdev_register);
256 
257 /**
258  * led_classdev_unregister - unregisters a object of led_properties class.
259  * @led_cdev: the led device to unregister
260  *
261  * Unregisters a previously registered via led_classdev_register object.
262  */
263 void led_classdev_unregister(struct led_classdev *led_cdev)
264 {
265 #ifdef CONFIG_LEDS_TRIGGERS
266 	down_write(&led_cdev->trigger_lock);
267 	if (led_cdev->trigger)
268 		led_trigger_set(led_cdev, NULL);
269 	up_write(&led_cdev->trigger_lock);
270 #endif
271 
272 	cancel_work_sync(&led_cdev->set_brightness_work);
273 
274 	/* Stop blinking */
275 	led_stop_software_blink(led_cdev);
276 	led_set_brightness(led_cdev, LED_OFF);
277 
278 	device_unregister(led_cdev->dev);
279 
280 	down_write(&leds_list_lock);
281 	list_del(&led_cdev->node);
282 	up_write(&leds_list_lock);
283 
284 	mutex_destroy(&led_cdev->led_access);
285 }
286 EXPORT_SYMBOL_GPL(led_classdev_unregister);
287 
288 static int __init leds_init(void)
289 {
290 	leds_class = class_create(THIS_MODULE, "leds");
291 	if (IS_ERR(leds_class))
292 		return PTR_ERR(leds_class);
293 	leds_class->pm = &leds_class_dev_pm_ops;
294 	leds_class->dev_groups = led_groups;
295 	return 0;
296 }
297 
298 static void __exit leds_exit(void)
299 {
300 	class_destroy(leds_class);
301 }
302 
303 subsys_initcall(leds_init);
304 module_exit(leds_exit);
305 
306 MODULE_AUTHOR("John Lenz, Richard Purdie");
307 MODULE_LICENSE("GPL");
308 MODULE_DESCRIPTION("LED Class Interface");
309