Commit | Line | Data |
---|---|---|
c72a1d60 RP |
1 | /* |
2 | * LED Class Core | |
3 | * | |
4 | * Copyright 2005-2006 Openedhand Ltd. | |
5 | * | |
6 | * Author: Richard Purdie <rpurdie@openedhand.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | */ | |
13 | ||
14 | #include <linux/kernel.h> | |
04713306 | 15 | #include <linux/leds.h> |
c72a1d60 RP |
16 | #include <linux/list.h> |
17 | #include <linux/module.h> | |
04713306 | 18 | #include <linux/mutex.h> |
72f8da32 | 19 | #include <linux/rwsem.h> |
c72a1d60 RP |
20 | #include "leds.h" |
21 | ||
72f8da32 | 22 | DECLARE_RWSEM(leds_list_lock); |
4d404fd5 | 23 | EXPORT_SYMBOL_GPL(leds_list_lock); |
c72a1d60 | 24 | |
4d404fd5 | 25 | LIST_HEAD(leds_list); |
c72a1d60 | 26 | EXPORT_SYMBOL_GPL(leds_list); |
a403d930 | 27 | |
757b06ae JA |
28 | static void led_timer_function(unsigned long data) |
29 | { | |
30 | struct led_classdev *led_cdev = (void *)data; | |
31 | unsigned long brightness; | |
32 | unsigned long delay; | |
33 | ||
34 | if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) { | |
81fe8e5b | 35 | led_set_brightness_nosleep(led_cdev, LED_OFF); |
757b06ae JA |
36 | return; |
37 | } | |
38 | ||
39 | if (led_cdev->flags & LED_BLINK_ONESHOT_STOP) { | |
40 | led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP; | |
41 | return; | |
42 | } | |
43 | ||
44 | brightness = led_get_brightness(led_cdev); | |
45 | if (!brightness) { | |
46 | /* Time to switch the LED on. */ | |
757b06ae JA |
47 | brightness = led_cdev->blink_brightness; |
48 | delay = led_cdev->blink_delay_on; | |
49 | } else { | |
50 | /* Store the current brightness value to be able | |
51 | * to restore it when the delay_off period is over. | |
f1e80c07 JA |
52 | * Do it only if there is no pending blink brightness |
53 | * change, to avoid overwriting the new value. | |
757b06ae | 54 | */ |
f1e80c07 JA |
55 | if (!(led_cdev->flags & LED_BLINK_BRIGHTNESS_CHANGE)) |
56 | led_cdev->blink_brightness = brightness; | |
57 | else | |
58 | led_cdev->flags &= ~LED_BLINK_BRIGHTNESS_CHANGE; | |
757b06ae JA |
59 | brightness = LED_OFF; |
60 | delay = led_cdev->blink_delay_off; | |
61 | } | |
62 | ||
81fe8e5b | 63 | led_set_brightness_nosleep(led_cdev, brightness); |
757b06ae JA |
64 | |
65 | /* Return in next iteration if led is in one-shot mode and we are in | |
66 | * the final blink state so that the led is toggled each delay_on + | |
67 | * delay_off milliseconds in worst case. | |
68 | */ | |
69 | if (led_cdev->flags & LED_BLINK_ONESHOT) { | |
70 | if (led_cdev->flags & LED_BLINK_INVERT) { | |
71 | if (brightness) | |
72 | led_cdev->flags |= LED_BLINK_ONESHOT_STOP; | |
73 | } else { | |
74 | if (!brightness) | |
75 | led_cdev->flags |= LED_BLINK_ONESHOT_STOP; | |
76 | } | |
77 | } | |
78 | ||
79 | mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay)); | |
80 | } | |
81 | ||
82 | static void set_brightness_delayed(struct work_struct *ws) | |
83 | { | |
84 | struct led_classdev *led_cdev = | |
85 | container_of(ws, struct led_classdev, set_brightness_work); | |
1afcadfc | 86 | int ret = 0; |
757b06ae | 87 | |
f1e80c07 JA |
88 | if (led_cdev->flags & LED_BLINK_DISABLE) { |
89 | led_cdev->delayed_set_value = LED_OFF; | |
90 | led_stop_software_blink(led_cdev); | |
91 | led_cdev->flags &= ~LED_BLINK_DISABLE; | |
92 | } | |
757b06ae | 93 | |
1afcadfc JA |
94 | if (led_cdev->brightness_set) |
95 | led_cdev->brightness_set(led_cdev, led_cdev->delayed_set_value); | |
96 | else if (led_cdev->brightness_set_blocking) | |
97 | ret = led_cdev->brightness_set_blocking(led_cdev, | |
98 | led_cdev->delayed_set_value); | |
99 | else | |
100 | ret = -ENOTSUPP; | |
d84d80f3 HK |
101 | if (ret < 0 && |
102 | /* LED HW might have been unplugged, therefore don't warn */ | |
103 | !(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) && | |
104 | (led_cdev->flags & LED_HW_PLUGGABLE))) | |
1afcadfc JA |
105 | dev_err(led_cdev->dev, |
106 | "Setting an LED's brightness failed (%d)\n", ret); | |
757b06ae JA |
107 | } |
108 | ||
a403d930 BW |
109 | static void led_set_software_blink(struct led_classdev *led_cdev, |
110 | unsigned long delay_on, | |
111 | unsigned long delay_off) | |
112 | { | |
113 | int current_brightness; | |
114 | ||
115 | current_brightness = led_get_brightness(led_cdev); | |
116 | if (current_brightness) | |
117 | led_cdev->blink_brightness = current_brightness; | |
118 | if (!led_cdev->blink_brightness) | |
119 | led_cdev->blink_brightness = led_cdev->max_brightness; | |
120 | ||
a403d930 BW |
121 | led_cdev->blink_delay_on = delay_on; |
122 | led_cdev->blink_delay_off = delay_off; | |
123 | ||
8d82fef8 SS |
124 | /* never on - just set to off */ |
125 | if (!delay_on) { | |
81fe8e5b | 126 | led_set_brightness_nosleep(led_cdev, LED_OFF); |
a403d930 | 127 | return; |
8d82fef8 | 128 | } |
a403d930 BW |
129 | |
130 | /* never off - just set to brightness */ | |
131 | if (!delay_off) { | |
81fe8e5b JA |
132 | led_set_brightness_nosleep(led_cdev, |
133 | led_cdev->blink_brightness); | |
a403d930 BW |
134 | return; |
135 | } | |
136 | ||
9067359f | 137 | mod_timer(&led_cdev->blink_timer, jiffies + 1); |
a403d930 BW |
138 | } |
139 | ||
140 | ||
20c0e6b8 | 141 | static void led_blink_setup(struct led_classdev *led_cdev, |
5bb629c5 FB |
142 | unsigned long *delay_on, |
143 | unsigned long *delay_off) | |
a403d930 | 144 | { |
5bb629c5 FB |
145 | if (!(led_cdev->flags & LED_BLINK_ONESHOT) && |
146 | led_cdev->blink_set && | |
a403d930 BW |
147 | !led_cdev->blink_set(led_cdev, delay_on, delay_off)) |
148 | return; | |
149 | ||
150 | /* blink with 1 Hz as default if nothing specified */ | |
151 | if (!*delay_on && !*delay_off) | |
152 | *delay_on = *delay_off = 500; | |
153 | ||
154 | led_set_software_blink(led_cdev, *delay_on, *delay_off); | |
155 | } | |
5bb629c5 | 156 | |
757b06ae JA |
157 | void led_init_core(struct led_classdev *led_cdev) |
158 | { | |
159 | INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed); | |
160 | ||
161 | setup_timer(&led_cdev->blink_timer, led_timer_function, | |
162 | (unsigned long)led_cdev); | |
163 | } | |
164 | EXPORT_SYMBOL_GPL(led_init_core); | |
165 | ||
5bb629c5 FB |
166 | void led_blink_set(struct led_classdev *led_cdev, |
167 | unsigned long *delay_on, | |
168 | unsigned long *delay_off) | |
169 | { | |
9067359f | 170 | del_timer_sync(&led_cdev->blink_timer); |
5bb629c5 FB |
171 | |
172 | led_cdev->flags &= ~LED_BLINK_ONESHOT; | |
173 | led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP; | |
174 | ||
175 | led_blink_setup(led_cdev, delay_on, delay_off); | |
176 | } | |
2806e2ff | 177 | EXPORT_SYMBOL_GPL(led_blink_set); |
a403d930 | 178 | |
5bb629c5 FB |
179 | void led_blink_set_oneshot(struct led_classdev *led_cdev, |
180 | unsigned long *delay_on, | |
181 | unsigned long *delay_off, | |
182 | int invert) | |
183 | { | |
184 | if ((led_cdev->flags & LED_BLINK_ONESHOT) && | |
9067359f | 185 | timer_pending(&led_cdev->blink_timer)) |
5bb629c5 FB |
186 | return; |
187 | ||
188 | led_cdev->flags |= LED_BLINK_ONESHOT; | |
189 | led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP; | |
190 | ||
191 | if (invert) | |
192 | led_cdev->flags |= LED_BLINK_INVERT; | |
193 | else | |
194 | led_cdev->flags &= ~LED_BLINK_INVERT; | |
195 | ||
196 | led_blink_setup(led_cdev, delay_on, delay_off); | |
197 | } | |
2806e2ff | 198 | EXPORT_SYMBOL_GPL(led_blink_set_oneshot); |
5bb629c5 | 199 | |
d23a22a7 | 200 | void led_stop_software_blink(struct led_classdev *led_cdev) |
a403d930 | 201 | { |
9067359f | 202 | del_timer_sync(&led_cdev->blink_timer); |
43786482 FB |
203 | led_cdev->blink_delay_on = 0; |
204 | led_cdev->blink_delay_off = 0; | |
d23a22a7 FB |
205 | } |
206 | EXPORT_SYMBOL_GPL(led_stop_software_blink); | |
207 | ||
208 | void led_set_brightness(struct led_classdev *led_cdev, | |
209 | enum led_brightness brightness) | |
210 | { | |
f1e80c07 JA |
211 | /* |
212 | * In case blinking is on delay brightness setting | |
213 | * until the next timer tick. | |
214 | */ | |
d23a22a7 | 215 | if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) { |
f1e80c07 JA |
216 | /* |
217 | * If we need to disable soft blinking delegate this to the | |
218 | * work queue task to avoid problems in case we are called | |
219 | * from hard irq context. | |
220 | */ | |
221 | if (brightness == LED_OFF) { | |
222 | led_cdev->flags |= LED_BLINK_DISABLE; | |
76931edd | 223 | schedule_work(&led_cdev->set_brightness_work); |
f1e80c07 JA |
224 | } else { |
225 | led_cdev->flags |= LED_BLINK_BRIGHTNESS_CHANGE; | |
226 | led_cdev->blink_brightness = brightness; | |
227 | } | |
d23a22a7 FB |
228 | return; |
229 | } | |
43786482 | 230 | |
13ae79bb | 231 | led_set_brightness_nosleep(led_cdev, brightness); |
a403d930 | 232 | } |
2806e2ff | 233 | EXPORT_SYMBOL_GPL(led_set_brightness); |
3ef7de53 | 234 | |
81fe8e5b JA |
235 | void led_set_brightness_nopm(struct led_classdev *led_cdev, |
236 | enum led_brightness value) | |
237 | { | |
238 | /* Use brightness_set op if available, it is guaranteed not to sleep */ | |
239 | if (led_cdev->brightness_set) { | |
240 | led_cdev->brightness_set(led_cdev, value); | |
241 | return; | |
242 | } | |
243 | ||
244 | /* If brightness setting can sleep, delegate it to a work queue task */ | |
245 | led_cdev->delayed_set_value = value; | |
246 | schedule_work(&led_cdev->set_brightness_work); | |
247 | } | |
248 | EXPORT_SYMBOL_GPL(led_set_brightness_nopm); | |
249 | ||
250 | void led_set_brightness_nosleep(struct led_classdev *led_cdev, | |
251 | enum led_brightness value) | |
252 | { | |
253 | led_cdev->brightness = min(value, led_cdev->max_brightness); | |
254 | ||
255 | if (led_cdev->flags & LED_SUSPENDED) | |
256 | return; | |
257 | ||
258 | led_set_brightness_nopm(led_cdev, led_cdev->brightness); | |
259 | } | |
260 | EXPORT_SYMBOL_GPL(led_set_brightness_nosleep); | |
261 | ||
13ae79bb JA |
262 | int led_set_brightness_sync(struct led_classdev *led_cdev, |
263 | enum led_brightness value) | |
264 | { | |
265 | if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) | |
266 | return -EBUSY; | |
267 | ||
268 | led_cdev->brightness = min(value, led_cdev->max_brightness); | |
269 | ||
270 | if (led_cdev->flags & LED_SUSPENDED) | |
271 | return 0; | |
272 | ||
273 | if (led_cdev->brightness_set_blocking) | |
274 | return led_cdev->brightness_set_blocking(led_cdev, | |
275 | led_cdev->brightness); | |
276 | return -ENOTSUPP; | |
277 | } | |
278 | EXPORT_SYMBOL_GPL(led_set_brightness_sync); | |
279 | ||
3ef7de53 JA |
280 | int led_update_brightness(struct led_classdev *led_cdev) |
281 | { | |
282 | int ret = 0; | |
283 | ||
284 | if (led_cdev->brightness_get) { | |
285 | ret = led_cdev->brightness_get(led_cdev); | |
286 | if (ret >= 0) { | |
287 | led_cdev->brightness = ret; | |
288 | return 0; | |
289 | } | |
290 | } | |
291 | ||
292 | return ret; | |
293 | } | |
2806e2ff | 294 | EXPORT_SYMBOL_GPL(led_update_brightness); |
acd899e4 JA |
295 | |
296 | /* Caller must ensure led_cdev->led_access held */ | |
297 | void led_sysfs_disable(struct led_classdev *led_cdev) | |
298 | { | |
299 | lockdep_assert_held(&led_cdev->led_access); | |
300 | ||
301 | led_cdev->flags |= LED_SYSFS_DISABLE; | |
302 | } | |
303 | EXPORT_SYMBOL_GPL(led_sysfs_disable); | |
304 | ||
305 | /* Caller must ensure led_cdev->led_access held */ | |
306 | void led_sysfs_enable(struct led_classdev *led_cdev) | |
307 | { | |
308 | lockdep_assert_held(&led_cdev->led_access); | |
309 | ||
310 | led_cdev->flags &= ~LED_SYSFS_DISABLE; | |
311 | } | |
312 | EXPORT_SYMBOL_GPL(led_sysfs_enable); |