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                 down_write(&led_cdev->trigger_lock);
  49                 led_trigger_set(led_cdev, NULL);
  50                 up_write(&led_cdev->trigger_lock);
  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
  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
 100 void led_trigger_event(struct led_trigger *trigger,
 101                         enum led_brightness brightness)
 102 {
 103         struct list_head *entry;
 104
 105         if (!trigger)
 106                 return;
 107
 108         read_lock(&trigger->leddev_list_lock);
 109         list_for_each(entry, &trigger->led_cdevs) {
 110                 struct led_classdev *led_cdev;
 111
 112                 led_cdev = list_entry(entry, struct led_classdev, trig_list);
 113                 led_set_brightness(led_cdev, brightness);
 114         }
 115         read_unlock(&trigger->leddev_list_lock);
 116 }
 117
 118 /* Caller must ensure led_cdev->trigger_lock held */
 119 void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger)
 120 {
 121         unsigned long flags;
 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, flags);
 128                 if (led_cdev->trigger->deactivate)
 129                         led_cdev->trigger->deactivate(led_cdev);
 130                 led_set_brightness(led_cdev, LED_OFF);
 131         }
 132         if (trigger) {
 133                 write_lock_irqsave(&trigger->leddev_list_lock, flags);
 134                 list_add_tail(&led_cdev->trig_list, &trigger->led_cdevs);
 135                 write_unlock_irqrestore(&trigger->leddev_list_lock, flags);
 136                 if (trigger->activate)
 137                         trigger->activate(led_cdev);
 138         }
 139         led_cdev->trigger = trigger;
 140 }
 141
 142 void led_trigger_set_default(struct led_classdev *led_cdev)
 143 {
 144         struct led_trigger *trig;
 145
 146         if (!led_cdev->default_trigger)
 147                 return;
 148
 149         down_read(&triggers_list_lock);
 150         down_write(&led_cdev->trigger_lock);
 151         list_for_each_entry(trig, &trigger_list, next_trig) {
 152                 if (!strcmp(led_cdev->default_trigger, trig->name))
 153                         led_trigger_set(led_cdev, trig);
 154         }
 155         up_write(&led_cdev->trigger_lock);
 156         up_read(&triggers_list_lock);
 157 }
 158
 159 int led_trigger_register(struct led_trigger *trigger)
 160 {
 161         struct led_classdev *led_cdev;
 162
 163         rwlock_init(&trigger->leddev_list_lock);
 164         INIT_LIST_HEAD(&trigger->led_cdevs);
 165
 166         /* Add to the list of led triggers */
 167         down_write(&triggers_list_lock);
 168         list_add_tail(&trigger->next_trig, &trigger_list);
 169         up_write(&triggers_list_lock);
 170
 171         /* Register with any LEDs that have this as a default trigger */
 172         read_lock(&leds_list_lock);
 173         list_for_each_entry(led_cdev, &leds_list, node) {
 174                 down_write(&led_cdev->trigger_lock);
 175                 if (!led_cdev->trigger && led_cdev->default_trigger &&
 176                             !strcmp(led_cdev->default_trigger, trigger->name))
 177                         led_trigger_set(led_cdev, trigger);
 178                 up_write(&led_cdev->trigger_lock);
 179         }
 180         read_unlock(&leds_list_lock);
 181
 182         return 0;
 183 }
 184
 185 void led_trigger_register_simple(const char *name, struct led_trigger **tp)
 186 {
 187         struct led_trigger *trigger;
 188         int err;
 189
 190         trigger = kzalloc(sizeof(struct led_trigger), GFP_KERNEL);
 191
 192         if (trigger) {
 193                 trigger->name = name;
 194                 err = led_trigger_register(trigger);
 195                 if (err < 0)
 196                         printk(KERN_WARNING "LED trigger %s failed to register"
 197                                 " (%d)\n", name, err);
 198         } else
 199                 printk(KERN_WARNING "LED trigger %s failed to register"
 200                         " (no memory)\n", name);
 201
 202         *tp = trigger;
 203 }
 204
 205 void led_trigger_unregister(struct led_trigger *trigger)
 206 {
 207         struct led_classdev *led_cdev;
 208
 209         /* Remove from the list of led triggers */
 210         down_write(&triggers_list_lock);
 211         list_del(&trigger->next_trig);
 212         up_write(&triggers_list_lock);
 213
 214         /* Remove anyone actively using this trigger */
 215         read_lock(&leds_list_lock);
 216         list_for_each_entry(led_cdev, &leds_list, node) {
 217                 down_write(&led_cdev->trigger_lock);
 218                 if (led_cdev->trigger == trigger)
 219                         led_trigger_set(led_cdev, NULL);
 220                 up_write(&led_cdev->trigger_lock);
 221         }
 222         read_unlock(&leds_list_lock);
 223 }
 224
 225 void led_trigger_unregister_simple(struct led_trigger *trigger)
 226 {
 227         if (trigger)
 228                 led_trigger_unregister(trigger);
 229         kfree(trigger);
 230 }
 231
 232 /* Used by LED Class */
 233 EXPORT_SYMBOL_GPL(led_trigger_set);
 234 EXPORT_SYMBOL_GPL(led_trigger_set_default);
 235 EXPORT_SYMBOL_GPL(led_trigger_show);
 236 EXPORT_SYMBOL_GPL(led_trigger_store);
 237
 238 /* LED Trigger Interface */
 239 EXPORT_SYMBOL_GPL(led_trigger_register);
 240 EXPORT_SYMBOL_GPL(led_trigger_unregister);
 241
 242 /* Simple LED Tigger Interface */
 243 EXPORT_SYMBOL_GPL(led_trigger_register_simple);
 244 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple);
 245 EXPORT_SYMBOL_GPL(led_trigger_event);
 246
 247 MODULE_AUTHOR("Richard Purdie");
 248 MODULE_LICENSE("GPL");
 249 MODULE_DESCRIPTION("LED Triggers Core");