leds-lp5523: minor code style fixes
[linux-2.6-block.git] / drivers / leds / led-triggers.c
CommitLineData
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
c3bc9956
RP
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/init.h>
17#include <linux/list.h>
18#include <linux/spinlock.h>
19#include <linux/device.h>
c3bc9956 20#include <linux/timer.h>
dc47206e 21#include <linux/rwsem.h>
c3bc9956 22#include <linux/leds.h>
5a0e3ad6 23#include <linux/slab.h>
c3bc9956
RP
24#include "leds.h"
25
26/*
27 * Nests outside led_cdev->trigger_lock
28 */
dc47206e 29static DECLARE_RWSEM(triggers_list_lock);
c3bc9956
RP
30static LIST_HEAD(trigger_list);
31
4d404fd5
NM
32 /* Used by LED Class */
33
f8a7c6fe
RP
34ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
35 const char *buf, size_t count)
c3bc9956 36{
f8a7c6fe 37 struct led_classdev *led_cdev = dev_get_drvdata(dev);
c3bc9956
RP
38 char trigger_name[TRIG_NAME_MAX];
39 struct led_trigger *trig;
40 size_t len;
41
42 trigger_name[sizeof(trigger_name) - 1] = '\0';
43 strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
44 len = strlen(trigger_name);
45
46 if (len && trigger_name[len - 1] == '\n')
47 trigger_name[len - 1] = '\0';
48
49 if (!strcmp(trigger_name, "none")) {
0013b23d 50 led_trigger_remove(led_cdev);
c3bc9956
RP
51 return count;
52 }
53
dc47206e 54 down_read(&triggers_list_lock);
c3bc9956
RP
55 list_for_each_entry(trig, &trigger_list, next_trig) {
56 if (!strcmp(trigger_name, trig->name)) {
dc47206e 57 down_write(&led_cdev->trigger_lock);
c3bc9956 58 led_trigger_set(led_cdev, trig);
dc47206e 59 up_write(&led_cdev->trigger_lock);
c3bc9956 60
dc47206e 61 up_read(&triggers_list_lock);
c3bc9956
RP
62 return count;
63 }
64 }
dc47206e 65 up_read(&triggers_list_lock);
c3bc9956
RP
66
67 return -EINVAL;
68}
4d404fd5 69EXPORT_SYMBOL_GPL(led_trigger_store);
c3bc9956 70
f8a7c6fe
RP
71ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
72 char *buf)
c3bc9956 73{
f8a7c6fe 74 struct led_classdev *led_cdev = dev_get_drvdata(dev);
c3bc9956
RP
75 struct led_trigger *trig;
76 int len = 0;
77
dc47206e
RP
78 down_read(&triggers_list_lock);
79 down_read(&led_cdev->trigger_lock);
c3bc9956
RP
80
81 if (!led_cdev->trigger)
82 len += sprintf(buf+len, "[none] ");
83 else
84 len += sprintf(buf+len, "none ");
85
86 list_for_each_entry(trig, &trigger_list, next_trig) {
87 if (led_cdev->trigger && !strcmp(led_cdev->trigger->name,
88 trig->name))
89 len += sprintf(buf+len, "[%s] ", trig->name);
90 else
91 len += sprintf(buf+len, "%s ", trig->name);
92 }
dc47206e
RP
93 up_read(&led_cdev->trigger_lock);
94 up_read(&triggers_list_lock);
c3bc9956
RP
95
96 len += sprintf(len+buf, "\n");
97 return len;
98}
4d404fd5 99EXPORT_SYMBOL_GPL(led_trigger_show);
c3bc9956
RP
100
101/* Caller must ensure led_cdev->trigger_lock held */
eb202621 102void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig)
c3bc9956
RP
103{
104 unsigned long flags;
105
106 /* Remove any existing trigger */
107 if (led_cdev->trigger) {
108 write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
109 list_del(&led_cdev->trig_list);
4d404fd5
NM
110 write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock,
111 flags);
d23a22a7
FB
112 cancel_work_sync(&led_cdev->set_brightness_work);
113 led_stop_software_blink(led_cdev);
c3bc9956
RP
114 if (led_cdev->trigger->deactivate)
115 led_cdev->trigger->deactivate(led_cdev);
fe3025b5 116 led_cdev->trigger = NULL;
19cd67e2 117 led_set_brightness(led_cdev, LED_OFF);
c3bc9956 118 }
eb202621
BW
119 if (trig) {
120 write_lock_irqsave(&trig->leddev_list_lock, flags);
121 list_add_tail(&led_cdev->trig_list, &trig->led_cdevs);
122 write_unlock_irqrestore(&trig->leddev_list_lock, flags);
123 led_cdev->trigger = trig;
124 if (trig->activate)
125 trig->activate(led_cdev);
c3bc9956 126 }
c3bc9956 127}
4d404fd5 128EXPORT_SYMBOL_GPL(led_trigger_set);
c3bc9956 129
0013b23d
NM
130void led_trigger_remove(struct led_classdev *led_cdev)
131{
132 down_write(&led_cdev->trigger_lock);
133 led_trigger_set(led_cdev, NULL);
134 up_write(&led_cdev->trigger_lock);
135}
4d404fd5 136EXPORT_SYMBOL_GPL(led_trigger_remove);
0013b23d 137
c3bc9956
RP
138void led_trigger_set_default(struct led_classdev *led_cdev)
139{
140 struct led_trigger *trig;
141
142 if (!led_cdev->default_trigger)
143 return;
144
dc47206e
RP
145 down_read(&triggers_list_lock);
146 down_write(&led_cdev->trigger_lock);
c3bc9956
RP
147 list_for_each_entry(trig, &trigger_list, next_trig) {
148 if (!strcmp(led_cdev->default_trigger, trig->name))
149 led_trigger_set(led_cdev, trig);
150 }
dc47206e
RP
151 up_write(&led_cdev->trigger_lock);
152 up_read(&triggers_list_lock);
c3bc9956 153}
4d404fd5
NM
154EXPORT_SYMBOL_GPL(led_trigger_set_default);
155
156/* LED Trigger Interface */
c3bc9956 157
eb202621 158int led_trigger_register(struct led_trigger *trig)
c3bc9956
RP
159{
160 struct led_classdev *led_cdev;
eb202621 161 struct led_trigger *_trig;
c3bc9956 162
eb202621
BW
163 rwlock_init(&trig->leddev_list_lock);
164 INIT_LIST_HEAD(&trig->led_cdevs);
c3bc9956 165
dc47206e 166 down_write(&triggers_list_lock);
700c6ea2 167 /* Make sure the trigger's name isn't already in use */
eb202621
BW
168 list_for_each_entry(_trig, &trigger_list, next_trig) {
169 if (!strcmp(_trig->name, trig->name)) {
700c6ea2
AN
170 up_write(&triggers_list_lock);
171 return -EEXIST;
172 }
173 }
174 /* Add to the list of led triggers */
eb202621 175 list_add_tail(&trig->next_trig, &trigger_list);
dc47206e 176 up_write(&triggers_list_lock);
c3bc9956
RP
177
178 /* Register with any LEDs that have this as a default trigger */
72f8da32 179 down_read(&leds_list_lock);
c3bc9956 180 list_for_each_entry(led_cdev, &leds_list, node) {
dc47206e 181 down_write(&led_cdev->trigger_lock);
c3bc9956 182 if (!led_cdev->trigger && led_cdev->default_trigger &&
eb202621
BW
183 !strcmp(led_cdev->default_trigger, trig->name))
184 led_trigger_set(led_cdev, trig);
dc47206e 185 up_write(&led_cdev->trigger_lock);
c3bc9956 186 }
72f8da32 187 up_read(&leds_list_lock);
c3bc9956
RP
188
189 return 0;
190}
4d404fd5 191EXPORT_SYMBOL_GPL(led_trigger_register);
c3bc9956 192
eb202621 193void led_trigger_unregister(struct led_trigger *trig)
c3bc9956
RP
194{
195 struct led_classdev *led_cdev;
196
197 /* Remove from the list of led triggers */
dc47206e 198 down_write(&triggers_list_lock);
eb202621 199 list_del(&trig->next_trig);
dc47206e 200 up_write(&triggers_list_lock);
c3bc9956
RP
201
202 /* Remove anyone actively using this trigger */
72f8da32 203 down_read(&leds_list_lock);
c3bc9956 204 list_for_each_entry(led_cdev, &leds_list, node) {
dc47206e 205 down_write(&led_cdev->trigger_lock);
eb202621 206 if (led_cdev->trigger == trig)
c3bc9956 207 led_trigger_set(led_cdev, NULL);
dc47206e 208 up_write(&led_cdev->trigger_lock);
c3bc9956 209 }
72f8da32 210 up_read(&leds_list_lock);
c3bc9956 211}
4d404fd5 212EXPORT_SYMBOL_GPL(led_trigger_unregister);
c3bc9956 213
4d404fd5
NM
214/* Simple LED Tigger Interface */
215
eb202621 216void led_trigger_event(struct led_trigger *trig,
4d404fd5 217 enum led_brightness brightness)
c3bc9956 218{
4d404fd5
NM
219 struct list_head *entry;
220
eb202621 221 if (!trig)
4d404fd5
NM
222 return;
223
eb202621
BW
224 read_lock(&trig->leddev_list_lock);
225 list_for_each(entry, &trig->led_cdevs) {
4d404fd5
NM
226 struct led_classdev *led_cdev;
227
228 led_cdev = list_entry(entry, struct led_classdev, trig_list);
d23a22a7 229 led_set_brightness(led_cdev, brightness);
4d404fd5 230 }
eb202621 231 read_unlock(&trig->leddev_list_lock);
c3bc9956 232}
4d404fd5 233EXPORT_SYMBOL_GPL(led_trigger_event);
c3bc9956 234
20c0e6b8 235static void led_trigger_blink_setup(struct led_trigger *trig,
5bb629c5
FB
236 unsigned long *delay_on,
237 unsigned long *delay_off,
238 int oneshot,
239 int invert)
0b9536c9
VK
240{
241 struct list_head *entry;
242
eb202621 243 if (!trig)
0b9536c9
VK
244 return;
245
eb202621
BW
246 read_lock(&trig->leddev_list_lock);
247 list_for_each(entry, &trig->led_cdevs) {
0b9536c9
VK
248 struct led_classdev *led_cdev;
249
250 led_cdev = list_entry(entry, struct led_classdev, trig_list);
5bb629c5
FB
251 if (oneshot)
252 led_blink_set_oneshot(led_cdev, delay_on, delay_off,
253 invert);
254 else
255 led_blink_set(led_cdev, delay_on, delay_off);
0b9536c9 256 }
eb202621 257 read_unlock(&trig->leddev_list_lock);
0b9536c9 258}
5bb629c5
FB
259
260void led_trigger_blink(struct led_trigger *trig,
261 unsigned long *delay_on,
262 unsigned long *delay_off)
263{
264 led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0);
265}
0b9536c9
VK
266EXPORT_SYMBOL_GPL(led_trigger_blink);
267
5bb629c5
FB
268void led_trigger_blink_oneshot(struct led_trigger *trig,
269 unsigned long *delay_on,
270 unsigned long *delay_off,
271 int invert)
272{
273 led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert);
274}
275EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot);
276
4d404fd5
NM
277void led_trigger_register_simple(const char *name, struct led_trigger **tp)
278{
eb202621 279 struct led_trigger *trig;
4d404fd5 280 int err;
c3bc9956 281
eb202621 282 trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
c3bc9956 283
eb202621
BW
284 if (trig) {
285 trig->name = name;
286 err = led_trigger_register(trig);
cba4c2ac 287 if (err < 0) {
eb202621
BW
288 kfree(trig);
289 trig = NULL;
4d404fd5
NM
290 printk(KERN_WARNING "LED trigger %s failed to register"
291 " (%d)\n", name, err);
cba4c2ac 292 }
4d404fd5
NM
293 } else
294 printk(KERN_WARNING "LED trigger %s failed to register"
295 " (no memory)\n", name);
296
eb202621 297 *tp = trig;
4d404fd5 298}
c3bc9956 299EXPORT_SYMBOL_GPL(led_trigger_register_simple);
4d404fd5 300
eb202621 301void led_trigger_unregister_simple(struct led_trigger *trig)
4d404fd5 302{
eb202621
BW
303 if (trig)
304 led_trigger_unregister(trig);
305 kfree(trig);
4d404fd5 306}
c3bc9956 307EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
c3bc9956
RP
308
309MODULE_AUTHOR("Richard Purdie");
310MODULE_LICENSE("GPL");
311MODULE_DESCRIPTION("LED Triggers Core");