544 lines · c
1// SPDX-License-Identifier: GPL-2.02 3/*4 * LED pattern trigger5 *6 * Idea discussed with Pavel Machek. Raphael Teysseyre implemented7 * 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#include <linux/hrtimer.h>17 18#define MAX_PATTERNS 102419/*20 * When doing gradual dimming, the led brightness will be updated21 * every 50 milliseconds.22 */23#define UPDATE_INTERVAL 5024 25enum pattern_type {26 PATTERN_TYPE_SW, /* Use standard timer for software pattern */27 PATTERN_TYPE_HR, /* Use hrtimer for software pattern */28 PATTERN_TYPE_HW, /* Hardware pattern */29};30 31struct pattern_trig_data {32 struct led_classdev *led_cdev;33 struct led_pattern patterns[MAX_PATTERNS];34 struct led_pattern *curr;35 struct led_pattern *next;36 struct mutex lock;37 u32 npatterns;38 int repeat;39 int last_repeat;40 int delta_t;41 bool is_indefinite;42 enum pattern_type type;43 struct timer_list timer;44 struct hrtimer hrtimer;45};46 47static void pattern_trig_update_patterns(struct pattern_trig_data *data)48{49 data->curr = data->next;50 if (!data->is_indefinite && data->curr == data->patterns)51 data->repeat--;52 53 if (data->next == data->patterns + data->npatterns - 1)54 data->next = data->patterns;55 else56 data->next++;57 58 data->delta_t = 0;59}60 61static int pattern_trig_compute_brightness(struct pattern_trig_data *data)62{63 int step_brightness;64 65 /*66 * If current tuple's duration is less than the dimming interval,67 * we should treat it as a step change of brightness instead of68 * doing gradual dimming.69 */70 if (data->delta_t == 0 || data->curr->delta_t < UPDATE_INTERVAL)71 return data->curr->brightness;72 73 step_brightness = abs(data->next->brightness - data->curr->brightness);74 step_brightness = data->delta_t * step_brightness / data->curr->delta_t;75 76 if (data->next->brightness > data->curr->brightness)77 return data->curr->brightness + step_brightness;78 else79 return data->curr->brightness - step_brightness;80}81 82static void pattern_trig_timer_start(struct pattern_trig_data *data)83{84 if (data->type == PATTERN_TYPE_HR) {85 hrtimer_start(&data->hrtimer, ns_to_ktime(0), HRTIMER_MODE_REL);86 } else {87 data->timer.expires = jiffies;88 add_timer(&data->timer);89 }90}91 92static void pattern_trig_timer_cancel(struct pattern_trig_data *data)93{94 if (data->type == PATTERN_TYPE_HR)95 hrtimer_cancel(&data->hrtimer);96 else97 del_timer_sync(&data->timer);98}99 100static void pattern_trig_timer_restart(struct pattern_trig_data *data,101 unsigned long interval)102{103 if (data->type == PATTERN_TYPE_HR)104 hrtimer_forward_now(&data->hrtimer, ms_to_ktime(interval));105 else106 mod_timer(&data->timer, jiffies + msecs_to_jiffies(interval));107}108 109static void pattern_trig_timer_common_function(struct pattern_trig_data *data)110{111 for (;;) {112 if (!data->is_indefinite && !data->repeat)113 break;114 115 if (data->curr->brightness == data->next->brightness) {116 /* Step change of brightness */117 led_set_brightness(data->led_cdev,118 data->curr->brightness);119 pattern_trig_timer_restart(data, data->curr->delta_t);120 if (!data->next->delta_t) {121 /* Skip the tuple with zero duration */122 pattern_trig_update_patterns(data);123 }124 /* Select next tuple */125 pattern_trig_update_patterns(data);126 } else {127 /* Gradual dimming */128 129 /*130 * If the accumulation time is larger than current131 * tuple's duration, we should go next one and re-check132 * if we repeated done.133 */134 if (data->delta_t > data->curr->delta_t) {135 pattern_trig_update_patterns(data);136 continue;137 }138 139 led_set_brightness(data->led_cdev,140 pattern_trig_compute_brightness(data));141 pattern_trig_timer_restart(data, UPDATE_INTERVAL);142 143 /* Accumulate the gradual dimming time */144 data->delta_t += UPDATE_INTERVAL;145 }146 147 break;148 }149}150 151static void pattern_trig_timer_function(struct timer_list *t)152{153 struct pattern_trig_data *data = from_timer(data, t, timer);154 155 return pattern_trig_timer_common_function(data);156}157 158static enum hrtimer_restart pattern_trig_hrtimer_function(struct hrtimer *t)159{160 struct pattern_trig_data *data =161 container_of(t, struct pattern_trig_data, hrtimer);162 163 pattern_trig_timer_common_function(data);164 if (!data->is_indefinite && !data->repeat)165 return HRTIMER_NORESTART;166 167 return HRTIMER_RESTART;168}169 170static int pattern_trig_start_pattern(struct led_classdev *led_cdev)171{172 struct pattern_trig_data *data = led_cdev->trigger_data;173 174 if (!data->npatterns)175 return 0;176 177 if (data->type == PATTERN_TYPE_HW) {178 return led_cdev->pattern_set(led_cdev, data->patterns,179 data->npatterns, data->repeat);180 }181 182 /* At least 2 tuples for software pattern. */183 if (data->npatterns < 2)184 return -EINVAL;185 186 data->delta_t = 0;187 data->curr = data->patterns;188 data->next = data->patterns + 1;189 pattern_trig_timer_start(data);190 191 return 0;192}193 194static ssize_t repeat_show(struct device *dev, struct device_attribute *attr,195 char *buf)196{197 struct led_classdev *led_cdev = dev_get_drvdata(dev);198 struct pattern_trig_data *data = led_cdev->trigger_data;199 int repeat;200 201 mutex_lock(&data->lock);202 203 repeat = data->last_repeat;204 205 mutex_unlock(&data->lock);206 207 return sysfs_emit(buf, "%d\n", repeat);208}209 210static ssize_t repeat_store(struct device *dev, struct device_attribute *attr,211 const char *buf, size_t count)212{213 struct led_classdev *led_cdev = dev_get_drvdata(dev);214 struct pattern_trig_data *data = led_cdev->trigger_data;215 int err, res;216 217 err = kstrtos32(buf, 10, &res);218 if (err)219 return err;220 221 /* Number 0 and negative numbers except -1 are invalid. */222 if (res < -1 || res == 0)223 return -EINVAL;224 225 mutex_lock(&data->lock);226 227 pattern_trig_timer_cancel(data);228 229 if (data->type == PATTERN_TYPE_HW)230 led_cdev->pattern_clear(led_cdev);231 232 data->last_repeat = data->repeat = res;233 /* -1 means repeat indefinitely */234 if (data->repeat == -1)235 data->is_indefinite = true;236 else237 data->is_indefinite = false;238 239 err = pattern_trig_start_pattern(led_cdev);240 241 mutex_unlock(&data->lock);242 return err < 0 ? err : count;243}244 245static DEVICE_ATTR_RW(repeat);246 247static ssize_t pattern_trig_show_patterns(struct pattern_trig_data *data,248 char *buf, enum pattern_type type)249{250 ssize_t count = 0;251 int i;252 253 mutex_lock(&data->lock);254 255 if (!data->npatterns || data->type != type)256 goto out;257 258 for (i = 0; i < data->npatterns; i++) {259 count += scnprintf(buf + count, PAGE_SIZE - count,260 "%d %u ",261 data->patterns[i].brightness,262 data->patterns[i].delta_t);263 }264 265 buf[count - 1] = '\n';266 267out:268 mutex_unlock(&data->lock);269 return count;270}271 272static int pattern_trig_store_patterns_string(struct pattern_trig_data *data,273 const char *buf, size_t count)274{275 int ccount, cr, offset = 0;276 277 while (offset < count - 1 && data->npatterns < MAX_PATTERNS) {278 cr = 0;279 ccount = sscanf(buf + offset, "%u %u %n",280 &data->patterns[data->npatterns].brightness,281 &data->patterns[data->npatterns].delta_t, &cr);282 283 if (ccount != 2 ||284 data->patterns[data->npatterns].brightness > data->led_cdev->max_brightness) {285 data->npatterns = 0;286 return -EINVAL;287 }288 289 offset += cr;290 data->npatterns++;291 }292 293 return 0;294}295 296static int pattern_trig_store_patterns_int(struct pattern_trig_data *data,297 const u32 *buf, size_t count)298{299 unsigned int i;300 301 for (i = 0; i < count; i += 2) {302 data->patterns[data->npatterns].brightness = buf[i];303 data->patterns[data->npatterns].delta_t = buf[i + 1];304 data->npatterns++;305 }306 307 return 0;308}309 310static ssize_t pattern_trig_store_patterns(struct led_classdev *led_cdev,311 const char *buf, const u32 *buf_int,312 size_t count, enum pattern_type type)313{314 struct pattern_trig_data *data = led_cdev->trigger_data;315 int err = 0;316 317 mutex_lock(&data->lock);318 319 pattern_trig_timer_cancel(data);320 321 if (data->type == PATTERN_TYPE_HW)322 led_cdev->pattern_clear(led_cdev);323 324 data->type = type;325 data->npatterns = 0;326 327 if (buf)328 err = pattern_trig_store_patterns_string(data, buf, count);329 else330 err = pattern_trig_store_patterns_int(data, buf_int, count);331 if (err)332 goto out;333 334 err = pattern_trig_start_pattern(led_cdev);335 if (err)336 data->npatterns = 0;337 338out:339 mutex_unlock(&data->lock);340 return err < 0 ? err : count;341}342 343static ssize_t pattern_show(struct device *dev, struct device_attribute *attr,344 char *buf)345{346 struct led_classdev *led_cdev = dev_get_drvdata(dev);347 struct pattern_trig_data *data = led_cdev->trigger_data;348 349 return pattern_trig_show_patterns(data, buf, PATTERN_TYPE_SW);350}351 352static ssize_t pattern_store(struct device *dev, struct device_attribute *attr,353 const char *buf, size_t count)354{355 struct led_classdev *led_cdev = dev_get_drvdata(dev);356 357 return pattern_trig_store_patterns(led_cdev, buf, NULL, count,358 PATTERN_TYPE_SW);359}360 361static DEVICE_ATTR_RW(pattern);362 363static ssize_t hw_pattern_show(struct device *dev,364 struct device_attribute *attr, char *buf)365{366 struct led_classdev *led_cdev = dev_get_drvdata(dev);367 struct pattern_trig_data *data = led_cdev->trigger_data;368 369 return pattern_trig_show_patterns(data, buf, PATTERN_TYPE_HW);370}371 372static ssize_t hw_pattern_store(struct device *dev,373 struct device_attribute *attr,374 const char *buf, size_t count)375{376 struct led_classdev *led_cdev = dev_get_drvdata(dev);377 378 return pattern_trig_store_patterns(led_cdev, buf, NULL, count,379 PATTERN_TYPE_HW);380}381 382static DEVICE_ATTR_RW(hw_pattern);383 384static ssize_t hr_pattern_show(struct device *dev,385 struct device_attribute *attr, char *buf)386{387 struct led_classdev *led_cdev = dev_get_drvdata(dev);388 struct pattern_trig_data *data = led_cdev->trigger_data;389 390 return pattern_trig_show_patterns(data, buf, PATTERN_TYPE_HR);391}392 393static ssize_t hr_pattern_store(struct device *dev,394 struct device_attribute *attr,395 const char *buf, size_t count)396{397 struct led_classdev *led_cdev = dev_get_drvdata(dev);398 399 return pattern_trig_store_patterns(led_cdev, buf, NULL, count,400 PATTERN_TYPE_HR);401}402 403static DEVICE_ATTR_RW(hr_pattern);404 405static umode_t pattern_trig_attrs_mode(struct kobject *kobj,406 struct attribute *attr, int index)407{408 struct device *dev = kobj_to_dev(kobj);409 struct led_classdev *led_cdev = dev_get_drvdata(dev);410 411 if (attr == &dev_attr_repeat.attr || attr == &dev_attr_pattern.attr)412 return attr->mode;413 else if (attr == &dev_attr_hr_pattern.attr)414 return attr->mode;415 else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set)416 return attr->mode;417 418 return 0;419}420 421static struct attribute *pattern_trig_attrs[] = {422 &dev_attr_pattern.attr,423 &dev_attr_hw_pattern.attr,424 &dev_attr_hr_pattern.attr,425 &dev_attr_repeat.attr,426 NULL427};428 429static const struct attribute_group pattern_trig_group = {430 .attrs = pattern_trig_attrs,431 .is_visible = pattern_trig_attrs_mode,432};433 434static const struct attribute_group *pattern_trig_groups[] = {435 &pattern_trig_group,436 NULL,437};438 439static void pattern_init(struct led_classdev *led_cdev)440{441 unsigned int size = 0;442 u32 *pattern;443 int err;444 445 pattern = led_get_default_pattern(led_cdev, &size);446 if (!pattern)447 return;448 449 if (size % 2) {450 dev_warn(led_cdev->dev, "Expected pattern of tuples\n");451 goto out;452 }453 454 err = pattern_trig_store_patterns(led_cdev, NULL, pattern, size,455 PATTERN_TYPE_SW);456 if (err < 0)457 dev_warn(led_cdev->dev,458 "Pattern initialization failed with error %d\n", err);459 460out:461 kfree(pattern);462}463 464static int pattern_trig_activate(struct led_classdev *led_cdev)465{466 struct pattern_trig_data *data;467 468 data = kzalloc(sizeof(*data), GFP_KERNEL);469 if (!data)470 return -ENOMEM;471 472 if (!!led_cdev->pattern_set ^ !!led_cdev->pattern_clear) {473 dev_warn(led_cdev->dev,474 "Hardware pattern ops validation failed\n");475 led_cdev->pattern_set = NULL;476 led_cdev->pattern_clear = NULL;477 }478 479 data->type = PATTERN_TYPE_SW;480 data->is_indefinite = true;481 data->last_repeat = -1;482 mutex_init(&data->lock);483 data->led_cdev = led_cdev;484 led_set_trigger_data(led_cdev, data);485 timer_setup(&data->timer, pattern_trig_timer_function, 0);486 hrtimer_init(&data->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);487 data->hrtimer.function = pattern_trig_hrtimer_function;488 led_cdev->activated = true;489 490 if (led_cdev->flags & LED_INIT_DEFAULT_TRIGGER) {491 pattern_init(led_cdev);492 /*493 * Mark as initialized even on pattern_init() error because494 * any consecutive call to it would produce the same error.495 */496 led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;497 }498 499 return 0;500}501 502static void pattern_trig_deactivate(struct led_classdev *led_cdev)503{504 struct pattern_trig_data *data = led_cdev->trigger_data;505 506 if (!led_cdev->activated)507 return;508 509 if (led_cdev->pattern_clear)510 led_cdev->pattern_clear(led_cdev);511 512 timer_shutdown_sync(&data->timer);513 hrtimer_cancel(&data->hrtimer);514 515 led_set_brightness(led_cdev, LED_OFF);516 kfree(data);517 led_cdev->activated = false;518}519 520static struct led_trigger pattern_led_trigger = {521 .name = "pattern",522 .activate = pattern_trig_activate,523 .deactivate = pattern_trig_deactivate,524 .groups = pattern_trig_groups,525};526 527static int __init pattern_trig_init(void)528{529 return led_trigger_register(&pattern_led_trigger);530}531 532static void __exit pattern_trig_exit(void)533{534 led_trigger_unregister(&pattern_led_trigger);535}536 537module_init(pattern_trig_init);538module_exit(pattern_trig_exit);539 540MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com>");541MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org>");542MODULE_DESCRIPTION("LED Pattern trigger");543MODULE_LICENSE("GPL v2");544