Linux 3.16-rc2
[linux-2.6-block.git] / drivers / leds / led-class.c
CommitLineData
c72a1d60
RP
1/*
2 * LED Class Core
3 *
4 * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
f8a7c6fe 5 * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
c72a1d60
RP
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
c72a1d60
RP
12#include <linux/module.h>
13#include <linux/kernel.h>
14#include <linux/init.h>
15#include <linux/list.h>
16#include <linux/spinlock.h>
17#include <linux/device.h>
c72a1d60
RP
18#include <linux/timer.h>
19#include <linux/err.h>
3dc7b82e 20#include <linux/ctype.h>
c72a1d60
RP
21#include <linux/leds.h>
22#include "leds.h"
23
24static struct class *leds_class;
25
29d76dfa
HMH
26static void led_update_brightness(struct led_classdev *led_cdev)
27{
28 if (led_cdev->brightness_get)
29 led_cdev->brightness = led_cdev->brightness_get(led_cdev);
30}
31
5baa7503 32static ssize_t brightness_show(struct device *dev,
f8a7c6fe 33 struct device_attribute *attr, char *buf)
c72a1d60 34{
f8a7c6fe 35 struct led_classdev *led_cdev = dev_get_drvdata(dev);
c72a1d60
RP
36
37 /* no lock needed for this */
29d76dfa 38 led_update_brightness(led_cdev);
c72a1d60 39
dd8e5a20 40 return sprintf(buf, "%u\n", led_cdev->brightness);
c72a1d60
RP
41}
42
5baa7503 43static ssize_t brightness_store(struct device *dev,
f8a7c6fe 44 struct device_attribute *attr, const char *buf, size_t size)
c72a1d60 45{
f8a7c6fe 46 struct led_classdev *led_cdev = dev_get_drvdata(dev);
872b86be 47 unsigned long state;
c72a1d60 48 ssize_t ret = -EINVAL;
c72a1d60 49
872b86be
SK
50 ret = kstrtoul(buf, 10, &state);
51 if (ret)
52 return ret;
3dc7b82e 53
872b86be
SK
54 if (state == LED_OFF)
55 led_trigger_remove(led_cdev);
0da3e65b 56 __led_set_brightness(led_cdev, state);
0013b23d 57
872b86be 58 return size;
c72a1d60 59}
5baa7503 60static DEVICE_ATTR_RW(brightness);
c72a1d60 61
1bd465e6
GL
62static ssize_t led_max_brightness_show(struct device *dev,
63 struct device_attribute *attr, char *buf)
64{
65 struct led_classdev *led_cdev = dev_get_drvdata(dev);
66
67 return sprintf(buf, "%u\n", led_cdev->max_brightness);
68}
5baa7503 69static DEVICE_ATTR(max_brightness, 0444, led_max_brightness_show, NULL);
1bd465e6 70
c3bc9956 71#ifdef CONFIG_LEDS_TRIGGERS
5baa7503
GKH
72static DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
73static struct attribute *led_trigger_attrs[] = {
74 &dev_attr_trigger.attr,
75 NULL,
76};
77static const struct attribute_group led_trigger_group = {
78 .attrs = led_trigger_attrs,
79};
80#endif
81
82static struct attribute *led_class_attrs[] = {
83 &dev_attr_brightness.attr,
84 &dev_attr_max_brightness.attr,
85 NULL,
86};
87
88static const struct attribute_group led_group = {
89 .attrs = led_class_attrs,
90};
91
92static const struct attribute_group *led_groups[] = {
93 &led_group,
94#ifdef CONFIG_LEDS_TRIGGERS
95 &led_trigger_group,
c3bc9956 96#endif
5baa7503 97 NULL,
14b5d6dd 98};
c72a1d60 99
5ada28bf
JB
100static void led_timer_function(unsigned long data)
101{
102 struct led_classdev *led_cdev = (void *)data;
103 unsigned long brightness;
104 unsigned long delay;
105
106 if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
0da3e65b 107 __led_set_brightness(led_cdev, LED_OFF);
5ada28bf
JB
108 return;
109 }
110
5bb629c5
FB
111 if (led_cdev->flags & LED_BLINK_ONESHOT_STOP) {
112 led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
113 return;
114 }
115
5ada28bf
JB
116 brightness = led_get_brightness(led_cdev);
117 if (!brightness) {
118 /* Time to switch the LED on. */
119 brightness = led_cdev->blink_brightness;
120 delay = led_cdev->blink_delay_on;
121 } else {
122 /* Store the current brightness value to be able
123 * to restore it when the delay_off period is over.
124 */
125 led_cdev->blink_brightness = brightness;
126 brightness = LED_OFF;
127 delay = led_cdev->blink_delay_off;
128 }
129
0da3e65b 130 __led_set_brightness(led_cdev, brightness);
5ada28bf 131
5bb629c5
FB
132 /* Return in next iteration if led is in one-shot mode and we are in
133 * the final blink state so that the led is toggled each delay_on +
134 * delay_off milliseconds in worst case.
135 */
136 if (led_cdev->flags & LED_BLINK_ONESHOT) {
137 if (led_cdev->flags & LED_BLINK_INVERT) {
138 if (brightness)
139 led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
140 } else {
141 if (!brightness)
142 led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
143 }
144 }
145
5ada28bf
JB
146 mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
147}
148
d23a22a7
FB
149static void set_brightness_delayed(struct work_struct *ws)
150{
151 struct led_classdev *led_cdev =
152 container_of(ws, struct led_classdev, set_brightness_work);
153
154 led_stop_software_blink(led_cdev);
155
156 __led_set_brightness(led_cdev, led_cdev->delayed_set_value);
157}
158
c72a1d60
RP
159/**
160 * led_classdev_suspend - suspend an led_classdev.
161 * @led_cdev: the led_classdev to suspend.
162 */
163void led_classdev_suspend(struct led_classdev *led_cdev)
164{
165 led_cdev->flags |= LED_SUSPENDED;
166 led_cdev->brightness_set(led_cdev, 0);
167}
168EXPORT_SYMBOL_GPL(led_classdev_suspend);
169
170/**
171 * led_classdev_resume - resume an led_classdev.
172 * @led_cdev: the led_classdev to resume.
173 */
174void led_classdev_resume(struct led_classdev *led_cdev)
175{
176 led_cdev->brightness_set(led_cdev, led_cdev->brightness);
177 led_cdev->flags &= ~LED_SUSPENDED;
178}
179EXPORT_SYMBOL_GPL(led_classdev_resume);
180
73e1ab41 181static int led_suspend(struct device *dev)
859cb7f2
RP
182{
183 struct led_classdev *led_cdev = dev_get_drvdata(dev);
184
185 if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
186 led_classdev_suspend(led_cdev);
187
188 return 0;
189}
190
191static int led_resume(struct device *dev)
192{
193 struct led_classdev *led_cdev = dev_get_drvdata(dev);
194
195 if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
196 led_classdev_resume(led_cdev);
197
198 return 0;
199}
200
73e1ab41
SK
201static const struct dev_pm_ops leds_class_dev_pm_ops = {
202 .suspend = led_suspend,
203 .resume = led_resume,
204};
205
c72a1d60
RP
206/**
207 * led_classdev_register - register a new object of led_classdev class.
ff8649af 208 * @parent: The device to register.
c72a1d60
RP
209 * @led_cdev: the led_classdev structure for this device.
210 */
211int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
212{
a9b12619
GKH
213 led_cdev->dev = device_create(leds_class, parent, 0, led_cdev,
214 "%s", led_cdev->name);
801678c5 215 if (IS_ERR(led_cdev->dev))
f8a7c6fe 216 return PTR_ERR(led_cdev->dev);
c72a1d60 217
270c3957
RP
218#ifdef CONFIG_LEDS_TRIGGERS
219 init_rwsem(&led_cdev->trigger_lock);
220#endif
c72a1d60 221 /* add to the list of leds */
72f8da32 222 down_write(&leds_list_lock);
c72a1d60 223 list_add_tail(&led_cdev->node, &leds_list);
72f8da32 224 up_write(&leds_list_lock);
c72a1d60 225
1bd465e6
GL
226 if (!led_cdev->max_brightness)
227 led_cdev->max_brightness = LED_FULL;
228
29d76dfa
HMH
229 led_update_brightness(led_cdev);
230
d23a22a7
FB
231 INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed);
232
5ada28bf
JB
233 init_timer(&led_cdev->blink_timer);
234 led_cdev->blink_timer.function = led_timer_function;
235 led_cdev->blink_timer.data = (unsigned long)led_cdev;
236
c3bc9956 237#ifdef CONFIG_LEDS_TRIGGERS
12fda168 238 led_trigger_set_default(led_cdev);
c3bc9956
RP
239#endif
240
d23e7b8b 241 dev_dbg(parent, "Registered led device: %s\n",
f8a7c6fe 242 led_cdev->name);
c72a1d60
RP
243
244 return 0;
245}
246EXPORT_SYMBOL_GPL(led_classdev_register);
247
248/**
0266a458 249 * led_classdev_unregister - unregisters a object of led_properties class.
70d63ccc 250 * @led_cdev: the led device to unregister
c72a1d60
RP
251 *
252 * Unregisters a previously registered via led_classdev_register object.
253 */
b844eba2 254void led_classdev_unregister(struct led_classdev *led_cdev)
c72a1d60 255{
c3bc9956 256#ifdef CONFIG_LEDS_TRIGGERS
dc47206e 257 down_write(&led_cdev->trigger_lock);
c3bc9956
RP
258 if (led_cdev->trigger)
259 led_trigger_set(led_cdev, NULL);
dc47206e 260 up_write(&led_cdev->trigger_lock);
c3bc9956 261#endif
c72a1d60 262
d23a22a7
FB
263 cancel_work_sync(&led_cdev->set_brightness_work);
264
5ada28bf 265 /* Stop blinking */
d23a22a7 266 led_stop_software_blink(led_cdev);
19cd67e2 267 led_set_brightness(led_cdev, LED_OFF);
5ada28bf 268
b844eba2 269 device_unregister(led_cdev->dev);
c72a1d60 270
72f8da32 271 down_write(&leds_list_lock);
c72a1d60 272 list_del(&led_cdev->node);
72f8da32 273 up_write(&leds_list_lock);
c72a1d60 274}
b844eba2 275EXPORT_SYMBOL_GPL(led_classdev_unregister);
c72a1d60
RP
276
277static int __init leds_init(void)
278{
279 leds_class = class_create(THIS_MODULE, "leds");
280 if (IS_ERR(leds_class))
281 return PTR_ERR(leds_class);
73e1ab41 282 leds_class->pm = &leds_class_dev_pm_ops;
5baa7503 283 leds_class->dev_groups = led_groups;
c72a1d60
RP
284 return 0;
285}
286
287static void __exit leds_exit(void)
288{
289 class_destroy(leds_class);
290}
291
292subsys_initcall(leds_init);
293module_exit(leds_exit);
294
295MODULE_AUTHOR("John Lenz, Richard Purdie");
296MODULE_LICENSE("GPL");
297MODULE_DESCRIPTION("LED Class Interface");