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