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 sysfs_emit(buf, "%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 int pattern_trig_store_patterns_string(struct pattern_trig_data *data, 224 const char *buf, size_t count) 225 { 226 int ccount, cr, offset = 0; 227 228 while (offset < count - 1 && data->npatterns < MAX_PATTERNS) { 229 cr = 0; 230 ccount = sscanf(buf + offset, "%u %u %n", 231 &data->patterns[data->npatterns].brightness, 232 &data->patterns[data->npatterns].delta_t, &cr); 233 234 if (ccount != 2 || 235 data->patterns[data->npatterns].brightness > data->led_cdev->max_brightness) { 236 data->npatterns = 0; 237 return -EINVAL; 238 } 239 240 offset += cr; 241 data->npatterns++; 242 } 243 244 return 0; 245 } 246 247 static int pattern_trig_store_patterns_int(struct pattern_trig_data *data, 248 const u32 *buf, size_t count) 249 { 250 unsigned int i; 251 252 for (i = 0; i < count; i += 2) { 253 data->patterns[data->npatterns].brightness = buf[i]; 254 data->patterns[data->npatterns].delta_t = buf[i + 1]; 255 data->npatterns++; 256 } 257 258 return 0; 259 } 260 261 static ssize_t pattern_trig_store_patterns(struct led_classdev *led_cdev, 262 const char *buf, const u32 *buf_int, 263 size_t count, bool hw_pattern) 264 { 265 struct pattern_trig_data *data = led_cdev->trigger_data; 266 int err = 0; 267 268 mutex_lock(&data->lock); 269 270 del_timer_sync(&data->timer); 271 272 if (data->is_hw_pattern) 273 led_cdev->pattern_clear(led_cdev); 274 275 data->is_hw_pattern = hw_pattern; 276 data->npatterns = 0; 277 278 if (buf) 279 err = pattern_trig_store_patterns_string(data, buf, count); 280 else 281 err = pattern_trig_store_patterns_int(data, buf_int, count); 282 if (err) 283 goto out; 284 285 err = pattern_trig_start_pattern(led_cdev); 286 if (err) 287 data->npatterns = 0; 288 289 out: 290 mutex_unlock(&data->lock); 291 return err < 0 ? err : count; 292 } 293 294 static ssize_t pattern_show(struct device *dev, struct device_attribute *attr, 295 char *buf) 296 { 297 struct led_classdev *led_cdev = dev_get_drvdata(dev); 298 struct pattern_trig_data *data = led_cdev->trigger_data; 299 300 return pattern_trig_show_patterns(data, buf, false); 301 } 302 303 static ssize_t pattern_store(struct device *dev, struct device_attribute *attr, 304 const char *buf, size_t count) 305 { 306 struct led_classdev *led_cdev = dev_get_drvdata(dev); 307 308 return pattern_trig_store_patterns(led_cdev, buf, NULL, count, false); 309 } 310 311 static DEVICE_ATTR_RW(pattern); 312 313 static ssize_t hw_pattern_show(struct device *dev, 314 struct device_attribute *attr, char *buf) 315 { 316 struct led_classdev *led_cdev = dev_get_drvdata(dev); 317 struct pattern_trig_data *data = led_cdev->trigger_data; 318 319 return pattern_trig_show_patterns(data, buf, true); 320 } 321 322 static ssize_t hw_pattern_store(struct device *dev, 323 struct device_attribute *attr, 324 const char *buf, size_t count) 325 { 326 struct led_classdev *led_cdev = dev_get_drvdata(dev); 327 328 return pattern_trig_store_patterns(led_cdev, buf, NULL, count, true); 329 } 330 331 static DEVICE_ATTR_RW(hw_pattern); 332 333 static umode_t pattern_trig_attrs_mode(struct kobject *kobj, 334 struct attribute *attr, int index) 335 { 336 struct device *dev = kobj_to_dev(kobj); 337 struct led_classdev *led_cdev = dev_get_drvdata(dev); 338 339 if (attr == &dev_attr_repeat.attr || attr == &dev_attr_pattern.attr) 340 return attr->mode; 341 else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set) 342 return attr->mode; 343 344 return 0; 345 } 346 347 static struct attribute *pattern_trig_attrs[] = { 348 &dev_attr_pattern.attr, 349 &dev_attr_hw_pattern.attr, 350 &dev_attr_repeat.attr, 351 NULL 352 }; 353 354 static const struct attribute_group pattern_trig_group = { 355 .attrs = pattern_trig_attrs, 356 .is_visible = pattern_trig_attrs_mode, 357 }; 358 359 static const struct attribute_group *pattern_trig_groups[] = { 360 &pattern_trig_group, 361 NULL, 362 }; 363 364 static void pattern_init(struct led_classdev *led_cdev) 365 { 366 unsigned int size = 0; 367 u32 *pattern; 368 int err; 369 370 pattern = led_get_default_pattern(led_cdev, &size); 371 if (!pattern) 372 return; 373 374 if (size % 2) { 375 dev_warn(led_cdev->dev, "Expected pattern of tuples\n"); 376 goto out; 377 } 378 379 err = pattern_trig_store_patterns(led_cdev, NULL, pattern, size, false); 380 if (err < 0) 381 dev_warn(led_cdev->dev, 382 "Pattern initialization failed with error %d\n", err); 383 384 out: 385 kfree(pattern); 386 } 387 388 static int pattern_trig_activate(struct led_classdev *led_cdev) 389 { 390 struct pattern_trig_data *data; 391 392 data = kzalloc(sizeof(*data), GFP_KERNEL); 393 if (!data) 394 return -ENOMEM; 395 396 if (!!led_cdev->pattern_set ^ !!led_cdev->pattern_clear) { 397 dev_warn(led_cdev->dev, 398 "Hardware pattern ops validation failed\n"); 399 led_cdev->pattern_set = NULL; 400 led_cdev->pattern_clear = NULL; 401 } 402 403 data->is_indefinite = true; 404 data->last_repeat = -1; 405 mutex_init(&data->lock); 406 data->led_cdev = led_cdev; 407 led_set_trigger_data(led_cdev, data); 408 timer_setup(&data->timer, pattern_trig_timer_function, 0); 409 led_cdev->activated = true; 410 411 if (led_cdev->flags & LED_INIT_DEFAULT_TRIGGER) { 412 pattern_init(led_cdev); 413 /* 414 * Mark as initialized even on pattern_init() error because 415 * any consecutive call to it would produce the same error. 416 */ 417 led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER; 418 } 419 420 return 0; 421 } 422 423 static void pattern_trig_deactivate(struct led_classdev *led_cdev) 424 { 425 struct pattern_trig_data *data = led_cdev->trigger_data; 426 427 if (!led_cdev->activated) 428 return; 429 430 if (led_cdev->pattern_clear) 431 led_cdev->pattern_clear(led_cdev); 432 433 timer_shutdown_sync(&data->timer); 434 435 led_set_brightness(led_cdev, LED_OFF); 436 kfree(data); 437 led_cdev->activated = false; 438 } 439 440 static struct led_trigger pattern_led_trigger = { 441 .name = "pattern", 442 .activate = pattern_trig_activate, 443 .deactivate = pattern_trig_deactivate, 444 .groups = pattern_trig_groups, 445 }; 446 447 static int __init pattern_trig_init(void) 448 { 449 return led_trigger_register(&pattern_led_trigger); 450 } 451 452 static void __exit pattern_trig_exit(void) 453 { 454 led_trigger_unregister(&pattern_led_trigger); 455 } 456 457 module_init(pattern_trig_init); 458 module_exit(pattern_trig_exit); 459 460 MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com>"); 461 MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org>"); 462 MODULE_DESCRIPTION("LED Pattern trigger"); 463 MODULE_LICENSE("GPL v2"); 464