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/init.h>
  17 #include <linux/list.h>
  18 #include <linux/spinlock.h>
  19 #include <linux/device.h>
  20 #include <linux/timer.h>
  21 #include <linux/rwsem.h>
  22 #include <linux/leds.h>
  23 #include <linux/slab.h>
  24 #include "leds.h"
  25
  26 /*
  27  * Nests outside led_cdev->trigger_lock
  28  */
  29 static DECLARE_RWSEM(triggers_list_lock);
  30 static LIST_HEAD(trigger_list);
  31
  32  /* Used by LED Class */
  33
  34 ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
  35                 const char *buf, size_t count)
  36 {
  37         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  38         char trigger_name[TRIG_NAME_MAX];
  39         struct led_trigger *trig;
  40         size_t len;
  41
  42         trigger_name[sizeof(trigger_name) - 1] = '\0';
  43         strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
  44         len = strlen(trigger_name);
  45
  46         if (len && trigger_name[len - 1] == '\n')
  47                 trigger_name[len - 1] = '\0';
  48
  49         if (!strcmp(trigger_name, "none")) {
  50                 led_trigger_remove(led_cdev);
  51                 return count;
  52         }
  53
  54         down_read(&triggers_list_lock);
  55         list_for_each_entry(trig, &trigger_list, next_trig) {
  56                 if (!strcmp(trigger_name, trig->name)) {
  57                         down_write(&led_cdev->trigger_lock);
  58                         led_trigger_set(led_cdev, trig);
  59                         up_write(&led_cdev->trigger_lock);
  60
  61                         up_read(&triggers_list_lock);
  62                         return count;
  63                 }
  64         }
  65         up_read(&triggers_list_lock);
  66
  67         return -EINVAL;
  68 }
  69 EXPORT_SYMBOL_GPL(led_trigger_store);
  70
  71 ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
  72                 char *buf)
  73 {
  74         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  75         struct led_trigger *trig;
  76         int len = 0;
  77
  78         down_read(&triggers_list_lock);
  79         down_read(&led_cdev->trigger_lock);
  80
  81         if (!led_cdev->trigger)
  82                 len += sprintf(buf+len, "[none] ");
  83         else
  84                 len += sprintf(buf+len, "none ");
  85
  86         list_for_each_entry(trig, &trigger_list, next_trig) {
  87                 if (led_cdev->trigger && !strcmp(led_cdev->trigger->name,
  88                                                         trig->name))
  89                         len += sprintf(buf+len, "[%s] ", trig->name);
  90                 else
  91                         len += sprintf(buf+len, "%s ", trig->name);
  92         }
  93         up_read(&led_cdev->trigger_lock);
  94         up_read(&triggers_list_lock);
  95
  96         len += sprintf(len+buf, "\n");
  97         return len;
  98 }
  99 EXPORT_SYMBOL_GPL(led_trigger_show);
 100
 101 /* Caller must ensure led_cdev->trigger_lock held */
 102 void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger)
 103 {
 104         unsigned long flags;
 105
 106         /* Remove any existing trigger */
 107         if (led_cdev->trigger) {
 108                 write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
 109                 list_del(&led_cdev->trig_list);
 110                 write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock,
 111                         flags);
 112                 if (led_cdev->trigger->deactivate)
 113                         led_cdev->trigger->deactivate(led_cdev);
 114                 led_cdev->trigger = NULL;
 115                 led_brightness_set(led_cdev, LED_OFF);
 116         }
 117         if (trigger) {
 118                 write_lock_irqsave(&trigger->leddev_list_lock, flags);
 119                 list_add_tail(&led_cdev->trig_list, &trigger->led_cdevs);
 120                 write_unlock_irqrestore(&trigger->leddev_list_lock, flags);
 121                 led_cdev->trigger = trigger;
 122                 if (trigger->activate)
 123                         trigger->activate(led_cdev);
 124         }
 125 }
 126 EXPORT_SYMBOL_GPL(led_trigger_set);
 127
 128 void led_trigger_remove(struct led_classdev *led_cdev)
 129 {
 130         down_write(&led_cdev->trigger_lock);
 131         led_trigger_set(led_cdev, NULL);
 132         up_write(&led_cdev->trigger_lock);
 133 }
 134 EXPORT_SYMBOL_GPL(led_trigger_remove);
 135
 136 void led_trigger_set_default(struct led_classdev *led_cdev)
 137 {
 138         struct led_trigger *trig;
 139
 140         if (!led_cdev->default_trigger)
 141                 return;
 142
 143         down_read(&triggers_list_lock);
 144         down_write(&led_cdev->trigger_lock);
 145         list_for_each_entry(trig, &trigger_list, next_trig) {
 146                 if (!strcmp(led_cdev->default_trigger, trig->name))
 147                         led_trigger_set(led_cdev, trig);
 148         }
 149         up_write(&led_cdev->trigger_lock);
 150         up_read(&triggers_list_lock);
 151 }
 152 EXPORT_SYMBOL_GPL(led_trigger_set_default);
 153
 154 /* LED Trigger Interface */
 155
 156 int led_trigger_register(struct led_trigger *trigger)
 157 {
 158         struct led_classdev *led_cdev;
 159         struct led_trigger *trig;
 160
 161         rwlock_init(&trigger->leddev_list_lock);
 162         INIT_LIST_HEAD(&trigger->led_cdevs);
 163
 164         down_write(&triggers_list_lock);
 165         /* Make sure the trigger's name isn't already in use */
 166         list_for_each_entry(trig, &trigger_list, next_trig) {
 167                 if (!strcmp(trig->name, trigger->name)) {
 168                         up_write(&triggers_list_lock);
 169                         return -EEXIST;
 170                 }
 171         }
 172         /* Add to the list of led triggers */
 173         list_add_tail(&trigger->next_trig, &trigger_list);
 174         up_write(&triggers_list_lock);
 175
 176         /* Register with any LEDs that have this as a default trigger */
 177         down_read(&leds_list_lock);
 178         list_for_each_entry(led_cdev, &leds_list, node) {
 179                 down_write(&led_cdev->trigger_lock);
 180                 if (!led_cdev->trigger && led_cdev->default_trigger &&
 181                             !strcmp(led_cdev->default_trigger, trigger->name))
 182                         led_trigger_set(led_cdev, trigger);
 183                 up_write(&led_cdev->trigger_lock);
 184         }
 185         up_read(&leds_list_lock);
 186
 187         return 0;
 188 }
 189 EXPORT_SYMBOL_GPL(led_trigger_register);
 190
 191 void led_trigger_unregister(struct led_trigger *trigger)
 192 {
 193         struct led_classdev *led_cdev;
 194
 195         /* Remove from the list of led triggers */
 196         down_write(&triggers_list_lock);
 197         list_del(&trigger->next_trig);
 198         up_write(&triggers_list_lock);
 199
 200         /* Remove anyone actively using this trigger */
 201         down_read(&leds_list_lock);
 202         list_for_each_entry(led_cdev, &leds_list, node) {
 203                 down_write(&led_cdev->trigger_lock);
 204                 if (led_cdev->trigger == trigger)
 205                         led_trigger_set(led_cdev, NULL);
 206                 up_write(&led_cdev->trigger_lock);
 207         }
 208         up_read(&leds_list_lock);
 209 }
 210 EXPORT_SYMBOL_GPL(led_trigger_unregister);
 211
 212 /* Simple LED Tigger Interface */
 213
 214 void led_trigger_event(struct led_trigger *trigger,
 215                         enum led_brightness brightness)
 216 {
 217         struct list_head *entry;
 218
 219         if (!trigger)
 220                 return;
 221
 222         read_lock(&trigger->leddev_list_lock);
 223         list_for_each(entry, &trigger->led_cdevs) {
 224                 struct led_classdev *led_cdev;
 225
 226                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
 227                 led_set_brightness(led_cdev, brightness);
 228         }
 229         read_unlock(&trigger->leddev_list_lock);
 230 }
 231 EXPORT_SYMBOL_GPL(led_trigger_event);
 232
 233 void led_trigger_blink(struct led_trigger *trigger,
 234                        unsigned long *delay_on,
 235                        unsigned long *delay_off)
 236 {
 237         struct list_head *entry;
 238
 239         if (!trigger)
 240                 return;
 241
 242         read_lock(&trigger->leddev_list_lock);
 243         list_for_each(entry, &trigger->led_cdevs) {
 244                 struct led_classdev *led_cdev;
 245
 246                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
 247                 led_blink_set(led_cdev, delay_on, delay_off);
 248         }
 249         read_unlock(&trigger->leddev_list_lock);
 250 }
 251 EXPORT_SYMBOL_GPL(led_trigger_blink);
 252
 253 void led_trigger_register_simple(const char *name, struct led_trigger **tp)
 254 {
 255         struct led_trigger *trigger;
 256         int err;
 257
 258         trigger = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
 259
 260         if (trigger) {
 261                 trigger->name = name;
 262                 err = led_trigger_register(trigger);
 263                 if (err < 0) {
 264                         kfree(trigger);
 265                         trigger = NULL;
 266                         printk(KERN_WARNING "LED trigger %s failed to register"
 267                                 " (%d)\n", name, err);
 268                 }
 269         } else
 270                 printk(KERN_WARNING "LED trigger %s failed to register"
 271                         " (no memory)\n", name);
 272
 273         *tp = trigger;
 274 }
 275 EXPORT_SYMBOL_GPL(led_trigger_register_simple);
 276
 277 void led_trigger_unregister_simple(struct led_trigger *trigger)
 278 {
 279         if (trigger)
 280                 led_trigger_unregister(trigger);
 281         kfree(trigger);
 282 }
 283 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
 284
 285 MODULE_AUTHOR("Richard Purdie");
 286 MODULE_LICENSE("GPL");
 287 MODULE_DESCRIPTION("LED Triggers Core");