LXR linux/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/list.h>
  16#include <linux/spinlock.h>
  17#include <linux/rwsem.h>
  18#include <linux/timer.h>
  19
  20struct device;
  21/*
  22 * LED Core
  23 */
  24
  25enum led_brightness {
  26        LED_OFF         = 0,
  27        LED_HALF        = 127,
  28        LED_FULL        = 255,
  29};
  30
  31struct led_classdev {
  32        const char              *name;
  33        int                      brightness;
  34        int                      max_brightness;
  35        int                      flags;
  36
  37        /* Lower 16 bits reflect status */
  38#define LED_SUSPENDED           (1 << 0)
  39        /* Upper 16 bits reflect control information */
  40#define LED_CORE_SUSPENDRESUME  (1 << 16)
  41#define LED_BLINK_ONESHOT       (1 << 17)
  42#define LED_BLINK_ONESHOT_STOP  (1 << 18)
  43#define LED_BLINK_INVERT        (1 << 19)
  44
  45        /* Set LED brightness level */
  46        /* Must not sleep, use a workqueue if needed */
  47        void            (*brightness_set)(struct led_classdev *led_cdev,
  48                                          enum led_brightness brightness);
  49        /* Get LED brightness level */
  50        enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
  51
  52        /*
  53         * Activate hardware accelerated blink, delays are in milliseconds
  54         * and if both are zero then a sensible default should be chosen.
  55         * The call should adjust the timings in that case and if it can't
  56         * match the values specified exactly.
  57         * Deactivate blinking again when the brightness is set to a fixed
  58         * value via the brightness_set() callback.
  59         */
  60        int             (*blink_set)(struct led_classdev *led_cdev,
  61                                     unsigned long *delay_on,
  62                                     unsigned long *delay_off);
  63
  64        struct device           *dev;
  65        struct list_head         node;                  /* LED Device list */
  66        const char              *default_trigger;       /* Trigger to use */
  67
  68        unsigned long            blink_delay_on, blink_delay_off;
  69        struct timer_list        blink_timer;
  70        int                      blink_brightness;
  71
  72#ifdef CONFIG_LEDS_TRIGGERS
  73        /* Protects the trigger data below */
  74        struct rw_semaphore      trigger_lock;
  75
  76        struct led_trigger      *trigger;
  77        struct list_head         trig_list;
  78        void                    *trigger_data;
  79        /* true if activated - deactivate routine uses it to do cleanup */
  80        bool                    activated;
  81#endif
  82};
  83
  84extern int led_classdev_register(struct device *parent,
  85                                 struct led_classdev *led_cdev);
  86extern void led_classdev_unregister(struct led_classdev *led_cdev);
  87extern void led_classdev_suspend(struct led_classdev *led_cdev);
  88extern void led_classdev_resume(struct led_classdev *led_cdev);
  89
  90/**
  91 * led_blink_set - set blinking with software fallback
  92 * @led_cdev: the LED to start blinking
  93 * @delay_on: the time it should be on (in ms)
  94 * @delay_off: the time it should ble off (in ms)
  95 *
  96 * This function makes the LED blink, attempting to use the
  97 * hardware acceleration if possible, but falling back to
  98 * software blinking if there is no hardware blinking or if
  99 * the LED refuses the passed values.
 100 *
 101 * Note that if software blinking is active, simply calling
 102 * led_cdev->brightness_set() will not stop the blinking,
 103 * use led_classdev_brightness_set() instead.
 104 */
 105extern void led_blink_set(struct led_classdev *led_cdev,
 106                          unsigned long *delay_on,
 107                          unsigned long *delay_off);
 108/**
 109 * led_blink_set_oneshot - do a oneshot software blink
 110 * @led_cdev: the LED to start blinking
 111 * @delay_on: the time it should be on (in ms)
 112 * @delay_off: the time it should ble off (in ms)
 113 * @invert: blink off, then on, leaving the led on
 114 *
 115 * This function makes the LED blink one time for delay_on +
 116 * delay_off time, ignoring the request if another one-shot
 117 * blink is already in progress.
 118 *
 119 * If invert is set, led blinks for delay_off first, then for
 120 * delay_on and leave the led on after the on-off cycle.
 121 */
 122extern void led_blink_set_oneshot(struct led_classdev *led_cdev,
 123                                  unsigned long *delay_on,
 124                                  unsigned long *delay_off,
 125                                  int invert);
 126/**
 127 * led_set_brightness - set LED brightness
 128 * @led_cdev: the LED to set
 129 * @brightness: the brightness to set it to
 130 *
 131 * Set an LED's brightness, and, if necessary, cancel the
 132 * software blink timer that implements blinking when the
 133 * hardware doesn't.
 134 */
 135extern void led_set_brightness(struct led_classdev *led_cdev,
 136                               enum led_brightness brightness);
 137
 138/*
 139 * LED Triggers
 140 */
 141#ifdef CONFIG_LEDS_TRIGGERS
 142
 143#define TRIG_NAME_MAX 50
 144
 145struct led_trigger {
 146        /* Trigger Properties */
 147        const char       *name;
 148        void            (*activate)(struct led_classdev *led_cdev);
 149        void            (*deactivate)(struct led_classdev *led_cdev);
 150
 151        /* LEDs under control by this trigger (for simple triggers) */
 152        rwlock_t          leddev_list_lock;
 153        struct list_head  led_cdevs;
 154
 155        /* Link to next registered trigger */
 156        struct list_head  next_trig;
 157};
 158
 159/* Registration functions for complex triggers */
 160extern int led_trigger_register(struct led_trigger *trigger);
 161extern void led_trigger_unregister(struct led_trigger *trigger);
 162
 163/* Registration functions for simple triggers */
 164#define DEFINE_LED_TRIGGER(x)           static struct led_trigger *x;
 165#define DEFINE_LED_TRIGGER_GLOBAL(x)    struct led_trigger *x;
 166extern void led_trigger_register_simple(const char *name,
 167                                struct led_trigger **trigger);
 168extern void led_trigger_unregister_simple(struct led_trigger *trigger);
 169extern void led_trigger_event(struct led_trigger *trigger,
 170                                enum led_brightness event);
 171extern void led_trigger_blink(struct led_trigger *trigger,
 172                              unsigned long *delay_on,
 173                              unsigned long *delay_off);
 174extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
 175                                      unsigned long *delay_on,
 176                                      unsigned long *delay_off,
 177                                      int invert);
 178
 179#else
 180
 181/* Triggers aren't active - null macros */
 182#define DEFINE_LED_TRIGGER(x)
 183#define DEFINE_LED_TRIGGER_GLOBAL(x)
 184#define led_trigger_register_simple(x, y) do {} while(0)
 185#define led_trigger_unregister_simple(x) do {} while(0)
 186#define led_trigger_event(x, y) do {} while(0)
 187
 188#endif
 189
 190/* Trigger specific functions */
 191#ifdef CONFIG_LEDS_TRIGGER_IDE_DISK
 192extern void ledtrig_ide_activity(void);
 193#else
 194#define ledtrig_ide_activity() do {} while(0)
 195#endif
 196
 197/*
 198 * Generic LED platform data for describing LED names and default triggers.
 199 */
 200struct led_info {
 201        const char      *name;
 202        const char      *default_trigger;
 203        int             flags;
 204};
 205
 206struct led_platform_data {
 207        int             num_leds;
 208        struct led_info *leds;
 209};
 210
 211/* For the leds-gpio driver */
 212struct gpio_led {
 213        const char *name;
 214        const char *default_trigger;
 215        unsigned        gpio;
 216        unsigned        active_low : 1;
 217        unsigned        retain_state_suspended : 1;
 218        unsigned        default_state : 2;
 219        /* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
 220};
 221#define LEDS_GPIO_DEFSTATE_OFF          0
 222#define LEDS_GPIO_DEFSTATE_ON           1
 223#define LEDS_GPIO_DEFSTATE_KEEP         2
 224
 225struct gpio_led_platform_data {
 226        int             num_leds;
 227        const struct gpio_led *leds;
 228
 229#define GPIO_LED_NO_BLINK_LOW   0       /* No blink GPIO state low */
 230#define GPIO_LED_NO_BLINK_HIGH  1       /* No blink GPIO state high */
 231#define GPIO_LED_BLINK          2       /* Please, blink */
 232        int             (*gpio_blink_set)(unsigned gpio, int state,
 233                                        unsigned long *delay_on,
 234                                        unsigned long *delay_off);
 235};
 236
 237struct platform_device *gpio_led_register_device(
 238                int id, const struct gpio_led_platform_data *pdata);
 239
 240#endif          /* __LINUX_LEDS_H_INCLUDED */
 241