[linux-2.6-block.git] / drivers / leds / led-triggers.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * LED Triggers Core
 *
 * Copyright 2005-2007 Openedhand Ltd.
 *
 * Author: Richard Purdie <rpurdie@openedhand.com>
 */

#include <linux/export.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/device.h>
#include <linux/timer.h>
#include <linux/rwsem.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include "leds.h"

/*
 * Nests outside led_cdev->trigger_lock
 */
static DECLARE_RWSEM(triggers_list_lock);
LIST_HEAD(trigger_list);

 /* Used by LED Class */

static inline bool
trigger_relevant(struct led_classdev *led_cdev, struct led_trigger *trig)
{
	return !trig->trigger_type || trig->trigger_type == led_cdev->trigger_type;
}

ssize_t led_trigger_write(struct file *filp, struct kobject *kobj,
			  struct bin_attribute *bin_attr, char *buf,
			  loff_t pos, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct led_trigger *trig;
	int ret = count;

	mutex_lock(&led_cdev->led_access);

	if (led_sysfs_is_disabled(led_cdev)) {
		ret = -EBUSY;
		goto unlock;
	}

	if (sysfs_streq(buf, "none")) {
		led_trigger_remove(led_cdev);
		goto unlock;
	}

	down_read(&triggers_list_lock);
	list_for_each_entry(trig, &trigger_list, next_trig) {
		if (sysfs_streq(buf, trig->name) && trigger_relevant(led_cdev, trig)) {
			down_write(&led_cdev->trigger_lock);
			led_trigger_set(led_cdev, trig);
			up_write(&led_cdev->trigger_lock);

			up_read(&triggers_list_lock);
			goto unlock;
		}
	}
	/* we come here only if buf matches no trigger */
	ret = -EINVAL;
	up_read(&triggers_list_lock);

unlock:
	mutex_unlock(&led_cdev->led_access);
	return ret;
}
EXPORT_SYMBOL_GPL(led_trigger_write);

__printf(3, 4)
static int led_trigger_snprintf(char *buf, ssize_t size, const char *fmt, ...)
{
	va_list args;
	int i;

	va_start(args, fmt);
	if (size <= 0)
		i = vsnprintf(NULL, 0, fmt, args);
	else
		i = vscnprintf(buf, size, fmt, args);
	va_end(args);

	return i;
}

static int led_trigger_format(char *buf, size_t size,
			      struct led_classdev *led_cdev)
{
	struct led_trigger *trig;
	int len = led_trigger_snprintf(buf, size, "%s",
				       led_cdev->trigger ? "none" : "[none]");

	list_for_each_entry(trig, &trigger_list, next_trig) {
		bool hit;

		if (!trigger_relevant(led_cdev, trig))
			continue;

		hit = led_cdev->trigger && !strcmp(led_cdev->trigger->name, trig->name);

		len += led_trigger_snprintf(buf + len, size - len,
					    " %s%s%s", hit ? "[" : "",
					    trig->name, hit ? "]" : "");
	}

	len += led_trigger_snprintf(buf + len, size - len, "\n");

	return len;
}

/*
 * It was stupid to create 10000 cpu triggers, but we are stuck with it now.
 * Don't make that mistake again. We work around it here by creating binary
 * attribute, which is not limited by length. This is _not_ good design, do not
 * copy it.
 */
ssize_t led_trigger_read(struct file *filp, struct kobject *kobj,
			struct bin_attribute *attr, char *buf,
			loff_t pos, size_t count)
{
	struct device *dev = kobj_to_dev(kobj);
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	void *data;
	int len;

	down_read(&triggers_list_lock);
	down_read(&led_cdev->trigger_lock);

	len = led_trigger_format(NULL, 0, led_cdev);
	data = kvmalloc(len + 1, GFP_KERNEL);
	if (!data) {
		up_read(&led_cdev->trigger_lock);
		up_read(&triggers_list_lock);
		return -ENOMEM;
	}
	len = led_trigger_format(data, len + 1, led_cdev);

	up_read(&led_cdev->trigger_lock);
	up_read(&triggers_list_lock);

	len = memory_read_from_buffer(buf, count, &pos, data, len);

	kvfree(data);

	return len;
}
EXPORT_SYMBOL_GPL(led_trigger_read);

/* Caller must ensure led_cdev->trigger_lock held */
int led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig)
{
	char *event = NULL;
	char *envp[2];
	const char *name;
	int ret;

	if (!led_cdev->trigger && !trig)
		return 0;

	name = trig ? trig->name : "none";
	event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name);

	/* Remove any existing trigger */
	if (led_cdev->trigger) {
		spin_lock(&led_cdev->trigger->leddev_list_lock);
		list_del_rcu(&led_cdev->trig_list);
		spin_unlock(&led_cdev->trigger->leddev_list_lock);

		/* ensure it's no longer visible on the led_cdevs list */
		synchronize_rcu();

		cancel_work_sync(&led_cdev->set_brightness_work);
		led_stop_software_blink(led_cdev);
		if (led_cdev->trigger->deactivate)
			led_cdev->trigger->deactivate(led_cdev);
		device_remove_groups(led_cdev->dev, led_cdev->trigger->groups);
		led_cdev->trigger = NULL;
		led_cdev->trigger_data = NULL;
		led_cdev->activated = false;
		led_set_brightness(led_cdev, LED_OFF);
	}
	if (trig) {
		spin_lock(&trig->leddev_list_lock);
		list_add_tail_rcu(&led_cdev->trig_list, &trig->led_cdevs);
		spin_unlock(&trig->leddev_list_lock);
		led_cdev->trigger = trig;

		if (trig->activate)
			ret = trig->activate(led_cdev);
		else
			ret = 0;

		if (ret)
			goto err_activate;

		ret = device_add_groups(led_cdev->dev, trig->groups);
		if (ret) {
			dev_err(led_cdev->dev, "Failed to add trigger attributes\n");
			goto err_add_groups;
		}
	}

	if (event) {
		envp[0] = event;
		envp[1] = NULL;
		if (kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp))
			dev_err(led_cdev->dev,
				"%s: Error sending uevent\n", __func__);
		kfree(event);
	}

	return 0;

err_add_groups:

	if (trig->deactivate)
		trig->deactivate(led_cdev);
err_activate:

	spin_lock(&led_cdev->trigger->leddev_list_lock);
	list_del_rcu(&led_cdev->trig_list);
	spin_unlock(&led_cdev->trigger->leddev_list_lock);
	synchronize_rcu();
	led_cdev->trigger = NULL;
	led_cdev->trigger_data = NULL;
	led_set_brightness(led_cdev, LED_OFF);
	kfree(event);

	return ret;
}
EXPORT_SYMBOL_GPL(led_trigger_set);

void led_trigger_remove(struct led_classdev *led_cdev)
{
	down_write(&led_cdev->trigger_lock);
	led_trigger_set(led_cdev, NULL);
	up_write(&led_cdev->trigger_lock);
}
EXPORT_SYMBOL_GPL(led_trigger_remove);

void led_trigger_set_default(struct led_classdev *led_cdev)
{
	struct led_trigger *trig;

	if (!led_cdev->default_trigger)
		return;

	down_read(&triggers_list_lock);
	down_write(&led_cdev->trigger_lock);
	list_for_each_entry(trig, &trigger_list, next_trig) {
		if (!strcmp(led_cdev->default_trigger, trig->name) &&
		    trigger_relevant(led_cdev, trig)) {
			led_cdev->flags |= LED_INIT_DEFAULT_TRIGGER;
			led_trigger_set(led_cdev, trig);
			break;
		}
	}
	up_write(&led_cdev->trigger_lock);
	up_read(&triggers_list_lock);
}
EXPORT_SYMBOL_GPL(led_trigger_set_default);

void led_trigger_rename_static(const char *name, struct led_trigger *trig)
{
	/* new name must be on a temporary string to prevent races */
	BUG_ON(name == trig->name);

	down_write(&triggers_list_lock);
	/* this assumes that trig->name was originaly allocated to
	 * non constant storage */
	strcpy((char *)trig->name, name);
	up_write(&triggers_list_lock);
}
EXPORT_SYMBOL_GPL(led_trigger_rename_static);

/* LED Trigger Interface */

int led_trigger_register(struct led_trigger *trig)
{
	struct led_classdev *led_cdev;
	struct led_trigger *_trig;

	spin_lock_init(&trig->leddev_list_lock);
	INIT_LIST_HEAD(&trig->led_cdevs);

	down_write(&triggers_list_lock);
	/* Make sure the trigger's name isn't already in use */
	list_for_each_entry(_trig, &trigger_list, next_trig) {
		if (!strcmp(_trig->name, trig->name) &&
		    (trig->trigger_type == _trig->trigger_type ||
		     !trig->trigger_type || !_trig->trigger_type)) {
			up_write(&triggers_list_lock);
			return -EEXIST;
		}
	}
	/* Add to the list of led triggers */
	list_add_tail(&trig->next_trig, &trigger_list);
	up_write(&triggers_list_lock);

	/* Register with any LEDs that have this as a default trigger */
	down_read(&leds_list_lock);
	list_for_each_entry(led_cdev, &leds_list, node) {
		down_write(&led_cdev->trigger_lock);
		if (!led_cdev->trigger && led_cdev->default_trigger &&
		    !strcmp(led_cdev->default_trigger, trig->name) &&
		    trigger_relevant(led_cdev, trig)) {
			led_cdev->flags |= LED_INIT_DEFAULT_TRIGGER;
			led_trigger_set(led_cdev, trig);
		}
		up_write(&led_cdev->trigger_lock);
	}
	up_read(&leds_list_lock);

	return 0;
}
EXPORT_SYMBOL_GPL(led_trigger_register);

void led_trigger_unregister(struct led_trigger *trig)
{
	struct led_classdev *led_cdev;

	if (list_empty_careful(&trig->next_trig))
		return;

	/* Remove from the list of led triggers */
	down_write(&triggers_list_lock);
	list_del_init(&trig->next_trig);
	up_write(&triggers_list_lock);

	/* Remove anyone actively using this trigger */
	down_read(&leds_list_lock);
	list_for_each_entry(led_cdev, &leds_list, node) {
		down_write(&led_cdev->trigger_lock);
		if (led_cdev->trigger == trig)
			led_trigger_set(led_cdev, NULL);
		up_write(&led_cdev->trigger_lock);
	}
	up_read(&leds_list_lock);
}
EXPORT_SYMBOL_GPL(led_trigger_unregister);

static void devm_led_trigger_release(struct device *dev, void *res)
{
	led_trigger_unregister(*(struct led_trigger **)res);
}

int devm_led_trigger_register(struct device *dev,
			      struct led_trigger *trig)
{
	struct led_trigger **dr;
	int rc;

	dr = devres_alloc(devm_led_trigger_release, sizeof(*dr),
			  GFP_KERNEL);
	if (!dr)
		return -ENOMEM;

	*dr = trig;

	rc = led_trigger_register(trig);
	if (rc)
		devres_free(dr);
	else
		devres_add(dev, dr);

	return rc;
}
EXPORT_SYMBOL_GPL(devm_led_trigger_register);

/* Simple LED Trigger Interface */

void led_trigger_event(struct led_trigger *trig,
			enum led_brightness brightness)
{
	struct led_classdev *led_cdev;

	if (!trig)
		return;

	rcu_read_lock();
	list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list)
		led_set_brightness(led_cdev, brightness);
	rcu_read_unlock();
}
EXPORT_SYMBOL_GPL(led_trigger_event);

static void led_trigger_blink_setup(struct led_trigger *trig,
			     unsigned long *delay_on,
			     unsigned long *delay_off,
			     int oneshot,
			     int invert)
{
	struct led_classdev *led_cdev;

	if (!trig)
		return;

	rcu_read_lock();
	list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list) {
		if (oneshot)
			led_blink_set_oneshot(led_cdev, delay_on, delay_off,
					      invert);
		else
			led_blink_set(led_cdev, delay_on, delay_off);
	}
	rcu_read_unlock();
}

void led_trigger_blink(struct led_trigger *trig,
		       unsigned long *delay_on,
		       unsigned long *delay_off)
{
	led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0);
}
EXPORT_SYMBOL_GPL(led_trigger_blink);

void led_trigger_blink_oneshot(struct led_trigger *trig,
			       unsigned long *delay_on,
			       unsigned long *delay_off,
			       int invert)
{
	led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert);
}
EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot);

void led_trigger_register_simple(const char *name, struct led_trigger **tp)
{
	struct led_trigger *trig;
	int err;

	trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);

	if (trig) {
		trig->name = name;
		err = led_trigger_register(trig);
		if (err < 0) {
			kfree(trig);
			trig = NULL;
			pr_warn("LED trigger %s failed to register (%d)\n",
				name, err);
		}
	} else {
		pr_warn("LED trigger %s failed to register (no memory)\n",
			name);
	}
	*tp = trig;
}
EXPORT_SYMBOL_GPL(led_trigger_register_simple);

void led_trigger_unregister_simple(struct led_trigger *trig)
{
	if (trig)
		led_trigger_unregister(trig);
	kfree(trig);
}
EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
c3bc9956 RP	2	/*
	3	* LED Triggers Core
	4	*
f8a7c6fe	5	* Copyright 2005-2007 Openedhand Ltd.
c3bc9956 RP	6	*
c3bc9956 RP	7	* Author: Richard Purdie <rpurdie@openedhand.com>
c3bc9956 RP	8	*/
c3bc9956 RP	9
50237863	10	#include <linux/export.h>
c3bc9956	11	#include <linux/kernel.h>
c3bc9956 RP	12	#include <linux/list.h>
	13	#include <linux/spinlock.h>
	14	#include <linux/device.h>
c3bc9956	15	#include <linux/timer.h>
dc47206e	16	#include <linux/rwsem.h>
c3bc9956	17	#include <linux/leds.h>
5a0e3ad6	18	#include <linux/slab.h>
11f70002	19	#include <linux/mm.h>
c3bc9956 RP	20	#include "leds.h"
	21
	22	/*
	23	* Nests outside led_cdev->trigger_lock
	24	*/
dc47206e	25	static DECLARE_RWSEM(triggers_list_lock);
ba93cdce	26	LIST_HEAD(trigger_list);
c3bc9956	27
4d404fd5 NM	28	/* Used by LED Class */
4d404fd5 NM	29
93690cdf MB	30	static inline bool
	31	trigger_relevant(struct led_classdev led_cdev, struct led_trigger trig)
	32	{
	33	return !trig->trigger_type \|\| trig->trigger_type == led_cdev->trigger_type;
	34	}
	35
11f70002 AM	36	ssize_t led_trigger_write(struct file filp, struct kobject kobj,
	37	struct bin_attribute bin_attr, char buf,
	38	loff_t pos, size_t count)
c3bc9956	39	{
11f70002	40	struct device *dev = kobj_to_dev(kobj);
f8a7c6fe	41	struct led_classdev *led_cdev = dev_get_drvdata(dev);
c3bc9956	42	struct led_trigger *trig;
acd899e4 JA	43	int ret = count;
	44
	45	mutex_lock(&led_cdev->led_access);
	46
	47	if (led_sysfs_is_disabled(led_cdev)) {
	48	ret = -EBUSY;
	49	goto unlock;
	50	}
c3bc9956	51
7296c33e	52	if (sysfs_streq(buf, "none")) {
0013b23d	53	led_trigger_remove(led_cdev);
acd899e4	54	goto unlock;
c3bc9956 RP	55	}
c3bc9956 RP	56
dc47206e	57	down_read(&triggers_list_lock);
c3bc9956	58	list_for_each_entry(trig, &trigger_list, next_trig) {
93690cdf	59	if (sysfs_streq(buf, trig->name) && trigger_relevant(led_cdev, trig)) {
dc47206e	60	down_write(&led_cdev->trigger_lock);
c3bc9956	61	led_trigger_set(led_cdev, trig);
dc47206e	62	up_write(&led_cdev->trigger_lock);
c3bc9956	63
dc47206e	64	up_read(&triggers_list_lock);
acd899e4	65	goto unlock;
c3bc9956 RP	66	}
c3bc9956 RP	67	}
a3eac76c HK	68	/* we come here only if buf matches no trigger */
a3eac76c HK	69	ret = -EINVAL;
dc47206e	70	up_read(&triggers_list_lock);
c3bc9956	71
acd899e4 JA	72	unlock:
	73	mutex_unlock(&led_cdev->led_access);
	74	return ret;
c3bc9956	75	}
11f70002	76	EXPORT_SYMBOL_GPL(led_trigger_write);
c3bc9956	77
11f70002 AM	78	__printf(3, 4)
	79	static int led_trigger_snprintf(char buf, ssize_t size, const char fmt, ...)
	80	{
	81	va_list args;
	82	int i;
	83
	84	va_start(args, fmt);
	85	if (size <= 0)
	86	i = vsnprintf(NULL, 0, fmt, args);
	87	else
	88	i = vscnprintf(buf, size, fmt, args);
	89	va_end(args);
	90
	91	return i;
	92	}
	93
	94	static int led_trigger_format(char *buf, size_t size,
	95	struct led_classdev *led_cdev)
c3bc9956	96	{
c3bc9956	97	struct led_trigger *trig;
11f70002 AM	98	int len = led_trigger_snprintf(buf, size, "%s",
	99	led_cdev->trigger ? "none" : "[none]");
	100
	101	list_for_each_entry(trig, &trigger_list, next_trig) {
93690cdf MB	102	bool hit;
	103
	104	if (!trigger_relevant(led_cdev, trig))
	105	continue;
	106
	107	hit = led_cdev->trigger && !strcmp(led_cdev->trigger->name, trig->name);
11f70002 AM	108
	109	len += led_trigger_snprintf(buf + len, size - len,
	110	" %s%s%s", hit ? "[" : "",
	111	trig->name, hit ? "]" : "");
	112	}
	113
	114	len += led_trigger_snprintf(buf + len, size - len, "\n");
	115
	116	return len;
	117	}
	118
	119	/*
	120	* It was stupid to create 10000 cpu triggers, but we are stuck with it now.
	121	* Don't make that mistake again. We work around it here by creating binary
	122	* attribute, which is not limited by length. This is _not_ good design, do not
	123	* copy it.
	124	*/
	125	ssize_t led_trigger_read(struct file filp, struct kobject kobj,
	126	struct bin_attribute attr, char buf,
	127	loff_t pos, size_t count)
	128	{
	129	struct device *dev = kobj_to_dev(kobj);
	130	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	131	void *data;
	132	int len;
c3bc9956	133
dc47206e RP	134	down_read(&triggers_list_lock);
dc47206e RP	135	down_read(&led_cdev->trigger_lock);
c3bc9956	136
11f70002 AM	137	len = led_trigger_format(NULL, 0, led_cdev);
	138	data = kvmalloc(len + 1, GFP_KERNEL);
	139	if (!data) {
	140	up_read(&led_cdev->trigger_lock);
	141	up_read(&triggers_list_lock);
	142	return -ENOMEM;
c3bc9956	143	}
11f70002 AM	144	len = led_trigger_format(data, len + 1, led_cdev);
11f70002 AM	145
dc47206e RP	146	up_read(&led_cdev->trigger_lock);
dc47206e RP	147	up_read(&triggers_list_lock);
c3bc9956	148
11f70002 AM	149	len = memory_read_from_buffer(buf, count, &pos, data, len);
	150
	151	kvfree(data);
	152
c3bc9956 RP	153	return len;
c3bc9956 RP	154	}
11f70002	155	EXPORT_SYMBOL_GPL(led_trigger_read);
c3bc9956 RP	156
c3bc9956 RP	157	/* Caller must ensure led_cdev->trigger_lock held */
2282e125	158	int led_trigger_set(struct led_classdev led_cdev, struct led_trigger trig)
c3bc9956	159	{
52c47742 CC	160	char *event = NULL;
	161	char *envp[2];
	162	const char *name;
2282e125	163	int ret;
52c47742	164
fbfa197a	165	if (!led_cdev->trigger && !trig)
2282e125	166	return 0;
fbfa197a	167
52c47742 CC	168	name = trig ? trig->name : "none";
52c47742 CC	169	event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name);
c3bc9956 RP	170
	171	/* Remove any existing trigger */
	172	if (led_cdev->trigger) {
2a5a8fa8 JB	173	spin_lock(&led_cdev->trigger->leddev_list_lock);
	174	list_del_rcu(&led_cdev->trig_list);
	175	spin_unlock(&led_cdev->trigger->leddev_list_lock);
	176
	177	/* ensure it's no longer visible on the led_cdevs list */
	178	synchronize_rcu();
	179
d23a22a7 FB	180	cancel_work_sync(&led_cdev->set_brightness_work);
d23a22a7 FB	181	led_stop_software_blink(led_cdev);
c3bc9956 RP	182	if (led_cdev->trigger->deactivate)
c3bc9956 RP	183	led_cdev->trigger->deactivate(led_cdev);
a7e7a315	184	device_remove_groups(led_cdev->dev, led_cdev->trigger->groups);
fe3025b5	185	led_cdev->trigger = NULL;
a7d5904a UKK	186	led_cdev->trigger_data = NULL;
a7d5904a UKK	187	led_cdev->activated = false;
19cd67e2	188	led_set_brightness(led_cdev, LED_OFF);
c3bc9956	189	}
eb202621	190	if (trig) {
2a5a8fa8 JB	191	spin_lock(&trig->leddev_list_lock);
	192	list_add_tail_rcu(&led_cdev->trig_list, &trig->led_cdevs);
	193	spin_unlock(&trig->leddev_list_lock);
eb202621	194	led_cdev->trigger = trig;
2282e125	195
eb202621	196	if (trig->activate)
2282e125 UKK	197	ret = trig->activate(led_cdev);
	198	else
	199	ret = 0;
	200
	201	if (ret)
	202	goto err_activate;
a7e7a315 UKK	203
	204	ret = device_add_groups(led_cdev->dev, trig->groups);
	205	if (ret) {
	206	dev_err(led_cdev->dev, "Failed to add trigger attributes\n");
	207	goto err_add_groups;
	208	}
c3bc9956	209	}
52c47742 CC	210
	211	if (event) {
	212	envp[0] = event;
	213	envp[1] = NULL;
6f3bad96 JA	214	if (kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp))
	215	dev_err(led_cdev->dev,
	216	"%s: Error sending uevent\n", __func__);
52c47742 CC	217	kfree(event);
52c47742 CC	218	}
2282e125 UKK	219
	220	return 0;
	221
a7e7a315 UKK	222	err_add_groups:
	223
	224	if (trig->deactivate)
	225	trig->deactivate(led_cdev);
2282e125	226	err_activate:
a7e7a315	227
2a5a8fa8 JB	228	spin_lock(&led_cdev->trigger->leddev_list_lock);
	229	list_del_rcu(&led_cdev->trig_list);
	230	spin_unlock(&led_cdev->trigger->leddev_list_lock);
	231	synchronize_rcu();
4016ba85 OK	232	led_cdev->trigger = NULL;
4016ba85 OK	233	led_cdev->trigger_data = NULL;
2282e125	234	led_set_brightness(led_cdev, LED_OFF);
60e2dde1	235	kfree(event);
2282e125 UKK	236
2282e125 UKK	237	return ret;
c3bc9956	238	}
4d404fd5	239	EXPORT_SYMBOL_GPL(led_trigger_set);
c3bc9956	240
0013b23d NM	241	void led_trigger_remove(struct led_classdev *led_cdev)
	242	{
	243	down_write(&led_cdev->trigger_lock);
	244	led_trigger_set(led_cdev, NULL);
	245	up_write(&led_cdev->trigger_lock);
	246	}
4d404fd5	247	EXPORT_SYMBOL_GPL(led_trigger_remove);
0013b23d	248
c3bc9956 RP	249	void led_trigger_set_default(struct led_classdev *led_cdev)
	250	{
	251	struct led_trigger *trig;
	252
	253	if (!led_cdev->default_trigger)
	254	return;
	255
dc47206e RP	256	down_read(&triggers_list_lock);
dc47206e RP	257	down_write(&led_cdev->trigger_lock);
c3bc9956	258	list_for_each_entry(trig, &trigger_list, next_trig) {
93690cdf MB	259	if (!strcmp(led_cdev->default_trigger, trig->name) &&
93690cdf MB	260	trigger_relevant(led_cdev, trig)) {
02d31765	261	led_cdev->flags \|= LED_INIT_DEFAULT_TRIGGER;
c3bc9956	262	led_trigger_set(led_cdev, trig);
c4f7bd4a JA	263	break;
c4f7bd4a JA	264	}
c3bc9956	265	}
dc47206e RP	266	up_write(&led_cdev->trigger_lock);
dc47206e RP	267	up_read(&triggers_list_lock);
c3bc9956	268	}
4d404fd5 NM	269	EXPORT_SYMBOL_GPL(led_trigger_set_default);
4d404fd5 NM	270
a8df7b1a FB	271	void led_trigger_rename_static(const char name, struct led_trigger trig)
	272	{
	273	/* new name must be on a temporary string to prevent races */
	274	BUG_ON(name == trig->name);
	275
	276	down_write(&triggers_list_lock);
	277	/* this assumes that trig->name was originaly allocated to
	278	* non constant storage */
	279	strcpy((char *)trig->name, name);
	280	up_write(&triggers_list_lock);
	281	}
	282	EXPORT_SYMBOL_GPL(led_trigger_rename_static);
	283
4d404fd5	284	/* LED Trigger Interface */
c3bc9956	285
eb202621	286	int led_trigger_register(struct led_trigger *trig)
c3bc9956 RP	287	{
c3bc9956 RP	288	struct led_classdev *led_cdev;
eb202621	289	struct led_trigger *_trig;
c3bc9956	290
2a5a8fa8	291	spin_lock_init(&trig->leddev_list_lock);
eb202621	292	INIT_LIST_HEAD(&trig->led_cdevs);
c3bc9956	293
dc47206e	294	down_write(&triggers_list_lock);
700c6ea2	295	/* Make sure the trigger's name isn't already in use */
eb202621	296	list_for_each_entry(_trig, &trigger_list, next_trig) {
93690cdf MB	297	if (!strcmp(_trig->name, trig->name) &&
	298	(trig->trigger_type == _trig->trigger_type \|\|
	299	!trig->trigger_type \|\| !_trig->trigger_type)) {
700c6ea2 AN	300	up_write(&triggers_list_lock);
	301	return -EEXIST;
	302	}
	303	}
	304	/* Add to the list of led triggers */
eb202621	305	list_add_tail(&trig->next_trig, &trigger_list);
dc47206e	306	up_write(&triggers_list_lock);
c3bc9956 RP	307
c3bc9956 RP	308	/* Register with any LEDs that have this as a default trigger */
72f8da32	309	down_read(&leds_list_lock);
c3bc9956	310	list_for_each_entry(led_cdev, &leds_list, node) {
dc47206e	311	down_write(&led_cdev->trigger_lock);
c3bc9956	312	if (!led_cdev->trigger && led_cdev->default_trigger &&
93690cdf MB	313	!strcmp(led_cdev->default_trigger, trig->name) &&
93690cdf MB	314	trigger_relevant(led_cdev, trig)) {
8146aace	315	led_cdev->flags \|= LED_INIT_DEFAULT_TRIGGER;
eb202621	316	led_trigger_set(led_cdev, trig);
8146aace	317	}
dc47206e	318	up_write(&led_cdev->trigger_lock);
c3bc9956	319	}
72f8da32	320	up_read(&leds_list_lock);
c3bc9956 RP	321
	322	return 0;
	323	}
4d404fd5	324	EXPORT_SYMBOL_GPL(led_trigger_register);
c3bc9956	325
eb202621	326	void led_trigger_unregister(struct led_trigger *trig)
c3bc9956 RP	327	{
	328	struct led_classdev *led_cdev;
	329
14f5716b SL	330	if (list_empty_careful(&trig->next_trig))
	331	return;
	332
c3bc9956	333	/* Remove from the list of led triggers */
dc47206e	334	down_write(&triggers_list_lock);
14f5716b	335	list_del_init(&trig->next_trig);
dc47206e	336	up_write(&triggers_list_lock);
c3bc9956 RP	337
c3bc9956 RP	338	/* Remove anyone actively using this trigger */
72f8da32	339	down_read(&leds_list_lock);
c3bc9956	340	list_for_each_entry(led_cdev, &leds_list, node) {
dc47206e	341	down_write(&led_cdev->trigger_lock);
eb202621	342	if (led_cdev->trigger == trig)
c3bc9956	343	led_trigger_set(led_cdev, NULL);
dc47206e	344	up_write(&led_cdev->trigger_lock);
c3bc9956	345	}
72f8da32	346	up_read(&leds_list_lock);
c3bc9956	347	}
4d404fd5	348	EXPORT_SYMBOL_GPL(led_trigger_unregister);
c3bc9956	349
9534cc31 HK	350	static void devm_led_trigger_release(struct device dev, void res)
	351	{
	352	led_trigger_unregister((struct led_trigger *)res);
	353	}
	354
	355	int devm_led_trigger_register(struct device *dev,
	356	struct led_trigger *trig)
	357	{
	358	struct led_trigger **dr;
	359	int rc;
	360
	361	dr = devres_alloc(devm_led_trigger_release, sizeof(*dr),
	362	GFP_KERNEL);
	363	if (!dr)
	364	return -ENOMEM;
	365
	366	*dr = trig;
	367
	368	rc = led_trigger_register(trig);
	369	if (rc)
	370	devres_free(dr);
	371	else
	372	devres_add(dev, dr);
	373
	374	return rc;
	375	}
	376	EXPORT_SYMBOL_GPL(devm_led_trigger_register);
	377
14d3e74f	378	/* Simple LED Trigger Interface */
4d404fd5	379
eb202621	380	void led_trigger_event(struct led_trigger *trig,
4d404fd5	381	enum led_brightness brightness)
c3bc9956	382	{
11e043b5	383	struct led_classdev *led_cdev;
4d404fd5	384
eb202621	385	if (!trig)
4d404fd5 NM	386	return;
4d404fd5 NM	387
2a5a8fa8 JB	388	rcu_read_lock();
2a5a8fa8 JB	389	list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list)
d23a22a7	390	led_set_brightness(led_cdev, brightness);
2a5a8fa8	391	rcu_read_unlock();
c3bc9956	392	}
4d404fd5	393	EXPORT_SYMBOL_GPL(led_trigger_event);
c3bc9956	394
20c0e6b8	395	static void led_trigger_blink_setup(struct led_trigger *trig,
5bb629c5 FB	396	unsigned long *delay_on,
	397	unsigned long *delay_off,
	398	int oneshot,
	399	int invert)
0b9536c9	400	{
11e043b5	401	struct led_classdev *led_cdev;
0b9536c9	402
eb202621	403	if (!trig)
0b9536c9 VK	404	return;
0b9536c9 VK	405
2a5a8fa8 JB	406	rcu_read_lock();
2a5a8fa8 JB	407	list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list) {
5bb629c5 FB	408	if (oneshot)
	409	led_blink_set_oneshot(led_cdev, delay_on, delay_off,
	410	invert);
	411	else
	412	led_blink_set(led_cdev, delay_on, delay_off);
0b9536c9	413	}
2a5a8fa8	414	rcu_read_unlock();
0b9536c9	415	}
5bb629c5 FB	416
	417	void led_trigger_blink(struct led_trigger *trig,
	418	unsigned long *delay_on,
	419	unsigned long *delay_off)
	420	{
	421	led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0);
	422	}
0b9536c9 VK	423	EXPORT_SYMBOL_GPL(led_trigger_blink);
0b9536c9 VK	424
5bb629c5 FB	425	void led_trigger_blink_oneshot(struct led_trigger *trig,
	426	unsigned long *delay_on,
	427	unsigned long *delay_off,
	428	int invert)
	429	{
	430	led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert);
	431	}
	432	EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot);
	433
4d404fd5 NM	434	void led_trigger_register_simple(const char name, struct led_trigger *tp)
4d404fd5 NM	435	{
eb202621	436	struct led_trigger *trig;
4d404fd5	437	int err;
c3bc9956	438
eb202621	439	trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
c3bc9956	440
eb202621 BW	441	if (trig) {
	442	trig->name = name;
	443	err = led_trigger_register(trig);
cba4c2ac	444	if (err < 0) {
eb202621 BW	445	kfree(trig);
eb202621 BW	446	trig = NULL;
09f5fe75 SK	447	pr_warn("LED trigger %s failed to register (%d)\n",
09f5fe75 SK	448	name, err);
cba4c2ac	449	}
09f5fe75 SK	450	} else {
	451	pr_warn("LED trigger %s failed to register (no memory)\n",
	452	name);
	453	}
eb202621	454	*tp = trig;
4d404fd5	455	}
c3bc9956	456	EXPORT_SYMBOL_GPL(led_trigger_register_simple);
4d404fd5	457
eb202621	458	void led_trigger_unregister_simple(struct led_trigger *trig)
4d404fd5	459	{
eb202621 BW	460	if (trig)
	461	led_trigger_unregister(trig);
	462	kfree(trig);
4d404fd5	463	}
c3bc9956	464	EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);