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