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/sysdev.h>
  21 #include <linux/timer.h>
  22 #include <linux/rwsem.h>
  23 #include <linux/leds.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_set_brightness(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
 160         rwlock_init(&trigger->leddev_list_lock);
 161         INIT_LIST_HEAD(&trigger->led_cdevs);
 162
 163         /* Add to the list of led triggers */
 164         down_write(&triggers_list_lock);
 165         list_add_tail(&trigger->next_trig, &trigger_list);
 166         up_write(&triggers_list_lock);
 167
 168         /* Register with any LEDs that have this as a default trigger */
 169         down_read(&leds_list_lock);
 170         list_for_each_entry(led_cdev, &leds_list, node) {
 171                 down_write(&led_cdev->trigger_lock);
 172                 if (!led_cdev->trigger && led_cdev->default_trigger &&
 173                             !strcmp(led_cdev->default_trigger, trigger->name))
 174                         led_trigger_set(led_cdev, trigger);
 175                 up_write(&led_cdev->trigger_lock);
 176         }
 177         up_read(&leds_list_lock);
 178
 179         return 0;
 180 }
 181 EXPORT_SYMBOL_GPL(led_trigger_register);
 182
 183 void led_trigger_unregister(struct led_trigger *trigger)
 184 {
 185         struct led_classdev *led_cdev;
 186
 187         /* Remove from the list of led triggers */
 188         down_write(&triggers_list_lock);
 189         list_del(&trigger->next_trig);
 190         up_write(&triggers_list_lock);
 191
 192         /* Remove anyone actively using this trigger */
 193         down_read(&leds_list_lock);
 194         list_for_each_entry(led_cdev, &leds_list, node) {
 195                 down_write(&led_cdev->trigger_lock);
 196                 if (led_cdev->trigger == trigger)
 197                         led_trigger_set(led_cdev, NULL);
 198                 up_write(&led_cdev->trigger_lock);
 199         }
 200         up_read(&leds_list_lock);
 201 }
 202 EXPORT_SYMBOL_GPL(led_trigger_unregister);
 203
 204 /* Simple LED Tigger Interface */
 205
 206 void led_trigger_event(struct led_trigger *trigger,
 207                         enum led_brightness brightness)
 208 {
 209         struct list_head *entry;
 210
 211         if (!trigger)
 212                 return;
 213
 214         read_lock(&trigger->leddev_list_lock);
 215         list_for_each(entry, &trigger->led_cdevs) {
 216                 struct led_classdev *led_cdev;
 217
 218                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
 219                 led_set_brightness(led_cdev, brightness);
 220         }
 221         read_unlock(&trigger->leddev_list_lock);
 222 }
 223 EXPORT_SYMBOL_GPL(led_trigger_event);
 224
 225 void led_trigger_register_simple(const char *name, struct led_trigger **tp)
 226 {
 227         struct led_trigger *trigger;
 228         int err;
 229
 230         trigger = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
 231
 232         if (trigger) {
 233                 trigger->name = name;
 234                 err = led_trigger_register(trigger);
 235                 if (err < 0)
 236                         printk(KERN_WARNING "LED trigger %s failed to register"
 237                                 " (%d)\n", name, err);
 238         } else
 239                 printk(KERN_WARNING "LED trigger %s failed to register"
 240                         " (no memory)\n", name);
 241
 242         *tp = trigger;
 243 }
 244 EXPORT_SYMBOL_GPL(led_trigger_register_simple);
 245
 246 void led_trigger_unregister_simple(struct led_trigger *trigger)
 247 {
 248         if (trigger)
 249                 led_trigger_unregister(trigger);
 250         kfree(trigger);
 251 }
 252 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
 253
 254 MODULE_AUTHOR("Richard Purdie");
 255 MODULE_LICENSE("GPL");
 256 MODULE_DESCRIPTION("LED Triggers Core");