[deliverable/linux.git] / drivers / leds / led-class.c

/*
 * LED Class Core
 *
 * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
 * Copyright (C) 2005-2006 Richard Purdie <rpurdie@openedhand.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/config.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/device.h>
#include <linux/sysdev.h>
#include <linux/timer.h>
#include <linux/err.h>
#include <linux/leds.h>
#include "leds.h"

static struct class *leds_class;

static ssize_t led_brightness_show(struct class_device *dev, char *buf)
{
	struct led_classdev *led_cdev = class_get_devdata(dev);
	ssize_t ret = 0;

	/* no lock needed for this */
	sprintf(buf, "%u\n", led_cdev->brightness);
	ret = strlen(buf) + 1;

	return ret;
}

static ssize_t led_brightness_store(struct class_device *dev,
				const char *buf, size_t size)
{
	struct led_classdev *led_cdev = class_get_devdata(dev);
	ssize_t ret = -EINVAL;
	char *after;
	unsigned long state = simple_strtoul(buf, &after, 10);

	if (after - buf > 0) {
		ret = after - buf;
		led_set_brightness(led_cdev, state);
	}

	return ret;
}

static CLASS_DEVICE_ATTR(brightness, 0644, led_brightness_show,
			led_brightness_store);
#ifdef CONFIG_LEDS_TRIGGERS
static CLASS_DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
#endif

/**
 * led_classdev_suspend - suspend an led_classdev.
 * @led_cdev: the led_classdev to suspend.
 */
void led_classdev_suspend(struct led_classdev *led_cdev)
{
	led_cdev->flags |= LED_SUSPENDED;
	led_cdev->brightness_set(led_cdev, 0);
}
EXPORT_SYMBOL_GPL(led_classdev_suspend);

/**
 * led_classdev_resume - resume an led_classdev.
 * @led_cdev: the led_classdev to resume.
 */
void led_classdev_resume(struct led_classdev *led_cdev)
{
	led_cdev->brightness_set(led_cdev, led_cdev->brightness);
	led_cdev->flags &= ~LED_SUSPENDED;
}
EXPORT_SYMBOL_GPL(led_classdev_resume);

/**
 * led_classdev_register - register a new object of led_classdev class.
 * @dev: The device to register.
 * @led_cdev: the led_classdev structure for this device.
 */
int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
{
	led_cdev->class_dev = class_device_create(leds_class, NULL, 0,
						parent, "%s", led_cdev->name);
	if (unlikely(IS_ERR(led_cdev->class_dev)))
		return PTR_ERR(led_cdev->class_dev);

	class_set_devdata(led_cdev->class_dev, led_cdev);

	/* register the attributes */
	class_device_create_file(led_cdev->class_dev,
				&class_device_attr_brightness);

	/* add to the list of leds */
	write_lock(&leds_list_lock);
	list_add_tail(&led_cdev->node, &leds_list);
	write_unlock(&leds_list_lock);

#ifdef CONFIG_LEDS_TRIGGERS
	rwlock_init(&led_cdev->trigger_lock);

	led_trigger_set_default(led_cdev);

	class_device_create_file(led_cdev->class_dev,
				&class_device_attr_trigger);
#endif

	printk(KERN_INFO "Registered led device: %s\n",
			led_cdev->class_dev->class_id);

	return 0;
}
EXPORT_SYMBOL_GPL(led_classdev_register);

/**
 * led_classdev_unregister - unregisters a object of led_properties class.
 * @led_cdev: the led device to unreigister
 *
 * Unregisters a previously registered via led_classdev_register object.
 */
void led_classdev_unregister(struct led_classdev *led_cdev)
{
	class_device_remove_file(led_cdev->class_dev,
				&class_device_attr_brightness);
#ifdef CONFIG_LEDS_TRIGGERS
	class_device_remove_file(led_cdev->class_dev,
				&class_device_attr_trigger);
	write_lock(&led_cdev->trigger_lock);
	if (led_cdev->trigger)
		led_trigger_set(led_cdev, NULL);
	write_unlock(&led_cdev->trigger_lock);
#endif

	class_device_unregister(led_cdev->class_dev);

	write_lock(&leds_list_lock);
	list_del(&led_cdev->node);
	write_unlock(&leds_list_lock);
}
EXPORT_SYMBOL_GPL(led_classdev_unregister);

static int __init leds_init(void)
{
	leds_class = class_create(THIS_MODULE, "leds");
	if (IS_ERR(leds_class))
		return PTR_ERR(leds_class);
	return 0;
}

static void __exit leds_exit(void)
{
	class_destroy(leds_class);
}

subsys_initcall(leds_init);
module_exit(leds_exit);

MODULE_AUTHOR("John Lenz, Richard Purdie");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("LED Class Interface");
Commit	Line	Data
c72a1d60 RP	1	/*
	2	* LED Class Core
	3	*
	4	* Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
	5	* Copyright (C) 2005-2006 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/config.h>
	13	#include <linux/module.h>
	14	#include <linux/kernel.h>
	15	#include <linux/init.h>
	16	#include <linux/list.h>
	17	#include <linux/spinlock.h>
	18	#include <linux/device.h>
	19	#include <linux/sysdev.h>
	20	#include <linux/timer.h>
	21	#include <linux/err.h>
	22	#include <linux/leds.h>
	23	#include "leds.h"
	24
	25	static struct class *leds_class;
	26
	27	static ssize_t led_brightness_show(struct class_device dev, char buf)
	28	{
	29	struct led_classdev *led_cdev = class_get_devdata(dev);
	30	ssize_t ret = 0;
	31
	32	/* no lock needed for this */
	33	sprintf(buf, "%u\n", led_cdev->brightness);
	34	ret = strlen(buf) + 1;
	35
	36	return ret;
	37	}
	38
	39	static ssize_t led_brightness_store(struct class_device *dev,
	40	const char *buf, size_t size)
	41	{
	42	struct led_classdev *led_cdev = class_get_devdata(dev);
	43	ssize_t ret = -EINVAL;
	44	char *after;
	45	unsigned long state = simple_strtoul(buf, &after, 10);
	46
	47	if (after - buf > 0) {
	48	ret = after - buf;
	49	led_set_brightness(led_cdev, state);
	50	}
	51
	52	return ret;
	53	}
	54
	55	static CLASS_DEVICE_ATTR(brightness, 0644, led_brightness_show,
	56	led_brightness_store);
c3bc9956 RP	57	#ifdef CONFIG_LEDS_TRIGGERS
	58	static CLASS_DEVICE_ATTR(trigger, 0644, led_trigger_show, led_trigger_store);
	59	#endif
c72a1d60 RP	60
	61	/**
	62	* led_classdev_suspend - suspend an led_classdev.
	63	* @led_cdev: the led_classdev to suspend.
	64	*/
	65	void led_classdev_suspend(struct led_classdev *led_cdev)
	66	{
	67	led_cdev->flags \|= LED_SUSPENDED;
	68	led_cdev->brightness_set(led_cdev, 0);
	69	}
	70	EXPORT_SYMBOL_GPL(led_classdev_suspend);
	71
	72	/**
	73	* led_classdev_resume - resume an led_classdev.
	74	* @led_cdev: the led_classdev to resume.
	75	*/
	76	void led_classdev_resume(struct led_classdev *led_cdev)
	77	{
	78	led_cdev->brightness_set(led_cdev, led_cdev->brightness);
	79	led_cdev->flags &= ~LED_SUSPENDED;
	80	}
	81	EXPORT_SYMBOL_GPL(led_classdev_resume);
	82
	83	/**
	84	* led_classdev_register - register a new object of led_classdev class.
	85	* @dev: The device to register.
	86	* @led_cdev: the led_classdev structure for this device.
	87	*/
	88	int led_classdev_register(struct device parent, struct led_classdev led_cdev)
	89	{
	90	led_cdev->class_dev = class_device_create(leds_class, NULL, 0,
	91	parent, "%s", led_cdev->name);
	92	if (unlikely(IS_ERR(led_cdev->class_dev)))
	93	return PTR_ERR(led_cdev->class_dev);
	94
	95	class_set_devdata(led_cdev->class_dev, led_cdev);
	96
	97	/* register the attributes */
	98	class_device_create_file(led_cdev->class_dev,
	99	&class_device_attr_brightness);
	100
	101	/* add to the list of leds */
	102	write_lock(&leds_list_lock);
	103	list_add_tail(&led_cdev->node, &leds_list);
	104	write_unlock(&leds_list_lock);
	105
c3bc9956 RP	106	#ifdef CONFIG_LEDS_TRIGGERS
	107	rwlock_init(&led_cdev->trigger_lock);
	108
	109	led_trigger_set_default(led_cdev);
	110
	111	class_device_create_file(led_cdev->class_dev,
	112	&class_device_attr_trigger);
	113	#endif
	114
c72a1d60 RP	115	printk(KERN_INFO "Registered led device: %s\n",
	116	led_cdev->class_dev->class_id);
	117
	118	return 0;
	119	}
	120	EXPORT_SYMBOL_GPL(led_classdev_register);
	121
	122	/**
	123	* led_classdev_unregister - unregisters a object of led_properties class.
	124	* @led_cdev: the led device to unreigister
	125	*
	126	* Unregisters a previously registered via led_classdev_register object.
	127	*/
	128	void led_classdev_unregister(struct led_classdev *led_cdev)
	129	{
	130	class_device_remove_file(led_cdev->class_dev,
	131	&class_device_attr_brightness);
c3bc9956 RP	132	#ifdef CONFIG_LEDS_TRIGGERS
	133	class_device_remove_file(led_cdev->class_dev,
	134	&class_device_attr_trigger);
	135	write_lock(&led_cdev->trigger_lock);
	136	if (led_cdev->trigger)
	137	led_trigger_set(led_cdev, NULL);
	138	write_unlock(&led_cdev->trigger_lock);
	139	#endif
c72a1d60 RP	140
	141	class_device_unregister(led_cdev->class_dev);
	142
	143	write_lock(&leds_list_lock);
	144	list_del(&led_cdev->node);
	145	write_unlock(&leds_list_lock);
	146	}
	147	EXPORT_SYMBOL_GPL(led_classdev_unregister);
	148
	149	static int __init leds_init(void)
	150	{
	151	leds_class = class_create(THIS_MODULE, "leds");
	152	if (IS_ERR(leds_class))
	153	return PTR_ERR(leds_class);
	154	return 0;
	155	}
	156
	157	static void __exit leds_exit(void)
	158	{
	159	class_destroy(leds_class);
	160	}
	161
	162	subsys_initcall(leds_init);
	163	module_exit(leds_exit);
	164
	165	MODULE_AUTHOR("John Lenz, Richard Purdie");
	166	MODULE_LICENSE("GPL");
	167	MODULE_DESCRIPTION("LED Class Interface");