Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / drivers / leds / led-class.c
1 /*
2  * LED Class Core
3  *
4  * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
5  * Copyright (C) 2005-2007 Richard Purdie <rpurdie@openedhand.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/list.h>
16 #include <linux/spinlock.h>
17 #include <linux/device.h>
18 #include <linux/sysdev.h>
19 #include <linux/timer.h>
20 #include <linux/err.h>
21 #include <linux/ctype.h>
22 #include <linux/leds.h>
23 #include "leds.h"
24
25 static struct class *leds_class;
26
27 static void led_update_brightness(struct led_classdev *led_cdev)
28 {
29         if (led_cdev->brightness_get)
30                 led_cdev->brightness = led_cdev->brightness_get(led_cdev);
31 }
32
33 static ssize_t led_brightness_show(struct device *dev, 
34                 struct device_attribute *attr, char *buf)
35 {
36         struct led_classdev *led_cdev = dev_get_drvdata(dev);
37
38         /* no lock needed for this */
39         led_update_brightness(led_cdev);
40
41         return sprintf(buf, "%u\n", led_cdev->brightness);
42 }
43
44 static ssize_t led_brightness_store(struct device *dev,
45                 struct device_attribute *attr, const char *buf, size_t size)
46 {
47         struct led_classdev *led_cdev = dev_get_drvdata(dev);
48         ssize_t ret = -EINVAL;
49         char *after;
50         unsigned long state = simple_strtoul(buf, &after, 10);
51         size_t count = after - buf;
52
53         if (*after && isspace(*after))
54                 count++;
55
56         if (count == size) {
57                 ret = count;
58
59                 if (state == LED_OFF)
60                         led_trigger_remove(led_cdev);
61                 led_set_brightness(led_cdev, state);
62         }
63
64         return ret;
65 }
66
67 static DEVICE_ATTR(brightness, 0644, led_brightness_show, led_brightness_store);
68 #ifdef CONFIG_LEDS_TRIGGERS
69 static DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
70 #endif
71
72 /**
73  * led_classdev_suspend - suspend an led_classdev.
74  * @led_cdev: the led_classdev to suspend.
75  */
76 void led_classdev_suspend(struct led_classdev *led_cdev)
77 {
78         led_cdev->flags |= LED_SUSPENDED;
79         led_cdev->brightness_set(led_cdev, 0);
80 }
81 EXPORT_SYMBOL_GPL(led_classdev_suspend);
82
83 /**
84  * led_classdev_resume - resume an led_classdev.
85  * @led_cdev: the led_classdev to resume.
86  */
87 void led_classdev_resume(struct led_classdev *led_cdev)
88 {
89         led_cdev->brightness_set(led_cdev, led_cdev->brightness);
90         led_cdev->flags &= ~LED_SUSPENDED;
91 }
92 EXPORT_SYMBOL_GPL(led_classdev_resume);
93
94 static int led_suspend(struct device *dev, pm_message_t state)
95 {
96         struct led_classdev *led_cdev = dev_get_drvdata(dev);
97
98         if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
99                 led_classdev_suspend(led_cdev);
100
101         return 0;
102 }
103
104 static int led_resume(struct device *dev)
105 {
106         struct led_classdev *led_cdev = dev_get_drvdata(dev);
107
108         if (led_cdev->flags & LED_CORE_SUSPENDRESUME)
109                 led_classdev_resume(led_cdev);
110
111         return 0;
112 }
113
114 /**
115  * led_classdev_register - register a new object of led_classdev class.
116  * @parent: The device to register.
117  * @led_cdev: the led_classdev structure for this device.
118  */
119 int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
120 {
121         int rc;
122
123         led_cdev->dev = device_create(leds_class, parent, 0, led_cdev,
124                                       "%s", led_cdev->name);
125         if (IS_ERR(led_cdev->dev))
126                 return PTR_ERR(led_cdev->dev);
127
128         /* register the attributes */
129         rc = device_create_file(led_cdev->dev, &dev_attr_brightness);
130         if (rc)
131                 goto err_out;
132
133 #ifdef CONFIG_LEDS_TRIGGERS
134         init_rwsem(&led_cdev->trigger_lock);
135 #endif
136         /* add to the list of leds */
137         down_write(&leds_list_lock);
138         list_add_tail(&led_cdev->node, &leds_list);
139         up_write(&leds_list_lock);
140
141         led_update_brightness(led_cdev);
142
143 #ifdef CONFIG_LEDS_TRIGGERS
144         rc = device_create_file(led_cdev->dev, &dev_attr_trigger);
145         if (rc)
146                 goto err_out_led_list;
147
148         led_trigger_set_default(led_cdev);
149 #endif
150
151         printk(KERN_INFO "Registered led device: %s\n",
152                         led_cdev->name);
153
154         return 0;
155
156 #ifdef CONFIG_LEDS_TRIGGERS
157 err_out_led_list:
158         device_remove_file(led_cdev->dev, &dev_attr_brightness);
159         list_del(&led_cdev->node);
160 #endif
161 err_out:
162         device_unregister(led_cdev->dev);
163         return rc;
164 }
165 EXPORT_SYMBOL_GPL(led_classdev_register);
166
167 /**
168  * led_classdev_unregister - unregisters a object of led_properties class.
169  * @led_cdev: the led device to unregister
170  *
171  * Unregisters a previously registered via led_classdev_register object.
172  */
173 void led_classdev_unregister(struct led_classdev *led_cdev)
174 {
175         device_remove_file(led_cdev->dev, &dev_attr_brightness);
176 #ifdef CONFIG_LEDS_TRIGGERS
177         device_remove_file(led_cdev->dev, &dev_attr_trigger);
178         down_write(&led_cdev->trigger_lock);
179         if (led_cdev->trigger)
180                 led_trigger_set(led_cdev, NULL);
181         up_write(&led_cdev->trigger_lock);
182 #endif
183
184         device_unregister(led_cdev->dev);
185
186         down_write(&leds_list_lock);
187         list_del(&led_cdev->node);
188         up_write(&leds_list_lock);
189 }
190 EXPORT_SYMBOL_GPL(led_classdev_unregister);
191
192 static int __init leds_init(void)
193 {
194         leds_class = class_create(THIS_MODULE, "leds");
195         if (IS_ERR(leds_class))
196                 return PTR_ERR(leds_class);
197         leds_class->suspend = led_suspend;
198         leds_class->resume = led_resume;
199         return 0;
200 }
201
202 static void __exit leds_exit(void)
203 {
204         class_destroy(leds_class);
205 }
206
207 subsys_initcall(leds_init);
208 module_exit(leds_exit);
209
210 MODULE_AUTHOR("John Lenz, Richard Purdie");
211 MODULE_LICENSE("GPL");
212 MODULE_DESCRIPTION("LED Class Interface");