SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
  33                 const char *buf, size_t count)
  34 {
  35         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  36         char trigger_name[TRIG_NAME_MAX];
  37         struct led_trigger *trig;
  38         size_t len;
  39
  40         trigger_name[sizeof(trigger_name) - 1] = '\0';
  41         strncpy(trigger_name, buf, sizeof(trigger_name) - 1);
  42         len = strlen(trigger_name);
  43
  44         if (len && trigger_name[len - 1] == '\n')
  45                 trigger_name[len - 1] = '\0';
  46
  47         if (!strcmp(trigger_name, "none")) {
  48                 led_trigger_remove(led_cdev);
  49                 return count;
  50         }
  51
  52         down_read(&triggers_list_lock);
  53         list_for_each_entry(trig, &trigger_list, next_trig) {
  54                 if (!strcmp(trigger_name, trig->name)) {
  55                         down_write(&led_cdev->trigger_lock);
  56                         led_trigger_set(led_cdev, trig);
  57                         up_write(&led_cdev->trigger_lock);
  58
  59                         up_read(&triggers_list_lock);
  60                         return count;
  61                 }
  62         }
  63         up_read(&triggers_list_lock);
  64
  65         return -EINVAL;
  66 }
  67
  68
  69 ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
  70                 char *buf)
  71 {
  72         struct led_classdev *led_cdev = dev_get_drvdata(dev);
  73         struct led_trigger *trig;
  74         int len = 0;
  75
  76         down_read(&triggers_list_lock);
  77         down_read(&led_cdev->trigger_lock);
  78
  79         if (!led_cdev->trigger)
  80                 len += sprintf(buf+len, "[none] ");
  81         else
  82                 len += sprintf(buf+len, "none ");
  83
  84         list_for_each_entry(trig, &trigger_list, next_trig) {
  85                 if (led_cdev->trigger && !strcmp(led_cdev->trigger->name,
  86                                                         trig->name))
  87                         len += sprintf(buf+len, "[%s] ", trig->name);
  88                 else
  89                         len += sprintf(buf+len, "%s ", trig->name);
  90         }
  91         up_read(&led_cdev->trigger_lock);
  92         up_read(&triggers_list_lock);
  93
  94         len += sprintf(len+buf, "\n");
  95         return len;
  96 }
  97
  98 void led_trigger_event(struct led_trigger *trigger,
  99                         enum led_brightness brightness)
 100 {
 101         struct list_head *entry;
 102
 103         if (!trigger)
 104                 return;
 105
 106         read_lock(&trigger->leddev_list_lock);
 107         list_for_each(entry, &trigger->led_cdevs) {
 108                 struct led_classdev *led_cdev;
 109
 110                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
 111                 led_set_brightness(led_cdev, brightness);
 112         }
 113         read_unlock(&trigger->leddev_list_lock);
 114 }
 115
 116 /* Caller must ensure led_cdev->trigger_lock held */
 117 void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger)
 118 {
 119         unsigned long flags;
 120
 121         /* Remove any existing trigger */
 122         if (led_cdev->trigger) {
 123                 write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
 124                 list_del(&led_cdev->trig_list);
 125                 write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, flags);
 126                 if (led_cdev->trigger->deactivate)
 127                         led_cdev->trigger->deactivate(led_cdev);
 128                 led_set_brightness(led_cdev, LED_OFF);
 129         }
 130         if (trigger) {
 131                 write_lock_irqsave(&trigger->leddev_list_lock, flags);
 132                 list_add_tail(&led_cdev->trig_list, &trigger->led_cdevs);
 133                 write_unlock_irqrestore(&trigger->leddev_list_lock, flags);
 134                 if (trigger->activate)
 135                         trigger->activate(led_cdev);
 136         }
 137         led_cdev->trigger = trigger;
 138 }
 139
 140 void led_trigger_remove(struct led_classdev *led_cdev)
 141 {
 142         down_write(&led_cdev->trigger_lock);
 143         led_trigger_set(led_cdev, NULL);
 144         up_write(&led_cdev->trigger_lock);
 145 }
 146
 147 void led_trigger_set_default(struct led_classdev *led_cdev)
 148 {
 149         struct led_trigger *trig;
 150
 151         if (!led_cdev->default_trigger)
 152                 return;
 153
 154         down_read(&triggers_list_lock);
 155         down_write(&led_cdev->trigger_lock);
 156         list_for_each_entry(trig, &trigger_list, next_trig) {
 157                 if (!strcmp(led_cdev->default_trigger, trig->name))
 158                         led_trigger_set(led_cdev, trig);
 159         }
 160         up_write(&led_cdev->trigger_lock);
 161         up_read(&triggers_list_lock);
 162 }
 163
 164 int led_trigger_register(struct led_trigger *trigger)
 165 {
 166         struct led_classdev *led_cdev;
 167
 168         rwlock_init(&trigger->leddev_list_lock);
 169         INIT_LIST_HEAD(&trigger->led_cdevs);
 170
 171         /* Add to the list of led triggers */
 172         down_write(&triggers_list_lock);
 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
 190 void led_trigger_register_simple(const char *name, struct led_trigger **tp)
 191 {
 192         struct led_trigger *trigger;
 193         int err;
 194
 195         trigger = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
 196
 197         if (trigger) {
 198                 trigger->name = name;
 199                 err = led_trigger_register(trigger);
 200                 if (err < 0)
 201                         printk(KERN_WARNING "LED trigger %s failed to register"
 202                                 " (%d)\n", name, err);
 203         } else
 204                 printk(KERN_WARNING "LED trigger %s failed to register"
 205                         " (no memory)\n", name);
 206
 207         *tp = trigger;
 208 }
 209
 210 void led_trigger_unregister(struct led_trigger *trigger)
 211 {
 212         struct led_classdev *led_cdev;
 213
 214         /* Remove from the list of led triggers */
 215         down_write(&triggers_list_lock);
 216         list_del(&trigger->next_trig);
 217         up_write(&triggers_list_lock);
 218
 219         /* Remove anyone actively using this trigger */
 220         down_read(&leds_list_lock);
 221         list_for_each_entry(led_cdev, &leds_list, node) {
 222                 down_write(&led_cdev->trigger_lock);
 223                 if (led_cdev->trigger == trigger)
 224                         led_trigger_set(led_cdev, NULL);
 225                 up_write(&led_cdev->trigger_lock);
 226         }
 227         up_read(&leds_list_lock);
 228 }
 229
 230 void led_trigger_unregister_simple(struct led_trigger *trigger)
 231 {
 232         if (trigger)
 233                 led_trigger_unregister(trigger);
 234         kfree(trigger);
 235 }
 236
 237 /* Used by LED Class */
 238 EXPORT_SYMBOL_GPL(led_trigger_set);
 239 EXPORT_SYMBOL_GPL(led_trigger_remove);
 240 EXPORT_SYMBOL_GPL(led_trigger_set_default);
 241 EXPORT_SYMBOL_GPL(led_trigger_show);
 242 EXPORT_SYMBOL_GPL(led_trigger_store);
 243
 244 /* LED Trigger Interface */
 245 EXPORT_SYMBOL_GPL(led_trigger_register);
 246 EXPORT_SYMBOL_GPL(led_trigger_unregister);
 247
 248 /* Simple LED Tigger Interface */
 249 EXPORT_SYMBOL_GPL(led_trigger_register_simple);
 250 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
 251 EXPORT_SYMBOL_GPL(led_trigger_event);
 252
 253 MODULE_AUTHOR("Richard Purdie");
 254 MODULE_LICENSE("GPL");
 255 MODULE_DESCRIPTION("LED Triggers Core");