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 mutex_lock(&data->lock); 79 80 for (;;) { 81 if (!data->is_indefinite && !data->repeat) 82 break; 83 84 if (data->curr->brightness == data->next->brightness) { 85 /* Step change of brightness */ 86 led_set_brightness(data->led_cdev, 87 data->curr->brightness); 88 mod_timer(&data->timer, 89 jiffies + msecs_to_jiffies(data->curr->delta_t)); 90 91 /* Skip the tuple with zero duration */ 92 pattern_trig_update_patterns(data); 93 /* Select next tuple */ 94 pattern_trig_update_patterns(data); 95 } else { 96 /* Gradual dimming */ 97 98 /* 99 * If the accumulation time is larger than current 100 * tuple's duration, we should go next one and re-check 101 * if we repeated done. 102 */ 103 if (data->delta_t > data->curr->delta_t) { 104 pattern_trig_update_patterns(data); 105 continue; 106 } 107 108 led_set_brightness(data->led_cdev, 109 pattern_trig_compute_brightness(data)); 110 mod_timer(&data->timer, 111 jiffies + msecs_to_jiffies(UPDATE_INTERVAL)); 112 113 /* Accumulate the gradual dimming time */ 114 data->delta_t += UPDATE_INTERVAL; 115 } 116 117 break; 118 } 119 120 mutex_unlock(&data->lock); 121 } 122 123 static int pattern_trig_start_pattern(struct led_classdev *led_cdev) 124 { 125 struct pattern_trig_data *data = led_cdev->trigger_data; 126 127 if (!data->npatterns) 128 return 0; 129 130 if (data->is_hw_pattern) { 131 return led_cdev->pattern_set(led_cdev, data->patterns, 132 data->npatterns, data->repeat); 133 } 134 135 /* At least 2 tuples for software pattern. */ 136 if (data->npatterns < 2) 137 return -EINVAL; 138 139 data->delta_t = 0; 140 data->curr = data->patterns; 141 data->next = data->patterns + 1; 142 data->timer.expires = jiffies; 143 add_timer(&data->timer); 144 145 return 0; 146 } 147 148 static ssize_t repeat_show(struct device *dev, struct device_attribute *attr, 149 char *buf) 150 { 151 struct led_classdev *led_cdev = dev_get_drvdata(dev); 152 struct pattern_trig_data *data = led_cdev->trigger_data; 153 int repeat; 154 155 mutex_lock(&data->lock); 156 157 repeat = data->last_repeat; 158 159 mutex_unlock(&data->lock); 160 161 return scnprintf(buf, PAGE_SIZE, "%d\n", repeat); 162 } 163 164 static ssize_t repeat_store(struct device *dev, struct device_attribute *attr, 165 const char *buf, size_t count) 166 { 167 struct led_classdev *led_cdev = dev_get_drvdata(dev); 168 struct pattern_trig_data *data = led_cdev->trigger_data; 169 int err, res; 170 171 err = kstrtos32(buf, 10, &res); 172 if (err) 173 return err; 174 175 /* Number 0 and negative numbers except -1 are invalid. */ 176 if (res < -1 || res == 0) 177 return -EINVAL; 178 179 /* 180 * Clear previous patterns' performence firstly, and remove the timer 181 * without mutex lock to avoid dead lock. 182 */ 183 del_timer_sync(&data->timer); 184 185 mutex_lock(&data->lock); 186 187 if (data->is_hw_pattern) 188 led_cdev->pattern_clear(led_cdev); 189 190 data->last_repeat = data->repeat = res; 191 /* -1 means repeat indefinitely */ 192 if (data->repeat == -1) 193 data->is_indefinite = true; 194 else 195 data->is_indefinite = false; 196 197 err = pattern_trig_start_pattern(led_cdev); 198 199 mutex_unlock(&data->lock); 200 return err < 0 ? err : count; 201 } 202 203 static DEVICE_ATTR_RW(repeat); 204 205 static ssize_t pattern_trig_show_patterns(struct pattern_trig_data *data, 206 char *buf, bool hw_pattern) 207 { 208 ssize_t count = 0; 209 int i; 210 211 mutex_lock(&data->lock); 212 213 if (!data->npatterns || (data->is_hw_pattern ^ hw_pattern)) 214 goto out; 215 216 for (i = 0; i < data->npatterns; i++) { 217 count += scnprintf(buf + count, PAGE_SIZE - count, 218 "%d %u ", 219 data->patterns[i].brightness, 220 data->patterns[i].delta_t); 221 } 222 223 buf[count - 1] = '\n'; 224 225 out: 226 mutex_unlock(&data->lock); 227 return count; 228 } 229 230 static ssize_t pattern_trig_store_patterns(struct led_classdev *led_cdev, 231 const char *buf, size_t count, 232 bool hw_pattern) 233 { 234 struct pattern_trig_data *data = led_cdev->trigger_data; 235 int ccount, cr, offset = 0, err = 0; 236 237 /* 238 * Clear previous patterns' performence firstly, and remove the timer 239 * without mutex lock to avoid dead lock. 240 */ 241 del_timer_sync(&data->timer); 242 243 mutex_lock(&data->lock); 244 245 if (data->is_hw_pattern) 246 led_cdev->pattern_clear(led_cdev); 247 248 data->is_hw_pattern = hw_pattern; 249 data->npatterns = 0; 250 251 while (offset < count - 1 && data->npatterns < MAX_PATTERNS) { 252 cr = 0; 253 ccount = sscanf(buf + offset, "%d %u %n", 254 &data->patterns[data->npatterns].brightness, 255 &data->patterns[data->npatterns].delta_t, &cr); 256 if (ccount != 2) { 257 data->npatterns = 0; 258 err = -EINVAL; 259 goto out; 260 } 261 262 offset += cr; 263 data->npatterns++; 264 } 265 266 err = pattern_trig_start_pattern(led_cdev); 267 if (err) 268 data->npatterns = 0; 269 270 out: 271 mutex_unlock(&data->lock); 272 return err < 0 ? err : count; 273 } 274 275 static ssize_t pattern_show(struct device *dev, struct device_attribute *attr, 276 char *buf) 277 { 278 struct led_classdev *led_cdev = dev_get_drvdata(dev); 279 struct pattern_trig_data *data = led_cdev->trigger_data; 280 281 return pattern_trig_show_patterns(data, buf, false); 282 } 283 284 static ssize_t pattern_store(struct device *dev, struct device_attribute *attr, 285 const char *buf, size_t count) 286 { 287 struct led_classdev *led_cdev = dev_get_drvdata(dev); 288 289 return pattern_trig_store_patterns(led_cdev, buf, count, false); 290 } 291 292 static DEVICE_ATTR_RW(pattern); 293 294 static ssize_t hw_pattern_show(struct device *dev, 295 struct device_attribute *attr, 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, true); 301 } 302 303 static ssize_t hw_pattern_store(struct device *dev, 304 struct device_attribute *attr, 305 const char *buf, size_t count) 306 { 307 struct led_classdev *led_cdev = dev_get_drvdata(dev); 308 309 return pattern_trig_store_patterns(led_cdev, buf, count, true); 310 } 311 312 static DEVICE_ATTR_RW(hw_pattern); 313 314 static umode_t pattern_trig_attrs_mode(struct kobject *kobj, 315 struct attribute *attr, int index) 316 { 317 struct device *dev = container_of(kobj, struct device, kobj); 318 struct led_classdev *led_cdev = dev_get_drvdata(dev); 319 320 if (attr == &dev_attr_repeat.attr || attr == &dev_attr_pattern.attr) 321 return attr->mode; 322 else if (attr == &dev_attr_hw_pattern.attr && led_cdev->pattern_set) 323 return attr->mode; 324 325 return 0; 326 } 327 328 static struct attribute *pattern_trig_attrs[] = { 329 &dev_attr_pattern.attr, 330 &dev_attr_hw_pattern.attr, 331 &dev_attr_repeat.attr, 332 NULL 333 }; 334 335 static const struct attribute_group pattern_trig_group = { 336 .attrs = pattern_trig_attrs, 337 .is_visible = pattern_trig_attrs_mode, 338 }; 339 340 static const struct attribute_group *pattern_trig_groups[] = { 341 &pattern_trig_group, 342 NULL, 343 }; 344 345 static int pattern_trig_activate(struct led_classdev *led_cdev) 346 { 347 struct pattern_trig_data *data; 348 349 data = kzalloc(sizeof(*data), GFP_KERNEL); 350 if (!data) 351 return -ENOMEM; 352 353 if (!!led_cdev->pattern_set ^ !!led_cdev->pattern_clear) { 354 dev_warn(led_cdev->dev, 355 "Hardware pattern ops validation failed\n"); 356 led_cdev->pattern_set = NULL; 357 led_cdev->pattern_clear = NULL; 358 } 359 360 data->is_indefinite = true; 361 data->last_repeat = -1; 362 mutex_init(&data->lock); 363 data->led_cdev = led_cdev; 364 led_set_trigger_data(led_cdev, data); 365 timer_setup(&data->timer, pattern_trig_timer_function, 0); 366 led_cdev->activated = true; 367 368 return 0; 369 } 370 371 static void pattern_trig_deactivate(struct led_classdev *led_cdev) 372 { 373 struct pattern_trig_data *data = led_cdev->trigger_data; 374 375 if (!led_cdev->activated) 376 return; 377 378 if (led_cdev->pattern_clear) 379 led_cdev->pattern_clear(led_cdev); 380 381 del_timer_sync(&data->timer); 382 383 led_set_brightness(led_cdev, LED_OFF); 384 kfree(data); 385 led_cdev->activated = false; 386 } 387 388 static struct led_trigger pattern_led_trigger = { 389 .name = "pattern", 390 .activate = pattern_trig_activate, 391 .deactivate = pattern_trig_deactivate, 392 .groups = pattern_trig_groups, 393 }; 394 395 static int __init pattern_trig_init(void) 396 { 397 return led_trigger_register(&pattern_led_trigger); 398 } 399 400 static void __exit pattern_trig_exit(void) 401 { 402 led_trigger_unregister(&pattern_led_trigger); 403 } 404 405 module_init(pattern_trig_init); 406 module_exit(pattern_trig_exit); 407 408 MODULE_AUTHOR("Raphael Teysseyre <rteysseyre@gmail.com"); 409 MODULE_AUTHOR("Baolin Wang <baolin.wang@linaro.org"); 410 MODULE_DESCRIPTION("LED Pattern trigger"); 411 MODULE_LICENSE("GPL v2"); 412