Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 1 | /* |
| 2 | * LED Triggers Core |
| 3 | * |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 4 | * Copyright 2005-2007 Openedhand Ltd. |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 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 | |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 14 | #include <linux/module.h> |
| 15 | #include <linux/kernel.h> |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 16 | #include <linux/list.h> |
| 17 | #include <linux/spinlock.h> |
| 18 | #include <linux/device.h> |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 19 | #include <linux/timer.h> |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 20 | #include <linux/rwsem.h> |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 21 | #include <linux/leds.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 22 | #include <linux/slab.h> |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 23 | #include "leds.h" |
| 24 | |
| 25 | /* |
| 26 | * Nests outside led_cdev->trigger_lock |
| 27 | */ |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 28 | static DECLARE_RWSEM(triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 29 | static LIST_HEAD(trigger_list); |
| 30 | |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 31 | /* Used by LED Class */ |
| 32 | |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 33 | ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr, |
| 34 | const char *buf, size_t count) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 35 | { |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 36 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 37 | char trigger_name[TRIG_NAME_MAX]; |
| 38 | struct led_trigger *trig; |
| 39 | size_t len; |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 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 | } |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 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")) { |
Németh Márton | 0013b23 | 2008-03-09 20:54:37 +0000 | [diff] [blame] | 57 | led_trigger_remove(led_cdev); |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 58 | goto unlock; |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 59 | } |
| 60 | |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 61 | down_read(&triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 62 | list_for_each_entry(trig, &trigger_list, next_trig) { |
| 63 | if (!strcmp(trigger_name, trig->name)) { |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 64 | down_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 65 | led_trigger_set(led_cdev, trig); |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 66 | up_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 67 | |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 68 | up_read(&triggers_list_lock); |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 69 | goto unlock; |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 70 | } |
| 71 | } |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 72 | up_read(&triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 73 | |
Jacek Anaszewski | acd899e | 2014-09-22 08:21:04 -0700 | [diff] [blame] | 74 | unlock: |
| 75 | mutex_unlock(&led_cdev->led_access); |
| 76 | return ret; |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 77 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 78 | EXPORT_SYMBOL_GPL(led_trigger_store); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 79 | |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 80 | ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr, |
| 81 | char *buf) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 82 | { |
Richard Purdie | f8a7c6f | 2007-07-08 23:19:31 +0100 | [diff] [blame] | 83 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 84 | struct led_trigger *trig; |
| 85 | int len = 0; |
| 86 | |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 87 | down_read(&triggers_list_lock); |
| 88 | down_read(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 89 | |
| 90 | if (!led_cdev->trigger) |
| 91 | len += sprintf(buf+len, "[none] "); |
| 92 | else |
| 93 | len += sprintf(buf+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 += sprintf(buf+len, "[%s] ", trig->name); |
| 99 | else |
| 100 | len += sprintf(buf+len, "%s ", trig->name); |
| 101 | } |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 102 | up_read(&led_cdev->trigger_lock); |
| 103 | up_read(&triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 104 | |
| 105 | len += sprintf(len+buf, "\n"); |
| 106 | return len; |
| 107 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 108 | EXPORT_SYMBOL_GPL(led_trigger_show); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 109 | |
| 110 | /* Caller must ensure led_cdev->trigger_lock held */ |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 111 | void led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 112 | { |
| 113 | unsigned long flags; |
Colin Cross | 52c4774 | 2012-08-27 09:31:49 +0800 | [diff] [blame] | 114 | char *event = NULL; |
| 115 | char *envp[2]; |
| 116 | const char *name; |
| 117 | |
| 118 | name = trig ? trig->name : "none"; |
| 119 | event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 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); |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 125 | write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, |
| 126 | flags); |
Fabio Baltieri | d23a22a | 2012-08-15 21:44:34 +0800 | [diff] [blame] | 127 | cancel_work_sync(&led_cdev->set_brightness_work); |
| 128 | led_stop_software_blink(led_cdev); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 129 | if (led_cdev->trigger->deactivate) |
| 130 | led_cdev->trigger->deactivate(led_cdev); |
Dmitry Baryshkov | fe3025b | 2008-07-16 22:51:14 +0100 | [diff] [blame] | 131 | led_cdev->trigger = NULL; |
Shuah Khan | 19cd67e | 2012-06-14 04:34:30 +0800 | [diff] [blame] | 132 | led_set_brightness(led_cdev, LED_OFF); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 133 | } |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 134 | if (trig) { |
| 135 | write_lock_irqsave(&trig->leddev_list_lock, flags); |
| 136 | list_add_tail(&led_cdev->trig_list, &trig->led_cdevs); |
| 137 | write_unlock_irqrestore(&trig->leddev_list_lock, flags); |
| 138 | led_cdev->trigger = trig; |
| 139 | if (trig->activate) |
| 140 | trig->activate(led_cdev); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 141 | } |
Colin Cross | 52c4774 | 2012-08-27 09:31:49 +0800 | [diff] [blame] | 142 | |
| 143 | if (event) { |
| 144 | envp[0] = event; |
| 145 | envp[1] = NULL; |
| 146 | kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp); |
| 147 | kfree(event); |
| 148 | } |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 149 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 150 | EXPORT_SYMBOL_GPL(led_trigger_set); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 151 | |
Németh Márton | 0013b23 | 2008-03-09 20:54:37 +0000 | [diff] [blame] | 152 | void led_trigger_remove(struct led_classdev *led_cdev) |
| 153 | { |
| 154 | down_write(&led_cdev->trigger_lock); |
| 155 | led_trigger_set(led_cdev, NULL); |
| 156 | up_write(&led_cdev->trigger_lock); |
| 157 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 158 | EXPORT_SYMBOL_GPL(led_trigger_remove); |
Németh Márton | 0013b23 | 2008-03-09 20:54:37 +0000 | [diff] [blame] | 159 | |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 160 | void led_trigger_set_default(struct led_classdev *led_cdev) |
| 161 | { |
| 162 | struct led_trigger *trig; |
| 163 | |
| 164 | if (!led_cdev->default_trigger) |
| 165 | return; |
| 166 | |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 167 | down_read(&triggers_list_lock); |
| 168 | down_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 169 | list_for_each_entry(trig, &trigger_list, next_trig) { |
| 170 | if (!strcmp(led_cdev->default_trigger, trig->name)) |
| 171 | led_trigger_set(led_cdev, trig); |
| 172 | } |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 173 | up_write(&led_cdev->trigger_lock); |
| 174 | up_read(&triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 175 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 176 | EXPORT_SYMBOL_GPL(led_trigger_set_default); |
| 177 | |
Fabio Baltieri | a8df7b1 | 2012-11-04 01:54:34 -0800 | [diff] [blame] | 178 | void led_trigger_rename_static(const char *name, struct led_trigger *trig) |
| 179 | { |
| 180 | /* new name must be on a temporary string to prevent races */ |
| 181 | BUG_ON(name == trig->name); |
| 182 | |
| 183 | down_write(&triggers_list_lock); |
| 184 | /* this assumes that trig->name was originaly allocated to |
| 185 | * non constant storage */ |
| 186 | strcpy((char *)trig->name, name); |
| 187 | up_write(&triggers_list_lock); |
| 188 | } |
| 189 | EXPORT_SYMBOL_GPL(led_trigger_rename_static); |
| 190 | |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 191 | /* LED Trigger Interface */ |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 192 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 193 | int led_trigger_register(struct led_trigger *trig) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 194 | { |
| 195 | struct led_classdev *led_cdev; |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 196 | struct led_trigger *_trig; |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 197 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 198 | rwlock_init(&trig->leddev_list_lock); |
| 199 | INIT_LIST_HEAD(&trig->led_cdevs); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 200 | |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 201 | down_write(&triggers_list_lock); |
Adam Nielsen | 700c6ea | 2009-02-18 08:18:04 +1000 | [diff] [blame] | 202 | /* Make sure the trigger's name isn't already in use */ |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 203 | list_for_each_entry(_trig, &trigger_list, next_trig) { |
| 204 | if (!strcmp(_trig->name, trig->name)) { |
Adam Nielsen | 700c6ea | 2009-02-18 08:18:04 +1000 | [diff] [blame] | 205 | up_write(&triggers_list_lock); |
| 206 | return -EEXIST; |
| 207 | } |
| 208 | } |
| 209 | /* Add to the list of led triggers */ |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 210 | list_add_tail(&trig->next_trig, &trigger_list); |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 211 | up_write(&triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 212 | |
| 213 | /* Register with any LEDs that have this as a default trigger */ |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 214 | down_read(&leds_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 215 | list_for_each_entry(led_cdev, &leds_list, node) { |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 216 | down_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 217 | if (!led_cdev->trigger && led_cdev->default_trigger && |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 218 | !strcmp(led_cdev->default_trigger, trig->name)) |
| 219 | led_trigger_set(led_cdev, trig); |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 220 | up_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 221 | } |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 222 | up_read(&leds_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 223 | |
| 224 | return 0; |
| 225 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 226 | EXPORT_SYMBOL_GPL(led_trigger_register); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 227 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 228 | void led_trigger_unregister(struct led_trigger *trig) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 229 | { |
| 230 | struct led_classdev *led_cdev; |
| 231 | |
Sasha Levin | 14f5716 | 2014-04-04 10:01:13 -0700 | [diff] [blame] | 232 | if (list_empty_careful(&trig->next_trig)) |
| 233 | return; |
| 234 | |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 235 | /* Remove from the list of led triggers */ |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 236 | down_write(&triggers_list_lock); |
Sasha Levin | 14f5716 | 2014-04-04 10:01:13 -0700 | [diff] [blame] | 237 | list_del_init(&trig->next_trig); |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 238 | up_write(&triggers_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 239 | |
| 240 | /* Remove anyone actively using this trigger */ |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 241 | down_read(&leds_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 242 | list_for_each_entry(led_cdev, &leds_list, node) { |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 243 | down_write(&led_cdev->trigger_lock); |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 244 | if (led_cdev->trigger == trig) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 245 | led_trigger_set(led_cdev, NULL); |
Richard Purdie | dc47206 | 2007-11-10 13:29:04 +0000 | [diff] [blame] | 246 | up_write(&led_cdev->trigger_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 247 | } |
Richard Purdie | 72f8da3 | 2007-12-31 23:09:44 +0000 | [diff] [blame] | 248 | up_read(&leds_list_lock); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 249 | } |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 250 | EXPORT_SYMBOL_GPL(led_trigger_unregister); |
| 251 | |
Heiner Kallweit | 9534cc3 | 2016-01-02 01:36:41 +0100 | [diff] [blame] | 252 | static void devm_led_trigger_release(struct device *dev, void *res) |
| 253 | { |
| 254 | led_trigger_unregister(*(struct led_trigger **)res); |
| 255 | } |
| 256 | |
| 257 | int devm_led_trigger_register(struct device *dev, |
| 258 | struct led_trigger *trig) |
| 259 | { |
| 260 | struct led_trigger **dr; |
| 261 | int rc; |
| 262 | |
| 263 | dr = devres_alloc(devm_led_trigger_release, sizeof(*dr), |
| 264 | GFP_KERNEL); |
| 265 | if (!dr) |
| 266 | return -ENOMEM; |
| 267 | |
| 268 | *dr = trig; |
| 269 | |
| 270 | rc = led_trigger_register(trig); |
| 271 | if (rc) |
| 272 | devres_free(dr); |
| 273 | else |
| 274 | devres_add(dev, dr); |
| 275 | |
| 276 | return rc; |
| 277 | } |
| 278 | EXPORT_SYMBOL_GPL(devm_led_trigger_register); |
| 279 | |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 280 | /* Simple LED Tigger Interface */ |
| 281 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 282 | void led_trigger_event(struct led_trigger *trig, |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 283 | enum led_brightness brightness) |
| 284 | { |
ZHAO Gang | 11e043b | 2013-12-28 07:00:26 -0800 | [diff] [blame] | 285 | struct led_classdev *led_cdev; |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 286 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 287 | if (!trig) |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 288 | return; |
| 289 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 290 | read_lock(&trig->leddev_list_lock); |
ZHAO Gang | 11e043b | 2013-12-28 07:00:26 -0800 | [diff] [blame] | 291 | list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list) |
Fabio Baltieri | d23a22a | 2012-08-15 21:44:34 +0800 | [diff] [blame] | 292 | led_set_brightness(led_cdev, brightness); |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 293 | read_unlock(&trig->leddev_list_lock); |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 294 | } |
| 295 | EXPORT_SYMBOL_GPL(led_trigger_event); |
| 296 | |
Bryan Wu | 20c0e6b | 2012-06-15 22:15:27 +0800 | [diff] [blame] | 297 | static void led_trigger_blink_setup(struct led_trigger *trig, |
Fabio Baltieri | 5bb629c | 2012-05-27 07:19:22 +0800 | [diff] [blame] | 298 | unsigned long *delay_on, |
| 299 | unsigned long *delay_off, |
| 300 | int oneshot, |
| 301 | int invert) |
Vasily Khoruzhick | 0b9536c | 2011-01-07 16:28:16 +0000 | [diff] [blame] | 302 | { |
ZHAO Gang | 11e043b | 2013-12-28 07:00:26 -0800 | [diff] [blame] | 303 | struct led_classdev *led_cdev; |
Vasily Khoruzhick | 0b9536c | 2011-01-07 16:28:16 +0000 | [diff] [blame] | 304 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 305 | if (!trig) |
Vasily Khoruzhick | 0b9536c | 2011-01-07 16:28:16 +0000 | [diff] [blame] | 306 | return; |
| 307 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 308 | read_lock(&trig->leddev_list_lock); |
ZHAO Gang | 11e043b | 2013-12-28 07:00:26 -0800 | [diff] [blame] | 309 | list_for_each_entry(led_cdev, &trig->led_cdevs, trig_list) { |
Fabio Baltieri | 5bb629c | 2012-05-27 07:19:22 +0800 | [diff] [blame] | 310 | if (oneshot) |
| 311 | led_blink_set_oneshot(led_cdev, delay_on, delay_off, |
| 312 | invert); |
| 313 | else |
| 314 | led_blink_set(led_cdev, delay_on, delay_off); |
Vasily Khoruzhick | 0b9536c | 2011-01-07 16:28:16 +0000 | [diff] [blame] | 315 | } |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 316 | read_unlock(&trig->leddev_list_lock); |
Vasily Khoruzhick | 0b9536c | 2011-01-07 16:28:16 +0000 | [diff] [blame] | 317 | } |
Fabio Baltieri | 5bb629c | 2012-05-27 07:19:22 +0800 | [diff] [blame] | 318 | |
| 319 | void led_trigger_blink(struct led_trigger *trig, |
| 320 | unsigned long *delay_on, |
| 321 | unsigned long *delay_off) |
| 322 | { |
| 323 | led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0); |
| 324 | } |
Vasily Khoruzhick | 0b9536c | 2011-01-07 16:28:16 +0000 | [diff] [blame] | 325 | EXPORT_SYMBOL_GPL(led_trigger_blink); |
| 326 | |
Fabio Baltieri | 5bb629c | 2012-05-27 07:19:22 +0800 | [diff] [blame] | 327 | void led_trigger_blink_oneshot(struct led_trigger *trig, |
| 328 | unsigned long *delay_on, |
| 329 | unsigned long *delay_off, |
| 330 | int invert) |
| 331 | { |
| 332 | led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert); |
| 333 | } |
| 334 | EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot); |
| 335 | |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 336 | void led_trigger_register_simple(const char *name, struct led_trigger **tp) |
| 337 | { |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 338 | struct led_trigger *trig; |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 339 | int err; |
| 340 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 341 | trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL); |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 342 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 343 | if (trig) { |
| 344 | trig->name = name; |
| 345 | err = led_trigger_register(trig); |
Masakazu Mokuno | cba4c2a | 2011-10-31 17:11:59 -0700 | [diff] [blame] | 346 | if (err < 0) { |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 347 | kfree(trig); |
| 348 | trig = NULL; |
Sachin Kamat | 09f5fe7 | 2012-11-25 13:00:44 +0530 | [diff] [blame] | 349 | pr_warn("LED trigger %s failed to register (%d)\n", |
| 350 | name, err); |
Masakazu Mokuno | cba4c2a | 2011-10-31 17:11:59 -0700 | [diff] [blame] | 351 | } |
Sachin Kamat | 09f5fe7 | 2012-11-25 13:00:44 +0530 | [diff] [blame] | 352 | } else { |
| 353 | pr_warn("LED trigger %s failed to register (no memory)\n", |
| 354 | name); |
| 355 | } |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 356 | *tp = trig; |
Németh Márton | 4d404fd | 2008-03-09 20:59:57 +0000 | [diff] [blame] | 357 | } |
| 358 | EXPORT_SYMBOL_GPL(led_trigger_register_simple); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 359 | |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 360 | void led_trigger_unregister_simple(struct led_trigger *trig) |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 361 | { |
Bryan Wu | eb20262 | 2012-04-19 11:46:33 +0800 | [diff] [blame] | 362 | if (trig) |
| 363 | led_trigger_unregister(trig); |
| 364 | kfree(trig); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 365 | } |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 366 | EXPORT_SYMBOL_GPL(led_trigger_unregister_simple); |
Richard Purdie | c3bc995 | 2006-03-31 02:31:05 -0800 | [diff] [blame] | 367 | |
| 368 | MODULE_AUTHOR("Richard Purdie"); |
| 369 | MODULE_LICENSE("GPL"); |
| 370 | MODULE_DESCRIPTION("LED Triggers Core"); |