[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);
static 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_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;
		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);

static bool led_match_default_trigger(struct led_classdev *led_cdev,
				      struct led_trigger *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);
		return true;
	}

	return false;
}

void led_trigger_set_default(struct led_classdev *led_cdev)
{
	struct led_trigger *trig;
	bool found = false;

	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) {
		found = led_match_default_trigger(led_cdev, trig);
		if (found)
			break;
	}
	up_write(&led_cdev->trigger_lock);
	up_read(&triggers_list_lock);

	/*
	 * If default trigger wasn't found, maybe trigger module isn't loaded yet.
	 * Once loaded it will re-probe with all led_cdev's.
	 */
	if (!found)
		request_module_nowait("ledtrig:%s", led_cdev->default_trigger);
}
EXPORT_SYMBOL_GPL(led_trigger_set_default);

/* 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)
			led_match_default_trigger(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_nosleep(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);
e838a5a1	26	static 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;
82f80ef5	188	led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;
19cd67e2	189	led_set_brightness(led_cdev, LED_OFF);
c3bc9956	190	}
eb202621	191	if (trig) {
2a5a8fa8 JB	192	spin_lock(&trig->leddev_list_lock);
	193	list_add_tail_rcu(&led_cdev->trig_list, &trig->led_cdevs);
	194	spin_unlock(&trig->leddev_list_lock);
eb202621	195	led_cdev->trigger = trig;
2282e125	196
eb202621	197	if (trig->activate)
2282e125 UKK	198	ret = trig->activate(led_cdev);
	199	else
	200	ret = 0;
	201
	202	if (ret)
	203	goto err_activate;
a7e7a315 UKK	204
	205	ret = device_add_groups(led_cdev->dev, trig->groups);
	206	if (ret) {
	207	dev_err(led_cdev->dev, "Failed to add trigger attributes\n");
	208	goto err_add_groups;
	209	}
c3bc9956	210	}
52c47742 CC	211
	212	if (event) {
	213	envp[0] = event;
	214	envp[1] = NULL;
6f3bad96 JA	215	if (kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp))
	216	dev_err(led_cdev->dev,
	217	"%s: Error sending uevent\n", __func__);
52c47742 CC	218	kfree(event);
52c47742 CC	219	}
2282e125 UKK	220
	221	return 0;
	222
a7e7a315 UKK	223	err_add_groups:
	224
	225	if (trig->deactivate)
	226	trig->deactivate(led_cdev);
2282e125	227	err_activate:
a7e7a315	228
2a5a8fa8 JB	229	spin_lock(&led_cdev->trigger->leddev_list_lock);
	230	list_del_rcu(&led_cdev->trig_list);
	231	spin_unlock(&led_cdev->trigger->leddev_list_lock);
	232	synchronize_rcu();
4016ba85 OK	233	led_cdev->trigger = NULL;
4016ba85 OK	234	led_cdev->trigger_data = NULL;
2282e125	235	led_set_brightness(led_cdev, LED_OFF);
60e2dde1	236	kfree(event);
2282e125 UKK	237
2282e125 UKK	238	return ret;
c3bc9956	239	}
4d404fd5	240	EXPORT_SYMBOL_GPL(led_trigger_set);
c3bc9956	241
0013b23d NM	242	void led_trigger_remove(struct led_classdev *led_cdev)
	243	{
	244	down_write(&led_cdev->trigger_lock);
	245	led_trigger_set(led_cdev, NULL);
	246	up_write(&led_cdev->trigger_lock);
	247	}
4d404fd5	248	EXPORT_SYMBOL_GPL(led_trigger_remove);
0013b23d	249
9225333e HK	250	static bool led_match_default_trigger(struct led_classdev *led_cdev,
	251	struct led_trigger *trig)
	252	{
	253	if (!strcmp(led_cdev->default_trigger, trig->name) &&
	254	trigger_relevant(led_cdev, trig)) {
	255	led_cdev->flags \|= LED_INIT_DEFAULT_TRIGGER;
	256	led_trigger_set(led_cdev, trig);
	257	return true;
	258	}
	259
	260	return false;
	261	}
	262
c3bc9956 RP	263	void led_trigger_set_default(struct led_classdev *led_cdev)
	264	{
	265	struct led_trigger *trig;
e09c706b	266	bool found = false;
c3bc9956 RP	267
	268	if (!led_cdev->default_trigger)
	269	return;
	270
dc47206e RP	271	down_read(&triggers_list_lock);
dc47206e RP	272	down_write(&led_cdev->trigger_lock);
c3bc9956	273	list_for_each_entry(trig, &trigger_list, next_trig) {
9225333e HK	274	found = led_match_default_trigger(led_cdev, trig);
9225333e HK	275	if (found)
c4f7bd4a	276	break;
c3bc9956	277	}
dc47206e RP	278	up_write(&led_cdev->trigger_lock);
dc47206e RP	279	up_read(&triggers_list_lock);
e09c706b HK	280
	281	/*
	282	* If default trigger wasn't found, maybe trigger module isn't loaded yet.
	283	* Once loaded it will re-probe with all led_cdev's.
	284	*/
	285	if (!found)
	286	request_module_nowait("ledtrig:%s", led_cdev->default_trigger);
c3bc9956	287	}
4d404fd5 NM	288	EXPORT_SYMBOL_GPL(led_trigger_set_default);
	289
	290	/* LED Trigger Interface */
c3bc9956	291
eb202621	292	int led_trigger_register(struct led_trigger *trig)
c3bc9956 RP	293	{
c3bc9956 RP	294	struct led_classdev *led_cdev;
eb202621	295	struct led_trigger *_trig;
c3bc9956	296
2a5a8fa8	297	spin_lock_init(&trig->leddev_list_lock);
eb202621	298	INIT_LIST_HEAD(&trig->led_cdevs);
c3bc9956	299
dc47206e	300	down_write(&triggers_list_lock);
700c6ea2	301	/* Make sure the trigger's name isn't already in use */
eb202621	302	list_for_each_entry(_trig, &trigger_list, next_trig) {
93690cdf MB	303	if (!strcmp(_trig->name, trig->name) &&
	304	(trig->trigger_type == _trig->trigger_type \|\|
	305	!trig->trigger_type \|\| !_trig->trigger_type)) {
700c6ea2 AN	306	up_write(&triggers_list_lock);
	307	return -EEXIST;
	308	}
	309	}
	310	/* Add to the list of led triggers */
eb202621	311	list_add_tail(&trig->next_trig, &trigger_list);
dc47206e	312	up_write(&triggers_list_lock);
c3bc9956 RP	313
c3bc9956 RP	314	/* Register with any LEDs that have this as a default trigger */
72f8da32	315	down_read(&leds_list_lock);
c3bc9956	316	list_for_each_entry(led_cdev, &leds_list, node) {
dc47206e	317	down_write(&led_cdev->trigger_lock);
9225333e HK	318	if (!led_cdev->trigger && led_cdev->default_trigger)
9225333e HK	319	led_match_default_trigger(led_cdev, trig);
dc47206e	320	up_write(&led_cdev->trigger_lock);
c3bc9956	321	}
72f8da32	322	up_read(&leds_list_lock);
c3bc9956 RP	323
	324	return 0;
	325	}
4d404fd5	326	EXPORT_SYMBOL_GPL(led_trigger_register);
c3bc9956	327
eb202621	328	void led_trigger_unregister(struct led_trigger *trig)
c3bc9956 RP	329	{
	330	struct led_classdev *led_cdev;
	331
14f5716b SL	332	if (list_empty_careful(&trig->next_trig))
	333	return;
	334
c3bc9956	335	/* Remove from the list of led triggers */
dc47206e	336	down_write(&triggers_list_lock);
14f5716b	337	list_del_init(&trig->next_trig);
dc47206e	338	up_write(&triggers_list_lock);
c3bc9956 RP	339
c3bc9956 RP	340	/* Remove anyone actively using this trigger */
72f8da32	341	down_read(&leds_list_lock);
c3bc9956	342	list_for_each_entry(led_cdev, &leds_list, node) {
dc47206e	343	down_write(&led_cdev->trigger_lock);
eb202621	344	if (led_cdev->trigger == trig)
c3bc9956	345	led_trigger_set(led_cdev, NULL);
dc47206e	346	up_write(&led_cdev->trigger_lock);
c3bc9956	347	}
72f8da32	348	up_read(&leds_list_lock);
c3bc9956	349	}
4d404fd5	350	EXPORT_SYMBOL_GPL(led_trigger_unregister);
c3bc9956	351
9534cc31 HK	352	static void devm_led_trigger_release(struct device dev, void res)
	353	{
	354	led_trigger_unregister((struct led_trigger *)res);
	355	}
	356
	357	int devm_led_trigger_register(struct device *dev,
	358	struct led_trigger *trig)
	359	{
	360	struct led_trigger **dr;
	361	int rc;
	362
	363	dr = devres_alloc(devm_led_trigger_release, sizeof(*dr),
	364	GFP_KERNEL);
	365	if (!dr)
	366	return -ENOMEM;
	367
	368	*dr = trig;
	369
	370	rc = led_trigger_register(trig);
	371	if (rc)
	372	devres_free(dr);
	373	else
	374	devres_add(dev, dr);
	375
	376	return rc;
	377	}
	378	EXPORT_SYMBOL_GPL(devm_led_trigger_register);
	379
14d3e74f	380	/* Simple LED Trigger Interface */
4d404fd5	381
eb202621	382	void led_trigger_event(struct led_trigger *trig,
4d404fd5	383	enum led_brightness brightness)
c3bc9956	384	{
11e043b5	385	struct led_classdev *led_cdev;
4d404fd5	386
eb202621	387	if (!trig)
4d404fd5 NM	388	return;
4d404fd5 NM	389
2a5a8fa8 JB	390	rcu_read_lock();
2a5a8fa8 JB	391	list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list)
d23a22a7	392	led_set_brightness(led_cdev, brightness);
2a5a8fa8	393	rcu_read_unlock();
c3bc9956	394	}
4d404fd5	395	EXPORT_SYMBOL_GPL(led_trigger_event);
c3bc9956	396
20c0e6b8	397	static void led_trigger_blink_setup(struct led_trigger *trig,
e298d8a3 HG	398	unsigned long delay_on,
e298d8a3 HG	399	unsigned long delay_off,
5bb629c5 FB	400	int oneshot,
5bb629c5 FB	401	int invert)
0b9536c9	402	{
11e043b5	403	struct led_classdev *led_cdev;
0b9536c9	404
eb202621	405	if (!trig)
0b9536c9 VK	406	return;
0b9536c9 VK	407
2a5a8fa8 JB	408	rcu_read_lock();
2a5a8fa8 JB	409	list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list) {
5bb629c5	410	if (oneshot)
e298d8a3	411	led_blink_set_oneshot(led_cdev, &delay_on, &delay_off,
5bb629c5 FB	412	invert);
5bb629c5 FB	413	else
22720a87	414	led_blink_set_nosleep(led_cdev, delay_on, delay_off);
0b9536c9	415	}
2a5a8fa8	416	rcu_read_unlock();
0b9536c9	417	}
5bb629c5 FB	418
5bb629c5 FB	419	void led_trigger_blink(struct led_trigger *trig,
e298d8a3 HG	420	unsigned long delay_on,
e298d8a3 HG	421	unsigned long delay_off)
5bb629c5 FB	422	{
	423	led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0);
	424	}
0b9536c9 VK	425	EXPORT_SYMBOL_GPL(led_trigger_blink);
0b9536c9 VK	426
5bb629c5	427	void led_trigger_blink_oneshot(struct led_trigger *trig,
e298d8a3 HG	428	unsigned long delay_on,
e298d8a3 HG	429	unsigned long delay_off,
5bb629c5 FB	430	int invert)
	431	{
	432	led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert);
	433	}
	434	EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot);
	435
4d404fd5 NM	436	void led_trigger_register_simple(const char name, struct led_trigger *tp)
4d404fd5 NM	437	{
eb202621	438	struct led_trigger *trig;
4d404fd5	439	int err;
c3bc9956	440
eb202621	441	trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
c3bc9956	442
eb202621 BW	443	if (trig) {
	444	trig->name = name;
	445	err = led_trigger_register(trig);
cba4c2ac	446	if (err < 0) {
eb202621 BW	447	kfree(trig);
eb202621 BW	448	trig = NULL;
09f5fe75 SK	449	pr_warn("LED trigger %s failed to register (%d)\n",
09f5fe75 SK	450	name, err);
cba4c2ac	451	}
09f5fe75 SK	452	} else {
	453	pr_warn("LED trigger %s failed to register (no memory)\n",
	454	name);
	455	}
eb202621	456	*tp = trig;
4d404fd5	457	}
c3bc9956	458	EXPORT_SYMBOL_GPL(led_trigger_register_simple);
4d404fd5	459
eb202621	460	void led_trigger_unregister_simple(struct led_trigger *trig)
4d404fd5	461	{
eb202621 BW	462	if (trig)
	463	led_trigger_unregister(trig);
	464	kfree(trig);
4d404fd5	465	}
c3bc9956	466	EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);