]>
Commit | Line | Data |
---|---|---|
c3bc9956 RP |
1 | /* |
2 | * LED Triggers Core | |
3 | * | |
f8a7c6fe | 4 | * Copyright 2005-2007 Openedhand Ltd. |
c3bc9956 RP |
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 | ||
50237863 | 14 | #include <linux/export.h> |
c3bc9956 | 15 | #include <linux/kernel.h> |
c3bc9956 RP |
16 | #include <linux/list.h> |
17 | #include <linux/spinlock.h> | |
18 | #include <linux/device.h> | |
c3bc9956 | 19 | #include <linux/timer.h> |
dc47206e | 20 | #include <linux/rwsem.h> |
c3bc9956 | 21 | #include <linux/leds.h> |
5a0e3ad6 | 22 | #include <linux/slab.h> |
c3bc9956 RP |
23 | #include "leds.h" |
24 | ||
25 | /* | |
26 | * Nests outside led_cdev->trigger_lock | |
27 | */ | |
dc47206e | 28 | static DECLARE_RWSEM(triggers_list_lock); |
ba93cdce | 29 | LIST_HEAD(trigger_list); |
c3bc9956 | 30 | |
4d404fd5 NM |
31 | /* Used by LED Class */ |
32 | ||
f8a7c6fe RP |
33 | ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr, |
34 | const char *buf, size_t count) | |
c3bc9956 | 35 | { |
f8a7c6fe | 36 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
c3bc9956 | 37 | struct led_trigger *trig; |
acd899e4 JA |
38 | int ret = count; |
39 | ||
40 | mutex_lock(&led_cdev->led_access); | |
41 | ||
42 | if (led_sysfs_is_disabled(led_cdev)) { | |
43 | ret = -EBUSY; | |
44 | goto unlock; | |
45 | } | |
c3bc9956 | 46 | |
7296c33e | 47 | if (sysfs_streq(buf, "none")) { |
0013b23d | 48 | led_trigger_remove(led_cdev); |
acd899e4 | 49 | goto unlock; |
c3bc9956 RP |
50 | } |
51 | ||
dc47206e | 52 | down_read(&triggers_list_lock); |
c3bc9956 | 53 | list_for_each_entry(trig, &trigger_list, next_trig) { |
7296c33e | 54 | if (sysfs_streq(buf, trig->name)) { |
dc47206e | 55 | down_write(&led_cdev->trigger_lock); |
c3bc9956 | 56 | led_trigger_set(led_cdev, trig); |
dc47206e | 57 | up_write(&led_cdev->trigger_lock); |
c3bc9956 | 58 | |
dc47206e | 59 | up_read(&triggers_list_lock); |
acd899e4 | 60 | goto unlock; |
c3bc9956 RP |
61 | } |
62 | } | |
a3eac76c HK |
63 | /* we come here only if buf matches no trigger */ |
64 | ret = -EINVAL; | |
dc47206e | 65 | up_read(&triggers_list_lock); |
c3bc9956 | 66 | |
acd899e4 JA |
67 | unlock: |
68 | mutex_unlock(&led_cdev->led_access); | |
69 | return ret; | |
c3bc9956 | 70 | } |
4d404fd5 | 71 | EXPORT_SYMBOL_GPL(led_trigger_store); |
c3bc9956 | 72 | |
f8a7c6fe RP |
73 | ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr, |
74 | char *buf) | |
c3bc9956 | 75 | { |
f8a7c6fe | 76 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
c3bc9956 RP |
77 | struct led_trigger *trig; |
78 | int len = 0; | |
79 | ||
dc47206e RP |
80 | down_read(&triggers_list_lock); |
81 | down_read(&led_cdev->trigger_lock); | |
c3bc9956 RP |
82 | |
83 | if (!led_cdev->trigger) | |
3b9b9536 | 84 | len += scnprintf(buf+len, PAGE_SIZE - len, "[none] "); |
c3bc9956 | 85 | else |
3b9b9536 | 86 | len += scnprintf(buf+len, PAGE_SIZE - len, "none "); |
c3bc9956 RP |
87 | |
88 | list_for_each_entry(trig, &trigger_list, next_trig) { | |
89 | if (led_cdev->trigger && !strcmp(led_cdev->trigger->name, | |
90 | trig->name)) | |
3b9b9536 NS |
91 | len += scnprintf(buf+len, PAGE_SIZE - len, "[%s] ", |
92 | trig->name); | |
c3bc9956 | 93 | else |
3b9b9536 NS |
94 | len += scnprintf(buf+len, PAGE_SIZE - len, "%s ", |
95 | trig->name); | |
c3bc9956 | 96 | } |
dc47206e RP |
97 | up_read(&led_cdev->trigger_lock); |
98 | up_read(&triggers_list_lock); | |
c3bc9956 | 99 | |
3b9b9536 | 100 | len += scnprintf(len+buf, PAGE_SIZE - len, "\n"); |
c3bc9956 RP |
101 | return len; |
102 | } | |
4d404fd5 | 103 | EXPORT_SYMBOL_GPL(led_trigger_show); |
c3bc9956 RP |
104 | |
105 | /* Caller must ensure led_cdev->trigger_lock held */ | |
2282e125 | 106 | int led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig) |
c3bc9956 RP |
107 | { |
108 | unsigned long flags; | |
52c47742 CC |
109 | char *event = NULL; |
110 | char *envp[2]; | |
111 | const char *name; | |
2282e125 | 112 | int ret; |
52c47742 | 113 | |
fbfa197a | 114 | if (!led_cdev->trigger && !trig) |
2282e125 | 115 | return 0; |
fbfa197a | 116 | |
52c47742 CC |
117 | name = trig ? trig->name : "none"; |
118 | event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name); | |
c3bc9956 RP |
119 | |
120 | /* Remove any existing trigger */ | |
121 | if (led_cdev->trigger) { | |
122 | write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags); | |
123 | list_del(&led_cdev->trig_list); | |
4d404fd5 NM |
124 | write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, |
125 | flags); | |
d23a22a7 FB |
126 | cancel_work_sync(&led_cdev->set_brightness_work); |
127 | led_stop_software_blink(led_cdev); | |
c3bc9956 RP |
128 | if (led_cdev->trigger->deactivate) |
129 | led_cdev->trigger->deactivate(led_cdev); | |
a7e7a315 | 130 | device_remove_groups(led_cdev->dev, led_cdev->trigger->groups); |
fe3025b5 | 131 | led_cdev->trigger = NULL; |
a7d5904a UKK |
132 | led_cdev->trigger_data = NULL; |
133 | led_cdev->activated = false; | |
19cd67e2 | 134 | led_set_brightness(led_cdev, LED_OFF); |
c3bc9956 | 135 | } |
eb202621 BW |
136 | if (trig) { |
137 | write_lock_irqsave(&trig->leddev_list_lock, flags); | |
138 | list_add_tail(&led_cdev->trig_list, &trig->led_cdevs); | |
139 | write_unlock_irqrestore(&trig->leddev_list_lock, flags); | |
140 | led_cdev->trigger = trig; | |
2282e125 | 141 | |
eb202621 | 142 | if (trig->activate) |
2282e125 UKK |
143 | ret = trig->activate(led_cdev); |
144 | else | |
145 | ret = 0; | |
146 | ||
147 | if (ret) | |
148 | goto err_activate; | |
a7e7a315 UKK |
149 | |
150 | ret = device_add_groups(led_cdev->dev, trig->groups); | |
151 | if (ret) { | |
152 | dev_err(led_cdev->dev, "Failed to add trigger attributes\n"); | |
153 | goto err_add_groups; | |
154 | } | |
c3bc9956 | 155 | } |
52c47742 CC |
156 | |
157 | if (event) { | |
158 | envp[0] = event; | |
159 | envp[1] = NULL; | |
6f3bad96 JA |
160 | if (kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp)) |
161 | dev_err(led_cdev->dev, | |
162 | "%s: Error sending uevent\n", __func__); | |
52c47742 CC |
163 | kfree(event); |
164 | } | |
2282e125 UKK |
165 | |
166 | return 0; | |
167 | ||
a7e7a315 UKK |
168 | err_add_groups: |
169 | ||
170 | if (trig->deactivate) | |
171 | trig->deactivate(led_cdev); | |
2282e125 | 172 | err_activate: |
a7e7a315 | 173 | |
2282e125 | 174 | led_cdev->trigger = NULL; |
a7d5904a | 175 | led_cdev->trigger_data = NULL; |
2282e125 UKK |
176 | write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags); |
177 | list_del(&led_cdev->trig_list); | |
178 | write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, flags); | |
179 | led_set_brightness(led_cdev, LED_OFF); | |
180 | ||
181 | return ret; | |
c3bc9956 | 182 | } |
4d404fd5 | 183 | EXPORT_SYMBOL_GPL(led_trigger_set); |
c3bc9956 | 184 | |
0013b23d NM |
185 | void led_trigger_remove(struct led_classdev *led_cdev) |
186 | { | |
187 | down_write(&led_cdev->trigger_lock); | |
188 | led_trigger_set(led_cdev, NULL); | |
189 | up_write(&led_cdev->trigger_lock); | |
190 | } | |
4d404fd5 | 191 | EXPORT_SYMBOL_GPL(led_trigger_remove); |
0013b23d | 192 | |
c3bc9956 RP |
193 | void led_trigger_set_default(struct led_classdev *led_cdev) |
194 | { | |
195 | struct led_trigger *trig; | |
196 | ||
197 | if (!led_cdev->default_trigger) | |
198 | return; | |
199 | ||
dc47206e RP |
200 | down_read(&triggers_list_lock); |
201 | down_write(&led_cdev->trigger_lock); | |
c3bc9956 | 202 | list_for_each_entry(trig, &trigger_list, next_trig) { |
c4f7bd4a | 203 | if (!strcmp(led_cdev->default_trigger, trig->name)) { |
02d31765 | 204 | led_cdev->flags |= LED_INIT_DEFAULT_TRIGGER; |
c3bc9956 | 205 | led_trigger_set(led_cdev, trig); |
c4f7bd4a JA |
206 | break; |
207 | } | |
c3bc9956 | 208 | } |
dc47206e RP |
209 | up_write(&led_cdev->trigger_lock); |
210 | up_read(&triggers_list_lock); | |
c3bc9956 | 211 | } |
4d404fd5 NM |
212 | EXPORT_SYMBOL_GPL(led_trigger_set_default); |
213 | ||
a8df7b1a FB |
214 | void led_trigger_rename_static(const char *name, struct led_trigger *trig) |
215 | { | |
216 | /* new name must be on a temporary string to prevent races */ | |
217 | BUG_ON(name == trig->name); | |
218 | ||
219 | down_write(&triggers_list_lock); | |
220 | /* this assumes that trig->name was originaly allocated to | |
221 | * non constant storage */ | |
222 | strcpy((char *)trig->name, name); | |
223 | up_write(&triggers_list_lock); | |
224 | } | |
225 | EXPORT_SYMBOL_GPL(led_trigger_rename_static); | |
226 | ||
4d404fd5 | 227 | /* LED Trigger Interface */ |
c3bc9956 | 228 | |
eb202621 | 229 | int led_trigger_register(struct led_trigger *trig) |
c3bc9956 RP |
230 | { |
231 | struct led_classdev *led_cdev; | |
eb202621 | 232 | struct led_trigger *_trig; |
c3bc9956 | 233 | |
eb202621 BW |
234 | rwlock_init(&trig->leddev_list_lock); |
235 | INIT_LIST_HEAD(&trig->led_cdevs); | |
c3bc9956 | 236 | |
dc47206e | 237 | down_write(&triggers_list_lock); |
700c6ea2 | 238 | /* Make sure the trigger's name isn't already in use */ |
eb202621 BW |
239 | list_for_each_entry(_trig, &trigger_list, next_trig) { |
240 | if (!strcmp(_trig->name, trig->name)) { | |
700c6ea2 AN |
241 | up_write(&triggers_list_lock); |
242 | return -EEXIST; | |
243 | } | |
244 | } | |
245 | /* Add to the list of led triggers */ | |
eb202621 | 246 | list_add_tail(&trig->next_trig, &trigger_list); |
dc47206e | 247 | up_write(&triggers_list_lock); |
c3bc9956 RP |
248 | |
249 | /* Register with any LEDs that have this as a default trigger */ | |
72f8da32 | 250 | down_read(&leds_list_lock); |
c3bc9956 | 251 | list_for_each_entry(led_cdev, &leds_list, node) { |
dc47206e | 252 | down_write(&led_cdev->trigger_lock); |
c3bc9956 | 253 | if (!led_cdev->trigger && led_cdev->default_trigger && |
eb202621 BW |
254 | !strcmp(led_cdev->default_trigger, trig->name)) |
255 | led_trigger_set(led_cdev, trig); | |
dc47206e | 256 | up_write(&led_cdev->trigger_lock); |
c3bc9956 | 257 | } |
72f8da32 | 258 | up_read(&leds_list_lock); |
c3bc9956 RP |
259 | |
260 | return 0; | |
261 | } | |
4d404fd5 | 262 | EXPORT_SYMBOL_GPL(led_trigger_register); |
c3bc9956 | 263 | |
eb202621 | 264 | void led_trigger_unregister(struct led_trigger *trig) |
c3bc9956 RP |
265 | { |
266 | struct led_classdev *led_cdev; | |
267 | ||
14f5716b SL |
268 | if (list_empty_careful(&trig->next_trig)) |
269 | return; | |
270 | ||
c3bc9956 | 271 | /* Remove from the list of led triggers */ |
dc47206e | 272 | down_write(&triggers_list_lock); |
14f5716b | 273 | list_del_init(&trig->next_trig); |
dc47206e | 274 | up_write(&triggers_list_lock); |
c3bc9956 RP |
275 | |
276 | /* Remove anyone actively using this trigger */ | |
72f8da32 | 277 | down_read(&leds_list_lock); |
c3bc9956 | 278 | list_for_each_entry(led_cdev, &leds_list, node) { |
dc47206e | 279 | down_write(&led_cdev->trigger_lock); |
eb202621 | 280 | if (led_cdev->trigger == trig) |
c3bc9956 | 281 | led_trigger_set(led_cdev, NULL); |
dc47206e | 282 | up_write(&led_cdev->trigger_lock); |
c3bc9956 | 283 | } |
72f8da32 | 284 | up_read(&leds_list_lock); |
c3bc9956 | 285 | } |
4d404fd5 | 286 | EXPORT_SYMBOL_GPL(led_trigger_unregister); |
c3bc9956 | 287 | |
9534cc31 HK |
288 | static void devm_led_trigger_release(struct device *dev, void *res) |
289 | { | |
290 | led_trigger_unregister(*(struct led_trigger **)res); | |
291 | } | |
292 | ||
293 | int devm_led_trigger_register(struct device *dev, | |
294 | struct led_trigger *trig) | |
295 | { | |
296 | struct led_trigger **dr; | |
297 | int rc; | |
298 | ||
299 | dr = devres_alloc(devm_led_trigger_release, sizeof(*dr), | |
300 | GFP_KERNEL); | |
301 | if (!dr) | |
302 | return -ENOMEM; | |
303 | ||
304 | *dr = trig; | |
305 | ||
306 | rc = led_trigger_register(trig); | |
307 | if (rc) | |
308 | devres_free(dr); | |
309 | else | |
310 | devres_add(dev, dr); | |
311 | ||
312 | return rc; | |
313 | } | |
314 | EXPORT_SYMBOL_GPL(devm_led_trigger_register); | |
315 | ||
4d404fd5 NM |
316 | /* Simple LED Tigger Interface */ |
317 | ||
eb202621 | 318 | void led_trigger_event(struct led_trigger *trig, |
4d404fd5 | 319 | enum led_brightness brightness) |
c3bc9956 | 320 | { |
11e043b5 | 321 | struct led_classdev *led_cdev; |
4d404fd5 | 322 | |
eb202621 | 323 | if (!trig) |
4d404fd5 NM |
324 | return; |
325 | ||
eb202621 | 326 | read_lock(&trig->leddev_list_lock); |
11e043b5 | 327 | list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list) |
d23a22a7 | 328 | led_set_brightness(led_cdev, brightness); |
eb202621 | 329 | read_unlock(&trig->leddev_list_lock); |
c3bc9956 | 330 | } |
4d404fd5 | 331 | EXPORT_SYMBOL_GPL(led_trigger_event); |
c3bc9956 | 332 | |
20c0e6b8 | 333 | static void led_trigger_blink_setup(struct led_trigger *trig, |
5bb629c5 FB |
334 | unsigned long *delay_on, |
335 | unsigned long *delay_off, | |
336 | int oneshot, | |
337 | int invert) | |
0b9536c9 | 338 | { |
11e043b5 | 339 | struct led_classdev *led_cdev; |
0b9536c9 | 340 | |
eb202621 | 341 | if (!trig) |
0b9536c9 VK |
342 | return; |
343 | ||
eb202621 | 344 | read_lock(&trig->leddev_list_lock); |
11e043b5 | 345 | list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list) { |
5bb629c5 FB |
346 | if (oneshot) |
347 | led_blink_set_oneshot(led_cdev, delay_on, delay_off, | |
348 | invert); | |
349 | else | |
350 | led_blink_set(led_cdev, delay_on, delay_off); | |
0b9536c9 | 351 | } |
eb202621 | 352 | read_unlock(&trig->leddev_list_lock); |
0b9536c9 | 353 | } |
5bb629c5 FB |
354 | |
355 | void led_trigger_blink(struct led_trigger *trig, | |
356 | unsigned long *delay_on, | |
357 | unsigned long *delay_off) | |
358 | { | |
359 | led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0); | |
360 | } | |
0b9536c9 VK |
361 | EXPORT_SYMBOL_GPL(led_trigger_blink); |
362 | ||
5bb629c5 FB |
363 | void led_trigger_blink_oneshot(struct led_trigger *trig, |
364 | unsigned long *delay_on, | |
365 | unsigned long *delay_off, | |
366 | int invert) | |
367 | { | |
368 | led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert); | |
369 | } | |
370 | EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot); | |
371 | ||
4d404fd5 NM |
372 | void led_trigger_register_simple(const char *name, struct led_trigger **tp) |
373 | { | |
eb202621 | 374 | struct led_trigger *trig; |
4d404fd5 | 375 | int err; |
c3bc9956 | 376 | |
eb202621 | 377 | trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL); |
c3bc9956 | 378 | |
eb202621 BW |
379 | if (trig) { |
380 | trig->name = name; | |
381 | err = led_trigger_register(trig); | |
cba4c2ac | 382 | if (err < 0) { |
eb202621 BW |
383 | kfree(trig); |
384 | trig = NULL; | |
09f5fe75 SK |
385 | pr_warn("LED trigger %s failed to register (%d)\n", |
386 | name, err); | |
cba4c2ac | 387 | } |
09f5fe75 SK |
388 | } else { |
389 | pr_warn("LED trigger %s failed to register (no memory)\n", | |
390 | name); | |
391 | } | |
eb202621 | 392 | *tp = trig; |
4d404fd5 | 393 | } |
c3bc9956 | 394 | EXPORT_SYMBOL_GPL(led_trigger_register_simple); |
4d404fd5 | 395 | |
eb202621 | 396 | void led_trigger_unregister_simple(struct led_trigger *trig) |
4d404fd5 | 397 | { |
eb202621 BW |
398 | if (trig) |
399 | led_trigger_unregister(trig); | |
400 | kfree(trig); | |
4d404fd5 | 401 | } |
c3bc9956 | 402 | EXPORT_SYMBOL_GPL(led_trigger_unregister_simple); |