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 
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));
88 			if (!data->next->delta_t) {
89 				/* Skip the tuple with zero duration */
90 				pattern_trig_update_patterns(data);
91 			}
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 	}
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 
176 	mutex_lock(&data->lock);
177 
178 	del_timer_sync(&data->timer);
179 
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 
223 static ssize_t pattern_trig_store_patterns(struct led_classdev *led_cdev,
224 					   const char *buf, size_t count,
225 					   bool hw_pattern)
226 {
227 	struct pattern_trig_data *data = led_cdev->trigger_data;
228 	int ccount, cr, offset = 0, err = 0;
229 
230 	mutex_lock(&data->lock);
231 
232 	del_timer_sync(&data->timer);
233 
234 	if (data->is_hw_pattern)
235 		led_cdev->pattern_clear(led_cdev);
236 
237 	data->is_hw_pattern = hw_pattern;
238 	data->npatterns = 0;
239 
240 	while (offset < count - 1 && data->npatterns < MAX_PATTERNS) {
241 		cr = 0;
242 		ccount = sscanf(buf + offset, "%d %u %n",
243 				&data->patterns[data->npatterns].brightness,
244 				&data->patterns[data->npatterns].delta_t, &cr);
245 		if (ccount != 2) {
246 			data->npatterns = 0;
247 			err = -EINVAL;
248 			goto out;
249 		}
250 
251 		offset += cr;
252 		data->npatterns++;
253 	}
254 
255 	err = pattern_trig_start_pattern(led_cdev);
256 	if (err)
257 		data->npatterns = 0;
258 
259 out:
260 	mutex_unlock(&data->lock);
261 	return err < 0 ? err : count;
262 }
263 
264 static ssize_t pattern_show(struct device *dev, struct device_attribute *attr,
265 			    char *buf)
266 {
267 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
268 	struct pattern_trig_data *data = led_cdev->trigger_data;
269 
270 	return pattern_trig_show_patterns(data, buf, false);
271 }
272 
273 static ssize_t pattern_store(struct device *dev, struct device_attribute *attr,
274 			     const char *buf, size_t count)
275 {
276 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
277 
278 	return pattern_trig_store_patterns(led_cdev, buf, count, false);
279 }
280 
281 static DEVICE_ATTR_RW(pattern);
282 
283 static ssize_t hw_pattern_show(struct device *dev,
284 			       struct device_attribute *attr, char *buf)
285 {
286 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
287 	struct pattern_trig_data *data = led_cdev->trigger_data;
288 
289 	return pattern_trig_show_patterns(data, buf, true);
290 }
291 
292 static ssize_t hw_pattern_store(struct device *dev,
293 				struct device_attribute *attr,
294 				const char *buf, size_t count)
295 {
296 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
297 
298 	return pattern_trig_store_patterns(led_cdev, buf, count, true);
299 }
300 
301 static DEVICE_ATTR_RW(hw_pattern);
302 
303 static umode_t pattern_trig_attrs_mode(struct kobject *kobj,
304 				       struct attribute *attr, int index)
305 {
306 	struct device *dev = container_of(kobj, struct device, kobj);
307 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
308 
309 	if (attr == &dev_attr_repeat.attr || attr == &dev_attr_pattern.attr)
310 		return attr->mode;
311 	else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set)
312 		return attr->mode;
313 
314 	return 0;
315 }
316 
317 static struct attribute *pattern_trig_attrs[] = {
318 	&dev_attr_pattern.attr,
319 	&dev_attr_hw_pattern.attr,
320 	&dev_attr_repeat.attr,
321 	NULL
322 };
323 
324 static const struct attribute_group pattern_trig_group = {
325 	.attrs = pattern_trig_attrs,
326 	.is_visible = pattern_trig_attrs_mode,
327 };
328 
329 static const struct attribute_group *pattern_trig_groups[] = {
330 	&pattern_trig_group,
331 	NULL,
332 };
333 
334 static int pattern_trig_activate(struct led_classdev *led_cdev)
335 {
336 	struct pattern_trig_data *data;
337 
338 	data = kzalloc(sizeof(*data), GFP_KERNEL);
339 	if (!data)
340 		return -ENOMEM;
341 
342 	if (!!led_cdev->pattern_set ^ !!led_cdev->pattern_clear) {
343 		dev_warn(led_cdev->dev,
344 			 "Hardware pattern ops validation failed\n");
345 		led_cdev->pattern_set = NULL;
346 		led_cdev->pattern_clear = NULL;
347 	}
348 
349 	data->is_indefinite = true;
350 	data->last_repeat = -1;
351 	mutex_init(&data->lock);
352 	data->led_cdev = led_cdev;
353 	led_set_trigger_data(led_cdev, data);
354 	timer_setup(&data->timer, pattern_trig_timer_function, 0);
355 	led_cdev->activated = true;
356 
357 	return 0;
358 }
359 
360 static void pattern_trig_deactivate(struct led_classdev *led_cdev)
361 {
362 	struct pattern_trig_data *data = led_cdev->trigger_data;
363 
364 	if (!led_cdev->activated)
365 		return;
366 
367 	if (led_cdev->pattern_clear)
368 		led_cdev->pattern_clear(led_cdev);
369 
370 	del_timer_sync(&data->timer);
371 
372 	led_set_brightness(led_cdev, LED_OFF);
373 	kfree(data);
374 	led_cdev->activated = false;
375 }
376 
377 static struct led_trigger pattern_led_trigger = {
378 	.name = "pattern",
379 	.activate = pattern_trig_activate,
380 	.deactivate = pattern_trig_deactivate,
381 	.groups = pattern_trig_groups,
382 };
383 
384 static int __init pattern_trig_init(void)
385 {
386 	return led_trigger_register(&pattern_led_trigger);
387 }
388 
389 static void __exit pattern_trig_exit(void)
390 {
391 	led_trigger_unregister(&pattern_led_trigger);
392 }
393 
394 module_init(pattern_trig_init);
395 module_exit(pattern_trig_exit);
396 
397 MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com");
398 MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org");
399 MODULE_DESCRIPTION("LED Pattern trigger");
400 MODULE_LICENSE("GPL v2");
401