[thirdparty/kernel/linux.git] / drivers / leds / trigger / ledtrig-pattern.c

// SPDX-License-Identifier: GPL-2.0

/*
 * LED pattern trigger
 *
 * Idea discussed with Pavel Machek. Raphael Teysseyre implemented
 * the first version, Baolin Wang simplified and improved the approach.
 */

#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/timer.h>

#define MAX_PATTERNS		1024
/*
 * When doing gradual dimming, the led brightness will be updated
 * every 50 milliseconds.
 */
#define UPDATE_INTERVAL		50

struct pattern_trig_data {
	struct led_classdev *led_cdev;
	struct led_pattern patterns[MAX_PATTERNS];
	struct led_pattern *curr;
	struct led_pattern *next;
	struct mutex lock;
	u32 npatterns;
	int repeat;
	int last_repeat;
	int delta_t;
	bool is_indefinite;
	bool is_hw_pattern;
	struct timer_list timer;
};

static void pattern_trig_update_patterns(struct pattern_trig_data *data)
{
	data->curr = data->next;
	if (!data->is_indefinite && data->curr == data->patterns)
		data->repeat--;

	if (data->next == data->patterns + data->npatterns - 1)
		data->next = data->patterns;
	else
		data->next++;

	data->delta_t = 0;
}

static int pattern_trig_compute_brightness(struct pattern_trig_data *data)
{
	int step_brightness;

	/*
	 * If current tuple's duration is less than the dimming interval,
	 * we should treat it as a step change of brightness instead of
	 * doing gradual dimming.
	 */
	if (data->delta_t == 0 || data->curr->delta_t < UPDATE_INTERVAL)
		return data->curr->brightness;

	step_brightness = abs(data->next->brightness - data->curr->brightness);
	step_brightness = data->delta_t * step_brightness / data->curr->delta_t;

	if (data->next->brightness > data->curr->brightness)
		return data->curr->brightness + step_brightness;
	else
		return data->curr->brightness - step_brightness;
}

static void pattern_trig_timer_function(struct timer_list *t)
{
	struct pattern_trig_data *data = from_timer(data, t, timer);

	for (;;) {
		if (!data->is_indefinite && !data->repeat)
			break;

		if (data->curr->brightness == data->next->brightness) {
			/* Step change of brightness */
			led_set_brightness(data->led_cdev,
					   data->curr->brightness);
			mod_timer(&data->timer,
				  jiffies + msecs_to_jiffies(data->curr->delta_t));
			if (!data->next->delta_t) {
				/* Skip the tuple with zero duration */
				pattern_trig_update_patterns(data);
			}
			/* Select next tuple */
			pattern_trig_update_patterns(data);
		} else {
			/* Gradual dimming */

			/*
			 * If the accumulation time is larger than current
			 * tuple's duration, we should go next one and re-check
			 * if we repeated done.
			 */
			if (data->delta_t > data->curr->delta_t) {
				pattern_trig_update_patterns(data);
				continue;
			}

			led_set_brightness(data->led_cdev,
					   pattern_trig_compute_brightness(data));
			mod_timer(&data->timer,
				  jiffies + msecs_to_jiffies(UPDATE_INTERVAL));

			/* Accumulate the gradual dimming time */
			data->delta_t += UPDATE_INTERVAL;
		}

		break;
	}
}

static int pattern_trig_start_pattern(struct led_classdev *led_cdev)
{
	struct pattern_trig_data *data = led_cdev->trigger_data;

	if (!data->npatterns)
		return 0;

	if (data->is_hw_pattern) {
		return led_cdev->pattern_set(led_cdev, data->patterns,
					     data->npatterns, data->repeat);
	}

	/* At least 2 tuples for software pattern. */
	if (data->npatterns < 2)
		return -EINVAL;

	data->delta_t = 0;
	data->curr = data->patterns;
	data->next = data->patterns + 1;
	data->timer.expires = jiffies;
	add_timer(&data->timer);

	return 0;
}

static ssize_t repeat_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct pattern_trig_data *data = led_cdev->trigger_data;
	int repeat;

	mutex_lock(&data->lock);

	repeat = data->last_repeat;

	mutex_unlock(&data->lock);

	return scnprintf(buf, PAGE_SIZE, "%d\n", repeat);
}

static ssize_t repeat_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct pattern_trig_data *data = led_cdev->trigger_data;
	int err, res;

	err = kstrtos32(buf, 10, &res);
	if (err)
		return err;

	/* Number 0 and negative numbers except -1 are invalid. */
	if (res < -1 || res == 0)
		return -EINVAL;

	mutex_lock(&data->lock);

	del_timer_sync(&data->timer);

	if (data->is_hw_pattern)
		led_cdev->pattern_clear(led_cdev);

	data->last_repeat = data->repeat = res;
	/* -1 means repeat indefinitely */
	if (data->repeat == -1)
		data->is_indefinite = true;
	else
		data->is_indefinite = false;

	err = pattern_trig_start_pattern(led_cdev);

	mutex_unlock(&data->lock);
	return err < 0 ? err : count;
}

static DEVICE_ATTR_RW(repeat);

static ssize_t pattern_trig_show_patterns(struct pattern_trig_data *data,
					  char *buf, bool hw_pattern)
{
	ssize_t count = 0;
	int i;

	mutex_lock(&data->lock);

	if (!data->npatterns || (data->is_hw_pattern ^ hw_pattern))
		goto out;

	for (i = 0; i < data->npatterns; i++) {
		count += scnprintf(buf + count, PAGE_SIZE - count,
				   "%d %u ",
				   data->patterns[i].brightness,
				   data->patterns[i].delta_t);
	}

	buf[count - 1] = '\n';

out:
	mutex_unlock(&data->lock);
	return count;
}

static int pattern_trig_store_patterns_string(struct pattern_trig_data *data,
					      const char *buf, size_t count)
{
	int ccount, cr, offset = 0;

	while (offset < count - 1 && data->npatterns < MAX_PATTERNS) {
		cr = 0;
		ccount = sscanf(buf + offset, "%d %u %n",
				&data->patterns[data->npatterns].brightness,
				&data->patterns[data->npatterns].delta_t, &cr);
		if (ccount != 2) {
			data->npatterns = 0;
			return -EINVAL;
		}

		offset += cr;
		data->npatterns++;
	}

	return 0;
}

static int pattern_trig_store_patterns_int(struct pattern_trig_data *data,
					   const u32 *buf, size_t count)
{
	unsigned int i;

	for (i = 0; i < count; i += 2) {
		data->patterns[data->npatterns].brightness = buf[i];
		data->patterns[data->npatterns].delta_t = buf[i + 1];
		data->npatterns++;
	}

	return 0;
}

static ssize_t pattern_trig_store_patterns(struct led_classdev *led_cdev,
					   const char *buf, const u32 *buf_int,
					   size_t count, bool hw_pattern)
{
	struct pattern_trig_data *data = led_cdev->trigger_data;
	int err = 0;

	mutex_lock(&data->lock);

	del_timer_sync(&data->timer);

	if (data->is_hw_pattern)
		led_cdev->pattern_clear(led_cdev);

	data->is_hw_pattern = hw_pattern;
	data->npatterns = 0;

	if (buf)
		err = pattern_trig_store_patterns_string(data, buf, count);
	else
		err = pattern_trig_store_patterns_int(data, buf_int, count);
	if (err)
		goto out;

	err = pattern_trig_start_pattern(led_cdev);
	if (err)
		data->npatterns = 0;

out:
	mutex_unlock(&data->lock);
	return err < 0 ? err : count;
}

static ssize_t pattern_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct pattern_trig_data *data = led_cdev->trigger_data;

	return pattern_trig_show_patterns(data, buf, false);
}

static ssize_t pattern_store(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t count)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);

	return pattern_trig_store_patterns(led_cdev, buf, NULL, count, false);
}

static DEVICE_ATTR_RW(pattern);

static ssize_t hw_pattern_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	struct pattern_trig_data *data = led_cdev->trigger_data;

	return pattern_trig_show_patterns(data, buf, true);
}

static ssize_t hw_pattern_store(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct led_classdev *led_cdev = dev_get_drvdata(dev);

	return pattern_trig_store_patterns(led_cdev, buf, NULL, count, true);
}

static DEVICE_ATTR_RW(hw_pattern);

static umode_t pattern_trig_attrs_mode(struct kobject *kobj,
				       struct attribute *attr, int index)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct led_classdev *led_cdev = dev_get_drvdata(dev);

	if (attr == &dev_attr_repeat.attr || attr == &dev_attr_pattern.attr)
		return attr->mode;
	else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set)
		return attr->mode;

	return 0;
}

static struct attribute *pattern_trig_attrs[] = {
	&dev_attr_pattern.attr,
	&dev_attr_hw_pattern.attr,
	&dev_attr_repeat.attr,
	NULL
};

static const struct attribute_group pattern_trig_group = {
	.attrs = pattern_trig_attrs,
	.is_visible = pattern_trig_attrs_mode,
};

static const struct attribute_group *pattern_trig_groups[] = {
	&pattern_trig_group,
	NULL,
};

static void pattern_init(struct led_classdev *led_cdev)
{
	unsigned int size = 0;
	u32 *pattern;
	int err;

	pattern = led_get_default_pattern(led_cdev, &size);
	if (!pattern)
		return;

	if (size % 2) {
		dev_warn(led_cdev->dev, "Expected pattern of tuples\n");
		goto out;
	}

	err = pattern_trig_store_patterns(led_cdev, NULL, pattern, size, false);
	if (err < 0)
		dev_warn(led_cdev->dev,
			 "Pattern initialization failed with error %d\n", err);

out:
	kfree(pattern);
}

static int pattern_trig_activate(struct led_classdev *led_cdev)
{
	struct pattern_trig_data *data;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	if (!!led_cdev->pattern_set ^ !!led_cdev->pattern_clear) {
		dev_warn(led_cdev->dev,
			 "Hardware pattern ops validation failed\n");
		led_cdev->pattern_set = NULL;
		led_cdev->pattern_clear = NULL;
	}

	data->is_indefinite = true;
	data->last_repeat = -1;
	mutex_init(&data->lock);
	data->led_cdev = led_cdev;
	led_set_trigger_data(led_cdev, data);
	timer_setup(&data->timer, pattern_trig_timer_function, 0);
	led_cdev->activated = true;

	if (led_cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
		pattern_init(led_cdev);
		/*
		 * Mark as initialized even on pattern_init() error because
		 * any consecutive call to it would produce the same error.
		 */
		led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;
	}

	return 0;
}

static void pattern_trig_deactivate(struct led_classdev *led_cdev)
{
	struct pattern_trig_data *data = led_cdev->trigger_data;

	if (!led_cdev->activated)
		return;

	if (led_cdev->pattern_clear)
		led_cdev->pattern_clear(led_cdev);

	del_timer_sync(&data->timer);

	led_set_brightness(led_cdev, LED_OFF);
	kfree(data);
	led_cdev->activated = false;
}

static struct led_trigger pattern_led_trigger = {
	.name = "pattern",
	.activate = pattern_trig_activate,
	.deactivate = pattern_trig_deactivate,
	.groups = pattern_trig_groups,
};

static int __init pattern_trig_init(void)
{
	return led_trigger_register(&pattern_led_trigger);
}

static void __exit pattern_trig_exit(void)
{
	led_trigger_unregister(&pattern_led_trigger);
}

module_init(pattern_trig_init);
module_exit(pattern_trig_exit);

MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com");
MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org");
MODULE_DESCRIPTION("LED Pattern trigger");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
5fd752b6 BW	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	/*
	4	* LED pattern trigger
	5	*
	6	* Idea discussed with Pavel Machek. Raphael Teysseyre implemented
	7	* the first version, Baolin Wang simplified and improved the approach.
	8	*/
	9
	10	#include <linux/kernel.h>
	11	#include <linux/leds.h>
	12	#include <linux/module.h>
	13	#include <linux/mutex.h>
	14	#include <linux/slab.h>
	15	#include <linux/timer.h>
	16
	17	#define MAX_PATTERNS 1024
	18	/*
	19	* When doing gradual dimming, the led brightness will be updated
	20	* every 50 milliseconds.
	21	*/
	22	#define UPDATE_INTERVAL 50
	23
	24	struct pattern_trig_data {
	25	struct led_classdev *led_cdev;
	26	struct led_pattern patterns[MAX_PATTERNS];
	27	struct led_pattern *curr;
	28	struct led_pattern *next;
	29	struct mutex lock;
	30	u32 npatterns;
	31	int repeat;
	32	int last_repeat;
	33	int delta_t;
	34	bool is_indefinite;
	35	bool is_hw_pattern;
	36	struct timer_list timer;
	37	};
	38
	39	static void pattern_trig_update_patterns(struct pattern_trig_data *data)
	40	{
	41	data->curr = data->next;
	42	if (!data->is_indefinite && data->curr == data->patterns)
	43	data->repeat--;
	44
	45	if (data->next == data->patterns + data->npatterns - 1)
	46	data->next = data->patterns;
	47	else
	48	data->next++;
	49
	50	data->delta_t = 0;
	51	}
	52
	53	static int pattern_trig_compute_brightness(struct pattern_trig_data *data)
	54	{
	55	int step_brightness;
	56
	57	/*
	58	* If current tuple's duration is less than the dimming interval,
	59	* we should treat it as a step change of brightness instead of
	60	* doing gradual dimming.
	61	*/
	62	if (data->delta_t == 0 \|\| data->curr->delta_t < UPDATE_INTERVAL)
	63	return data->curr->brightness;
	64
65	step_brightness = abs(data->next->brightness - data->curr->brightness);
66	step_brightness = data->delta_t * step_brightness / data->curr->delta_t;
67
68	if (data->next->brightness > data->curr->brightness)
69	return data->curr->brightness + step_brightness;
70	else
71	return data->curr->brightness - step_brightness;
72	}
73
74	static void pattern_trig_timer_function(struct timer_list *t)
75	{
76	struct pattern_trig_data *data = from_timer(data, t, timer);
77
5fd752b6 BW	78	for (;;) {
	79	if (!data->is_indefinite && !data->repeat)
	80	break;
	81
	82	if (data->curr->brightness == data->next->brightness) {
	83	/* Step change of brightness */
	84	led_set_brightness(data->led_cdev,
	85	data->curr->brightness);
	86	mod_timer(&data->timer,
	87	jiffies + msecs_to_jiffies(data->curr->delta_t));
1b50bb4d PM	88	if (!data->next->delta_t) {
	89	/* Skip the tuple with zero duration */
	90	pattern_trig_update_patterns(data);
	91	}
5fd752b6 BW	92	/* Select next tuple */
	93	pattern_trig_update_patterns(data);
	94	} else {
	95	/* Gradual dimming */
	96
	97	/*
	98	* If the accumulation time is larger than current
	99	* tuple's duration, we should go next one and re-check
	100	* if we repeated done.
	101	*/
	102	if (data->delta_t > data->curr->delta_t) {
	103	pattern_trig_update_patterns(data);
	104	continue;
	105	}
	106
	107	led_set_brightness(data->led_cdev,
	108	pattern_trig_compute_brightness(data));
	109	mod_timer(&data->timer,
	110	jiffies + msecs_to_jiffies(UPDATE_INTERVAL));
	111
	112	/* Accumulate the gradual dimming time */
	113	data->delta_t += UPDATE_INTERVAL;
	114	}
	115
	116	break;
	117	}
5fd752b6 BW	118	}
	119
	120	static int pattern_trig_start_pattern(struct led_classdev *led_cdev)
	121	{
	122	struct pattern_trig_data *data = led_cdev->trigger_data;
	123
	124	if (!data->npatterns)
	125	return 0;
	126
	127	if (data->is_hw_pattern) {
	128	return led_cdev->pattern_set(led_cdev, data->patterns,
	129	data->npatterns, data->repeat);
	130	}
	131
	132	/* At least 2 tuples for software pattern. */
	133	if (data->npatterns < 2)
	134	return -EINVAL;
	135
	136	data->delta_t = 0;
	137	data->curr = data->patterns;
	138	data->next = data->patterns + 1;
	139	data->timer.expires = jiffies;
	140	add_timer(&data->timer);
	141
	142	return 0;
	143	}
	144
	145	static ssize_t repeat_show(struct device dev, struct device_attribute attr,
	146	char *buf)
	147	{
	148	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	149	struct pattern_trig_data *data = led_cdev->trigger_data;
	150	int repeat;
	151
	152	mutex_lock(&data->lock);
	153
	154	repeat = data->last_repeat;
	155
	156	mutex_unlock(&data->lock);
	157
	158	return scnprintf(buf, PAGE_SIZE, "%d\n", repeat);
	159	}
	160
	161	static ssize_t repeat_store(struct device dev, struct device_attribute attr,
	162	const char *buf, size_t count)
	163	{
	164	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	165	struct pattern_trig_data *data = led_cdev->trigger_data;
	166	int err, res;
	167
	168	err = kstrtos32(buf, 10, &res);
	169	if (err)
	170	return err;
	171
	172	/* Number 0 and negative numbers except -1 are invalid. */
	173	if (res < -1 \|\| res == 0)
	174	return -EINVAL;
	175
5fd752b6 BW	176	mutex_lock(&data->lock);
5fd752b6 BW	177
3a40cfe8 BW	178	del_timer_sync(&data->timer);
3a40cfe8 BW	179
5fd752b6 BW	180	if (data->is_hw_pattern)
	181	led_cdev->pattern_clear(led_cdev);
	182
	183	data->last_repeat = data->repeat = res;
	184	/* -1 means repeat indefinitely */
	185	if (data->repeat == -1)
	186	data->is_indefinite = true;
	187	else
	188	data->is_indefinite = false;
	189
	190	err = pattern_trig_start_pattern(led_cdev);
	191
	192	mutex_unlock(&data->lock);
	193	return err < 0 ? err : count;
	194	}
	195
	196	static DEVICE_ATTR_RW(repeat);
	197
	198	static ssize_t pattern_trig_show_patterns(struct pattern_trig_data *data,
	199	char *buf, bool hw_pattern)
	200	{
	201	ssize_t count = 0;
	202	int i;
	203
	204	mutex_lock(&data->lock);
	205
	206	if (!data->npatterns \|\| (data->is_hw_pattern ^ hw_pattern))
	207	goto out;
	208
	209	for (i = 0; i < data->npatterns; i++) {
	210	count += scnprintf(buf + count, PAGE_SIZE - count,
	211	"%d %u ",
	212	data->patterns[i].brightness,
	213	data->patterns[i].delta_t);
	214	}
	215
	216	buf[count - 1] = '\n';
	217
	218	out:
	219	mutex_unlock(&data->lock);
	220	return count;
	221	}
	222
aa6fd104 KK	223	static int pattern_trig_store_patterns_string(struct pattern_trig_data *data,
aa6fd104 KK	224	const char *buf, size_t count)
5fd752b6	225	{
aa6fd104	226	int ccount, cr, offset = 0;
5fd752b6 BW	227
	228	while (offset < count - 1 && data->npatterns < MAX_PATTERNS) {
	229	cr = 0;
	230	ccount = sscanf(buf + offset, "%d %u %n",
	231	&data->patterns[data->npatterns].brightness,
	232	&data->patterns[data->npatterns].delta_t, &cr);
	233	if (ccount != 2) {
	234	data->npatterns = 0;
aa6fd104	235	return -EINVAL;
5fd752b6 BW	236	}
	237
	238	offset += cr;
	239	data->npatterns++;
	240	}
	241
aa6fd104 KK	242	return 0;
	243	}
	244
	245	static int pattern_trig_store_patterns_int(struct pattern_trig_data *data,
	246	const u32 *buf, size_t count)
	247	{
	248	unsigned int i;
	249
	250	for (i = 0; i < count; i += 2) {
	251	data->patterns[data->npatterns].brightness = buf[i];
	252	data->patterns[data->npatterns].delta_t = buf[i + 1];
	253	data->npatterns++;
	254	}
	255
	256	return 0;
	257	}
	258
	259	static ssize_t pattern_trig_store_patterns(struct led_classdev *led_cdev,
	260	const char buf, const u32 buf_int,
	261	size_t count, bool hw_pattern)
	262	{
	263	struct pattern_trig_data *data = led_cdev->trigger_data;
	264	int err = 0;
	265
	266	mutex_lock(&data->lock);
	267
	268	del_timer_sync(&data->timer);
	269
	270	if (data->is_hw_pattern)
	271	led_cdev->pattern_clear(led_cdev);
	272
	273	data->is_hw_pattern = hw_pattern;
	274	data->npatterns = 0;
	275
	276	if (buf)
	277	err = pattern_trig_store_patterns_string(data, buf, count);
	278	else
	279	err = pattern_trig_store_patterns_int(data, buf_int, count);
	280	if (err)
	281	goto out;
	282
5fd752b6 BW	283	err = pattern_trig_start_pattern(led_cdev);
	284	if (err)
	285	data->npatterns = 0;
	286
	287	out:
	288	mutex_unlock(&data->lock);
	289	return err < 0 ? err : count;
	290	}
	291
	292	static ssize_t pattern_show(struct device dev, struct device_attribute attr,
	293	char *buf)
	294	{
	295	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	296	struct pattern_trig_data *data = led_cdev->trigger_data;
	297
	298	return pattern_trig_show_patterns(data, buf, false);
	299	}
	300
	301	static ssize_t pattern_store(struct device dev, struct device_attribute attr,
	302	const char *buf, size_t count)
	303	{
	304	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	305
aa6fd104	306	return pattern_trig_store_patterns(led_cdev, buf, NULL, count, false);
5fd752b6 BW	307	}
	308
	309	static DEVICE_ATTR_RW(pattern);
	310
	311	static ssize_t hw_pattern_show(struct device *dev,
	312	struct device_attribute attr, char buf)
	313	{
	314	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	315	struct pattern_trig_data *data = led_cdev->trigger_data;
	316
	317	return pattern_trig_show_patterns(data, buf, true);
	318	}
	319
	320	static ssize_t hw_pattern_store(struct device *dev,
	321	struct device_attribute *attr,
	322	const char *buf, size_t count)
	323	{
	324	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	325
aa6fd104	326	return pattern_trig_store_patterns(led_cdev, buf, NULL, count, true);
5fd752b6 BW	327	}
	328
	329	static DEVICE_ATTR_RW(hw_pattern);
	330
	331	static umode_t pattern_trig_attrs_mode(struct kobject *kobj,
	332	struct attribute *attr, int index)
	333	{
	334	struct device *dev = container_of(kobj, struct device, kobj);
	335	struct led_classdev *led_cdev = dev_get_drvdata(dev);
	336
	337	if (attr == &dev_attr_repeat.attr \|\| attr == &dev_attr_pattern.attr)
	338	return attr->mode;
	339	else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set)
	340	return attr->mode;
	341
	342	return 0;
	343	}
	344
	345	static struct attribute *pattern_trig_attrs[] = {
	346	&dev_attr_pattern.attr,
	347	&dev_attr_hw_pattern.attr,
	348	&dev_attr_repeat.attr,
	349	NULL
	350	};
	351
	352	static const struct attribute_group pattern_trig_group = {
	353	.attrs = pattern_trig_attrs,
	354	.is_visible = pattern_trig_attrs_mode,
	355	};
	356
	357	static const struct attribute_group *pattern_trig_groups[] = {
	358	&pattern_trig_group,
	359	NULL,
	360	};
	361
aa6fd104 KK	362	static void pattern_init(struct led_classdev *led_cdev)
	363	{
	364	unsigned int size = 0;
	365	u32 *pattern;
	366	int err;
	367
	368	pattern = led_get_default_pattern(led_cdev, &size);
	369	if (!pattern)
	370	return;
	371
	372	if (size % 2) {
	373	dev_warn(led_cdev->dev, "Expected pattern of tuples\n");
	374	goto out;
	375	}
	376
	377	err = pattern_trig_store_patterns(led_cdev, NULL, pattern, size, false);
	378	if (err < 0)
	379	dev_warn(led_cdev->dev,
	380	"Pattern initialization failed with error %d\n", err);
	381
	382	out:
	383	kfree(pattern);
	384	}
	385
5fd752b6 BW	386	static int pattern_trig_activate(struct led_classdev *led_cdev)
	387	{
	388	struct pattern_trig_data *data;
	389
	390	data = kzalloc(sizeof(*data), GFP_KERNEL);
	391	if (!data)
	392	return -ENOMEM;
	393
	394	if (!!led_cdev->pattern_set ^ !!led_cdev->pattern_clear) {
	395	dev_warn(led_cdev->dev,
	396	"Hardware pattern ops validation failed\n");
	397	led_cdev->pattern_set = NULL;
	398	led_cdev->pattern_clear = NULL;
	399	}
	400
	401	data->is_indefinite = true;
	402	data->last_repeat = -1;
	403	mutex_init(&data->lock);
	404	data->led_cdev = led_cdev;
	405	led_set_trigger_data(led_cdev, data);
	406	timer_setup(&data->timer, pattern_trig_timer_function, 0);
	407	led_cdev->activated = true;
	408
aa6fd104 KK	409	if (led_cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
	410	pattern_init(led_cdev);
	411	/*
	412	* Mark as initialized even on pattern_init() error because
	413	* any consecutive call to it would produce the same error.
	414	*/
	415	led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;
	416	}
	417
5fd752b6 BW	418	return 0;
	419	}
	420
	421	static void pattern_trig_deactivate(struct led_classdev *led_cdev)
	422	{
	423	struct pattern_trig_data *data = led_cdev->trigger_data;
	424
	425	if (!led_cdev->activated)
	426	return;
	427
	428	if (led_cdev->pattern_clear)
	429	led_cdev->pattern_clear(led_cdev);
	430
	431	del_timer_sync(&data->timer);
	432
	433	led_set_brightness(led_cdev, LED_OFF);
	434	kfree(data);
	435	led_cdev->activated = false;
	436	}
	437
	438	static struct led_trigger pattern_led_trigger = {
	439	.name = "pattern",
	440	.activate = pattern_trig_activate,
	441	.deactivate = pattern_trig_deactivate,
	442	.groups = pattern_trig_groups,
	443	};
	444
	445	static int __init pattern_trig_init(void)
	446	{
	447	return led_trigger_register(&pattern_led_trigger);
	448	}
	449
	450	static void __exit pattern_trig_exit(void)
	451	{
	452	led_trigger_unregister(&pattern_led_trigger);
	453	}
	454
	455	module_init(pattern_trig_init);
	456	module_exit(pattern_trig_exit);
	457
	458	MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com");
	459	MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org");
	460	MODULE_DESCRIPTION("LED Pattern trigger");
	461	MODULE_LICENSE("GPL v2");