1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * LED Class Core 4 * 5 * Copyright 2005-2006 Openedhand Ltd. 6 * 7 * Author: Richard Purdie <rpurdie@openedhand.com> 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/led-class-multicolor.h> 12 #include <linux/leds.h> 13 #include <linux/list.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/of.h> 17 #include <linux/property.h> 18 #include <linux/rwsem.h> 19 #include <linux/slab.h> 20 #include <uapi/linux/uleds.h> 21 #include "leds.h" 22 23 DECLARE_RWSEM(leds_list_lock); 24 EXPORT_SYMBOL_GPL(leds_list_lock); 25 26 LIST_HEAD(leds_list); 27 EXPORT_SYMBOL_GPL(leds_list); 28 29 static const char * const led_colors[LED_COLOR_ID_MAX] = { 30 [LED_COLOR_ID_WHITE] = "white", 31 [LED_COLOR_ID_RED] = "red", 32 [LED_COLOR_ID_GREEN] = "green", 33 [LED_COLOR_ID_BLUE] = "blue", 34 [LED_COLOR_ID_AMBER] = "amber", 35 [LED_COLOR_ID_VIOLET] = "violet", 36 [LED_COLOR_ID_YELLOW] = "yellow", 37 [LED_COLOR_ID_IR] = "ir", 38 [LED_COLOR_ID_MULTI] = "multicolor", 39 [LED_COLOR_ID_RGB] = "rgb", 40 [LED_COLOR_ID_PURPLE] = "purple", 41 [LED_COLOR_ID_ORANGE] = "orange", 42 [LED_COLOR_ID_PINK] = "pink", 43 [LED_COLOR_ID_CYAN] = "cyan", 44 [LED_COLOR_ID_LIME] = "lime", 45 }; 46 47 static int __led_set_brightness(struct led_classdev *led_cdev, unsigned int value) 48 { 49 if (!led_cdev->brightness_set) 50 return -ENOTSUPP; 51 52 led_cdev->brightness_set(led_cdev, value); 53 54 return 0; 55 } 56 57 static int __led_set_brightness_blocking(struct led_classdev *led_cdev, unsigned int value) 58 { 59 if (!led_cdev->brightness_set_blocking) 60 return -ENOTSUPP; 61 62 return led_cdev->brightness_set_blocking(led_cdev, value); 63 } 64 65 static void led_timer_function(struct timer_list *t) 66 { 67 struct led_classdev *led_cdev = timer_container_of(led_cdev, t, 68 blink_timer); 69 unsigned long brightness; 70 unsigned long delay; 71 72 if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) { 73 led_set_brightness_nosleep(led_cdev, LED_OFF); 74 clear_bit(LED_BLINK_SW, &led_cdev->work_flags); 75 return; 76 } 77 78 if (test_and_clear_bit(LED_BLINK_ONESHOT_STOP, 79 &led_cdev->work_flags)) { 80 clear_bit(LED_BLINK_SW, &led_cdev->work_flags); 81 return; 82 } 83 84 brightness = led_get_brightness(led_cdev); 85 if (!brightness) { 86 /* Time to switch the LED on. */ 87 if (test_and_clear_bit(LED_BLINK_BRIGHTNESS_CHANGE, 88 &led_cdev->work_flags)) 89 brightness = led_cdev->new_blink_brightness; 90 else 91 brightness = led_cdev->blink_brightness; 92 delay = led_cdev->blink_delay_on; 93 } else { 94 /* Store the current brightness value to be able 95 * to restore it when the delay_off period is over. 96 */ 97 led_cdev->blink_brightness = brightness; 98 brightness = LED_OFF; 99 delay = led_cdev->blink_delay_off; 100 } 101 102 led_set_brightness_nosleep(led_cdev, brightness); 103 104 /* Return in next iteration if led is in one-shot mode and we are in 105 * the final blink state so that the led is toggled each delay_on + 106 * delay_off milliseconds in worst case. 107 */ 108 if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags)) { 109 if (test_bit(LED_BLINK_INVERT, &led_cdev->work_flags)) { 110 if (brightness) 111 set_bit(LED_BLINK_ONESHOT_STOP, 112 &led_cdev->work_flags); 113 } else { 114 if (!brightness) 115 set_bit(LED_BLINK_ONESHOT_STOP, 116 &led_cdev->work_flags); 117 } 118 } 119 120 mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay)); 121 } 122 123 static void set_brightness_delayed_set_brightness(struct led_classdev *led_cdev, 124 unsigned int value) 125 { 126 int ret; 127 128 ret = __led_set_brightness(led_cdev, value); 129 if (ret == -ENOTSUPP) { 130 ret = __led_set_brightness_blocking(led_cdev, value); 131 if (ret == -ENOTSUPP) 132 /* No back-end support to set a fixed brightness value */ 133 return; 134 } 135 136 /* LED HW might have been unplugged, therefore don't warn */ 137 if (ret == -ENODEV && led_cdev->flags & LED_UNREGISTERING && 138 led_cdev->flags & LED_HW_PLUGGABLE) 139 return; 140 141 if (ret < 0) 142 dev_err(led_cdev->dev, 143 "Setting an LED's brightness failed (%d)\n", ret); 144 } 145 146 static void set_brightness_delayed(struct work_struct *ws) 147 { 148 struct led_classdev *led_cdev = 149 container_of(ws, struct led_classdev, set_brightness_work); 150 151 if (test_and_clear_bit(LED_BLINK_DISABLE, &led_cdev->work_flags)) { 152 led_stop_software_blink(led_cdev); 153 set_bit(LED_SET_BRIGHTNESS_OFF, &led_cdev->work_flags); 154 } 155 156 /* 157 * Triggers may call led_set_brightness(LED_OFF), 158 * led_set_brightness(LED_FULL) in quick succession to disable blinking 159 * and turn the LED on. Both actions may have been scheduled to run 160 * before this work item runs once. To make sure this works properly 161 * handle LED_SET_BRIGHTNESS_OFF first. 162 */ 163 if (test_and_clear_bit(LED_SET_BRIGHTNESS_OFF, &led_cdev->work_flags)) { 164 set_brightness_delayed_set_brightness(led_cdev, LED_OFF); 165 /* 166 * The consecutives led_set_brightness(LED_OFF), 167 * led_set_brightness(LED_FULL) could have been executed out of 168 * order (LED_FULL first), if the work_flags has been set 169 * between LED_SET_BRIGHTNESS_OFF and LED_SET_BRIGHTNESS of this 170 * work. To avoid ending with the LED turned off, turn the LED 171 * on again. 172 */ 173 if (led_cdev->delayed_set_value != LED_OFF) 174 set_bit(LED_SET_BRIGHTNESS, &led_cdev->work_flags); 175 } 176 177 if (test_and_clear_bit(LED_SET_BRIGHTNESS, &led_cdev->work_flags)) 178 set_brightness_delayed_set_brightness(led_cdev, led_cdev->delayed_set_value); 179 180 if (test_and_clear_bit(LED_SET_BLINK, &led_cdev->work_flags)) { 181 unsigned long delay_on = led_cdev->delayed_delay_on; 182 unsigned long delay_off = led_cdev->delayed_delay_off; 183 184 led_blink_set(led_cdev, &delay_on, &delay_off); 185 } 186 } 187 188 static void led_set_software_blink(struct led_classdev *led_cdev, 189 unsigned long delay_on, 190 unsigned long delay_off) 191 { 192 int current_brightness; 193 194 current_brightness = led_get_brightness(led_cdev); 195 if (current_brightness) 196 led_cdev->blink_brightness = current_brightness; 197 if (!led_cdev->blink_brightness) 198 led_cdev->blink_brightness = led_cdev->max_brightness; 199 200 led_cdev->blink_delay_on = delay_on; 201 led_cdev->blink_delay_off = delay_off; 202 203 /* never on - just set to off */ 204 if (!delay_on) { 205 led_set_brightness_nosleep(led_cdev, LED_OFF); 206 return; 207 } 208 209 /* never off - just set to brightness */ 210 if (!delay_off) { 211 led_set_brightness_nosleep(led_cdev, 212 led_cdev->blink_brightness); 213 return; 214 } 215 216 set_bit(LED_BLINK_SW, &led_cdev->work_flags); 217 mod_timer(&led_cdev->blink_timer, jiffies + 1); 218 } 219 220 221 static void led_blink_setup(struct led_classdev *led_cdev, 222 unsigned long *delay_on, 223 unsigned long *delay_off) 224 { 225 if (!test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) && 226 led_cdev->blink_set && 227 !led_cdev->blink_set(led_cdev, delay_on, delay_off)) 228 return; 229 230 /* blink with 1 Hz as default if nothing specified */ 231 if (!*delay_on && !*delay_off) 232 *delay_on = *delay_off = 500; 233 234 led_set_software_blink(led_cdev, *delay_on, *delay_off); 235 } 236 237 void led_init_core(struct led_classdev *led_cdev) 238 { 239 INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed); 240 241 timer_setup(&led_cdev->blink_timer, led_timer_function, 0); 242 } 243 EXPORT_SYMBOL_GPL(led_init_core); 244 245 void led_blink_set(struct led_classdev *led_cdev, 246 unsigned long *delay_on, 247 unsigned long *delay_off) 248 { 249 timer_delete_sync(&led_cdev->blink_timer); 250 251 clear_bit(LED_BLINK_SW, &led_cdev->work_flags); 252 clear_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags); 253 clear_bit(LED_BLINK_ONESHOT_STOP, &led_cdev->work_flags); 254 255 led_blink_setup(led_cdev, delay_on, delay_off); 256 } 257 EXPORT_SYMBOL_GPL(led_blink_set); 258 259 void led_blink_set_oneshot(struct led_classdev *led_cdev, 260 unsigned long *delay_on, 261 unsigned long *delay_off, 262 int invert) 263 { 264 if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) && 265 timer_pending(&led_cdev->blink_timer)) 266 return; 267 268 set_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags); 269 clear_bit(LED_BLINK_ONESHOT_STOP, &led_cdev->work_flags); 270 271 if (invert) 272 set_bit(LED_BLINK_INVERT, &led_cdev->work_flags); 273 else 274 clear_bit(LED_BLINK_INVERT, &led_cdev->work_flags); 275 276 led_blink_setup(led_cdev, delay_on, delay_off); 277 } 278 EXPORT_SYMBOL_GPL(led_blink_set_oneshot); 279 280 void led_blink_set_nosleep(struct led_classdev *led_cdev, unsigned long delay_on, 281 unsigned long delay_off) 282 { 283 /* If necessary delegate to a work queue task. */ 284 if (led_cdev->blink_set && led_cdev->brightness_set_blocking) { 285 led_cdev->delayed_delay_on = delay_on; 286 led_cdev->delayed_delay_off = delay_off; 287 set_bit(LED_SET_BLINK, &led_cdev->work_flags); 288 queue_work(led_cdev->wq, &led_cdev->set_brightness_work); 289 return; 290 } 291 292 led_blink_set(led_cdev, &delay_on, &delay_off); 293 } 294 EXPORT_SYMBOL_GPL(led_blink_set_nosleep); 295 296 void led_stop_software_blink(struct led_classdev *led_cdev) 297 { 298 timer_delete_sync(&led_cdev->blink_timer); 299 led_cdev->blink_delay_on = 0; 300 led_cdev->blink_delay_off = 0; 301 clear_bit(LED_BLINK_SW, &led_cdev->work_flags); 302 } 303 EXPORT_SYMBOL_GPL(led_stop_software_blink); 304 305 void led_set_brightness(struct led_classdev *led_cdev, unsigned int brightness) 306 { 307 /* 308 * If software blink is active, delay brightness setting 309 * until the next timer tick. 310 */ 311 if (test_bit(LED_BLINK_SW, &led_cdev->work_flags)) { 312 /* 313 * If we need to disable soft blinking delegate this to the 314 * work queue task to avoid problems in case we are called 315 * from hard irq context. 316 */ 317 if (!brightness) { 318 set_bit(LED_BLINK_DISABLE, &led_cdev->work_flags); 319 queue_work(led_cdev->wq, &led_cdev->set_brightness_work); 320 } else { 321 set_bit(LED_BLINK_BRIGHTNESS_CHANGE, 322 &led_cdev->work_flags); 323 led_cdev->new_blink_brightness = brightness; 324 } 325 return; 326 } 327 328 led_set_brightness_nosleep(led_cdev, brightness); 329 } 330 EXPORT_SYMBOL_GPL(led_set_brightness); 331 332 void led_set_brightness_nopm(struct led_classdev *led_cdev, unsigned int value) 333 { 334 /* Use brightness_set op if available, it is guaranteed not to sleep */ 335 if (!__led_set_brightness(led_cdev, value)) 336 return; 337 338 /* 339 * Brightness setting can sleep, delegate it to a work queue task. 340 * value 0 / LED_OFF is special, since it also disables hw-blinking 341 * (sw-blink disable is handled in led_set_brightness()). 342 * To avoid a hw-blink-disable getting lost when a second brightness 343 * change is done immediately afterwards (before the work runs), 344 * it uses a separate work_flag. 345 */ 346 led_cdev->delayed_set_value = value; 347 /* Ensure delayed_set_value is seen before work_flags modification */ 348 smp_mb__before_atomic(); 349 350 if (value) 351 set_bit(LED_SET_BRIGHTNESS, &led_cdev->work_flags); 352 else { 353 clear_bit(LED_SET_BRIGHTNESS, &led_cdev->work_flags); 354 clear_bit(LED_SET_BLINK, &led_cdev->work_flags); 355 set_bit(LED_SET_BRIGHTNESS_OFF, &led_cdev->work_flags); 356 } 357 358 queue_work(led_cdev->wq, &led_cdev->set_brightness_work); 359 } 360 EXPORT_SYMBOL_GPL(led_set_brightness_nopm); 361 362 void led_set_brightness_nosleep(struct led_classdev *led_cdev, unsigned int value) 363 { 364 led_cdev->brightness = min(value, led_cdev->max_brightness); 365 366 if (led_cdev->flags & LED_SUSPENDED) 367 return; 368 369 led_set_brightness_nopm(led_cdev, led_cdev->brightness); 370 } 371 EXPORT_SYMBOL_GPL(led_set_brightness_nosleep); 372 373 int led_set_brightness_sync(struct led_classdev *led_cdev, unsigned int value) 374 { 375 if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) 376 return -EBUSY; 377 378 led_cdev->brightness = min(value, led_cdev->max_brightness); 379 380 if (led_cdev->flags & LED_SUSPENDED) 381 return 0; 382 383 return __led_set_brightness_blocking(led_cdev, led_cdev->brightness); 384 } 385 EXPORT_SYMBOL_GPL(led_set_brightness_sync); 386 387 /* 388 * This is a led-core function because just like led_set_brightness() 389 * it is used in the kernel by e.g. triggers. 390 */ 391 void led_mc_set_brightness(struct led_classdev *led_cdev, 392 unsigned int *intensity_value, unsigned int num_colors, 393 unsigned int brightness) 394 { 395 struct led_classdev_mc *mcled_cdev; 396 unsigned int i; 397 398 if (!(led_cdev->flags & LED_MULTI_COLOR)) { 399 dev_err_once(led_cdev->dev, "error not a multi-color LED\n"); 400 return; 401 } 402 403 mcled_cdev = lcdev_to_mccdev(led_cdev); 404 if (num_colors != mcled_cdev->num_colors) { 405 dev_err_once(led_cdev->dev, "error num_colors mismatch %u != %u\n", 406 num_colors, mcled_cdev->num_colors); 407 return; 408 } 409 410 for (i = 0; i < mcled_cdev->num_colors; i++) 411 mcled_cdev->subled_info[i].intensity = intensity_value[i]; 412 413 led_set_brightness(led_cdev, brightness); 414 } 415 EXPORT_SYMBOL_GPL(led_mc_set_brightness); 416 417 int led_update_brightness(struct led_classdev *led_cdev) 418 { 419 int ret; 420 421 if (led_cdev->brightness_get) { 422 ret = led_cdev->brightness_get(led_cdev); 423 if (ret < 0) 424 return ret; 425 426 led_cdev->brightness = ret; 427 } 428 429 return 0; 430 } 431 EXPORT_SYMBOL_GPL(led_update_brightness); 432 433 u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size) 434 { 435 struct fwnode_handle *fwnode = led_cdev->dev->fwnode; 436 u32 *pattern; 437 int count; 438 439 count = fwnode_property_count_u32(fwnode, "led-pattern"); 440 if (count < 0) 441 return NULL; 442 443 pattern = kcalloc(count, sizeof(*pattern), GFP_KERNEL); 444 if (!pattern) 445 return NULL; 446 447 if (fwnode_property_read_u32_array(fwnode, "led-pattern", pattern, count)) { 448 kfree(pattern); 449 return NULL; 450 } 451 452 *size = count; 453 454 return pattern; 455 } 456 EXPORT_SYMBOL_GPL(led_get_default_pattern); 457 458 /* Caller must ensure led_cdev->led_access held */ 459 void led_sysfs_disable(struct led_classdev *led_cdev) 460 { 461 lockdep_assert_held(&led_cdev->led_access); 462 463 led_cdev->flags |= LED_SYSFS_DISABLE; 464 } 465 EXPORT_SYMBOL_GPL(led_sysfs_disable); 466 467 /* Caller must ensure led_cdev->led_access held */ 468 void led_sysfs_enable(struct led_classdev *led_cdev) 469 { 470 lockdep_assert_held(&led_cdev->led_access); 471 472 led_cdev->flags &= ~LED_SYSFS_DISABLE; 473 } 474 EXPORT_SYMBOL_GPL(led_sysfs_enable); 475 476 static void led_parse_fwnode_props(struct device *dev, 477 struct fwnode_handle *fwnode, 478 struct led_properties *props) 479 { 480 int ret; 481 482 if (!fwnode) 483 return; 484 485 if (fwnode_property_present(fwnode, "label")) { 486 ret = fwnode_property_read_string(fwnode, "label", &props->label); 487 if (ret) 488 dev_err(dev, "Error parsing 'label' property (%d)\n", ret); 489 return; 490 } 491 492 if (fwnode_property_present(fwnode, "color")) { 493 ret = fwnode_property_read_u32(fwnode, "color", &props->color); 494 if (ret) 495 dev_err(dev, "Error parsing 'color' property (%d)\n", ret); 496 else if (props->color >= LED_COLOR_ID_MAX) 497 dev_err(dev, "LED color identifier out of range\n"); 498 else 499 props->color_present = true; 500 } 501 502 503 if (!fwnode_property_present(fwnode, "function")) 504 return; 505 506 ret = fwnode_property_read_string(fwnode, "function", &props->function); 507 if (ret) { 508 dev_err(dev, 509 "Error parsing 'function' property (%d)\n", 510 ret); 511 } 512 513 if (!fwnode_property_present(fwnode, "function-enumerator")) 514 return; 515 516 ret = fwnode_property_read_u32(fwnode, "function-enumerator", 517 &props->func_enum); 518 if (ret) { 519 dev_err(dev, 520 "Error parsing 'function-enumerator' property (%d)\n", 521 ret); 522 } else { 523 props->func_enum_present = true; 524 } 525 } 526 527 int led_compose_name(struct device *dev, struct led_init_data *init_data, 528 char *led_classdev_name) 529 { 530 struct led_properties props = {}; 531 struct fwnode_handle *fwnode = init_data->fwnode; 532 const char *devicename = init_data->devicename; 533 int n; 534 535 if (!led_classdev_name) 536 return -EINVAL; 537 538 led_parse_fwnode_props(dev, fwnode, &props); 539 540 if (props.label) { 541 /* 542 * If init_data.devicename is NULL, then it indicates that 543 * DT label should be used as-is for LED class device name. 544 * Otherwise the label is prepended with devicename to compose 545 * the final LED class device name. 546 */ 547 if (devicename) { 548 n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s", 549 devicename, props.label); 550 } else { 551 n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s", props.label); 552 } 553 } else if (props.function || props.color_present) { 554 char tmp_buf[LED_MAX_NAME_SIZE]; 555 556 if (props.func_enum_present) { 557 n = snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s-%d", 558 props.color_present ? led_colors[props.color] : "", 559 props.function ?: "", props.func_enum); 560 } else { 561 n = snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s", 562 props.color_present ? led_colors[props.color] : "", 563 props.function ?: ""); 564 } 565 if (n >= LED_MAX_NAME_SIZE) 566 return -E2BIG; 567 568 if (init_data->devname_mandatory) { 569 n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s", 570 devicename, tmp_buf); 571 } else { 572 n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s", tmp_buf); 573 } 574 } else if (init_data->default_label) { 575 if (!devicename) { 576 dev_err(dev, "Legacy LED naming requires devicename segment"); 577 return -EINVAL; 578 } 579 n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s", 580 devicename, init_data->default_label); 581 } else if (is_of_node(fwnode)) { 582 n = snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s", 583 to_of_node(fwnode)->name); 584 } else 585 return -EINVAL; 586 587 if (n >= LED_MAX_NAME_SIZE) 588 return -E2BIG; 589 590 return 0; 591 } 592 EXPORT_SYMBOL_GPL(led_compose_name); 593 594 const char *led_get_color_name(u8 color_id) 595 { 596 if (color_id >= ARRAY_SIZE(led_colors)) 597 return NULL; 598 599 return led_colors[color_id]; 600 } 601 EXPORT_SYMBOL_GPL(led_get_color_name); 602 603 enum led_default_state led_init_default_state_get(struct fwnode_handle *fwnode) 604 { 605 const char *state = NULL; 606 607 if (!fwnode_property_read_string(fwnode, "default-state", &state)) { 608 if (!strcmp(state, "keep")) 609 return LEDS_DEFSTATE_KEEP; 610 if (!strcmp(state, "on")) 611 return LEDS_DEFSTATE_ON; 612 } 613 614 return LEDS_DEFSTATE_OFF; 615 } 616 EXPORT_SYMBOL_GPL(led_init_default_state_get); 617