Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mattst88...
[linux-2.6-microblaze.git] / include / linux / leds.h
1 /*
2  * Driver model for leds and led triggers
3  *
4  * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
5  * Copyright (C) 2005 Richard Purdie <rpurdie@openedhand.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  *
11  */
12 #ifndef __LINUX_LEDS_H_INCLUDED
13 #define __LINUX_LEDS_H_INCLUDED
14
15 #include <linux/device.h>
16 #include <linux/kernfs.h>
17 #include <linux/list.h>
18 #include <linux/mutex.h>
19 #include <linux/rwsem.h>
20 #include <linux/spinlock.h>
21 #include <linux/timer.h>
22 #include <linux/workqueue.h>
23
24 struct device;
25 /*
26  * LED Core
27  */
28
29 enum led_brightness {
30         LED_OFF         = 0,
31         LED_ON          = 1,
32         LED_HALF        = 127,
33         LED_FULL        = 255,
34 };
35
36 struct led_classdev {
37         const char              *name;
38         enum led_brightness      brightness;
39         enum led_brightness      max_brightness;
40         int                      flags;
41
42         /* Lower 16 bits reflect status */
43 #define LED_SUSPENDED           BIT(0)
44 #define LED_UNREGISTERING       BIT(1)
45         /* Upper 16 bits reflect control information */
46 #define LED_CORE_SUSPENDRESUME  BIT(16)
47 #define LED_SYSFS_DISABLE       BIT(17)
48 #define LED_DEV_CAP_FLASH       BIT(18)
49 #define LED_HW_PLUGGABLE        BIT(19)
50 #define LED_PANIC_INDICATOR     BIT(20)
51 #define LED_BRIGHT_HW_CHANGED   BIT(21)
52 #define LED_RETAIN_AT_SHUTDOWN  BIT(22)
53
54         /* set_brightness_work / blink_timer flags, atomic, private. */
55         unsigned long           work_flags;
56
57 #define LED_BLINK_SW                    0
58 #define LED_BLINK_ONESHOT               1
59 #define LED_BLINK_ONESHOT_STOP          2
60 #define LED_BLINK_INVERT                3
61 #define LED_BLINK_BRIGHTNESS_CHANGE     4
62 #define LED_BLINK_DISABLE               5
63
64         /* Set LED brightness level
65          * Must not sleep. Use brightness_set_blocking for drivers
66          * that can sleep while setting brightness.
67          */
68         void            (*brightness_set)(struct led_classdev *led_cdev,
69                                           enum led_brightness brightness);
70         /*
71          * Set LED brightness level immediately - it can block the caller for
72          * the time required for accessing a LED device register.
73          */
74         int (*brightness_set_blocking)(struct led_classdev *led_cdev,
75                                        enum led_brightness brightness);
76         /* Get LED brightness level */
77         enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
78
79         /*
80          * Activate hardware accelerated blink, delays are in milliseconds
81          * and if both are zero then a sensible default should be chosen.
82          * The call should adjust the timings in that case and if it can't
83          * match the values specified exactly.
84          * Deactivate blinking again when the brightness is set to LED_OFF
85          * via the brightness_set() callback.
86          */
87         int             (*blink_set)(struct led_classdev *led_cdev,
88                                      unsigned long *delay_on,
89                                      unsigned long *delay_off);
90
91         struct device           *dev;
92         const struct attribute_group    **groups;
93
94         struct list_head         node;                  /* LED Device list */
95         const char              *default_trigger;       /* Trigger to use */
96
97         unsigned long            blink_delay_on, blink_delay_off;
98         struct timer_list        blink_timer;
99         int                      blink_brightness;
100         int                      new_blink_brightness;
101         void                    (*flash_resume)(struct led_classdev *led_cdev);
102
103         struct work_struct      set_brightness_work;
104         int                     delayed_set_value;
105
106 #ifdef CONFIG_LEDS_TRIGGERS
107         /* Protects the trigger data below */
108         struct rw_semaphore      trigger_lock;
109
110         struct led_trigger      *trigger;
111         struct list_head         trig_list;
112         void                    *trigger_data;
113         /* true if activated - deactivate routine uses it to do cleanup */
114         bool                    activated;
115 #endif
116
117 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
118         int                      brightness_hw_changed;
119         struct kernfs_node      *brightness_hw_changed_kn;
120 #endif
121
122         /* Ensures consistent access to the LED Flash Class device */
123         struct mutex            led_access;
124 };
125
126 extern int of_led_classdev_register(struct device *parent,
127                                     struct device_node *np,
128                                     struct led_classdev *led_cdev);
129 #define led_classdev_register(parent, led_cdev)                         \
130         of_led_classdev_register(parent, NULL, led_cdev)
131 extern int devm_of_led_classdev_register(struct device *parent,
132                                          struct device_node *np,
133                                          struct led_classdev *led_cdev);
134 #define devm_led_classdev_register(parent, led_cdev)                    \
135         devm_of_led_classdev_register(parent, NULL, led_cdev)
136 extern void led_classdev_unregister(struct led_classdev *led_cdev);
137 extern void devm_led_classdev_unregister(struct device *parent,
138                                          struct led_classdev *led_cdev);
139 extern void led_classdev_suspend(struct led_classdev *led_cdev);
140 extern void led_classdev_resume(struct led_classdev *led_cdev);
141
142 /**
143  * led_blink_set - set blinking with software fallback
144  * @led_cdev: the LED to start blinking
145  * @delay_on: the time it should be on (in ms)
146  * @delay_off: the time it should ble off (in ms)
147  *
148  * This function makes the LED blink, attempting to use the
149  * hardware acceleration if possible, but falling back to
150  * software blinking if there is no hardware blinking or if
151  * the LED refuses the passed values.
152  *
153  * Note that if software blinking is active, simply calling
154  * led_cdev->brightness_set() will not stop the blinking,
155  * use led_classdev_brightness_set() instead.
156  */
157 extern void led_blink_set(struct led_classdev *led_cdev,
158                           unsigned long *delay_on,
159                           unsigned long *delay_off);
160 /**
161  * led_blink_set_oneshot - do a oneshot software blink
162  * @led_cdev: the LED to start blinking
163  * @delay_on: the time it should be on (in ms)
164  * @delay_off: the time it should ble off (in ms)
165  * @invert: blink off, then on, leaving the led on
166  *
167  * This function makes the LED blink one time for delay_on +
168  * delay_off time, ignoring the request if another one-shot
169  * blink is already in progress.
170  *
171  * If invert is set, led blinks for delay_off first, then for
172  * delay_on and leave the led on after the on-off cycle.
173  */
174 extern void led_blink_set_oneshot(struct led_classdev *led_cdev,
175                                   unsigned long *delay_on,
176                                   unsigned long *delay_off,
177                                   int invert);
178 /**
179  * led_set_brightness - set LED brightness
180  * @led_cdev: the LED to set
181  * @brightness: the brightness to set it to
182  *
183  * Set an LED's brightness, and, if necessary, cancel the
184  * software blink timer that implements blinking when the
185  * hardware doesn't. This function is guaranteed not to sleep.
186  */
187 extern void led_set_brightness(struct led_classdev *led_cdev,
188                                enum led_brightness brightness);
189
190 /**
191  * led_set_brightness_sync - set LED brightness synchronously
192  * @led_cdev: the LED to set
193  * @brightness: the brightness to set it to
194  *
195  * Set an LED's brightness immediately. This function will block
196  * the caller for the time required for accessing device registers,
197  * and it can sleep.
198  *
199  * Returns: 0 on success or negative error value on failure
200  */
201 extern int led_set_brightness_sync(struct led_classdev *led_cdev,
202                                    enum led_brightness value);
203
204 /**
205  * led_update_brightness - update LED brightness
206  * @led_cdev: the LED to query
207  *
208  * Get an LED's current brightness and update led_cdev->brightness
209  * member with the obtained value.
210  *
211  * Returns: 0 on success or negative error value on failure
212  */
213 extern int led_update_brightness(struct led_classdev *led_cdev);
214
215 /**
216  * led_sysfs_disable - disable LED sysfs interface
217  * @led_cdev: the LED to set
218  *
219  * Disable the led_cdev's sysfs interface.
220  */
221 extern void led_sysfs_disable(struct led_classdev *led_cdev);
222
223 /**
224  * led_sysfs_enable - enable LED sysfs interface
225  * @led_cdev: the LED to set
226  *
227  * Enable the led_cdev's sysfs interface.
228  */
229 extern void led_sysfs_enable(struct led_classdev *led_cdev);
230
231 /**
232  * led_sysfs_is_disabled - check if LED sysfs interface is disabled
233  * @led_cdev: the LED to query
234  *
235  * Returns: true if the led_cdev's sysfs interface is disabled.
236  */
237 static inline bool led_sysfs_is_disabled(struct led_classdev *led_cdev)
238 {
239         return led_cdev->flags & LED_SYSFS_DISABLE;
240 }
241
242 /*
243  * LED Triggers
244  */
245 /* Registration functions for simple triggers */
246 #define DEFINE_LED_TRIGGER(x)           static struct led_trigger *x;
247 #define DEFINE_LED_TRIGGER_GLOBAL(x)    struct led_trigger *x;
248
249 #ifdef CONFIG_LEDS_TRIGGERS
250
251 #define TRIG_NAME_MAX 50
252
253 struct led_trigger {
254         /* Trigger Properties */
255         const char       *name;
256         void            (*activate)(struct led_classdev *led_cdev);
257         void            (*deactivate)(struct led_classdev *led_cdev);
258
259         /* LEDs under control by this trigger (for simple triggers) */
260         rwlock_t          leddev_list_lock;
261         struct list_head  led_cdevs;
262
263         /* Link to next registered trigger */
264         struct list_head  next_trig;
265 };
266
267 ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
268                         const char *buf, size_t count);
269 ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
270                         char *buf);
271
272 /* Registration functions for complex triggers */
273 extern int led_trigger_register(struct led_trigger *trigger);
274 extern void led_trigger_unregister(struct led_trigger *trigger);
275 extern int devm_led_trigger_register(struct device *dev,
276                                      struct led_trigger *trigger);
277
278 extern void led_trigger_register_simple(const char *name,
279                                 struct led_trigger **trigger);
280 extern void led_trigger_unregister_simple(struct led_trigger *trigger);
281 extern void led_trigger_event(struct led_trigger *trigger,
282                                 enum led_brightness event);
283 extern void led_trigger_blink(struct led_trigger *trigger,
284                               unsigned long *delay_on,
285                               unsigned long *delay_off);
286 extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
287                                       unsigned long *delay_on,
288                                       unsigned long *delay_off,
289                                       int invert);
290 extern void led_trigger_set_default(struct led_classdev *led_cdev);
291 extern void led_trigger_set(struct led_classdev *led_cdev,
292                         struct led_trigger *trigger);
293 extern void led_trigger_remove(struct led_classdev *led_cdev);
294
295 static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
296 {
297         return led_cdev->trigger_data;
298 }
299
300 /**
301  * led_trigger_rename_static - rename a trigger
302  * @name: the new trigger name
303  * @trig: the LED trigger to rename
304  *
305  * Change a LED trigger name by copying the string passed in
306  * name into current trigger name, which MUST be large
307  * enough for the new string.
308  *
309  * Note that name must NOT point to the same string used
310  * during LED registration, as that could lead to races.
311  *
312  * This is meant to be used on triggers with statically
313  * allocated name.
314  */
315 extern void led_trigger_rename_static(const char *name,
316                                       struct led_trigger *trig);
317
318 #else
319
320 /* Trigger has no members */
321 struct led_trigger {};
322
323 /* Trigger inline empty functions */
324 static inline void led_trigger_register_simple(const char *name,
325                                         struct led_trigger **trigger) {}
326 static inline void led_trigger_unregister_simple(struct led_trigger *trigger) {}
327 static inline void led_trigger_event(struct led_trigger *trigger,
328                                 enum led_brightness event) {}
329 static inline void led_trigger_blink(struct led_trigger *trigger,
330                                       unsigned long *delay_on,
331                                       unsigned long *delay_off) {}
332 static inline void led_trigger_blink_oneshot(struct led_trigger *trigger,
333                                       unsigned long *delay_on,
334                                       unsigned long *delay_off,
335                                       int invert) {}
336 static inline void led_trigger_set_default(struct led_classdev *led_cdev) {}
337 static inline void led_trigger_set(struct led_classdev *led_cdev,
338                                 struct led_trigger *trigger) {}
339 static inline void led_trigger_remove(struct led_classdev *led_cdev) {}
340 static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
341 {
342         return NULL;
343 }
344
345 #endif /* CONFIG_LEDS_TRIGGERS */
346
347 /* Trigger specific functions */
348 #ifdef CONFIG_LEDS_TRIGGER_DISK
349 extern void ledtrig_disk_activity(bool write);
350 #else
351 static inline void ledtrig_disk_activity(bool write) {}
352 #endif
353
354 #ifdef CONFIG_LEDS_TRIGGER_MTD
355 extern void ledtrig_mtd_activity(void);
356 #else
357 static inline void ledtrig_mtd_activity(void) {}
358 #endif
359
360 #if defined(CONFIG_LEDS_TRIGGER_CAMERA) || defined(CONFIG_LEDS_TRIGGER_CAMERA_MODULE)
361 extern void ledtrig_flash_ctrl(bool on);
362 extern void ledtrig_torch_ctrl(bool on);
363 #else
364 static inline void ledtrig_flash_ctrl(bool on) {}
365 static inline void ledtrig_torch_ctrl(bool on) {}
366 #endif
367
368 /*
369  * Generic LED platform data for describing LED names and default triggers.
370  */
371 struct led_info {
372         const char      *name;
373         const char      *default_trigger;
374         int             flags;
375 };
376
377 struct led_platform_data {
378         int             num_leds;
379         struct led_info *leds;
380 };
381
382 struct gpio_desc;
383 typedef int (*gpio_blink_set_t)(struct gpio_desc *desc, int state,
384                                 unsigned long *delay_on,
385                                 unsigned long *delay_off);
386
387 /* For the leds-gpio driver */
388 struct gpio_led {
389         const char *name;
390         const char *default_trigger;
391         unsigned        gpio;
392         unsigned        active_low : 1;
393         unsigned        retain_state_suspended : 1;
394         unsigned        panic_indicator : 1;
395         unsigned        default_state : 2;
396         unsigned        retain_state_shutdown : 1;
397         /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
398         struct gpio_desc *gpiod;
399 };
400 #define LEDS_GPIO_DEFSTATE_OFF          0
401 #define LEDS_GPIO_DEFSTATE_ON           1
402 #define LEDS_GPIO_DEFSTATE_KEEP         2
403
404 struct gpio_led_platform_data {
405         int             num_leds;
406         const struct gpio_led *leds;
407
408 #define GPIO_LED_NO_BLINK_LOW   0       /* No blink GPIO state low */
409 #define GPIO_LED_NO_BLINK_HIGH  1       /* No blink GPIO state high */
410 #define GPIO_LED_BLINK          2       /* Please, blink */
411         gpio_blink_set_t        gpio_blink_set;
412 };
413
414 #ifdef CONFIG_NEW_LEDS
415 struct platform_device *gpio_led_register_device(
416                 int id, const struct gpio_led_platform_data *pdata);
417 #else
418 static inline struct platform_device *gpio_led_register_device(
419                 int id, const struct gpio_led_platform_data *pdata)
420 {
421         return 0;
422 }
423 #endif
424
425 enum cpu_led_event {
426         CPU_LED_IDLE_START,     /* CPU enters idle */
427         CPU_LED_IDLE_END,       /* CPU idle ends */
428         CPU_LED_START,          /* Machine starts, especially resume */
429         CPU_LED_STOP,           /* Machine stops, especially suspend */
430         CPU_LED_HALTED,         /* Machine shutdown */
431 };
432 #ifdef CONFIG_LEDS_TRIGGER_CPU
433 extern void ledtrig_cpu(enum cpu_led_event evt);
434 #else
435 static inline void ledtrig_cpu(enum cpu_led_event evt)
436 {
437         return;
438 }
439 #endif
440
441 #ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
442 extern void led_classdev_notify_brightness_hw_changed(
443         struct led_classdev *led_cdev, enum led_brightness brightness);
444 #else
445 static inline void led_classdev_notify_brightness_hw_changed(
446         struct led_classdev *led_cdev, enum led_brightness brightness) { }
447 #endif
448
449 #endif          /* __LINUX_LEDS_H_INCLUDED */