[net-next-2.6.git] / drivers / leds / ledtrig-gpio.c

/*
 * ledtrig-gio.c - LED Trigger Based on GPIO events
 *
 * Copyright 2009 Felipe Balbi <me@felipebalbi.com>
 *
 * 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;

	/* After inverting, we need to update the LED. */
	schedule_work(&gpio_data->work);

	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_data->gpio == gpio)
		return n;

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

	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);
	} else {
		if (gpio_data->gpio != 0)
			free_irq(gpio_to_irq(gpio_data->gpio), led);
		gpio_data->gpio = gpio;
	}

	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);
		if (gpio_data->gpio != 0)
			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 <me@felipebalbi.com>");
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 <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 "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
cc674c81 TLSC	120	/* After inverting, we need to update the LED. */
	121	schedule_work(&gpio_data->work);
	122
17354bfe FB	123	return n;
	124	}
	125	static DEVICE_ATTR(inverted, 0644, gpio_trig_inverted_show,
	126	gpio_trig_inverted_store);
	127
	128	static ssize_t gpio_trig_gpio_show(struct device *dev,
	129	struct device_attribute attr, char buf)
	130	{
	131	struct led_classdev *led = dev_get_drvdata(dev);
	132	struct gpio_trig_data *gpio_data = led->trigger_data;
	133
	134	return sprintf(buf, "%u\n", gpio_data->gpio);
	135	}
	136
	137	static ssize_t gpio_trig_gpio_store(struct device *dev,
	138	struct device_attribute attr, const char buf, size_t n)
	139	{
	140	struct led_classdev *led = dev_get_drvdata(dev);
	141	struct gpio_trig_data *gpio_data = led->trigger_data;
	142	unsigned gpio;
	143	int ret;
	144
	145	ret = sscanf(buf, "%u", &gpio);
	146	if (ret < 1) {
	147	dev_err(dev, "couldn't read gpio number\n");
	148	flush_work(&gpio_data->work);
	149	return -EINVAL;
	150	}
	151
48cccd26 TLSC	152	if (gpio_data->gpio == gpio)
	153	return n;
	154
17354bfe	155	if (!gpio) {
48cccd26 TLSC	156	if (gpio_data->gpio != 0)
	157	free_irq(gpio_to_irq(gpio_data->gpio), led);
	158	gpio_data->gpio = 0;
17354bfe FB	159	return n;
	160	}
	161
17354bfe FB	162	ret = request_irq(gpio_to_irq(gpio), gpio_trig_irq,
	163	IRQF_SHARED \| IRQF_TRIGGER_RISING
	164	\| IRQF_TRIGGER_FALLING, "ledtrig-gpio", led);
48cccd26	165	if (ret) {
17354bfe	166	dev_err(dev, "request_irq failed with error %d\n", ret);
48cccd26 TLSC	167	} else {
	168	if (gpio_data->gpio != 0)
	169	free_irq(gpio_to_irq(gpio_data->gpio), led);
	170	gpio_data->gpio = gpio;
	171	}
17354bfe FB	172
	173	return ret ? ret : n;
	174	}
	175	static DEVICE_ATTR(gpio, 0644, gpio_trig_gpio_show, gpio_trig_gpio_store);
	176
	177	static void gpio_trig_activate(struct led_classdev *led)
	178	{
	179	struct gpio_trig_data *gpio_data;
	180	int ret;
	181
	182	gpio_data = kzalloc(sizeof(*gpio_data), GFP_KERNEL);
	183	if (!gpio_data)
	184	return;
	185
	186	ret = device_create_file(led->dev, &dev_attr_gpio);
	187	if (ret)
	188	goto err_gpio;
	189
	190	ret = device_create_file(led->dev, &dev_attr_inverted);
	191	if (ret)
	192	goto err_inverted;
	193
	194	ret = device_create_file(led->dev, &dev_attr_desired_brightness);
	195	if (ret)
	196	goto err_brightness;
	197
	198	gpio_data->led = led;
	199	led->trigger_data = gpio_data;
	200	INIT_WORK(&gpio_data->work, gpio_trig_work);
	201
	202	return;
	203
	204	err_brightness:
	205	device_remove_file(led->dev, &dev_attr_inverted);
	206
	207	err_inverted:
	208	device_remove_file(led->dev, &dev_attr_gpio);
	209
	210	err_gpio:
	211	kfree(gpio_data);
	212	}
	213
	214	static void gpio_trig_deactivate(struct led_classdev *led)
	215	{
	216	struct gpio_trig_data *gpio_data = led->trigger_data;
	217
	218	if (gpio_data) {
	219	device_remove_file(led->dev, &dev_attr_gpio);
	220	device_remove_file(led->dev, &dev_attr_inverted);
	221	device_remove_file(led->dev, &dev_attr_desired_brightness);
	222	flush_work(&gpio_data->work);
48cccd26 TLSC	223	if (gpio_data->gpio != 0)
48cccd26 TLSC	224	free_irq(gpio_to_irq(gpio_data->gpio), led);
17354bfe FB	225	kfree(gpio_data);
	226	}
	227	}
	228
	229	static struct led_trigger gpio_led_trigger = {
	230	.name = "gpio",
	231	.activate = gpio_trig_activate,
	232	.deactivate = gpio_trig_deactivate,
	233	};
	234
	235	static int __init gpio_trig_init(void)
	236	{
	237	return led_trigger_register(&gpio_led_trigger);
	238	}
	239	module_init(gpio_trig_init);
	240
	241	static void __exit gpio_trig_exit(void)
	242	{
	243	led_trigger_unregister(&gpio_led_trigger);
	244	}
	245	module_exit(gpio_trig_exit);
	246
	247	MODULE_AUTHOR("Felipe Balbi <me@felipebalbi.com>");
	248	MODULE_DESCRIPTION("GPIO LED trigger");
	249	MODULE_LICENSE("GPL");