1 // SPDX-License-Identifier: GPL-2.0
6 * Idea discussed with Pavel Machek. Raphael Teysseyre implemented
7 * the first version, Baolin Wang simplified and improved the approach.
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>
17 #define MAX_PATTERNS 1024
19 * When doing gradual dimming, the led brightness will be updated
20 * every 50 milliseconds.
22 #define UPDATE_INTERVAL 50
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;
36 struct timer_list timer;
39 static void pattern_trig_update_patterns(struct pattern_trig_data *data)
41 data->curr = data->next;
42 if (!data->is_indefinite && data->curr == data->patterns)
45 if (data->next == data->patterns + data->npatterns - 1)
46 data->next = data->patterns;
53 static int pattern_trig_compute_brightness(struct pattern_trig_data *data)
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.
62 if (data->delta_t == 0 || data->curr->delta_t < UPDATE_INTERVAL)
63 return data->curr->brightness;
65 step_brightness = abs(data->next->brightness - data->curr->brightness);
66 step_brightness = data->delta_t * step_brightness / data->curr->delta_t;
68 if (data->next->brightness > data->curr->brightness)
69 return data->curr->brightness + step_brightness;
71 return data->curr->brightness - step_brightness;
74 static void pattern_trig_timer_function(struct timer_list *t)
76 struct pattern_trig_data *data = from_timer(data, t, timer);
79 if (!data->is_indefinite && !data->repeat)
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);
92 /* Select next tuple */
93 pattern_trig_update_patterns(data);
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.
102 if (data->delta_t > data->curr->delta_t) {
103 pattern_trig_update_patterns(data);
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));
112 /* Accumulate the gradual dimming time */
113 data->delta_t += UPDATE_INTERVAL;
120 static int pattern_trig_start_pattern(struct led_classdev *led_cdev)
122 struct pattern_trig_data *data = led_cdev->trigger_data;
124 if (!data->npatterns)
127 if (data->is_hw_pattern) {
128 return led_cdev->pattern_set(led_cdev, data->patterns,
129 data->npatterns, data->repeat);
132 /* At least 2 tuples for software pattern. */
133 if (data->npatterns < 2)
137 data->curr = data->patterns;
138 data->next = data->patterns + 1;
139 data->timer.expires = jiffies;
140 add_timer(&data->timer);
145 static ssize_t repeat_show(struct device *dev, struct device_attribute *attr,
148 struct led_classdev *led_cdev = dev_get_drvdata(dev);
149 struct pattern_trig_data *data = led_cdev->trigger_data;
152 mutex_lock(&data->lock);
154 repeat = data->last_repeat;
156 mutex_unlock(&data->lock);
158 return scnprintf(buf, PAGE_SIZE, "%d\n", repeat);
161 static ssize_t repeat_store(struct device *dev, struct device_attribute *attr,
162 const char *buf, size_t count)
164 struct led_classdev *led_cdev = dev_get_drvdata(dev);
165 struct pattern_trig_data *data = led_cdev->trigger_data;
168 err = kstrtos32(buf, 10, &res);
172 /* Number 0 and negative numbers except -1 are invalid. */
173 if (res < -1 || res == 0)
176 mutex_lock(&data->lock);
178 del_timer_sync(&data->timer);
180 if (data->is_hw_pattern)
181 led_cdev->pattern_clear(led_cdev);
183 data->last_repeat = data->repeat = res;
184 /* -1 means repeat indefinitely */
185 if (data->repeat == -1)
186 data->is_indefinite = true;
188 data->is_indefinite = false;
190 err = pattern_trig_start_pattern(led_cdev);
192 mutex_unlock(&data->lock);
193 return err < 0 ? err : count;
196 static DEVICE_ATTR_RW(repeat);
198 static ssize_t pattern_trig_show_patterns(struct pattern_trig_data *data,
199 char *buf, bool hw_pattern)
204 mutex_lock(&data->lock);
206 if (!data->npatterns || (data->is_hw_pattern ^ hw_pattern))
209 for (i = 0; i < data->npatterns; i++) {
210 count += scnprintf(buf + count, PAGE_SIZE - count,
212 data->patterns[i].brightness,
213 data->patterns[i].delta_t);
216 buf[count - 1] = '\n';
219 mutex_unlock(&data->lock);
223 static int pattern_trig_store_patterns_string(struct pattern_trig_data *data,
224 const char *buf, size_t count)
226 int ccount, cr, offset = 0;
228 while (offset < count - 1 && data->npatterns < MAX_PATTERNS) {
230 ccount = sscanf(buf + offset, "%d %u %n",
231 &data->patterns[data->npatterns].brightness,
232 &data->patterns[data->npatterns].delta_t, &cr);
245 static int pattern_trig_store_patterns_int(struct pattern_trig_data *data,
246 const u32 *buf, size_t count)
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];
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)
263 struct pattern_trig_data *data = led_cdev->trigger_data;
266 mutex_lock(&data->lock);
268 del_timer_sync(&data->timer);
270 if (data->is_hw_pattern)
271 led_cdev->pattern_clear(led_cdev);
273 data->is_hw_pattern = hw_pattern;
277 err = pattern_trig_store_patterns_string(data, buf, count);
279 err = pattern_trig_store_patterns_int(data, buf_int, count);
283 err = pattern_trig_start_pattern(led_cdev);
288 mutex_unlock(&data->lock);
289 return err < 0 ? err : count;
292 static ssize_t pattern_show(struct device *dev, struct device_attribute *attr,
295 struct led_classdev *led_cdev = dev_get_drvdata(dev);
296 struct pattern_trig_data *data = led_cdev->trigger_data;
298 return pattern_trig_show_patterns(data, buf, false);
301 static ssize_t pattern_store(struct device *dev, struct device_attribute *attr,
302 const char *buf, size_t count)
304 struct led_classdev *led_cdev = dev_get_drvdata(dev);
306 return pattern_trig_store_patterns(led_cdev, buf, NULL, count, false);
309 static DEVICE_ATTR_RW(pattern);
311 static ssize_t hw_pattern_show(struct device *dev,
312 struct device_attribute *attr, char *buf)
314 struct led_classdev *led_cdev = dev_get_drvdata(dev);
315 struct pattern_trig_data *data = led_cdev->trigger_data;
317 return pattern_trig_show_patterns(data, buf, true);
320 static ssize_t hw_pattern_store(struct device *dev,
321 struct device_attribute *attr,
322 const char *buf, size_t count)
324 struct led_classdev *led_cdev = dev_get_drvdata(dev);
326 return pattern_trig_store_patterns(led_cdev, buf, NULL, count, true);
329 static DEVICE_ATTR_RW(hw_pattern);
331 static umode_t pattern_trig_attrs_mode(struct kobject *kobj,
332 struct attribute *attr, int index)
334 struct device *dev = container_of(kobj, struct device, kobj);
335 struct led_classdev *led_cdev = dev_get_drvdata(dev);
337 if (attr == &dev_attr_repeat.attr || attr == &dev_attr_pattern.attr)
339 else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set)
345 static struct attribute *pattern_trig_attrs[] = {
346 &dev_attr_pattern.attr,
347 &dev_attr_hw_pattern.attr,
348 &dev_attr_repeat.attr,
352 static const struct attribute_group pattern_trig_group = {
353 .attrs = pattern_trig_attrs,
354 .is_visible = pattern_trig_attrs_mode,
357 static const struct attribute_group *pattern_trig_groups[] = {
362 static void pattern_init(struct led_classdev *led_cdev)
364 unsigned int size = 0;
368 pattern = led_get_default_pattern(led_cdev, &size);
373 dev_warn(led_cdev->dev, "Expected pattern of tuples\n");
377 err = pattern_trig_store_patterns(led_cdev, NULL, pattern, size, false);
379 dev_warn(led_cdev->dev,
380 "Pattern initialization failed with error %d\n", err);
386 static int pattern_trig_activate(struct led_classdev *led_cdev)
388 struct pattern_trig_data *data;
390 data = kzalloc(sizeof(*data), GFP_KERNEL);
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;
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;
409 if (led_cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
410 pattern_init(led_cdev);
412 * Mark as initialized even on pattern_init() error because
413 * any consecutive call to it would produce the same error.
415 led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;
421 static void pattern_trig_deactivate(struct led_classdev *led_cdev)
423 struct pattern_trig_data *data = led_cdev->trigger_data;
425 if (!led_cdev->activated)
428 if (led_cdev->pattern_clear)
429 led_cdev->pattern_clear(led_cdev);
431 del_timer_sync(&data->timer);
433 led_set_brightness(led_cdev, LED_OFF);
435 led_cdev->activated = false;
438 static struct led_trigger pattern_led_trigger = {
440 .activate = pattern_trig_activate,
441 .deactivate = pattern_trig_deactivate,
442 .groups = pattern_trig_groups,
445 static int __init pattern_trig_init(void)
447 return led_trigger_register(&pattern_led_trigger);
450 static void __exit pattern_trig_exit(void)
452 led_trigger_unregister(&pattern_led_trigger);
455 module_init(pattern_trig_init);
456 module_exit(pattern_trig_exit);
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");