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 #include <linux/hrtimer.h> 17 18 #define MAX_PATTERNS 1024 19 /* 20 * When doing gradual dimming, the led brightness will be updated 21 * every 50 milliseconds. 22 */ 23 #define UPDATE_INTERVAL 50 24 25 enum 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 31 struct 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 47 static 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 else 56 data->next++; 57 58 data->delta_t = 0; 59 } 60 61 static 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 of 68 * 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 else 79 return data->curr->brightness - step_brightness; 80 } 81 82 static 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 92 static void pattern_trig_timer_cancel(struct pattern_trig_data *data) 93 { 94 if (data->type == PATTERN_TYPE_HR) 95 hrtimer_cancel(&data->hrtimer); 96 else 97 del_timer_sync(&data->timer); 98 } 99 100 static 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 else 106 mod_timer(&data->timer, jiffies + msecs_to_jiffies(interval)); 107 } 108 109 static 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 current 131 * tuple's duration, we should go next one and re-check 132 * 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 151 static 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 158 static 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 170 static 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 194 static 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 210 static 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 else 237 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 245 static DEVICE_ATTR_RW(repeat); 246 247 static 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 267 out: 268 mutex_unlock(&data->lock); 269 return count; 270 } 271 272 static 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 296 static 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 310 static 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 else 330 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 338 out: 339 mutex_unlock(&data->lock); 340 return err < 0 ? err : count; 341 } 342 343 static 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 352 static 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 361 static DEVICE_ATTR_RW(pattern); 362 363 static 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 372 static 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 382 static DEVICE_ATTR_RW(hw_pattern); 383 384 static 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 393 static 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 403 static DEVICE_ATTR_RW(hr_pattern); 404 405 static 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 421 static 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 NULL 427 }; 428 429 static const struct attribute_group pattern_trig_group = { 430 .attrs = pattern_trig_attrs, 431 .is_visible = pattern_trig_attrs_mode, 432 }; 433 434 static const struct attribute_group *pattern_trig_groups[] = { 435 &pattern_trig_group, 436 NULL, 437 }; 438 439 static 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 460 out: 461 kfree(pattern); 462 } 463 464 static 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 because 494 * 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 502 static 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 520 static 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 527 static int __init pattern_trig_init(void) 528 { 529 return led_trigger_register(&pattern_led_trigger); 530 } 531 532 static void __exit pattern_trig_exit(void) 533 { 534 led_trigger_unregister(&pattern_led_trigger); 535 } 536 537 module_init(pattern_trig_init); 538 module_exit(pattern_trig_exit); 539 540 MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com>"); 541 MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org>"); 542 MODULE_DESCRIPTION("LED Pattern trigger"); 543 MODULE_LICENSE("GPL v2"); 544