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