Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
c72a1d60 RP |
2 | /* |
3 | * LED Class Core | |
4 | * | |
5 | * Copyright 2005-2006 Openedhand Ltd. | |
6 | * | |
7 | * Author: Richard Purdie <rpurdie@openedhand.com> | |
c72a1d60 RP |
8 | */ |
9 | ||
10 | #include <linux/kernel.h> | |
04713306 | 11 | #include <linux/leds.h> |
c72a1d60 RP |
12 | #include <linux/list.h> |
13 | #include <linux/module.h> | |
04713306 | 14 | #include <linux/mutex.h> |
8e1f4561 | 15 | #include <linux/of.h> |
bb4e9af0 | 16 | #include <linux/property.h> |
72f8da32 | 17 | #include <linux/rwsem.h> |
8e1f4561 | 18 | #include <linux/slab.h> |
bb4e9af0 | 19 | #include <uapi/linux/uleds.h> |
c72a1d60 RP |
20 | #include "leds.h" |
21 | ||
72f8da32 | 22 | DECLARE_RWSEM(leds_list_lock); |
4d404fd5 | 23 | EXPORT_SYMBOL_GPL(leds_list_lock); |
c72a1d60 | 24 | |
4d404fd5 | 25 | LIST_HEAD(leds_list); |
c72a1d60 | 26 | EXPORT_SYMBOL_GPL(leds_list); |
a403d930 | 27 | |
bb4e9af0 JA |
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", | |
10d3e0d8 | 37 | [LED_COLOR_ID_MULTI] = "multicolor", |
54212f5a | 38 | [LED_COLOR_ID_RGB] = "rgb", |
bb4e9af0 JA |
39 | }; |
40 | EXPORT_SYMBOL_GPL(led_colors); | |
41 | ||
af0bfab9 | 42 | static int __led_set_brightness(struct led_classdev *led_cdev, unsigned int value) |
d4887af9 HK |
43 | { |
44 | if (!led_cdev->brightness_set) | |
45 | return -ENOTSUPP; | |
46 | ||
47 | led_cdev->brightness_set(led_cdev, value); | |
48 | ||
49 | return 0; | |
50 | } | |
51 | ||
af0bfab9 | 52 | static int __led_set_brightness_blocking(struct led_classdev *led_cdev, unsigned int value) |
d4887af9 HK |
53 | { |
54 | if (!led_cdev->brightness_set_blocking) | |
55 | return -ENOTSUPP; | |
56 | ||
57 | return led_cdev->brightness_set_blocking(led_cdev, value); | |
58 | } | |
59 | ||
49404665 | 60 | static void led_timer_function(struct timer_list *t) |
757b06ae | 61 | { |
49404665 | 62 | struct led_classdev *led_cdev = from_timer(led_cdev, t, blink_timer); |
757b06ae JA |
63 | unsigned long brightness; |
64 | unsigned long delay; | |
65 | ||
66 | if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) { | |
81fe8e5b | 67 | led_set_brightness_nosleep(led_cdev, LED_OFF); |
a9c6ce57 | 68 | clear_bit(LED_BLINK_SW, &led_cdev->work_flags); |
757b06ae JA |
69 | return; |
70 | } | |
71 | ||
a9c6ce57 HG |
72 | if (test_and_clear_bit(LED_BLINK_ONESHOT_STOP, |
73 | &led_cdev->work_flags)) { | |
74 | clear_bit(LED_BLINK_SW, &led_cdev->work_flags); | |
757b06ae JA |
75 | return; |
76 | } | |
77 | ||
78 | brightness = led_get_brightness(led_cdev); | |
79 | if (!brightness) { | |
80 | /* Time to switch the LED on. */ | |
eb1610b4 HG |
81 | if (test_and_clear_bit(LED_BLINK_BRIGHTNESS_CHANGE, |
82 | &led_cdev->work_flags)) | |
83 | brightness = led_cdev->new_blink_brightness; | |
84 | else | |
85 | brightness = led_cdev->blink_brightness; | |
757b06ae JA |
86 | delay = led_cdev->blink_delay_on; |
87 | } else { | |
88 | /* Store the current brightness value to be able | |
89 | * to restore it when the delay_off period is over. | |
90 | */ | |
eb1610b4 | 91 | led_cdev->blink_brightness = brightness; |
757b06ae JA |
92 | brightness = LED_OFF; |
93 | delay = led_cdev->blink_delay_off; | |
94 | } | |
95 | ||
81fe8e5b | 96 | led_set_brightness_nosleep(led_cdev, brightness); |
757b06ae JA |
97 | |
98 | /* Return in next iteration if led is in one-shot mode and we are in | |
99 | * the final blink state so that the led is toggled each delay_on + | |
100 | * delay_off milliseconds in worst case. | |
101 | */ | |
a9c6ce57 HG |
102 | if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags)) { |
103 | if (test_bit(LED_BLINK_INVERT, &led_cdev->work_flags)) { | |
757b06ae | 104 | if (brightness) |
a9c6ce57 HG |
105 | set_bit(LED_BLINK_ONESHOT_STOP, |
106 | &led_cdev->work_flags); | |
757b06ae JA |
107 | } else { |
108 | if (!brightness) | |
a9c6ce57 HG |
109 | set_bit(LED_BLINK_ONESHOT_STOP, |
110 | &led_cdev->work_flags); | |
757b06ae JA |
111 | } |
112 | } | |
113 | ||
114 | mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay)); | |
115 | } | |
116 | ||
117 | static void set_brightness_delayed(struct work_struct *ws) | |
118 | { | |
119 | struct led_classdev *led_cdev = | |
120 | container_of(ws, struct led_classdev, set_brightness_work); | |
1afcadfc | 121 | int ret = 0; |
757b06ae | 122 | |
a9c6ce57 | 123 | if (test_and_clear_bit(LED_BLINK_DISABLE, &led_cdev->work_flags)) { |
f1e80c07 JA |
124 | led_cdev->delayed_set_value = LED_OFF; |
125 | led_stop_software_blink(led_cdev); | |
f1e80c07 | 126 | } |
757b06ae | 127 | |
d4887af9 HK |
128 | ret = __led_set_brightness(led_cdev, led_cdev->delayed_set_value); |
129 | if (ret == -ENOTSUPP) | |
130 | ret = __led_set_brightness_blocking(led_cdev, | |
131 | led_cdev->delayed_set_value); | |
d84d80f3 HK |
132 | if (ret < 0 && |
133 | /* LED HW might have been unplugged, therefore don't warn */ | |
134 | !(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) && | |
135 | (led_cdev->flags & LED_HW_PLUGGABLE))) | |
1afcadfc JA |
136 | dev_err(led_cdev->dev, |
137 | "Setting an LED's brightness failed (%d)\n", ret); | |
757b06ae JA |
138 | } |
139 | ||
a403d930 BW |
140 | static void led_set_software_blink(struct led_classdev *led_cdev, |
141 | unsigned long delay_on, | |
142 | unsigned long delay_off) | |
143 | { | |
144 | int current_brightness; | |
145 | ||
146 | current_brightness = led_get_brightness(led_cdev); | |
147 | if (current_brightness) | |
148 | led_cdev->blink_brightness = current_brightness; | |
149 | if (!led_cdev->blink_brightness) | |
150 | led_cdev->blink_brightness = led_cdev->max_brightness; | |
151 | ||
a403d930 BW |
152 | led_cdev->blink_delay_on = delay_on; |
153 | led_cdev->blink_delay_off = delay_off; | |
154 | ||
8d82fef8 SS |
155 | /* never on - just set to off */ |
156 | if (!delay_on) { | |
81fe8e5b | 157 | led_set_brightness_nosleep(led_cdev, LED_OFF); |
a403d930 | 158 | return; |
8d82fef8 | 159 | } |
a403d930 BW |
160 | |
161 | /* never off - just set to brightness */ | |
162 | if (!delay_off) { | |
81fe8e5b JA |
163 | led_set_brightness_nosleep(led_cdev, |
164 | led_cdev->blink_brightness); | |
a403d930 BW |
165 | return; |
166 | } | |
167 | ||
a9c6ce57 | 168 | set_bit(LED_BLINK_SW, &led_cdev->work_flags); |
9067359f | 169 | mod_timer(&led_cdev->blink_timer, jiffies + 1); |
a403d930 BW |
170 | } |
171 | ||
172 | ||
20c0e6b8 | 173 | static void led_blink_setup(struct led_classdev *led_cdev, |
5bb629c5 FB |
174 | unsigned long *delay_on, |
175 | unsigned long *delay_off) | |
a403d930 | 176 | { |
a9c6ce57 | 177 | if (!test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) && |
5bb629c5 | 178 | led_cdev->blink_set && |
a403d930 BW |
179 | !led_cdev->blink_set(led_cdev, delay_on, delay_off)) |
180 | return; | |
181 | ||
182 | /* blink with 1 Hz as default if nothing specified */ | |
183 | if (!*delay_on && !*delay_off) | |
184 | *delay_on = *delay_off = 500; | |
185 | ||
186 | led_set_software_blink(led_cdev, *delay_on, *delay_off); | |
187 | } | |
5bb629c5 | 188 | |
757b06ae JA |
189 | void led_init_core(struct led_classdev *led_cdev) |
190 | { | |
191 | INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed); | |
192 | ||
49404665 | 193 | timer_setup(&led_cdev->blink_timer, led_timer_function, 0); |
757b06ae JA |
194 | } |
195 | EXPORT_SYMBOL_GPL(led_init_core); | |
196 | ||
5bb629c5 FB |
197 | void led_blink_set(struct led_classdev *led_cdev, |
198 | unsigned long *delay_on, | |
199 | unsigned long *delay_off) | |
200 | { | |
7b6af2c5 | 201 | del_timer_sync(&led_cdev->blink_timer); |
5bb629c5 | 202 | |
7b6af2c5 | 203 | clear_bit(LED_BLINK_SW, &led_cdev->work_flags); |
a9c6ce57 HG |
204 | clear_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags); |
205 | clear_bit(LED_BLINK_ONESHOT_STOP, &led_cdev->work_flags); | |
5bb629c5 FB |
206 | |
207 | led_blink_setup(led_cdev, delay_on, delay_off); | |
208 | } | |
2806e2ff | 209 | EXPORT_SYMBOL_GPL(led_blink_set); |
a403d930 | 210 | |
5bb629c5 FB |
211 | void led_blink_set_oneshot(struct led_classdev *led_cdev, |
212 | unsigned long *delay_on, | |
213 | unsigned long *delay_off, | |
214 | int invert) | |
215 | { | |
a9c6ce57 | 216 | if (test_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags) && |
9067359f | 217 | timer_pending(&led_cdev->blink_timer)) |
5bb629c5 FB |
218 | return; |
219 | ||
a9c6ce57 HG |
220 | set_bit(LED_BLINK_ONESHOT, &led_cdev->work_flags); |
221 | clear_bit(LED_BLINK_ONESHOT_STOP, &led_cdev->work_flags); | |
5bb629c5 FB |
222 | |
223 | if (invert) | |
a9c6ce57 | 224 | set_bit(LED_BLINK_INVERT, &led_cdev->work_flags); |
5bb629c5 | 225 | else |
a9c6ce57 | 226 | clear_bit(LED_BLINK_INVERT, &led_cdev->work_flags); |
5bb629c5 FB |
227 | |
228 | led_blink_setup(led_cdev, delay_on, delay_off); | |
229 | } | |
2806e2ff | 230 | EXPORT_SYMBOL_GPL(led_blink_set_oneshot); |
5bb629c5 | 231 | |
d23a22a7 | 232 | void led_stop_software_blink(struct led_classdev *led_cdev) |
a403d930 | 233 | { |
9067359f | 234 | del_timer_sync(&led_cdev->blink_timer); |
43786482 FB |
235 | led_cdev->blink_delay_on = 0; |
236 | led_cdev->blink_delay_off = 0; | |
a9c6ce57 | 237 | clear_bit(LED_BLINK_SW, &led_cdev->work_flags); |
d23a22a7 FB |
238 | } |
239 | EXPORT_SYMBOL_GPL(led_stop_software_blink); | |
240 | ||
af0bfab9 | 241 | void led_set_brightness(struct led_classdev *led_cdev, unsigned int brightness) |
d23a22a7 | 242 | { |
f1e80c07 | 243 | /* |
7cfe749f | 244 | * If software blink is active, delay brightness setting |
f1e80c07 JA |
245 | * until the next timer tick. |
246 | */ | |
a9c6ce57 | 247 | if (test_bit(LED_BLINK_SW, &led_cdev->work_flags)) { |
f1e80c07 JA |
248 | /* |
249 | * If we need to disable soft blinking delegate this to the | |
250 | * work queue task to avoid problems in case we are called | |
251 | * from hard irq context. | |
252 | */ | |
af0bfab9 | 253 | if (!brightness) { |
a9c6ce57 | 254 | set_bit(LED_BLINK_DISABLE, &led_cdev->work_flags); |
76931edd | 255 | schedule_work(&led_cdev->set_brightness_work); |
f1e80c07 | 256 | } else { |
a9c6ce57 HG |
257 | set_bit(LED_BLINK_BRIGHTNESS_CHANGE, |
258 | &led_cdev->work_flags); | |
eb1610b4 | 259 | led_cdev->new_blink_brightness = brightness; |
f1e80c07 | 260 | } |
d23a22a7 FB |
261 | return; |
262 | } | |
43786482 | 263 | |
13ae79bb | 264 | led_set_brightness_nosleep(led_cdev, brightness); |
a403d930 | 265 | } |
2806e2ff | 266 | EXPORT_SYMBOL_GPL(led_set_brightness); |
3ef7de53 | 267 | |
af0bfab9 | 268 | void led_set_brightness_nopm(struct led_classdev *led_cdev, unsigned int value) |
81fe8e5b JA |
269 | { |
270 | /* Use brightness_set op if available, it is guaranteed not to sleep */ | |
d4887af9 | 271 | if (!__led_set_brightness(led_cdev, value)) |
81fe8e5b | 272 | return; |
81fe8e5b JA |
273 | |
274 | /* If brightness setting can sleep, delegate it to a work queue task */ | |
275 | led_cdev->delayed_set_value = value; | |
276 | schedule_work(&led_cdev->set_brightness_work); | |
277 | } | |
278 | EXPORT_SYMBOL_GPL(led_set_brightness_nopm); | |
279 | ||
af0bfab9 | 280 | void led_set_brightness_nosleep(struct led_classdev *led_cdev, unsigned int value) |
81fe8e5b JA |
281 | { |
282 | led_cdev->brightness = min(value, led_cdev->max_brightness); | |
283 | ||
284 | if (led_cdev->flags & LED_SUSPENDED) | |
285 | return; | |
286 | ||
287 | led_set_brightness_nopm(led_cdev, led_cdev->brightness); | |
288 | } | |
289 | EXPORT_SYMBOL_GPL(led_set_brightness_nosleep); | |
290 | ||
af0bfab9 | 291 | int led_set_brightness_sync(struct led_classdev *led_cdev, unsigned int value) |
13ae79bb JA |
292 | { |
293 | if (led_cdev->blink_delay_on || led_cdev->blink_delay_off) | |
294 | return -EBUSY; | |
295 | ||
296 | led_cdev->brightness = min(value, led_cdev->max_brightness); | |
297 | ||
298 | if (led_cdev->flags & LED_SUSPENDED) | |
299 | return 0; | |
300 | ||
d4887af9 | 301 | return __led_set_brightness_blocking(led_cdev, led_cdev->brightness); |
13ae79bb JA |
302 | } |
303 | EXPORT_SYMBOL_GPL(led_set_brightness_sync); | |
304 | ||
3ef7de53 JA |
305 | int led_update_brightness(struct led_classdev *led_cdev) |
306 | { | |
307 | int ret = 0; | |
308 | ||
309 | if (led_cdev->brightness_get) { | |
310 | ret = led_cdev->brightness_get(led_cdev); | |
311 | if (ret >= 0) { | |
312 | led_cdev->brightness = ret; | |
313 | return 0; | |
314 | } | |
315 | } | |
316 | ||
317 | return ret; | |
318 | } | |
2806e2ff | 319 | EXPORT_SYMBOL_GPL(led_update_brightness); |
acd899e4 | 320 | |
8e1f4561 KK |
321 | u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size) |
322 | { | |
fd81d7e9 | 323 | struct fwnode_handle *fwnode = led_cdev->dev->fwnode; |
8e1f4561 KK |
324 | u32 *pattern; |
325 | int count; | |
326 | ||
fd81d7e9 | 327 | count = fwnode_property_count_u32(fwnode, "led-pattern"); |
8e1f4561 KK |
328 | if (count < 0) |
329 | return NULL; | |
330 | ||
331 | pattern = kcalloc(count, sizeof(*pattern), GFP_KERNEL); | |
332 | if (!pattern) | |
333 | return NULL; | |
334 | ||
fd81d7e9 | 335 | if (fwnode_property_read_u32_array(fwnode, "led-pattern", pattern, count)) { |
8e1f4561 KK |
336 | kfree(pattern); |
337 | return NULL; | |
338 | } | |
339 | ||
340 | *size = count; | |
341 | ||
342 | return pattern; | |
343 | } | |
344 | EXPORT_SYMBOL_GPL(led_get_default_pattern); | |
345 | ||
acd899e4 JA |
346 | /* Caller must ensure led_cdev->led_access held */ |
347 | void led_sysfs_disable(struct led_classdev *led_cdev) | |
348 | { | |
349 | lockdep_assert_held(&led_cdev->led_access); | |
350 | ||
351 | led_cdev->flags |= LED_SYSFS_DISABLE; | |
352 | } | |
353 | EXPORT_SYMBOL_GPL(led_sysfs_disable); | |
354 | ||
355 | /* Caller must ensure led_cdev->led_access held */ | |
356 | void led_sysfs_enable(struct led_classdev *led_cdev) | |
357 | { | |
358 | lockdep_assert_held(&led_cdev->led_access); | |
359 | ||
360 | led_cdev->flags &= ~LED_SYSFS_DISABLE; | |
361 | } | |
362 | EXPORT_SYMBOL_GPL(led_sysfs_enable); | |
bb4e9af0 JA |
363 | |
364 | static void led_parse_fwnode_props(struct device *dev, | |
365 | struct fwnode_handle *fwnode, | |
366 | struct led_properties *props) | |
367 | { | |
368 | int ret; | |
369 | ||
370 | if (!fwnode) | |
371 | return; | |
372 | ||
373 | if (fwnode_property_present(fwnode, "label")) { | |
374 | ret = fwnode_property_read_string(fwnode, "label", &props->label); | |
375 | if (ret) | |
376 | dev_err(dev, "Error parsing 'label' property (%d)\n", ret); | |
377 | return; | |
378 | } | |
379 | ||
380 | if (fwnode_property_present(fwnode, "color")) { | |
381 | ret = fwnode_property_read_u32(fwnode, "color", &props->color); | |
382 | if (ret) | |
383 | dev_err(dev, "Error parsing 'color' property (%d)\n", ret); | |
384 | else if (props->color >= LED_COLOR_ID_MAX) | |
385 | dev_err(dev, "LED color identifier out of range\n"); | |
386 | else | |
387 | props->color_present = true; | |
388 | } | |
389 | ||
390 | ||
391 | if (!fwnode_property_present(fwnode, "function")) | |
392 | return; | |
393 | ||
394 | ret = fwnode_property_read_string(fwnode, "function", &props->function); | |
395 | if (ret) { | |
396 | dev_err(dev, | |
397 | "Error parsing 'function' property (%d)\n", | |
398 | ret); | |
399 | } | |
400 | ||
401 | if (!fwnode_property_present(fwnode, "function-enumerator")) | |
402 | return; | |
403 | ||
404 | ret = fwnode_property_read_u32(fwnode, "function-enumerator", | |
405 | &props->func_enum); | |
406 | if (ret) { | |
407 | dev_err(dev, | |
408 | "Error parsing 'function-enumerator' property (%d)\n", | |
409 | ret); | |
410 | } else { | |
411 | props->func_enum_present = true; | |
412 | } | |
413 | } | |
414 | ||
415 | int led_compose_name(struct device *dev, struct led_init_data *init_data, | |
416 | char *led_classdev_name) | |
417 | { | |
418 | struct led_properties props = {}; | |
419 | struct fwnode_handle *fwnode = init_data->fwnode; | |
420 | const char *devicename = init_data->devicename; | |
421 | ||
77dce3a2 PM |
422 | /* We want to label LEDs that can produce full range of colors |
423 | * as RGB, not multicolor */ | |
424 | BUG_ON(props.color == LED_COLOR_ID_MULTI); | |
425 | ||
bb4e9af0 JA |
426 | if (!led_classdev_name) |
427 | return -EINVAL; | |
428 | ||
429 | led_parse_fwnode_props(dev, fwnode, &props); | |
430 | ||
431 | if (props.label) { | |
432 | /* | |
433 | * If init_data.devicename is NULL, then it indicates that | |
434 | * DT label should be used as-is for LED class device name. | |
435 | * Otherwise the label is prepended with devicename to compose | |
436 | * the final LED class device name. | |
437 | */ | |
438 | if (!devicename) { | |
439 | strscpy(led_classdev_name, props.label, | |
440 | LED_MAX_NAME_SIZE); | |
441 | } else { | |
442 | snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s", | |
443 | devicename, props.label); | |
444 | } | |
445 | } else if (props.function || props.color_present) { | |
446 | char tmp_buf[LED_MAX_NAME_SIZE]; | |
447 | ||
448 | if (props.func_enum_present) { | |
449 | snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s-%d", | |
450 | props.color_present ? led_colors[props.color] : "", | |
451 | props.function ?: "", props.func_enum); | |
452 | } else { | |
453 | snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s", | |
454 | props.color_present ? led_colors[props.color] : "", | |
455 | props.function ?: ""); | |
456 | } | |
457 | if (init_data->devname_mandatory) { | |
458 | snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s", | |
459 | devicename, tmp_buf); | |
460 | } else { | |
461 | strscpy(led_classdev_name, tmp_buf, LED_MAX_NAME_SIZE); | |
462 | ||
463 | } | |
464 | } else if (init_data->default_label) { | |
465 | if (!devicename) { | |
466 | dev_err(dev, "Legacy LED naming requires devicename segment"); | |
467 | return -EINVAL; | |
468 | } | |
469 | snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s", | |
470 | devicename, init_data->default_label); | |
471 | } else if (is_of_node(fwnode)) { | |
472 | strscpy(led_classdev_name, to_of_node(fwnode)->name, | |
473 | LED_MAX_NAME_SIZE); | |
474 | } else | |
475 | return -EINVAL; | |
476 | ||
477 | return 0; | |
478 | } | |
479 | EXPORT_SYMBOL_GPL(led_compose_name); | |
791bc411 DOH |
480 | |
481 | enum led_default_state led_init_default_state_get(struct fwnode_handle *fwnode) | |
482 | { | |
483 | const char *state = NULL; | |
484 | ||
485 | if (!fwnode_property_read_string(fwnode, "default-state", &state)) { | |
486 | if (!strcmp(state, "keep")) | |
487 | return LEDS_DEFSTATE_KEEP; | |
488 | if (!strcmp(state, "on")) | |
489 | return LEDS_DEFSTATE_ON; | |
490 | } | |
491 | ||
492 | return LEDS_DEFSTATE_OFF; | |
493 | } | |
494 | EXPORT_SYMBOL_GPL(led_init_default_state_get); |