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/leds.h> |
12 | #include <linux/list.h> |
13 | #include <linux/module.h> |
14 | #include <linux/mutex.h> |
15 | #include <linux/of.h> |
16 | #include <linux/property.h> |
17 | #include <linux/rwsem.h> |
18 | #include <linux/slab.h> |
19 | #include <uapi/linux/uleds.h> |
20 | #include "leds.h" |
21 | |
22 | DECLARE_RWSEM(leds_list_lock); |
23 | EXPORT_SYMBOL_GPL(leds_list_lock); |
24 | |
25 | LIST_HEAD(leds_list); |
26 | EXPORT_SYMBOL_GPL(leds_list); |
27 | |
28 | const char * const led_colors[LED_COLOR_ID_MAX] = { |
29 | [LED_COLOR_ID_WHITE] = "white" , |
30 | [LED_COLOR_ID_RED] = "red" , |
31 | [LED_COLOR_ID_GREEN] = "green" , |
32 | [LED_COLOR_ID_BLUE] = "blue" , |
33 | [LED_COLOR_ID_AMBER] = "amber" , |
34 | [LED_COLOR_ID_VIOLET] = "violet" , |
35 | [LED_COLOR_ID_YELLOW] = "yellow" , |
36 | [LED_COLOR_ID_IR] = "ir" , |
37 | [LED_COLOR_ID_MULTI] = "multicolor" , |
38 | [LED_COLOR_ID_RGB] = "rgb" , |
39 | [LED_COLOR_ID_PURPLE] = "purple" , |
40 | [LED_COLOR_ID_ORANGE] = "orange" , |
41 | [LED_COLOR_ID_PINK] = "pink" , |
42 | [LED_COLOR_ID_CYAN] = "cyan" , |
43 | [LED_COLOR_ID_LIME] = "lime" , |
44 | }; |
45 | EXPORT_SYMBOL_GPL(led_colors); |
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 = 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, value: LED_OFF); |
73 | clear_bit(LED_BLINK_SW, addr: &led_cdev->work_flags); |
74 | return; |
75 | } |
76 | |
77 | if (test_and_clear_bit(LED_BLINK_ONESHOT_STOP, |
78 | addr: &led_cdev->work_flags)) { |
79 | clear_bit(LED_BLINK_SW, addr: &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 | addr: &led_cdev->work_flags)) |
88 | brightness = led_cdev->new_blink_brightness; |
89 | else |
90 | brightness = led_cdev->blink_brightness; |
91 | delay = led_cdev->blink_delay_on; |
92 | } else { |
93 | /* Store the current brightness value to be able |
94 | * 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, value: brightness); |
102 | |
103 | /* Return in next iteration if led is in one-shot mode and we are in |
104 | * 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 | addr: &led_cdev->work_flags); |
112 | } else { |
113 | if (!brightness) |
114 | set_bit(LED_BLINK_ONESHOT_STOP, |
115 | addr: &led_cdev->work_flags); |
116 | } |
117 | } |
118 | |
119 | mod_timer(timer: &led_cdev->blink_timer, expires: jiffies + msecs_to_jiffies(m: delay)); |
120 | } |
121 | |
122 | static void set_brightness_delayed_set_brightness(struct led_classdev *led_cdev, |
123 | unsigned int value) |
124 | { |
125 | int ret = 0; |
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 < 0 && |
131 | /* LED HW might have been unplugged, therefore don't warn */ |
132 | !(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) && |
133 | (led_cdev->flags & LED_HW_PLUGGABLE))) |
134 | dev_err(led_cdev->dev, |
135 | "Setting an LED's brightness failed (%d)\n" , ret); |
136 | } |
137 | |
138 | static void set_brightness_delayed(struct work_struct *ws) |
139 | { |
140 | struct led_classdev *led_cdev = |
141 | container_of(ws, struct led_classdev, set_brightness_work); |
142 | |
143 | if (test_and_clear_bit(LED_BLINK_DISABLE, addr: &led_cdev->work_flags)) { |
144 | led_stop_software_blink(led_cdev); |
145 | set_bit(LED_SET_BRIGHTNESS_OFF, addr: &led_cdev->work_flags); |
146 | } |
147 | |
148 | /* |
149 | * Triggers may call led_set_brightness(LED_OFF), |
150 | * led_set_brightness(LED_FULL) in quick succession to disable blinking |
151 | * and turn the LED on. Both actions may have been scheduled to run |
152 | * before this work item runs once. To make sure this works properly |
153 | * handle LED_SET_BRIGHTNESS_OFF first. |
154 | */ |
155 | if (test_and_clear_bit(LED_SET_BRIGHTNESS_OFF, addr: &led_cdev->work_flags)) |
156 | set_brightness_delayed_set_brightness(led_cdev, value: LED_OFF); |
157 | |
158 | if (test_and_clear_bit(LED_SET_BRIGHTNESS, addr: &led_cdev->work_flags)) |
159 | set_brightness_delayed_set_brightness(led_cdev, value: led_cdev->delayed_set_value); |
160 | |
161 | if (test_and_clear_bit(LED_SET_BLINK, addr: &led_cdev->work_flags)) { |
162 | unsigned long delay_on = led_cdev->delayed_delay_on; |
163 | unsigned long delay_off = led_cdev->delayed_delay_off; |
164 | |
165 | led_blink_set(led_cdev, delay_on: &delay_on, delay_off: &delay_off); |
166 | } |
167 | } |
168 | |
169 | static void led_set_software_blink(struct led_classdev *led_cdev, |
170 | unsigned long delay_on, |
171 | unsigned long delay_off) |
172 | { |
173 | int current_brightness; |
174 | |
175 | current_brightness = led_get_brightness(led_cdev); |
176 | if (current_brightness) |
177 | led_cdev->blink_brightness = current_brightness; |
178 | if (!led_cdev->blink_brightness) |
179 | led_cdev->blink_brightness = led_cdev->max_brightness; |
180 | |
181 | led_cdev->blink_delay_on = delay_on; |
182 | led_cdev->blink_delay_off = delay_off; |
183 | |
184 | /* never on - just set to off */ |
185 | if (!delay_on) { |
186 | led_set_brightness_nosleep(led_cdev, value: LED_OFF); |
187 | return; |
188 | } |
189 | |
190 | /* never off - just set to brightness */ |
191 | if (!delay_off) { |
192 | led_set_brightness_nosleep(led_cdev, |
193 | value: led_cdev->blink_brightness); |
194 | return; |
195 | } |
196 | |
197 | set_bit(LED_BLINK_SW, addr: &led_cdev->work_flags); |
198 | mod_timer(timer: &led_cdev->blink_timer, expires: jiffies + 1); |
199 | } |
200 | |
201 | |
202 | static void led_blink_setup(struct led_classdev *led_cdev, |
203 | unsigned long *delay_on, |
204 | unsigned long *delay_off) |
205 | { |
206 | if (!test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) && |
207 | led_cdev->blink_set && |
208 | !led_cdev->blink_set(led_cdev, delay_on, delay_off)) |
209 | return; |
210 | |
211 | /* blink with 1 Hz as default if nothing specified */ |
212 | if (!*delay_on && !*delay_off) |
213 | *delay_on = *delay_off = 500; |
214 | |
215 | led_set_software_blink(led_cdev, delay_on: *delay_on, delay_off: *delay_off); |
216 | } |
217 | |
218 | void led_init_core(struct led_classdev *led_cdev) |
219 | { |
220 | INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed); |
221 | |
222 | timer_setup(&led_cdev->blink_timer, led_timer_function, 0); |
223 | } |
224 | EXPORT_SYMBOL_GPL(led_init_core); |
225 | |
226 | void led_blink_set(struct led_classdev *led_cdev, |
227 | unsigned long *delay_on, |
228 | unsigned long *delay_off) |
229 | { |
230 | del_timer_sync(timer: &led_cdev->blink_timer); |
231 | |
232 | clear_bit(LED_BLINK_SW, addr: &led_cdev->work_flags); |
233 | clear_bit(LED_BLINK_ONESHOT, addr: &led_cdev->work_flags); |
234 | clear_bit(LED_BLINK_ONESHOT_STOP, addr: &led_cdev->work_flags); |
235 | |
236 | led_blink_setup(led_cdev, delay_on, delay_off); |
237 | } |
238 | EXPORT_SYMBOL_GPL(led_blink_set); |
239 | |
240 | void led_blink_set_oneshot(struct led_classdev *led_cdev, |
241 | unsigned long *delay_on, |
242 | unsigned long *delay_off, |
243 | int invert) |
244 | { |
245 | if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) && |
246 | timer_pending(timer: &led_cdev->blink_timer)) |
247 | return; |
248 | |
249 | set_bit(LED_BLINK_ONESHOT, addr: &led_cdev->work_flags); |
250 | clear_bit(LED_BLINK_ONESHOT_STOP, addr: &led_cdev->work_flags); |
251 | |
252 | if (invert) |
253 | set_bit(LED_BLINK_INVERT, addr: &led_cdev->work_flags); |
254 | else |
255 | clear_bit(LED_BLINK_INVERT, addr: &led_cdev->work_flags); |
256 | |
257 | led_blink_setup(led_cdev, delay_on, delay_off); |
258 | } |
259 | EXPORT_SYMBOL_GPL(led_blink_set_oneshot); |
260 | |
261 | void led_blink_set_nosleep(struct led_classdev *led_cdev, unsigned long delay_on, |
262 | unsigned long delay_off) |
263 | { |
264 | /* If necessary delegate to a work queue task. */ |
265 | if (led_cdev->blink_set && led_cdev->brightness_set_blocking) { |
266 | led_cdev->delayed_delay_on = delay_on; |
267 | led_cdev->delayed_delay_off = delay_off; |
268 | set_bit(LED_SET_BLINK, addr: &led_cdev->work_flags); |
269 | schedule_work(work: &led_cdev->set_brightness_work); |
270 | return; |
271 | } |
272 | |
273 | led_blink_set(led_cdev, &delay_on, &delay_off); |
274 | } |
275 | EXPORT_SYMBOL_GPL(led_blink_set_nosleep); |
276 | |
277 | void led_stop_software_blink(struct led_classdev *led_cdev) |
278 | { |
279 | del_timer_sync(timer: &led_cdev->blink_timer); |
280 | led_cdev->blink_delay_on = 0; |
281 | led_cdev->blink_delay_off = 0; |
282 | clear_bit(LED_BLINK_SW, addr: &led_cdev->work_flags); |
283 | } |
284 | EXPORT_SYMBOL_GPL(led_stop_software_blink); |
285 | |
286 | void led_set_brightness(struct led_classdev *led_cdev, unsigned int brightness) |
287 | { |
288 | /* |
289 | * If software blink is active, delay brightness setting |
290 | * until the next timer tick. |
291 | */ |
292 | if (test_bit(LED_BLINK_SW, &led_cdev->work_flags)) { |
293 | /* |
294 | * If we need to disable soft blinking delegate this to the |
295 | * work queue task to avoid problems in case we are called |
296 | * from hard irq context. |
297 | */ |
298 | if (!brightness) { |
299 | set_bit(LED_BLINK_DISABLE, addr: &led_cdev->work_flags); |
300 | schedule_work(work: &led_cdev->set_brightness_work); |
301 | } else { |
302 | set_bit(LED_BLINK_BRIGHTNESS_CHANGE, |
303 | addr: &led_cdev->work_flags); |
304 | led_cdev->new_blink_brightness = brightness; |
305 | } |
306 | return; |
307 | } |
308 | |
309 | led_set_brightness_nosleep(led_cdev, value: brightness); |
310 | } |
311 | EXPORT_SYMBOL_GPL(led_set_brightness); |
312 | |
313 | void led_set_brightness_nopm(struct led_classdev *led_cdev, unsigned int value) |
314 | { |
315 | /* Use brightness_set op if available, it is guaranteed not to sleep */ |
316 | if (!__led_set_brightness(led_cdev, value)) |
317 | return; |
318 | |
319 | /* |
320 | * Brightness setting can sleep, delegate it to a work queue task. |
321 | * value 0 / LED_OFF is special, since it also disables hw-blinking |
322 | * (sw-blink disable is handled in led_set_brightness()). |
323 | * To avoid a hw-blink-disable getting lost when a second brightness |
324 | * change is done immediately afterwards (before the work runs), |
325 | * it uses a separate work_flag. |
326 | */ |
327 | if (value) { |
328 | led_cdev->delayed_set_value = value; |
329 | set_bit(LED_SET_BRIGHTNESS, addr: &led_cdev->work_flags); |
330 | } else { |
331 | clear_bit(LED_SET_BRIGHTNESS, addr: &led_cdev->work_flags); |
332 | clear_bit(LED_SET_BLINK, addr: &led_cdev->work_flags); |
333 | set_bit(LED_SET_BRIGHTNESS_OFF, addr: &led_cdev->work_flags); |
334 | } |
335 | |
336 | schedule_work(work: &led_cdev->set_brightness_work); |
337 | } |
338 | EXPORT_SYMBOL_GPL(led_set_brightness_nopm); |
339 | |
340 | void led_set_brightness_nosleep(struct led_classdev *led_cdev, unsigned int value) |
341 | { |
342 | led_cdev->brightness = min(value, led_cdev->max_brightness); |
343 | |
344 | if (led_cdev->flags & LED_SUSPENDED) |
345 | return; |
346 | |
347 | led_set_brightness_nopm(led_cdev, led_cdev->brightness); |
348 | } |
349 | EXPORT_SYMBOL_GPL(led_set_brightness_nosleep); |
350 | |
351 | int led_set_brightness_sync(struct led_classdev *led_cdev, unsigned int value) |
352 | { |
353 | if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) |
354 | return -EBUSY; |
355 | |
356 | led_cdev->brightness = min(value, led_cdev->max_brightness); |
357 | |
358 | if (led_cdev->flags & LED_SUSPENDED) |
359 | return 0; |
360 | |
361 | return __led_set_brightness_blocking(led_cdev, value: led_cdev->brightness); |
362 | } |
363 | EXPORT_SYMBOL_GPL(led_set_brightness_sync); |
364 | |
365 | int led_update_brightness(struct led_classdev *led_cdev) |
366 | { |
367 | int ret; |
368 | |
369 | if (led_cdev->brightness_get) { |
370 | ret = led_cdev->brightness_get(led_cdev); |
371 | if (ret < 0) |
372 | return ret; |
373 | |
374 | led_cdev->brightness = ret; |
375 | } |
376 | |
377 | return 0; |
378 | } |
379 | EXPORT_SYMBOL_GPL(led_update_brightness); |
380 | |
381 | u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size) |
382 | { |
383 | struct fwnode_handle *fwnode = led_cdev->dev->fwnode; |
384 | u32 *pattern; |
385 | int count; |
386 | |
387 | count = fwnode_property_count_u32(fwnode, propname: "led-pattern" ); |
388 | if (count < 0) |
389 | return NULL; |
390 | |
391 | pattern = kcalloc(n: count, size: sizeof(*pattern), GFP_KERNEL); |
392 | if (!pattern) |
393 | return NULL; |
394 | |
395 | if (fwnode_property_read_u32_array(fwnode, propname: "led-pattern" , val: pattern, nval: count)) { |
396 | kfree(objp: pattern); |
397 | return NULL; |
398 | } |
399 | |
400 | *size = count; |
401 | |
402 | return pattern; |
403 | } |
404 | EXPORT_SYMBOL_GPL(led_get_default_pattern); |
405 | |
406 | /* Caller must ensure led_cdev->led_access held */ |
407 | void led_sysfs_disable(struct led_classdev *led_cdev) |
408 | { |
409 | lockdep_assert_held(&led_cdev->led_access); |
410 | |
411 | led_cdev->flags |= LED_SYSFS_DISABLE; |
412 | } |
413 | EXPORT_SYMBOL_GPL(led_sysfs_disable); |
414 | |
415 | /* Caller must ensure led_cdev->led_access held */ |
416 | void led_sysfs_enable(struct led_classdev *led_cdev) |
417 | { |
418 | lockdep_assert_held(&led_cdev->led_access); |
419 | |
420 | led_cdev->flags &= ~LED_SYSFS_DISABLE; |
421 | } |
422 | EXPORT_SYMBOL_GPL(led_sysfs_enable); |
423 | |
424 | static void led_parse_fwnode_props(struct device *dev, |
425 | struct fwnode_handle *fwnode, |
426 | struct led_properties *props) |
427 | { |
428 | int ret; |
429 | |
430 | if (!fwnode) |
431 | return; |
432 | |
433 | if (fwnode_property_present(fwnode, propname: "label" )) { |
434 | ret = fwnode_property_read_string(fwnode, propname: "label" , val: &props->label); |
435 | if (ret) |
436 | dev_err(dev, "Error parsing 'label' property (%d)\n" , ret); |
437 | return; |
438 | } |
439 | |
440 | if (fwnode_property_present(fwnode, propname: "color" )) { |
441 | ret = fwnode_property_read_u32(fwnode, propname: "color" , val: &props->color); |
442 | if (ret) |
443 | dev_err(dev, "Error parsing 'color' property (%d)\n" , ret); |
444 | else if (props->color >= LED_COLOR_ID_MAX) |
445 | dev_err(dev, "LED color identifier out of range\n" ); |
446 | else |
447 | props->color_present = true; |
448 | } |
449 | |
450 | |
451 | if (!fwnode_property_present(fwnode, propname: "function" )) |
452 | return; |
453 | |
454 | ret = fwnode_property_read_string(fwnode, propname: "function" , val: &props->function); |
455 | if (ret) { |
456 | dev_err(dev, |
457 | "Error parsing 'function' property (%d)\n" , |
458 | ret); |
459 | } |
460 | |
461 | if (!fwnode_property_present(fwnode, propname: "function-enumerator" )) |
462 | return; |
463 | |
464 | ret = fwnode_property_read_u32(fwnode, propname: "function-enumerator" , |
465 | val: &props->func_enum); |
466 | if (ret) { |
467 | dev_err(dev, |
468 | "Error parsing 'function-enumerator' property (%d)\n" , |
469 | ret); |
470 | } else { |
471 | props->func_enum_present = true; |
472 | } |
473 | } |
474 | |
475 | int led_compose_name(struct device *dev, struct led_init_data *init_data, |
476 | char *led_classdev_name) |
477 | { |
478 | struct led_properties props = {}; |
479 | struct fwnode_handle *fwnode = init_data->fwnode; |
480 | const char *devicename = init_data->devicename; |
481 | |
482 | if (!led_classdev_name) |
483 | return -EINVAL; |
484 | |
485 | led_parse_fwnode_props(dev, fwnode, props: &props); |
486 | |
487 | if (props.label) { |
488 | /* |
489 | * If init_data.devicename is NULL, then it indicates that |
490 | * DT label should be used as-is for LED class device name. |
491 | * Otherwise the label is prepended with devicename to compose |
492 | * the final LED class device name. |
493 | */ |
494 | if (!devicename) { |
495 | strscpy(p: led_classdev_name, q: props.label, |
496 | LED_MAX_NAME_SIZE); |
497 | } else { |
498 | snprintf(buf: led_classdev_name, LED_MAX_NAME_SIZE, fmt: "%s:%s" , |
499 | devicename, props.label); |
500 | } |
501 | } else if (props.function || props.color_present) { |
502 | char tmp_buf[LED_MAX_NAME_SIZE]; |
503 | |
504 | if (props.func_enum_present) { |
505 | snprintf(buf: tmp_buf, LED_MAX_NAME_SIZE, fmt: "%s:%s-%d" , |
506 | props.color_present ? led_colors[props.color] : "" , |
507 | props.function ?: "" , props.func_enum); |
508 | } else { |
509 | snprintf(buf: tmp_buf, LED_MAX_NAME_SIZE, fmt: "%s:%s" , |
510 | props.color_present ? led_colors[props.color] : "" , |
511 | props.function ?: "" ); |
512 | } |
513 | if (init_data->devname_mandatory) { |
514 | snprintf(buf: led_classdev_name, LED_MAX_NAME_SIZE, fmt: "%s:%s" , |
515 | devicename, tmp_buf); |
516 | } else { |
517 | strscpy(p: led_classdev_name, q: tmp_buf, LED_MAX_NAME_SIZE); |
518 | |
519 | } |
520 | } else if (init_data->default_label) { |
521 | if (!devicename) { |
522 | dev_err(dev, "Legacy LED naming requires devicename segment" ); |
523 | return -EINVAL; |
524 | } |
525 | snprintf(buf: led_classdev_name, LED_MAX_NAME_SIZE, fmt: "%s:%s" , |
526 | devicename, init_data->default_label); |
527 | } else if (is_of_node(fwnode)) { |
528 | strscpy(p: led_classdev_name, to_of_node(fwnode)->name, |
529 | LED_MAX_NAME_SIZE); |
530 | } else |
531 | return -EINVAL; |
532 | |
533 | return 0; |
534 | } |
535 | EXPORT_SYMBOL_GPL(led_compose_name); |
536 | |
537 | enum led_default_state led_init_default_state_get(struct fwnode_handle *fwnode) |
538 | { |
539 | const char *state = NULL; |
540 | |
541 | if (!fwnode_property_read_string(fwnode, propname: "default-state" , val: &state)) { |
542 | if (!strcmp(state, "keep" )) |
543 | return LEDS_DEFSTATE_KEEP; |
544 | if (!strcmp(state, "on" )) |
545 | return LEDS_DEFSTATE_ON; |
546 | } |
547 | |
548 | return LEDS_DEFSTATE_OFF; |
549 | } |
550 | EXPORT_SYMBOL_GPL(led_init_default_state_get); |
551 | |