drivers/leds/led-triggers.c

   1 /*
   2  * LED Triggers Core
   3  *
   4  * Copyright 2005-2007 Openedhand Ltd.
   5  *
   6  * Author: Richard Purdie <rpurdie@openedhand.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/list.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/device.h>
  19 #include <linux/timer.h>
  20 #include <linux/rwsem.h>
  21 #include <linux/leds.h>
  22 #include <linux/slab.h>
  23 #include "leds.h"
  24
  25 /*
  26  * Nests outside led_cdev->trigger_lock
  27  */
  28 static DECLARE_RWSEM(triggers_list_lock);
  29 static LIST_HEAD(trigger_list);
  30
  31  /* Used by LED Class */
  32
  33 ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
  34                 const char *buf, size_t count)
  35 {
  36         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  37         char trigger_name[TRIG_NAME_MAX];
  38         struct led_trigger *trig;
  39         size_t len;
  40         int ret = count;
  41
  42         mutex_lock(&led_cdev->led_access);
  43
  44         if (led_sysfs_is_disabled(led_cdev)) {
  45                 ret = -EBUSY;
  46                 goto unlock;
  47         }
  48
  49         trigger_name[sizeof(trigger_name) - 1] = '\0';
  50         strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
  51         len = strlen(trigger_name);
  52
  53         if (len && trigger_name[len - 1] == '\n')
  54                 trigger_name[len - 1] = '\0';
  55
  56         if (!strcmp(trigger_name, "none")) {
  57                 led_trigger_remove(led_cdev);
  58                 goto unlock;
  59         }
  60
  61         down_read(&triggers_list_lock);
  62         list_for_each_entry(trig, &trigger_list, next_trig) {
  63                 if (!strcmp(trigger_name, trig->name)) {
  64                         down_write(&led_cdev->trigger_lock);
  65                         led_trigger_set(led_cdev, trig);
  66                         up_write(&led_cdev->trigger_lock);
  67
  68                         up_read(&triggers_list_lock);
  69                         goto unlock;
  70                 }
  71         }
  72         up_read(&triggers_list_lock);
  73
  74 unlock:
  75         mutex_unlock(&led_cdev->led_access);
  76         return ret;
  77 }
  78 EXPORT_SYMBOL_GPL(led_trigger_store);
  79
  80 ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
  81                 char *buf)
  82 {
  83         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  84         struct led_trigger *trig;
  85         int len = 0;
  86
  87         down_read(&triggers_list_lock);
  88         down_read(&led_cdev->trigger_lock);
  89
  90         if (!led_cdev->trigger)
  91                 len += scnprintf(buf+len, PAGE_SIZE - len, "[none] ");
  92         else
  93                 len += scnprintf(buf+len, PAGE_SIZE - len, "none ");
  94
  95         list_for_each_entry(trig, &trigger_list, next_trig) {
  96                 if (led_cdev->trigger && !strcmp(led_cdev->trigger->name,
  97                                                         trig->name))
  98                         len += scnprintf(buf+len, PAGE_SIZE - len, "[%s] ",
  99                                          trig->name);
 100                 else
 101                         len += scnprintf(buf+len, PAGE_SIZE - len, "%s ",
 102                                          trig->name);
 103         }
 104         up_read(&led_cdev->trigger_lock);
 105         up_read(&triggers_list_lock);
 106
 107         len += scnprintf(len+buf, PAGE_SIZE - len, "\n");
 108         return len;
 109 }
 110 EXPORT_SYMBOL_GPL(led_trigger_show);
 111
 112 /* Caller must ensure led_cdev->trigger_lock held */
 113 void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig)
 114 {
 115         unsigned long flags;
 116         char *event = NULL;
 117         char *envp[2];
 118         const char *name;
 119
 120         name = trig ? trig->name : "none";
 121         event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name);
 122
 123         /* Remove any existing trigger */
 124         if (led_cdev->trigger) {
 125                 write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
 126                 list_del(&led_cdev->trig_list);
 127                 write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock,
 128                         flags);
 129                 cancel_work_sync(&led_cdev->set_brightness_work);
 130                 led_stop_software_blink(led_cdev);
 131                 if (led_cdev->trigger->deactivate)
 132                         led_cdev->trigger->deactivate(led_cdev);
 133                 led_cdev->trigger = NULL;
 134                 led_set_brightness(led_cdev, LED_OFF);
 135         }
 136         if (trig) {
 137                 write_lock_irqsave(&trig->leddev_list_lock, flags);
 138                 list_add_tail(&led_cdev->trig_list, &trig->led_cdevs);
 139                 write_unlock_irqrestore(&trig->leddev_list_lock, flags);
 140                 led_cdev->trigger = trig;
 141                 if (trig->activate)
 142                         trig->activate(led_cdev);
 143         }
 144
 145         if (event) {
 146                 envp[0] = event;
 147                 envp[1] = NULL;
 148                 kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp);
 149                 kfree(event);
 150         }
 151 }
 152 EXPORT_SYMBOL_GPL(led_trigger_set);
 153
 154 void led_trigger_remove(struct led_classdev *led_cdev)
 155 {
 156         down_write(&led_cdev->trigger_lock);
 157         led_trigger_set(led_cdev, NULL);
 158         up_write(&led_cdev->trigger_lock);
 159 }
 160 EXPORT_SYMBOL_GPL(led_trigger_remove);
 161
 162 void led_trigger_set_default(struct led_classdev *led_cdev)
 163 {
 164         struct led_trigger *trig;
 165
 166         if (!led_cdev->default_trigger)
 167                 return;
 168
 169         down_read(&triggers_list_lock);
 170         down_write(&led_cdev->trigger_lock);
 171         list_for_each_entry(trig, &trigger_list, next_trig) {
 172                 if (!strcmp(led_cdev->default_trigger, trig->name))
 173                         led_trigger_set(led_cdev, trig);
 174         }
 175         up_write(&led_cdev->trigger_lock);
 176         up_read(&triggers_list_lock);
 177 }
 178 EXPORT_SYMBOL_GPL(led_trigger_set_default);
 179
 180 void led_trigger_rename_static(const char *name, struct led_trigger *trig)
 181 {
 182         /* new name must be on a temporary string to prevent races */
 183         BUG_ON(name == trig->name);
 184
 185         down_write(&triggers_list_lock);
 186         /* this assumes that trig->name was originaly allocated to
 187          * non constant storage */
 188         strcpy((char *)trig->name, name);
 189         up_write(&triggers_list_lock);
 190 }
 191 EXPORT_SYMBOL_GPL(led_trigger_rename_static);
 192
 193 /* LED Trigger Interface */
 194
 195 int led_trigger_register(struct led_trigger *trig)
 196 {
 197         struct led_classdev *led_cdev;
 198         struct led_trigger *_trig;
 199
 200         rwlock_init(&trig->leddev_list_lock);
 201         INIT_LIST_HEAD(&trig->led_cdevs);
 202
 203         down_write(&triggers_list_lock);
 204         /* Make sure the trigger's name isn't already in use */
 205         list_for_each_entry(_trig, &trigger_list, next_trig) {
 206                 if (!strcmp(_trig->name, trig->name)) {
 207                         up_write(&triggers_list_lock);
 208                         return -EEXIST;
 209                 }
 210         }
 211         /* Add to the list of led triggers */
 212         list_add_tail(&trig->next_trig, &trigger_list);
 213         up_write(&triggers_list_lock);
 214
 215         /* Register with any LEDs that have this as a default trigger */
 216         down_read(&leds_list_lock);
 217         list_for_each_entry(led_cdev, &leds_list, node) {
 218                 down_write(&led_cdev->trigger_lock);
 219                 if (!led_cdev->trigger && led_cdev->default_trigger &&
 220                             !strcmp(led_cdev->default_trigger, trig->name))
 221                         led_trigger_set(led_cdev, trig);
 222                 up_write(&led_cdev->trigger_lock);
 223         }
 224         up_read(&leds_list_lock);
 225
 226         return 0;
 227 }
 228 EXPORT_SYMBOL_GPL(led_trigger_register);
 229
 230 void led_trigger_unregister(struct led_trigger *trig)
 231 {
 232         struct led_classdev *led_cdev;
 233
 234         if (list_empty_careful(&trig->next_trig))
 235                 return;
 236
 237         /* Remove from the list of led triggers */
 238         down_write(&triggers_list_lock);
 239         list_del_init(&trig->next_trig);
 240         up_write(&triggers_list_lock);
 241
 242         /* Remove anyone actively using this trigger */
 243         down_read(&leds_list_lock);
 244         list_for_each_entry(led_cdev, &leds_list, node) {
 245                 down_write(&led_cdev->trigger_lock);
 246                 if (led_cdev->trigger == trig)
 247                         led_trigger_set(led_cdev, NULL);
 248                 up_write(&led_cdev->trigger_lock);
 249         }
 250         up_read(&leds_list_lock);
 251 }
 252 EXPORT_SYMBOL_GPL(led_trigger_unregister);
 253
 254 /* Simple LED Tigger Interface */
 255
 256 void led_trigger_event(struct led_trigger *trig,
 257                         enum led_brightness brightness)
 258 {
 259         struct led_classdev *led_cdev;
 260
 261         if (!trig)
 262                 return;
 263
 264         read_lock(&trig->leddev_list_lock);
 265         list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list)
 266                 led_set_brightness(led_cdev, brightness);
 267         read_unlock(&trig->leddev_list_lock);
 268 }
 269 EXPORT_SYMBOL_GPL(led_trigger_event);
 270
 271 static void led_trigger_blink_setup(struct led_trigger *trig,
 272                              unsigned long *delay_on,
 273                              unsigned long *delay_off,
 274                              int oneshot,
 275                              int invert)
 276 {
 277         struct led_classdev *led_cdev;
 278
 279         if (!trig)
 280                 return;
 281
 282         read_lock(&trig->leddev_list_lock);
 283         list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list) {
 284                 if (oneshot)
 285                         led_blink_set_oneshot(led_cdev, delay_on, delay_off,
 286                                               invert);
 287                 else
 288                         led_blink_set(led_cdev, delay_on, delay_off);
 289         }
 290         read_unlock(&trig->leddev_list_lock);
 291 }
 292
 293 void led_trigger_blink(struct led_trigger *trig,
 294                        unsigned long *delay_on,
 295                        unsigned long *delay_off)
 296 {
 297         led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0);
 298 }
 299 EXPORT_SYMBOL_GPL(led_trigger_blink);
 300
 301 void led_trigger_blink_oneshot(struct led_trigger *trig,
 302                                unsigned long *delay_on,
 303                                unsigned long *delay_off,
 304                                int invert)
 305 {
 306         led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert);
 307 }
 308 EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot);
 309
 310 void led_trigger_register_simple(const char *name, struct led_trigger **tp)
 311 {
 312         struct led_trigger *trig;
 313         int err;
 314
 315         trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
 316
 317         if (trig) {
 318                 trig->name = name;
 319                 err = led_trigger_register(trig);
 320                 if (err < 0) {
 321                         kfree(trig);
 322                         trig = NULL;
 323                         pr_warn("LED trigger %s failed to register (%d)\n",
 324                                 name, err);
 325                 }
 326         } else {
 327                 pr_warn("LED trigger %s failed to register (no memory)\n",
 328                         name);
 329         }
 330         *tp = trig;
 331 }
 332 EXPORT_SYMBOL_GPL(led_trigger_register_simple);
 333
 334 void led_trigger_unregister_simple(struct led_trigger *trig)
 335 {
 336         if (trig)
 337                 led_trigger_unregister(trig);
 338         kfree(trig);
 339 }
 340 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
 341
 342 MODULE_AUTHOR("Richard Purdie");
 343 MODULE_LICENSE("GPL");
 344 MODULE_DESCRIPTION("LED Triggers Core");