[linux.git] / drivers / leds / ledtrig-gpio.c

/*
 * ledtrig-gio.c - LED Trigger Based on GPIO events
 *
 * Copyright 2009 Felipe Balbi <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/leds.h>
#include "leds.h"

struct gpio_trig_data {
	struct led_classdev *led;
	struct work_struct work;

	unsigned desired_brightness;	/* desired brightness when led is on */
	unsigned inverted;		/* true when gpio is inverted */
	unsigned gpio;			/* gpio that triggers the leds */
};

static irqreturn_t gpio_trig_irq(int irq, void *_led)
{
	struct led_classdev *led = _led;
	struct gpio_trig_data *gpio_data = led->trigger_data;

	/* just schedule_work since gpio_get_value can sleep */
	schedule_work(&gpio_data->work);

	return IRQ_HANDLED;
};

static void gpio_trig_work(struct work_struct *work)
{
	struct gpio_trig_data *gpio_data = container_of(work,
			struct gpio_trig_data, work);
	int tmp;

       if (!gpio_data->gpio)
	       return;

       tmp = gpio_get_value(gpio_data->gpio);
       if (gpio_data->inverted)
	       tmp = !tmp;

       if (tmp) {
               if (gpio_data->desired_brightness)
                       led_set_brightness(gpio_data->led,
                                       gpio_data->desired_brightness);
               else
                       led_set_brightness(gpio_data->led, LED_FULL);
       } else {
               led_set_brightness(gpio_data->led, LED_OFF);
       }
}

static ssize_t gpio_trig_brightness_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct led_classdev *led = dev_get_drvdata(dev);
	struct gpio_trig_data *gpio_data = led->trigger_data;

	return sprintf(buf, "%u\n", gpio_data->desired_brightness);
}

static ssize_t gpio_trig_brightness_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t n)
{
	struct led_classdev *led = dev_get_drvdata(dev);
	struct gpio_trig_data *gpio_data = led->trigger_data;
	unsigned desired_brightness;
	int ret;

	ret = sscanf(buf, "%u", &desired_brightness);
	if (ret < 1 || desired_brightness > 255) {
		dev_err(dev, "invalid value\n");
		return -EINVAL;
	}

	gpio_data->desired_brightness = desired_brightness;

	return n;
}
static DEVICE_ATTR(desired_brightness, 0644, gpio_trig_brightness_show,
		gpio_trig_brightness_store);

static ssize_t gpio_trig_inverted_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct led_classdev *led = dev_get_drvdata(dev);
	struct gpio_trig_data *gpio_data = led->trigger_data;

	return sprintf(buf, "%s\n", gpio_data->inverted ? "yes" : "no");
}

static ssize_t gpio_trig_inverted_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t n)
{
	struct led_classdev *led = dev_get_drvdata(dev);
	struct gpio_trig_data *gpio_data = led->trigger_data;
	unsigned inverted;
	int ret;

	ret = sscanf(buf, "%u", &inverted);
	if (ret < 1) {
		dev_err(dev, "invalid value\n");
		return -EINVAL;
	}

	gpio_data->inverted = !!inverted;

	return n;
}
static DEVICE_ATTR(inverted, 0644, gpio_trig_inverted_show,
		gpio_trig_inverted_store);

static ssize_t gpio_trig_gpio_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct led_classdev *led = dev_get_drvdata(dev);
	struct gpio_trig_data *gpio_data = led->trigger_data;

	return sprintf(buf, "%u\n", gpio_data->gpio);
}

static ssize_t gpio_trig_gpio_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t n)
{
	struct led_classdev *led = dev_get_drvdata(dev);
	struct gpio_trig_data *gpio_data = led->trigger_data;
	unsigned gpio;
	int ret;

	ret = sscanf(buf, "%u", &gpio);
	if (ret < 1) {
		dev_err(dev, "couldn't read gpio number\n");
		flush_work(&gpio_data->work);
		return -EINVAL;
	}

	if (!gpio) {
		free_irq(gpio_to_irq(gpio_data->gpio), led);
		return n;
	}

	if (gpio_data->gpio > 0 && gpio_data->gpio != gpio)
		free_irq(gpio_to_irq(gpio_data->gpio), led);

	gpio_data->gpio = gpio;
	ret = request_irq(gpio_to_irq(gpio), gpio_trig_irq,
			IRQF_SHARED | IRQF_TRIGGER_RISING
			| IRQF_TRIGGER_FALLING, "ledtrig-gpio", led);
	if (ret)
		dev_err(dev, "request_irq failed with error %d\n", ret);

	return ret ? ret : n;
}
static DEVICE_ATTR(gpio, 0644, gpio_trig_gpio_show, gpio_trig_gpio_store);

static void gpio_trig_activate(struct led_classdev *led)
{
	struct gpio_trig_data *gpio_data;
	int ret;

	gpio_data = kzalloc(sizeof(*gpio_data), GFP_KERNEL);
	if (!gpio_data)
		return;

	ret = device_create_file(led->dev, &dev_attr_gpio);
	if (ret)
		goto err_gpio;

	ret = device_create_file(led->dev, &dev_attr_inverted);
	if (ret)
		goto err_inverted;

	ret = device_create_file(led->dev, &dev_attr_desired_brightness);
	if (ret)
		goto err_brightness;

	gpio_data->led = led;
	led->trigger_data = gpio_data;
	INIT_WORK(&gpio_data->work, gpio_trig_work);

	return;

err_brightness:
	device_remove_file(led->dev, &dev_attr_inverted);

err_inverted:
	device_remove_file(led->dev, &dev_attr_gpio);

err_gpio:
	kfree(gpio_data);
}

static void gpio_trig_deactivate(struct led_classdev *led)
{
	struct gpio_trig_data *gpio_data = led->trigger_data;

	if (gpio_data) {
		device_remove_file(led->dev, &dev_attr_gpio);
		device_remove_file(led->dev, &dev_attr_inverted);
		device_remove_file(led->dev, &dev_attr_desired_brightness);
		flush_work(&gpio_data->work);
		free_irq(gpio_to_irq(gpio_data->gpio),led);
		kfree(gpio_data);
	}
}

static struct led_trigger gpio_led_trigger = {
	.name		= "gpio",
	.activate	= gpio_trig_activate,
	.deactivate	= gpio_trig_deactivate,
};

static int __init gpio_trig_init(void)
{
	return led_trigger_register(&gpio_led_trigger);
}
module_init(gpio_trig_init);

static void __exit gpio_trig_exit(void)
{
	led_trigger_unregister(&gpio_led_trigger);
}
module_exit(gpio_trig_exit);

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