hwmon: (adt7411) add MODULE_DEVICE_TABLE
[linux-2.6.git] / drivers / leds / ledtrig-gpio.c
1 /*
2  * ledtrig-gio.c - LED Trigger Based on GPIO events
3  *
4  * Copyright 2009 Felipe Balbi <me@felipebalbi.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  *
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/gpio.h>
16 #include <linux/interrupt.h>
17 #include <linux/workqueue.h>
18 #include <linux/leds.h>
19 #include <linux/slab.h>
20 #include "leds.h"
21
22 struct gpio_trig_data {
23         struct led_classdev *led;
24         struct work_struct work;
25
26         unsigned desired_brightness;    /* desired brightness when led is on */
27         unsigned inverted;              /* true when gpio is inverted */
28         unsigned gpio;                  /* gpio that triggers the leds */
29 };
30
31 static irqreturn_t gpio_trig_irq(int irq, void *_led)
32 {
33         struct led_classdev *led = _led;
34         struct gpio_trig_data *gpio_data = led->trigger_data;
35
36         /* just schedule_work since gpio_get_value can sleep */
37         schedule_work(&gpio_data->work);
38
39         return IRQ_HANDLED;
40 };
41
42 static void gpio_trig_work(struct work_struct *work)
43 {
44         struct gpio_trig_data *gpio_data = container_of(work,
45                         struct gpio_trig_data, work);
46         int tmp;
47
48         if (!gpio_data->gpio)
49                 return;
50
51         tmp = gpio_get_value(gpio_data->gpio);
52         if (gpio_data->inverted)
53                 tmp = !tmp;
54
55         if (tmp) {
56                 if (gpio_data->desired_brightness)
57                         led_set_brightness(gpio_data->led,
58                                            gpio_data->desired_brightness);
59                 else
60                         led_set_brightness(gpio_data->led, LED_FULL);
61         } else {
62                 led_set_brightness(gpio_data->led, LED_OFF);
63         }
64 }
65
66 static ssize_t gpio_trig_brightness_show(struct device *dev,
67                 struct device_attribute *attr, char *buf)
68 {
69         struct led_classdev *led = dev_get_drvdata(dev);
70         struct gpio_trig_data *gpio_data = led->trigger_data;
71
72         return sprintf(buf, "%u\n", gpio_data->desired_brightness);
73 }
74
75 static ssize_t gpio_trig_brightness_store(struct device *dev,
76                 struct device_attribute *attr, const char *buf, size_t n)
77 {
78         struct led_classdev *led = dev_get_drvdata(dev);
79         struct gpio_trig_data *gpio_data = led->trigger_data;
80         unsigned desired_brightness;
81         int ret;
82
83         ret = sscanf(buf, "%u", &desired_brightness);
84         if (ret < 1 || desired_brightness > 255) {
85                 dev_err(dev, "invalid value\n");
86                 return -EINVAL;
87         }
88
89         gpio_data->desired_brightness = desired_brightness;
90
91         return n;
92 }
93 static DEVICE_ATTR(desired_brightness, 0644, gpio_trig_brightness_show,
94                 gpio_trig_brightness_store);
95
96 static ssize_t gpio_trig_inverted_show(struct device *dev,
97                 struct device_attribute *attr, char *buf)
98 {
99         struct led_classdev *led = dev_get_drvdata(dev);
100         struct gpio_trig_data *gpio_data = led->trigger_data;
101
102         return sprintf(buf, "%u\n", gpio_data->inverted);
103 }
104
105 static ssize_t gpio_trig_inverted_store(struct device *dev,
106                 struct device_attribute *attr, const char *buf, size_t n)
107 {
108         struct led_classdev *led = dev_get_drvdata(dev);
109         struct gpio_trig_data *gpio_data = led->trigger_data;
110         unsigned long inverted;
111         int ret;
112
113         ret = strict_strtoul(buf, 10, &inverted);
114         if (ret < 0)
115                 return ret;
116
117         if (inverted > 1)
118                 return -EINVAL;
119
120         gpio_data->inverted = inverted;
121
122         /* After inverting, we need to update the LED. */
123         schedule_work(&gpio_data->work);
124
125         return n;
126 }
127 static DEVICE_ATTR(inverted, 0644, gpio_trig_inverted_show,
128                 gpio_trig_inverted_store);
129
130 static ssize_t gpio_trig_gpio_show(struct device *dev,
131                 struct device_attribute *attr, char *buf)
132 {
133         struct led_classdev *led = dev_get_drvdata(dev);
134         struct gpio_trig_data *gpio_data = led->trigger_data;
135
136         return sprintf(buf, "%u\n", gpio_data->gpio);
137 }
138
139 static ssize_t gpio_trig_gpio_store(struct device *dev,
140                 struct device_attribute *attr, const char *buf, size_t n)
141 {
142         struct led_classdev *led = dev_get_drvdata(dev);
143         struct gpio_trig_data *gpio_data = led->trigger_data;
144         unsigned gpio;
145         int ret;
146
147         ret = sscanf(buf, "%u", &gpio);
148         if (ret < 1) {
149                 dev_err(dev, "couldn't read gpio number\n");
150                 flush_work(&gpio_data->work);
151                 return -EINVAL;
152         }
153
154         if (gpio_data->gpio == gpio)
155                 return n;
156
157         if (!gpio) {
158                 if (gpio_data->gpio != 0)
159                         free_irq(gpio_to_irq(gpio_data->gpio), led);
160                 gpio_data->gpio = 0;
161                 return n;
162         }
163
164         ret = request_irq(gpio_to_irq(gpio), gpio_trig_irq,
165                         IRQF_SHARED | IRQF_TRIGGER_RISING
166                         | IRQF_TRIGGER_FALLING, "ledtrig-gpio", led);
167         if (ret) {
168                 dev_err(dev, "request_irq failed with error %d\n", ret);
169         } else {
170                 if (gpio_data->gpio != 0)
171                         free_irq(gpio_to_irq(gpio_data->gpio), led);
172                 gpio_data->gpio = gpio;
173         }
174
175         return ret ? ret : n;
176 }
177 static DEVICE_ATTR(gpio, 0644, gpio_trig_gpio_show, gpio_trig_gpio_store);
178
179 static void gpio_trig_activate(struct led_classdev *led)
180 {
181         struct gpio_trig_data *gpio_data;
182         int ret;
183
184         gpio_data = kzalloc(sizeof(*gpio_data), GFP_KERNEL);
185         if (!gpio_data)
186                 return;
187
188         ret = device_create_file(led->dev, &dev_attr_gpio);
189         if (ret)
190                 goto err_gpio;
191
192         ret = device_create_file(led->dev, &dev_attr_inverted);
193         if (ret)
194                 goto err_inverted;
195
196         ret = device_create_file(led->dev, &dev_attr_desired_brightness);
197         if (ret)
198                 goto err_brightness;
199
200         gpio_data->led = led;
201         led->trigger_data = gpio_data;
202         INIT_WORK(&gpio_data->work, gpio_trig_work);
203
204         return;
205
206 err_brightness:
207         device_remove_file(led->dev, &dev_attr_inverted);
208
209 err_inverted:
210         device_remove_file(led->dev, &dev_attr_gpio);
211
212 err_gpio:
213         kfree(gpio_data);
214 }
215
216 static void gpio_trig_deactivate(struct led_classdev *led)
217 {
218         struct gpio_trig_data *gpio_data = led->trigger_data;
219
220         if (gpio_data) {
221                 device_remove_file(led->dev, &dev_attr_gpio);
222                 device_remove_file(led->dev, &dev_attr_inverted);
223                 device_remove_file(led->dev, &dev_attr_desired_brightness);
224                 flush_work(&gpio_data->work);
225                 if (gpio_data->gpio != 0)
226                         free_irq(gpio_to_irq(gpio_data->gpio), led);
227                 kfree(gpio_data);
228         }
229 }
230
231 static struct led_trigger gpio_led_trigger = {
232         .name           = "gpio",
233         .activate       = gpio_trig_activate,
234         .deactivate     = gpio_trig_deactivate,
235 };
236
237 static int __init gpio_trig_init(void)
238 {
239         return led_trigger_register(&gpio_led_trigger);
240 }
241 module_init(gpio_trig_init);
242
243 static void __exit gpio_trig_exit(void)
244 {
245         led_trigger_unregister(&gpio_led_trigger);
246 }
247 module_exit(gpio_trig_exit);
248
249 MODULE_AUTHOR("Felipe Balbi <me@felipebalbi.com>");
250 MODULE_DESCRIPTION("GPIO LED trigger");
251 MODULE_LICENSE("GPL");