1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * LED Triggers Core 4 * 5 * Copyright 2005-2007 Openedhand Ltd. 6 * 7 * Author: Richard Purdie <rpurdie@openedhand.com> 8 */ 9 10 #include <linux/export.h> 11 #include <linux/kernel.h> 12 #include <linux/list.h> 13 #include <linux/spinlock.h> 14 #include <linux/device.h> 15 #include <linux/timer.h> 16 #include <linux/rwsem.h> 17 #include <linux/leds.h> 18 #include <linux/slab.h> 19 #include <linux/mm.h> 20 #include "leds.h" 21 22 /* 23 * Nests outside led_cdev->trigger_lock 24 */ 25 static DECLARE_RWSEM(triggers_list_lock); 26 static LIST_HEAD(trigger_list); 27 28 /* Used by LED Class */ 29 30 static inline bool 31 trigger_relevant(struct led_classdev *led_cdev, struct led_trigger *trig) 32 { 33 return !trig->trigger_type || trig->trigger_type == led_cdev->trigger_type; 34 } 35 36 ssize_t led_trigger_write(struct file *filp, struct kobject *kobj, 37 struct bin_attribute *bin_attr, char *buf, 38 loff_t pos, size_t count) 39 { 40 struct device *dev = kobj_to_dev(kobj); 41 struct led_classdev *led_cdev = dev_get_drvdata(dev); 42 struct led_trigger *trig; 43 int ret = count; 44 45 mutex_lock(&led_cdev->led_access); 46 47 if (led_sysfs_is_disabled(led_cdev)) { 48 ret = -EBUSY; 49 goto unlock; 50 } 51 52 if (sysfs_streq(buf, "none")) { 53 led_trigger_remove(led_cdev); 54 goto unlock; 55 } 56 57 down_read(&triggers_list_lock); 58 list_for_each_entry(trig, &trigger_list, next_trig) { 59 if (sysfs_streq(buf, trig->name) && trigger_relevant(led_cdev, trig)) { 60 down_write(&led_cdev->trigger_lock); 61 led_trigger_set(led_cdev, trig); 62 up_write(&led_cdev->trigger_lock); 63 64 up_read(&triggers_list_lock); 65 goto unlock; 66 } 67 } 68 /* we come here only if buf matches no trigger */ 69 ret = -EINVAL; 70 up_read(&triggers_list_lock); 71 72 unlock: 73 mutex_unlock(&led_cdev->led_access); 74 return ret; 75 } 76 EXPORT_SYMBOL_GPL(led_trigger_write); 77 78 __printf(3, 4) 79 static int led_trigger_snprintf(char *buf, ssize_t size, const char *fmt, ...) 80 { 81 va_list args; 82 int i; 83 84 va_start(args, fmt); 85 if (size <= 0) 86 i = vsnprintf(NULL, 0, fmt, args); 87 else 88 i = vscnprintf(buf, size, fmt, args); 89 va_end(args); 90 91 return i; 92 } 93 94 static int led_trigger_format(char *buf, size_t size, 95 struct led_classdev *led_cdev) 96 { 97 struct led_trigger *trig; 98 int len = led_trigger_snprintf(buf, size, "%s", 99 led_cdev->trigger ? "none" : "[none]"); 100 101 list_for_each_entry(trig, &trigger_list, next_trig) { 102 bool hit; 103 104 if (!trigger_relevant(led_cdev, trig)) 105 continue; 106 107 hit = led_cdev->trigger && !strcmp(led_cdev->trigger->name, trig->name); 108 109 len += led_trigger_snprintf(buf + len, size - len, 110 " %s%s%s", hit ? "[" : "", 111 trig->name, hit ? "]" : ""); 112 } 113 114 len += led_trigger_snprintf(buf + len, size - len, "\n"); 115 116 return len; 117 } 118 119 /* 120 * It was stupid to create 10000 cpu triggers, but we are stuck with it now. 121 * Don't make that mistake again. We work around it here by creating binary 122 * attribute, which is not limited by length. This is _not_ good design, do not 123 * copy it. 124 */ 125 ssize_t led_trigger_read(struct file *filp, struct kobject *kobj, 126 struct bin_attribute *attr, char *buf, 127 loff_t pos, size_t count) 128 { 129 struct device *dev = kobj_to_dev(kobj); 130 struct led_classdev *led_cdev = dev_get_drvdata(dev); 131 void *data; 132 int len; 133 134 down_read(&triggers_list_lock); 135 down_read(&led_cdev->trigger_lock); 136 137 len = led_trigger_format(NULL, 0, led_cdev); 138 data = kvmalloc(len + 1, GFP_KERNEL); 139 if (!data) { 140 up_read(&led_cdev->trigger_lock); 141 up_read(&triggers_list_lock); 142 return -ENOMEM; 143 } 144 len = led_trigger_format(data, len + 1, led_cdev); 145 146 up_read(&led_cdev->trigger_lock); 147 up_read(&triggers_list_lock); 148 149 len = memory_read_from_buffer(buf, count, &pos, data, len); 150 151 kvfree(data); 152 153 return len; 154 } 155 EXPORT_SYMBOL_GPL(led_trigger_read); 156 157 /* Caller must ensure led_cdev->trigger_lock held */ 158 int led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig) 159 { 160 char *event = NULL; 161 char *envp[2]; 162 const char *name; 163 int ret; 164 165 if (!led_cdev->trigger && !trig) 166 return 0; 167 168 name = trig ? trig->name : "none"; 169 event = kasprintf(GFP_KERNEL, "TRIGGER=%s", name); 170 171 /* Remove any existing trigger */ 172 if (led_cdev->trigger) { 173 spin_lock(&led_cdev->trigger->leddev_list_lock); 174 list_del_rcu(&led_cdev->trig_list); 175 spin_unlock(&led_cdev->trigger->leddev_list_lock); 176 177 /* ensure it's no longer visible on the led_cdevs list */ 178 synchronize_rcu(); 179 180 cancel_work_sync(&led_cdev->set_brightness_work); 181 led_stop_software_blink(led_cdev); 182 device_remove_groups(led_cdev->dev, led_cdev->trigger->groups); 183 if (led_cdev->trigger->deactivate) 184 led_cdev->trigger->deactivate(led_cdev); 185 led_cdev->trigger = NULL; 186 led_cdev->trigger_data = NULL; 187 led_cdev->activated = false; 188 led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER; 189 led_set_brightness(led_cdev, LED_OFF); 190 } 191 if (trig) { 192 spin_lock(&trig->leddev_list_lock); 193 list_add_tail_rcu(&led_cdev->trig_list, &trig->led_cdevs); 194 spin_unlock(&trig->leddev_list_lock); 195 led_cdev->trigger = trig; 196 197 /* 198 * Some activate() calls use led_trigger_event() to initialize 199 * the brightness of the LED for which the trigger is being set. 200 * Ensure the led_cdev is visible on trig->led_cdevs for this. 201 */ 202 synchronize_rcu(); 203 204 /* 205 * If "set brightness to 0" is pending in workqueue, 206 * we don't want that to be reordered after ->activate() 207 */ 208 flush_work(&led_cdev->set_brightness_work); 209 210 ret = 0; 211 if (trig->activate) 212 ret = trig->activate(led_cdev); 213 else 214 led_set_brightness(led_cdev, trig->brightness); 215 if (ret) 216 goto err_activate; 217 218 ret = device_add_groups(led_cdev->dev, trig->groups); 219 if (ret) { 220 dev_err(led_cdev->dev, "Failed to add trigger attributes\n"); 221 goto err_add_groups; 222 } 223 } 224 225 if (event) { 226 envp[0] = event; 227 envp[1] = NULL; 228 if (kobject_uevent_env(&led_cdev->dev->kobj, KOBJ_CHANGE, envp)) 229 dev_err(led_cdev->dev, 230 "%s: Error sending uevent\n", __func__); 231 kfree(event); 232 } 233 234 return 0; 235 236 err_add_groups: 237 238 if (trig->deactivate) 239 trig->deactivate(led_cdev); 240 err_activate: 241 242 spin_lock(&led_cdev->trigger->leddev_list_lock); 243 list_del_rcu(&led_cdev->trig_list); 244 spin_unlock(&led_cdev->trigger->leddev_list_lock); 245 synchronize_rcu(); 246 led_cdev->trigger = NULL; 247 led_cdev->trigger_data = NULL; 248 led_set_brightness(led_cdev, LED_OFF); 249 kfree(event); 250 251 return ret; 252 } 253 EXPORT_SYMBOL_GPL(led_trigger_set); 254 255 void led_trigger_remove(struct led_classdev *led_cdev) 256 { 257 down_write(&led_cdev->trigger_lock); 258 led_trigger_set(led_cdev, NULL); 259 up_write(&led_cdev->trigger_lock); 260 } 261 EXPORT_SYMBOL_GPL(led_trigger_remove); 262 263 static bool led_match_default_trigger(struct led_classdev *led_cdev, 264 struct led_trigger *trig) 265 { 266 if (!strcmp(led_cdev->default_trigger, trig->name) && 267 trigger_relevant(led_cdev, trig)) { 268 led_cdev->flags |= LED_INIT_DEFAULT_TRIGGER; 269 led_trigger_set(led_cdev, trig); 270 return true; 271 } 272 273 return false; 274 } 275 276 void led_trigger_set_default(struct led_classdev *led_cdev) 277 { 278 struct led_trigger *trig; 279 bool found = false; 280 281 if (!led_cdev->default_trigger) 282 return; 283 284 down_read(&triggers_list_lock); 285 down_write(&led_cdev->trigger_lock); 286 list_for_each_entry(trig, &trigger_list, next_trig) { 287 found = led_match_default_trigger(led_cdev, trig); 288 if (found) 289 break; 290 } 291 up_write(&led_cdev->trigger_lock); 292 up_read(&triggers_list_lock); 293 294 /* 295 * If default trigger wasn't found, maybe trigger module isn't loaded yet. 296 * Once loaded it will re-probe with all led_cdev's. 297 */ 298 if (!found) 299 request_module_nowait("ledtrig:%s", led_cdev->default_trigger); 300 } 301 EXPORT_SYMBOL_GPL(led_trigger_set_default); 302 303 /* LED Trigger Interface */ 304 305 int led_trigger_register(struct led_trigger *trig) 306 { 307 struct led_classdev *led_cdev; 308 struct led_trigger *_trig; 309 310 spin_lock_init(&trig->leddev_list_lock); 311 INIT_LIST_HEAD(&trig->led_cdevs); 312 313 down_write(&triggers_list_lock); 314 /* Make sure the trigger's name isn't already in use */ 315 list_for_each_entry(_trig, &trigger_list, next_trig) { 316 if (!strcmp(_trig->name, trig->name) && 317 (trig->trigger_type == _trig->trigger_type || 318 !trig->trigger_type || !_trig->trigger_type)) { 319 up_write(&triggers_list_lock); 320 return -EEXIST; 321 } 322 } 323 /* Add to the list of led triggers */ 324 list_add_tail(&trig->next_trig, &trigger_list); 325 up_write(&triggers_list_lock); 326 327 /* Register with any LEDs that have this as a default trigger */ 328 down_read(&leds_list_lock); 329 list_for_each_entry(led_cdev, &leds_list, node) { 330 down_write(&led_cdev->trigger_lock); 331 if (!led_cdev->trigger && led_cdev->default_trigger) 332 led_match_default_trigger(led_cdev, trig); 333 up_write(&led_cdev->trigger_lock); 334 } 335 up_read(&leds_list_lock); 336 337 return 0; 338 } 339 EXPORT_SYMBOL_GPL(led_trigger_register); 340 341 void led_trigger_unregister(struct led_trigger *trig) 342 { 343 struct led_classdev *led_cdev; 344 345 if (list_empty_careful(&trig->next_trig)) 346 return; 347 348 /* Remove from the list of led triggers */ 349 down_write(&triggers_list_lock); 350 list_del_init(&trig->next_trig); 351 up_write(&triggers_list_lock); 352 353 /* Remove anyone actively using this trigger */ 354 down_read(&leds_list_lock); 355 list_for_each_entry(led_cdev, &leds_list, node) { 356 down_write(&led_cdev->trigger_lock); 357 if (led_cdev->trigger == trig) 358 led_trigger_set(led_cdev, NULL); 359 up_write(&led_cdev->trigger_lock); 360 } 361 up_read(&leds_list_lock); 362 } 363 EXPORT_SYMBOL_GPL(led_trigger_unregister); 364 365 static void devm_led_trigger_release(struct device *dev, void *res) 366 { 367 led_trigger_unregister(*(struct led_trigger **)res); 368 } 369 370 int devm_led_trigger_register(struct device *dev, 371 struct led_trigger *trig) 372 { 373 struct led_trigger **dr; 374 int rc; 375 376 dr = devres_alloc(devm_led_trigger_release, sizeof(*dr), 377 GFP_KERNEL); 378 if (!dr) 379 return -ENOMEM; 380 381 *dr = trig; 382 383 rc = led_trigger_register(trig); 384 if (rc) 385 devres_free(dr); 386 else 387 devres_add(dev, dr); 388 389 return rc; 390 } 391 EXPORT_SYMBOL_GPL(devm_led_trigger_register); 392 393 /* Simple LED Trigger Interface */ 394 395 void led_trigger_event(struct led_trigger *trig, 396 enum led_brightness brightness) 397 { 398 struct led_classdev *led_cdev; 399 400 if (!trig) 401 return; 402 403 trig->brightness = brightness; 404 405 rcu_read_lock(); 406 list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list) 407 led_set_brightness(led_cdev, brightness); 408 rcu_read_unlock(); 409 } 410 EXPORT_SYMBOL_GPL(led_trigger_event); 411 412 void led_mc_trigger_event(struct led_trigger *trig, 413 unsigned int *intensity_value, unsigned int num_colors, 414 enum led_brightness brightness) 415 { 416 struct led_classdev *led_cdev; 417 418 if (!trig) 419 return; 420 421 rcu_read_lock(); 422 list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list) { 423 if (!(led_cdev->flags & LED_MULTI_COLOR)) 424 continue; 425 426 led_mc_set_brightness(led_cdev, intensity_value, num_colors, brightness); 427 } 428 rcu_read_unlock(); 429 } 430 EXPORT_SYMBOL_GPL(led_mc_trigger_event); 431 432 static void led_trigger_blink_setup(struct led_trigger *trig, 433 unsigned long delay_on, 434 unsigned long delay_off, 435 int oneshot, 436 int invert) 437 { 438 struct led_classdev *led_cdev; 439 440 if (!trig) 441 return; 442 443 rcu_read_lock(); 444 list_for_each_entry_rcu(led_cdev, &trig->led_cdevs, trig_list) { 445 if (oneshot) 446 led_blink_set_oneshot(led_cdev, &delay_on, &delay_off, 447 invert); 448 else 449 led_blink_set_nosleep(led_cdev, delay_on, delay_off); 450 } 451 rcu_read_unlock(); 452 } 453 454 void led_trigger_blink(struct led_trigger *trig, 455 unsigned long delay_on, 456 unsigned long delay_off) 457 { 458 led_trigger_blink_setup(trig, delay_on, delay_off, 0, 0); 459 } 460 EXPORT_SYMBOL_GPL(led_trigger_blink); 461 462 void led_trigger_blink_oneshot(struct led_trigger *trig, 463 unsigned long delay_on, 464 unsigned long delay_off, 465 int invert) 466 { 467 led_trigger_blink_setup(trig, delay_on, delay_off, 1, invert); 468 } 469 EXPORT_SYMBOL_GPL(led_trigger_blink_oneshot); 470 471 void led_trigger_register_simple(const char *name, struct led_trigger **tp) 472 { 473 struct led_trigger *trig; 474 int err; 475 476 trig = kzalloc(sizeof(struct led_trigger), GFP_KERNEL); 477 478 if (trig) { 479 trig->name = name; 480 err = led_trigger_register(trig); 481 if (err < 0) { 482 kfree(trig); 483 trig = NULL; 484 pr_warn("LED trigger %s failed to register (%d)\n", 485 name, err); 486 } 487 } else { 488 pr_warn("LED trigger %s failed to register (no memory)\n", 489 name); 490 } 491 *tp = trig; 492 } 493 EXPORT_SYMBOL_GPL(led_trigger_register_simple); 494 495 void led_trigger_unregister_simple(struct led_trigger *trig) 496 { 497 if (trig) 498 led_trigger_unregister(trig); 499 kfree(trig); 500 } 501 EXPORT_SYMBOL_GPL(led_trigger_unregister_simple); 502