[linux-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 */

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)) {
			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 = 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)
{
	unsigned long flags;
	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) {
		write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
		list_del(&led_cdev->trig_list);
		write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock,
			flags);
		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) {
		write_lock_irqsave(&trig->leddev_list_lock, flags);
		list_add_tail(&led_cdev->trig_list, &trig->led_cdevs);
		write_unlock_irqrestore(&trig->leddev_list_lock, flags);
		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:

	write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
	list_del(&led_cdev->trig_list);
	write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, flags);
	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)) {
			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;

	rwlock_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)) {
			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)) {
			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 Tigger Interface */

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

	if (!trig)
		return;

	read_lock(&trig->leddev_list_lock);
	list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list)
		led_set_brightness(led_cdev, brightness);
	read_unlock(&trig->leddev_list_lock);
}
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;

	read_lock(&trig->leddev_list_lock);
	list_for_each_entry(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);
	}
	read_unlock(&trig->leddev_list_lock);
}

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