Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0-only */
2 : : /*
3 : : * Driver model for leds and led triggers
4 : : *
5 : : * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
6 : : * Copyright (C) 2005 Richard Purdie <rpurdie@openedhand.com>
7 : : */
8 : : #ifndef __LINUX_LEDS_H_INCLUDED
9 : : #define __LINUX_LEDS_H_INCLUDED
10 : :
11 : : #include <dt-bindings/leds/common.h>
12 : : #include <linux/device.h>
13 : : #include <linux/kernfs.h>
14 : : #include <linux/list.h>
15 : : #include <linux/mutex.h>
16 : : #include <linux/rwsem.h>
17 : : #include <linux/spinlock.h>
18 : : #include <linux/timer.h>
19 : : #include <linux/workqueue.h>
20 : :
21 : : struct device;
22 : : struct led_pattern;
23 : : /*
24 : : * LED Core
25 : : */
26 : :
27 : : enum led_brightness {
28 : : LED_OFF = 0,
29 : : LED_ON = 1,
30 : : LED_HALF = 127,
31 : : LED_FULL = 255,
32 : : };
33 : :
34 : : struct led_init_data {
35 : : /* device fwnode handle */
36 : : struct fwnode_handle *fwnode;
37 : : /*
38 : : * default <color:function> tuple, for backward compatibility
39 : : * with in-driver hard-coded LED names used as a fallback when
40 : : * DT "label" property is absent; it should be set to NULL
41 : : * in new LED class drivers.
42 : : */
43 : : const char *default_label;
44 : : /*
45 : : * string to be used for devicename section of LED class device
46 : : * either for label based LED name composition path or for fwnode
47 : : * based when devname_mandatory is true
48 : : */
49 : : const char *devicename;
50 : : /*
51 : : * indicates if LED name should always comprise devicename section;
52 : : * only LEDs exposed by drivers of hot-pluggable devices should
53 : : * set it to true
54 : : */
55 : : bool devname_mandatory;
56 : : };
57 : :
58 : : struct led_classdev {
59 : : const char *name;
60 : : enum led_brightness brightness;
61 : : enum led_brightness max_brightness;
62 : : int flags;
63 : :
64 : : /* Lower 16 bits reflect status */
65 : : #define LED_SUSPENDED BIT(0)
66 : : #define LED_UNREGISTERING BIT(1)
67 : : /* Upper 16 bits reflect control information */
68 : : #define LED_CORE_SUSPENDRESUME BIT(16)
69 : : #define LED_SYSFS_DISABLE BIT(17)
70 : : #define LED_DEV_CAP_FLASH BIT(18)
71 : : #define LED_HW_PLUGGABLE BIT(19)
72 : : #define LED_PANIC_INDICATOR BIT(20)
73 : : #define LED_BRIGHT_HW_CHANGED BIT(21)
74 : : #define LED_RETAIN_AT_SHUTDOWN BIT(22)
75 : : #define LED_INIT_DEFAULT_TRIGGER BIT(23)
76 : : /* Additions for Raspberry Pi PWR LED */
77 : : #define SET_GPIO_INPUT BIT(30)
78 : : #define SET_GPIO_OUTPUT BIT(31)
79 : :
80 : : /* set_brightness_work / blink_timer flags, atomic, private. */
81 : : unsigned long work_flags;
82 : :
83 : : #define LED_BLINK_SW 0
84 : : #define LED_BLINK_ONESHOT 1
85 : : #define LED_BLINK_ONESHOT_STOP 2
86 : : #define LED_BLINK_INVERT 3
87 : : #define LED_BLINK_BRIGHTNESS_CHANGE 4
88 : : #define LED_BLINK_DISABLE 5
89 : :
90 : : /* Set LED brightness level
91 : : * Must not sleep. Use brightness_set_blocking for drivers
92 : : * that can sleep while setting brightness.
93 : : */
94 : : void (*brightness_set)(struct led_classdev *led_cdev,
95 : : enum led_brightness brightness);
96 : : /*
97 : : * Set LED brightness level immediately - it can block the caller for
98 : : * the time required for accessing a LED device register.
99 : : */
100 : : int (*brightness_set_blocking)(struct led_classdev *led_cdev,
101 : : enum led_brightness brightness);
102 : : /* Get LED brightness level */
103 : : enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
104 : :
105 : : /*
106 : : * Activate hardware accelerated blink, delays are in milliseconds
107 : : * and if both are zero then a sensible default should be chosen.
108 : : * The call should adjust the timings in that case and if it can't
109 : : * match the values specified exactly.
110 : : * Deactivate blinking again when the brightness is set to LED_OFF
111 : : * via the brightness_set() callback.
112 : : */
113 : : int (*blink_set)(struct led_classdev *led_cdev,
114 : : unsigned long *delay_on,
115 : : unsigned long *delay_off);
116 : :
117 : : int (*pattern_set)(struct led_classdev *led_cdev,
118 : : struct led_pattern *pattern, u32 len, int repeat);
119 : : int (*pattern_clear)(struct led_classdev *led_cdev);
120 : :
121 : : struct device *dev;
122 : : const struct attribute_group **groups;
123 : :
124 : : struct list_head node; /* LED Device list */
125 : : const char *default_trigger; /* Trigger to use */
126 : :
127 : : unsigned long blink_delay_on, blink_delay_off;
128 : : struct timer_list blink_timer;
129 : : int blink_brightness;
130 : : int new_blink_brightness;
131 : : void (*flash_resume)(struct led_classdev *led_cdev);
132 : :
133 : : struct work_struct set_brightness_work;
134 : : int delayed_set_value;
135 : :
136 : : #ifdef CONFIG_LEDS_TRIGGERS
137 : : /* Protects the trigger data below */
138 : : struct rw_semaphore trigger_lock;
139 : :
140 : : struct led_trigger *trigger;
141 : : struct list_head trig_list;
142 : : void *trigger_data;
143 : : /* true if activated - deactivate routine uses it to do cleanup */
144 : : bool activated;
145 : : #endif
146 : :
147 : : #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
148 : : int brightness_hw_changed;
149 : : struct kernfs_node *brightness_hw_changed_kn;
150 : : #endif
151 : :
152 : : /* Ensures consistent access to the LED Flash Class device */
153 : : struct mutex led_access;
154 : : };
155 : :
156 : : /**
157 : : * led_classdev_register_ext - register a new object of LED class with
158 : : * init data
159 : : * @parent: LED controller device this LED is driven by
160 : : * @led_cdev: the led_classdev structure for this device
161 : : * @init_data: the LED class device initialization data
162 : : *
163 : : * Register a new object of LED class, with name derived from init_data.
164 : : *
165 : : * Returns: 0 on success or negative error value on failure
166 : : */
167 : : extern int led_classdev_register_ext(struct device *parent,
168 : : struct led_classdev *led_cdev,
169 : : struct led_init_data *init_data);
170 : :
171 : : /**
172 : : * led_classdev_register - register a new object of LED class
173 : : * @parent: LED controller device this LED is driven by
174 : : * @led_cdev: the led_classdev structure for this device
175 : : *
176 : : * Register a new object of LED class, with name derived from the name property
177 : : * of passed led_cdev argument.
178 : : *
179 : : * Returns: 0 on success or negative error value on failure
180 : : */
181 : : static inline int led_classdev_register(struct device *parent,
182 : : struct led_classdev *led_cdev)
183 : : {
184 : 1449 : return led_classdev_register_ext(parent, led_cdev, NULL);
185 : : }
186 : :
187 : : extern int devm_led_classdev_register_ext(struct device *parent,
188 : : struct led_classdev *led_cdev,
189 : : struct led_init_data *init_data);
190 : :
191 : : static inline int devm_led_classdev_register(struct device *parent,
192 : : struct led_classdev *led_cdev)
193 : : {
194 : 0 : return devm_led_classdev_register_ext(parent, led_cdev, NULL);
195 : : }
196 : : extern void led_classdev_unregister(struct led_classdev *led_cdev);
197 : : extern void devm_led_classdev_unregister(struct device *parent,
198 : : struct led_classdev *led_cdev);
199 : : extern void led_classdev_suspend(struct led_classdev *led_cdev);
200 : : extern void led_classdev_resume(struct led_classdev *led_cdev);
201 : :
202 : : /**
203 : : * led_blink_set - set blinking with software fallback
204 : : * @led_cdev: the LED to start blinking
205 : : * @delay_on: the time it should be on (in ms)
206 : : * @delay_off: the time it should ble off (in ms)
207 : : *
208 : : * This function makes the LED blink, attempting to use the
209 : : * hardware acceleration if possible, but falling back to
210 : : * software blinking if there is no hardware blinking or if
211 : : * the LED refuses the passed values.
212 : : *
213 : : * Note that if software blinking is active, simply calling
214 : : * led_cdev->brightness_set() will not stop the blinking,
215 : : * use led_classdev_brightness_set() instead.
216 : : */
217 : : extern void led_blink_set(struct led_classdev *led_cdev,
218 : : unsigned long *delay_on,
219 : : unsigned long *delay_off);
220 : : /**
221 : : * led_blink_set_oneshot - do a oneshot software blink
222 : : * @led_cdev: the LED to start blinking
223 : : * @delay_on: the time it should be on (in ms)
224 : : * @delay_off: the time it should ble off (in ms)
225 : : * @invert: blink off, then on, leaving the led on
226 : : *
227 : : * This function makes the LED blink one time for delay_on +
228 : : * delay_off time, ignoring the request if another one-shot
229 : : * blink is already in progress.
230 : : *
231 : : * If invert is set, led blinks for delay_off first, then for
232 : : * delay_on and leave the led on after the on-off cycle.
233 : : */
234 : : extern void led_blink_set_oneshot(struct led_classdev *led_cdev,
235 : : unsigned long *delay_on,
236 : : unsigned long *delay_off,
237 : : int invert);
238 : : /**
239 : : * led_set_brightness - set LED brightness
240 : : * @led_cdev: the LED to set
241 : : * @brightness: the brightness to set it to
242 : : *
243 : : * Set an LED's brightness, and, if necessary, cancel the
244 : : * software blink timer that implements blinking when the
245 : : * hardware doesn't. This function is guaranteed not to sleep.
246 : : */
247 : : extern void led_set_brightness(struct led_classdev *led_cdev,
248 : : enum led_brightness brightness);
249 : :
250 : : /**
251 : : * led_set_brightness_sync - set LED brightness synchronously
252 : : * @led_cdev: the LED to set
253 : : * @value: the brightness to set it to
254 : : *
255 : : * Set an LED's brightness immediately. This function will block
256 : : * the caller for the time required for accessing device registers,
257 : : * and it can sleep.
258 : : *
259 : : * Returns: 0 on success or negative error value on failure
260 : : */
261 : : extern int led_set_brightness_sync(struct led_classdev *led_cdev,
262 : : enum led_brightness value);
263 : :
264 : : /**
265 : : * led_update_brightness - update LED brightness
266 : : * @led_cdev: the LED to query
267 : : *
268 : : * Get an LED's current brightness and update led_cdev->brightness
269 : : * member with the obtained value.
270 : : *
271 : : * Returns: 0 on success or negative error value on failure
272 : : */
273 : : extern int led_update_brightness(struct led_classdev *led_cdev);
274 : :
275 : : /**
276 : : * led_get_default_pattern - return default pattern
277 : : *
278 : : * @led_cdev: the LED to get default pattern for
279 : : * @size: pointer for storing the number of elements in returned array,
280 : : * modified only if return != NULL
281 : : *
282 : : * Return: Allocated array of integers with default pattern from device tree
283 : : * or NULL. Caller is responsible for kfree().
284 : : */
285 : : extern u32 *led_get_default_pattern(struct led_classdev *led_cdev,
286 : : unsigned int *size);
287 : :
288 : : /**
289 : : * led_sysfs_disable - disable LED sysfs interface
290 : : * @led_cdev: the LED to set
291 : : *
292 : : * Disable the led_cdev's sysfs interface.
293 : : */
294 : : extern void led_sysfs_disable(struct led_classdev *led_cdev);
295 : :
296 : : /**
297 : : * led_sysfs_enable - enable LED sysfs interface
298 : : * @led_cdev: the LED to set
299 : : *
300 : : * Enable the led_cdev's sysfs interface.
301 : : */
302 : : extern void led_sysfs_enable(struct led_classdev *led_cdev);
303 : :
304 : : /**
305 : : * led_compose_name - compose LED class device name
306 : : * @dev: LED controller device object
307 : : * @init_data: the LED class device initialization data
308 : : * @led_classdev_name: composed LED class device name
309 : : *
310 : : * Create LED class device name basing on the provided init_data argument.
311 : : * The name can have <devicename:color:function> or <color:function>.
312 : : * form, depending on the init_data configuration.
313 : : *
314 : : * Returns: 0 on success or negative error value on failure
315 : : */
316 : : extern int led_compose_name(struct device *dev, struct led_init_data *init_data,
317 : : char *led_classdev_name);
318 : :
319 : : /**
320 : : * led_sysfs_is_disabled - check if LED sysfs interface is disabled
321 : : * @led_cdev: the LED to query
322 : : *
323 : : * Returns: true if the led_cdev's sysfs interface is disabled.
324 : : */
325 : : static inline bool led_sysfs_is_disabled(struct led_classdev *led_cdev)
326 : : {
327 : 0 : return led_cdev->flags & LED_SYSFS_DISABLE;
328 : : }
329 : :
330 : : /*
331 : : * LED Triggers
332 : : */
333 : : /* Registration functions for simple triggers */
334 : : #define DEFINE_LED_TRIGGER(x) static struct led_trigger *x;
335 : : #define DEFINE_LED_TRIGGER_GLOBAL(x) struct led_trigger *x;
336 : :
337 : : #ifdef CONFIG_LEDS_TRIGGERS
338 : :
339 : : #define TRIG_NAME_MAX 50
340 : :
341 : : struct led_trigger {
342 : : /* Trigger Properties */
343 : : const char *name;
344 : : int (*activate)(struct led_classdev *led_cdev);
345 : : void (*deactivate)(struct led_classdev *led_cdev);
346 : :
347 : : /* LEDs under control by this trigger (for simple triggers) */
348 : : rwlock_t leddev_list_lock;
349 : : struct list_head led_cdevs;
350 : :
351 : : /* Link to next registered trigger */
352 : : struct list_head next_trig;
353 : :
354 : : const struct attribute_group **groups;
355 : : };
356 : :
357 : : /*
358 : : * Currently the attributes in struct led_trigger::groups are added directly to
359 : : * the LED device. As this might change in the future, the following
360 : : * macros abstract getting the LED device and its trigger_data from the dev
361 : : * parameter passed to the attribute accessor functions.
362 : : */
363 : : #define led_trigger_get_led(dev) ((struct led_classdev *)dev_get_drvdata((dev)))
364 : : #define led_trigger_get_drvdata(dev) (led_get_trigger_data(led_trigger_get_led(dev)))
365 : :
366 : : ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
367 : : const char *buf, size_t count);
368 : : ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
369 : : char *buf);
370 : :
371 : : /* Registration functions for complex triggers */
372 : : extern int led_trigger_register(struct led_trigger *trigger);
373 : : extern void led_trigger_unregister(struct led_trigger *trigger);
374 : : extern int devm_led_trigger_register(struct device *dev,
375 : : struct led_trigger *trigger);
376 : :
377 : : extern void led_trigger_register_simple(const char *name,
378 : : struct led_trigger **trigger);
379 : : extern void led_trigger_unregister_simple(struct led_trigger *trigger);
380 : : extern void led_trigger_event(struct led_trigger *trigger,
381 : : enum led_brightness event);
382 : : extern void led_trigger_blink(struct led_trigger *trigger,
383 : : unsigned long *delay_on,
384 : : unsigned long *delay_off);
385 : : extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
386 : : unsigned long *delay_on,
387 : : unsigned long *delay_off,
388 : : int invert);
389 : : extern void led_trigger_set_default(struct led_classdev *led_cdev);
390 : : extern int led_trigger_set(struct led_classdev *led_cdev,
391 : : struct led_trigger *trigger);
392 : : extern void led_trigger_remove(struct led_classdev *led_cdev);
393 : :
394 : : static inline void led_set_trigger_data(struct led_classdev *led_cdev,
395 : : void *trigger_data)
396 : : {
397 : 0 : led_cdev->trigger_data = trigger_data;
398 : : }
399 : :
400 : : static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
401 : : {
402 : 0 : return led_cdev->trigger_data;
403 : : }
404 : :
405 : : /**
406 : : * led_trigger_rename_static - rename a trigger
407 : : * @name: the new trigger name
408 : : * @trig: the LED trigger to rename
409 : : *
410 : : * Change a LED trigger name by copying the string passed in
411 : : * name into current trigger name, which MUST be large
412 : : * enough for the new string.
413 : : *
414 : : * Note that name must NOT point to the same string used
415 : : * during LED registration, as that could lead to races.
416 : : *
417 : : * This is meant to be used on triggers with statically
418 : : * allocated name.
419 : : */
420 : : extern void led_trigger_rename_static(const char *name,
421 : : struct led_trigger *trig);
422 : :
423 : : #define module_led_trigger(__led_trigger) \
424 : : module_driver(__led_trigger, led_trigger_register, \
425 : : led_trigger_unregister)
426 : :
427 : : #else
428 : :
429 : : /* Trigger has no members */
430 : : struct led_trigger {};
431 : :
432 : : /* Trigger inline empty functions */
433 : : static inline void led_trigger_register_simple(const char *name,
434 : : struct led_trigger **trigger) {}
435 : : static inline void led_trigger_unregister_simple(struct led_trigger *trigger) {}
436 : : static inline void led_trigger_event(struct led_trigger *trigger,
437 : : enum led_brightness event) {}
438 : : static inline void led_trigger_blink(struct led_trigger *trigger,
439 : : unsigned long *delay_on,
440 : : unsigned long *delay_off) {}
441 : : static inline void led_trigger_blink_oneshot(struct led_trigger *trigger,
442 : : unsigned long *delay_on,
443 : : unsigned long *delay_off,
444 : : int invert) {}
445 : : static inline void led_trigger_set_default(struct led_classdev *led_cdev) {}
446 : : static inline int led_trigger_set(struct led_classdev *led_cdev,
447 : : struct led_trigger *trigger)
448 : : {
449 : : return 0;
450 : : }
451 : :
452 : : static inline void led_trigger_remove(struct led_classdev *led_cdev) {}
453 : : static inline void led_set_trigger_data(struct led_classdev *led_cdev) {}
454 : : static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
455 : : {
456 : : return NULL;
457 : : }
458 : :
459 : : #endif /* CONFIG_LEDS_TRIGGERS */
460 : :
461 : : /* Trigger specific functions */
462 : : #ifdef CONFIG_LEDS_TRIGGER_DISK
463 : : extern void ledtrig_disk_activity(bool write);
464 : : #else
465 : : static inline void ledtrig_disk_activity(bool write) {}
466 : : #endif
467 : :
468 : : #ifdef CONFIG_LEDS_TRIGGER_MTD
469 : : extern void ledtrig_mtd_activity(void);
470 : : #else
471 : : static inline void ledtrig_mtd_activity(void) {}
472 : : #endif
473 : :
474 : : #if defined(CONFIG_LEDS_TRIGGER_CAMERA) || defined(CONFIG_LEDS_TRIGGER_CAMERA_MODULE)
475 : : extern void ledtrig_flash_ctrl(bool on);
476 : : extern void ledtrig_torch_ctrl(bool on);
477 : : #else
478 : : static inline void ledtrig_flash_ctrl(bool on) {}
479 : : static inline void ledtrig_torch_ctrl(bool on) {}
480 : : #endif
481 : :
482 : : /*
483 : : * Generic LED platform data for describing LED names and default triggers.
484 : : */
485 : : struct led_info {
486 : : const char *name;
487 : : const char *default_trigger;
488 : : int flags;
489 : : };
490 : :
491 : : struct led_platform_data {
492 : : int num_leds;
493 : : struct led_info *leds;
494 : : };
495 : :
496 : : struct led_properties {
497 : : u32 color;
498 : : bool color_present;
499 : : const char *function;
500 : : u32 func_enum;
501 : : bool func_enum_present;
502 : : const char *label;
503 : : };
504 : :
505 : : struct gpio_desc;
506 : : typedef int (*gpio_blink_set_t)(struct gpio_desc *desc, int state,
507 : : unsigned long *delay_on,
508 : : unsigned long *delay_off);
509 : :
510 : : /* For the leds-gpio driver */
511 : : struct gpio_led {
512 : : const char *name;
513 : : const char *default_trigger;
514 : : unsigned gpio;
515 : : unsigned active_low : 1;
516 : : unsigned retain_state_suspended : 1;
517 : : unsigned panic_indicator : 1;
518 : : unsigned default_state : 2;
519 : : unsigned retain_state_shutdown : 1;
520 : : /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
521 : : struct gpio_desc *gpiod;
522 : : };
523 : : #define LEDS_GPIO_DEFSTATE_OFF 0
524 : : #define LEDS_GPIO_DEFSTATE_ON 1
525 : : #define LEDS_GPIO_DEFSTATE_KEEP 2
526 : :
527 : : struct gpio_led_platform_data {
528 : : int num_leds;
529 : : const struct gpio_led *leds;
530 : :
531 : : #define GPIO_LED_NO_BLINK_LOW 0 /* No blink GPIO state low */
532 : : #define GPIO_LED_NO_BLINK_HIGH 1 /* No blink GPIO state high */
533 : : #define GPIO_LED_BLINK 2 /* Please, blink */
534 : : gpio_blink_set_t gpio_blink_set;
535 : : };
536 : :
537 : : #ifdef CONFIG_NEW_LEDS
538 : : struct platform_device *gpio_led_register_device(
539 : : int id, const struct gpio_led_platform_data *pdata);
540 : : #else
541 : : static inline struct platform_device *gpio_led_register_device(
542 : : int id, const struct gpio_led_platform_data *pdata)
543 : : {
544 : : return 0;
545 : : }
546 : : #endif
547 : :
548 : : enum cpu_led_event {
549 : : CPU_LED_IDLE_START, /* CPU enters idle */
550 : : CPU_LED_IDLE_END, /* CPU idle ends */
551 : : CPU_LED_START, /* Machine starts, especially resume */
552 : : CPU_LED_STOP, /* Machine stops, especially suspend */
553 : : CPU_LED_HALTED, /* Machine shutdown */
554 : : };
555 : : #ifdef CONFIG_LEDS_TRIGGER_CPU
556 : : extern void ledtrig_cpu(enum cpu_led_event evt);
557 : : #else
558 : : static inline void ledtrig_cpu(enum cpu_led_event evt)
559 : : {
560 : : return;
561 : : }
562 : : #endif
563 : :
564 : : #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
565 : : extern void led_classdev_notify_brightness_hw_changed(
566 : : struct led_classdev *led_cdev, enum led_brightness brightness);
567 : : #else
568 : : static inline void led_classdev_notify_brightness_hw_changed(
569 : : struct led_classdev *led_cdev, enum led_brightness brightness) { }
570 : : #endif
571 : :
572 : : /**
573 : : * struct led_pattern - pattern interval settings
574 : : * @delta_t: pattern interval delay, in milliseconds
575 : : * @brightness: pattern interval brightness
576 : : */
577 : : struct led_pattern {
578 : : u32 delta_t;
579 : : int brightness;
580 : : };
581 : :
582 : : enum led_audio {
583 : : LED_AUDIO_MUTE, /* master mute LED */
584 : : LED_AUDIO_MICMUTE, /* mic mute LED */
585 : : NUM_AUDIO_LEDS
586 : : };
587 : :
588 : : #if IS_ENABLED(CONFIG_LEDS_TRIGGER_AUDIO)
589 : : enum led_brightness ledtrig_audio_get(enum led_audio type);
590 : : void ledtrig_audio_set(enum led_audio type, enum led_brightness state);
591 : : #else
592 : : static inline enum led_brightness ledtrig_audio_get(enum led_audio type)
593 : : {
594 : : return LED_OFF;
595 : : }
596 : : static inline void ledtrig_audio_set(enum led_audio type,
597 : : enum led_brightness state)
598 : : {
599 : : }
600 : : #endif
601 : :
602 : : #endif /* __LINUX_LEDS_H_INCLUDED */
|
