root/drivers/leds/trigger/ledtrig-pattern.c

DEFINITIONS

1. pattern_trig_update_patterns
2. pattern_trig_compute_brightness
3. pattern_trig_timer_function
4. pattern_trig_start_pattern
5. repeat_show
6. repeat_store
7. pattern_trig_show_patterns
8. pattern_trig_store_patterns_string
9. pattern_trig_store_patterns_int
10. pattern_trig_store_patterns
11. pattern_show
12. pattern_store
13. hw_pattern_show
14. hw_pattern_store
15. pattern_trig_attrs_mode
16. pattern_init
17. pattern_trig_activate
18. pattern_trig_deactivate
19. pattern_trig_init
20. pattern_trig_exit

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