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) { | |
35 | led_set_brightness_async(led_cdev, LED_OFF); | |
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 | ||
63 | led_set_brightness_async(led_cdev, brightness); | |
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); | |
86 | ||
f1e80c07 JA |
87 | if (led_cdev->flags & LED_BLINK_DISABLE) { |
88 | led_cdev->delayed_set_value = LED_OFF; | |
89 | led_stop_software_blink(led_cdev); | |
90 | led_cdev->flags &= ~LED_BLINK_DISABLE; | |
91 | } | |
757b06ae JA |
92 | |
93 | led_set_brightness_async(led_cdev, led_cdev->delayed_set_value); | |
94 | } | |
95 | ||
a403d930 BW |
96 | static void led_set_software_blink(struct led_classdev *led_cdev, |
97 | unsigned long delay_on, | |
98 | unsigned long delay_off) | |
99 | { | |
100 | int current_brightness; | |
101 | ||
102 | current_brightness = led_get_brightness(led_cdev); | |
103 | if (current_brightness) | |
104 | led_cdev->blink_brightness = current_brightness; | |
105 | if (!led_cdev->blink_brightness) | |
106 | led_cdev->blink_brightness = led_cdev->max_brightness; | |
107 | ||
a403d930 BW |
108 | led_cdev->blink_delay_on = delay_on; |
109 | led_cdev->blink_delay_off = delay_off; | |
110 | ||
8d82fef8 SS |
111 | /* never on - just set to off */ |
112 | if (!delay_on) { | |
4d71a4a1 | 113 | led_set_brightness_async(led_cdev, LED_OFF); |
a403d930 | 114 | return; |
8d82fef8 | 115 | } |
a403d930 BW |
116 | |
117 | /* never off - just set to brightness */ | |
118 | if (!delay_off) { | |
4d71a4a1 | 119 | led_set_brightness_async(led_cdev, led_cdev->blink_brightness); |
a403d930 BW |
120 | return; |
121 | } | |
122 | ||
9067359f | 123 | mod_timer(&led_cdev->blink_timer, jiffies + 1); |
a403d930 BW |
124 | } |
125 | ||
126 | ||
20c0e6b8 | 127 | static void led_blink_setup(struct led_classdev *led_cdev, |
5bb629c5 FB |
128 | unsigned long *delay_on, |
129 | unsigned long *delay_off) | |
a403d930 | 130 | { |
5bb629c5 FB |
131 | if (!(led_cdev->flags & LED_BLINK_ONESHOT) && |
132 | led_cdev->blink_set && | |
a403d930 BW |
133 | !led_cdev->blink_set(led_cdev, delay_on, delay_off)) |
134 | return; | |
135 | ||
136 | /* blink with 1 Hz as default if nothing specified */ | |
137 | if (!*delay_on && !*delay_off) | |
138 | *delay_on = *delay_off = 500; | |
139 | ||
140 | led_set_software_blink(led_cdev, *delay_on, *delay_off); | |
141 | } | |
5bb629c5 | 142 | |
757b06ae JA |
143 | void led_init_core(struct led_classdev *led_cdev) |
144 | { | |
145 | INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed); | |
146 | ||
147 | setup_timer(&led_cdev->blink_timer, led_timer_function, | |
148 | (unsigned long)led_cdev); | |
149 | } | |
150 | EXPORT_SYMBOL_GPL(led_init_core); | |
151 | ||
5bb629c5 FB |
152 | void led_blink_set(struct led_classdev *led_cdev, |
153 | unsigned long *delay_on, | |
154 | unsigned long *delay_off) | |
155 | { | |
9067359f | 156 | del_timer_sync(&led_cdev->blink_timer); |
5bb629c5 FB |
157 | |
158 | led_cdev->flags &= ~LED_BLINK_ONESHOT; | |
159 | led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP; | |
160 | ||
161 | led_blink_setup(led_cdev, delay_on, delay_off); | |
162 | } | |
2806e2ff | 163 | EXPORT_SYMBOL_GPL(led_blink_set); |
a403d930 | 164 | |
5bb629c5 FB |
165 | void led_blink_set_oneshot(struct led_classdev *led_cdev, |
166 | unsigned long *delay_on, | |
167 | unsigned long *delay_off, | |
168 | int invert) | |
169 | { | |
170 | if ((led_cdev->flags & LED_BLINK_ONESHOT) && | |
9067359f | 171 | timer_pending(&led_cdev->blink_timer)) |
5bb629c5 FB |
172 | return; |
173 | ||
174 | led_cdev->flags |= LED_BLINK_ONESHOT; | |
175 | led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP; | |
176 | ||
177 | if (invert) | |
178 | led_cdev->flags |= LED_BLINK_INVERT; | |
179 | else | |
180 | led_cdev->flags &= ~LED_BLINK_INVERT; | |
181 | ||
182 | led_blink_setup(led_cdev, delay_on, delay_off); | |
183 | } | |
2806e2ff | 184 | EXPORT_SYMBOL_GPL(led_blink_set_oneshot); |
5bb629c5 | 185 | |
d23a22a7 | 186 | void led_stop_software_blink(struct led_classdev *led_cdev) |
a403d930 | 187 | { |
9067359f | 188 | del_timer_sync(&led_cdev->blink_timer); |
43786482 FB |
189 | led_cdev->blink_delay_on = 0; |
190 | led_cdev->blink_delay_off = 0; | |
d23a22a7 FB |
191 | } |
192 | EXPORT_SYMBOL_GPL(led_stop_software_blink); | |
193 | ||
194 | void led_set_brightness(struct led_classdev *led_cdev, | |
195 | enum led_brightness brightness) | |
196 | { | |
4d71a4a1 JA |
197 | int ret = 0; |
198 | ||
f1e80c07 JA |
199 | /* |
200 | * In case blinking is on delay brightness setting | |
201 | * until the next timer tick. | |
202 | */ | |
d23a22a7 | 203 | if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) { |
f1e80c07 JA |
204 | /* |
205 | * If we need to disable soft blinking delegate this to the | |
206 | * work queue task to avoid problems in case we are called | |
207 | * from hard irq context. | |
208 | */ | |
209 | if (brightness == LED_OFF) { | |
210 | led_cdev->flags |= LED_BLINK_DISABLE; | |
76931edd | 211 | schedule_work(&led_cdev->set_brightness_work); |
f1e80c07 JA |
212 | } else { |
213 | led_cdev->flags |= LED_BLINK_BRIGHTNESS_CHANGE; | |
214 | led_cdev->blink_brightness = brightness; | |
215 | } | |
d23a22a7 FB |
216 | return; |
217 | } | |
43786482 | 218 | |
4d71a4a1 JA |
219 | if (led_cdev->flags & SET_BRIGHTNESS_ASYNC) { |
220 | led_set_brightness_async(led_cdev, brightness); | |
221 | return; | |
222 | } else if (led_cdev->flags & SET_BRIGHTNESS_SYNC) | |
223 | ret = led_set_brightness_sync(led_cdev, brightness); | |
224 | else | |
225 | ret = -EINVAL; | |
226 | ||
227 | if (ret < 0) | |
228 | dev_dbg(led_cdev->dev, "Setting LED brightness failed (%d)\n", | |
229 | ret); | |
a403d930 | 230 | } |
2806e2ff | 231 | EXPORT_SYMBOL_GPL(led_set_brightness); |
3ef7de53 JA |
232 | |
233 | int led_update_brightness(struct led_classdev *led_cdev) | |
234 | { | |
235 | int ret = 0; | |
236 | ||
237 | if (led_cdev->brightness_get) { | |
238 | ret = led_cdev->brightness_get(led_cdev); | |
239 | if (ret >= 0) { | |
240 | led_cdev->brightness = ret; | |
241 | return 0; | |
242 | } | |
243 | } | |
244 | ||
245 | return ret; | |
246 | } | |
2806e2ff | 247 | EXPORT_SYMBOL_GPL(led_update_brightness); |
acd899e4 JA |
248 | |
249 | /* Caller must ensure led_cdev->led_access held */ | |
250 | void led_sysfs_disable(struct led_classdev *led_cdev) | |
251 | { | |
252 | lockdep_assert_held(&led_cdev->led_access); | |
253 | ||
254 | led_cdev->flags |= LED_SYSFS_DISABLE; | |
255 | } | |
256 | EXPORT_SYMBOL_GPL(led_sysfs_disable); | |
257 | ||
258 | /* Caller must ensure led_cdev->led_access held */ | |
259 | void led_sysfs_enable(struct led_classdev *led_cdev) | |
260 | { | |
261 | lockdep_assert_held(&led_cdev->led_access); | |
262 | ||
263 | led_cdev->flags &= ~LED_SYSFS_DISABLE; | |
264 | } | |
265 | EXPORT_SYMBOL_GPL(led_sysfs_enable); |