2006-03-31 03:31:04 -07:00
|
|
|
/*
|
|
|
|
* Driver model for leds and led triggers
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
|
|
|
|
* Copyright (C) 2005 Richard Purdie <rpurdie@openedhand.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
#ifndef __LINUX_LEDS_H_INCLUDED
|
|
|
|
#define __LINUX_LEDS_H_INCLUDED
|
|
|
|
|
2006-09-29 03:00:14 -06:00
|
|
|
#include <linux/list.h>
|
2007-09-11 15:24:45 -06:00
|
|
|
#include <linux/spinlock.h>
|
2007-11-10 06:29:04 -07:00
|
|
|
#include <linux/rwsem.h>
|
2010-11-11 15:05:21 -07:00
|
|
|
#include <linux/timer.h>
|
2006-09-29 03:00:14 -06:00
|
|
|
|
2006-03-31 03:31:04 -07:00
|
|
|
struct device;
|
|
|
|
/*
|
|
|
|
* LED Core
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum led_brightness {
|
2006-04-10 23:54:02 -06:00
|
|
|
LED_OFF = 0,
|
|
|
|
LED_HALF = 127,
|
|
|
|
LED_FULL = 255,
|
2006-03-31 03:31:04 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct led_classdev {
|
2006-04-10 23:54:02 -06:00
|
|
|
const char *name;
|
|
|
|
int brightness;
|
2009-01-10 11:54:39 -07:00
|
|
|
int max_brightness;
|
2006-04-10 23:54:02 -06:00
|
|
|
int flags;
|
2006-03-31 03:31:04 -07:00
|
|
|
|
2009-01-08 10:55:03 -07:00
|
|
|
/* Lower 16 bits reflect status */
|
2006-04-10 23:54:02 -06:00
|
|
|
#define LED_SUSPENDED (1 << 0)
|
2009-01-08 10:55:03 -07:00
|
|
|
/* Upper 16 bits reflect control information */
|
|
|
|
#define LED_CORE_SUSPENDRESUME (1 << 16)
|
2012-05-26 17:19:22 -06:00
|
|
|
#define LED_BLINK_ONESHOT (1 << 17)
|
|
|
|
#define LED_BLINK_ONESHOT_STOP (1 << 18)
|
|
|
|
#define LED_BLINK_INVERT (1 << 19)
|
2006-03-31 03:31:04 -07:00
|
|
|
|
2006-04-10 23:54:02 -06:00
|
|
|
/* Set LED brightness level */
|
2008-04-24 16:49:30 -06:00
|
|
|
/* Must not sleep, use a workqueue if needed */
|
2006-04-10 23:54:02 -06:00
|
|
|
void (*brightness_set)(struct led_classdev *led_cdev,
|
|
|
|
enum led_brightness brightness);
|
2008-03-18 03:47:48 -06:00
|
|
|
/* Get LED brightness level */
|
|
|
|
enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
|
2006-04-10 23:54:02 -06:00
|
|
|
|
2010-11-11 15:05:21 -07:00
|
|
|
/*
|
|
|
|
* Activate hardware accelerated blink, delays are in milliseconds
|
|
|
|
* and if both are zero then a sensible default should be chosen.
|
|
|
|
* The call should adjust the timings in that case and if it can't
|
|
|
|
* match the values specified exactly.
|
|
|
|
* Deactivate blinking again when the brightness is set to a fixed
|
|
|
|
* value via the brightness_set() callback.
|
|
|
|
*/
|
2007-10-31 08:07:12 -06:00
|
|
|
int (*blink_set)(struct led_classdev *led_cdev,
|
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off);
|
|
|
|
|
2007-07-08 16:19:31 -06:00
|
|
|
struct device *dev;
|
2006-04-10 23:54:02 -06:00
|
|
|
struct list_head node; /* LED Device list */
|
2008-05-31 08:23:19 -06:00
|
|
|
const char *default_trigger; /* Trigger to use */
|
2006-03-31 03:31:04 -07:00
|
|
|
|
2010-11-11 15:05:21 -07:00
|
|
|
unsigned long blink_delay_on, blink_delay_off;
|
|
|
|
struct timer_list blink_timer;
|
|
|
|
int blink_brightness;
|
|
|
|
|
2006-03-31 03:31:05 -07:00
|
|
|
#ifdef CONFIG_LEDS_TRIGGERS
|
|
|
|
/* Protects the trigger data below */
|
2007-11-10 06:29:04 -07:00
|
|
|
struct rw_semaphore trigger_lock;
|
2006-03-31 03:31:05 -07:00
|
|
|
|
2006-04-10 23:54:02 -06:00
|
|
|
struct led_trigger *trigger;
|
|
|
|
struct list_head trig_list;
|
|
|
|
void *trigger_data;
|
2012-05-29 16:07:27 -06:00
|
|
|
/* true if activated - deactivate routine uses it to do cleanup */
|
|
|
|
bool activated;
|
2006-03-31 03:31:05 -07:00
|
|
|
#endif
|
2006-03-31 03:31:04 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
extern int led_classdev_register(struct device *parent,
|
2006-04-10 23:54:02 -06:00
|
|
|
struct led_classdev *led_cdev);
|
2008-11-17 07:35:44 -07:00
|
|
|
extern void led_classdev_unregister(struct led_classdev *led_cdev);
|
2006-03-31 03:31:04 -07:00
|
|
|
extern void led_classdev_suspend(struct led_classdev *led_cdev);
|
|
|
|
extern void led_classdev_resume(struct led_classdev *led_cdev);
|
|
|
|
|
2010-11-11 15:05:21 -07:00
|
|
|
/**
|
|
|
|
* led_blink_set - set blinking with software fallback
|
|
|
|
* @led_cdev: the LED to start blinking
|
|
|
|
* @delay_on: the time it should be on (in ms)
|
|
|
|
* @delay_off: the time it should ble off (in ms)
|
|
|
|
*
|
|
|
|
* This function makes the LED blink, attempting to use the
|
|
|
|
* hardware acceleration if possible, but falling back to
|
|
|
|
* software blinking if there is no hardware blinking or if
|
|
|
|
* the LED refuses the passed values.
|
|
|
|
*
|
|
|
|
* Note that if software blinking is active, simply calling
|
|
|
|
* led_cdev->brightness_set() will not stop the blinking,
|
|
|
|
* use led_classdev_brightness_set() instead.
|
|
|
|
*/
|
|
|
|
extern void led_blink_set(struct led_classdev *led_cdev,
|
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off);
|
2012-05-26 17:19:22 -06:00
|
|
|
/**
|
|
|
|
* led_blink_set_oneshot - do a oneshot software blink
|
|
|
|
* @led_cdev: the LED to start blinking
|
|
|
|
* @delay_on: the time it should be on (in ms)
|
|
|
|
* @delay_off: the time it should ble off (in ms)
|
|
|
|
* @invert: blink off, then on, leaving the led on
|
|
|
|
*
|
|
|
|
* This function makes the LED blink one time for delay_on +
|
|
|
|
* delay_off time, ignoring the request if another one-shot
|
|
|
|
* blink is already in progress.
|
|
|
|
*
|
|
|
|
* If invert is set, led blinks for delay_off first, then for
|
|
|
|
* delay_on and leave the led on after the on-off cycle.
|
|
|
|
*/
|
|
|
|
extern void led_blink_set_oneshot(struct led_classdev *led_cdev,
|
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off,
|
|
|
|
int invert);
|
2010-11-11 15:05:21 -07:00
|
|
|
/**
|
2012-06-13 14:34:30 -06:00
|
|
|
* led_set_brightness - set LED brightness
|
2010-11-11 15:05:21 -07:00
|
|
|
* @led_cdev: the LED to set
|
|
|
|
* @brightness: the brightness to set it to
|
|
|
|
*
|
|
|
|
* Set an LED's brightness, and, if necessary, cancel the
|
|
|
|
* software blink timer that implements blinking when the
|
|
|
|
* hardware doesn't.
|
|
|
|
*/
|
2012-06-13 14:34:30 -06:00
|
|
|
extern void led_set_brightness(struct led_classdev *led_cdev,
|
2010-11-11 15:05:21 -07:00
|
|
|
enum led_brightness brightness);
|
|
|
|
|
2006-03-31 03:31:05 -07:00
|
|
|
/*
|
|
|
|
* LED Triggers
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_LEDS_TRIGGERS
|
|
|
|
|
|
|
|
#define TRIG_NAME_MAX 50
|
|
|
|
|
|
|
|
struct led_trigger {
|
|
|
|
/* Trigger Properties */
|
2006-04-10 23:54:02 -06:00
|
|
|
const char *name;
|
|
|
|
void (*activate)(struct led_classdev *led_cdev);
|
|
|
|
void (*deactivate)(struct led_classdev *led_cdev);
|
2006-03-31 03:31:05 -07:00
|
|
|
|
|
|
|
/* LEDs under control by this trigger (for simple triggers) */
|
2006-04-10 23:54:02 -06:00
|
|
|
rwlock_t leddev_list_lock;
|
|
|
|
struct list_head led_cdevs;
|
2006-03-31 03:31:05 -07:00
|
|
|
|
|
|
|
/* Link to next registered trigger */
|
2006-04-10 23:54:02 -06:00
|
|
|
struct list_head next_trig;
|
2006-03-31 03:31:05 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Registration functions for complex triggers */
|
|
|
|
extern int led_trigger_register(struct led_trigger *trigger);
|
|
|
|
extern void led_trigger_unregister(struct led_trigger *trigger);
|
|
|
|
|
|
|
|
/* Registration functions for simple triggers */
|
|
|
|
#define DEFINE_LED_TRIGGER(x) static struct led_trigger *x;
|
|
|
|
#define DEFINE_LED_TRIGGER_GLOBAL(x) struct led_trigger *x;
|
|
|
|
extern void led_trigger_register_simple(const char *name,
|
|
|
|
struct led_trigger **trigger);
|
|
|
|
extern void led_trigger_unregister_simple(struct led_trigger *trigger);
|
|
|
|
extern void led_trigger_event(struct led_trigger *trigger,
|
|
|
|
enum led_brightness event);
|
2011-01-07 09:28:16 -07:00
|
|
|
extern void led_trigger_blink(struct led_trigger *trigger,
|
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off);
|
2012-05-26 17:19:22 -06:00
|
|
|
extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
|
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off,
|
|
|
|
int invert);
|
2006-03-31 03:31:05 -07:00
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
/* Triggers aren't active - null macros */
|
|
|
|
#define DEFINE_LED_TRIGGER(x)
|
|
|
|
#define DEFINE_LED_TRIGGER_GLOBAL(x)
|
|
|
|
#define led_trigger_register_simple(x, y) do {} while(0)
|
|
|
|
#define led_trigger_unregister_simple(x) do {} while(0)
|
|
|
|
#define led_trigger_event(x, y) do {} while(0)
|
|
|
|
|
|
|
|
#endif
|
2006-03-31 03:31:16 -07:00
|
|
|
|
|
|
|
/* Trigger specific functions */
|
|
|
|
#ifdef CONFIG_LEDS_TRIGGER_IDE_DISK
|
|
|
|
extern void ledtrig_ide_activity(void);
|
|
|
|
#else
|
|
|
|
#define ledtrig_ide_activity() do {} while(0)
|
|
|
|
#endif
|
|
|
|
|
2008-07-16 15:49:55 -06:00
|
|
|
/*
|
|
|
|
* Generic LED platform data for describing LED names and default triggers.
|
|
|
|
*/
|
|
|
|
struct led_info {
|
|
|
|
const char *name;
|
2008-10-13 03:13:01 -06:00
|
|
|
const char *default_trigger;
|
2008-07-16 15:49:55 -06:00
|
|
|
int flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct led_platform_data {
|
|
|
|
int num_leds;
|
|
|
|
struct led_info *leds;
|
|
|
|
};
|
|
|
|
|
2007-02-27 12:49:53 -07:00
|
|
|
/* For the leds-gpio driver */
|
|
|
|
struct gpio_led {
|
|
|
|
const char *name;
|
2008-10-13 03:13:01 -06:00
|
|
|
const char *default_trigger;
|
2007-02-27 12:49:53 -07:00
|
|
|
unsigned gpio;
|
leds: Add options to have GPIO LEDs start on or keep their state
There already is a "default-on" trigger but there are problems with it.
For one, it's a inefficient way to do it and requires led trigger support
to be compiled in.
But the real reason is that is produces a glitch on the LED. The GPIO is
allocate with the LED *off*, then *later* when the trigger runs it is
turned back on. If the LED was already on via the GPIO's reset default or
action of the firmware, this produces a glitch where the LED goes from on
to off to on. While normally this is fast enough that it wouldn't be
noticeable to a human observer, there are still serious problems.
One is that there may be something else on the GPIO line, like a hardware
alarm or watchdog, that is fast enough to notice the glitch.
Another is that the kernel may panic before the LED is turned back on, thus
hanging with the LED in the wrong state. This is not just speculation, but
actually happened to me with an embedded system that has an LED which
should turn off when the kernel finishes booting, which was left in the
incorrect state due to a bug in the OF LED binding code.
We also let GPIO LEDs get their initial value from whatever the current
state of the GPIO line is. On some systems the LEDs are put into some
state by the firmware or hardware before Linux boots, and it is desired to
have them keep this state which is otherwise unknown to Linux.
This requires that the underlying GPIO driver support reading the value of
output GPIOs. Some drivers support this and some do not.
The platform device binding gains a field in the platform data
"default_state" that controls this. There are three constants defined to
select from on, off, or keeping the current state. The OpenFirmware
binding uses a property named "default-state" that can be set to "on",
"off", or "keep". The default if the property isn't present is off.
Signed-off-by: Trent Piepho <xyzzy@speakeasy.org>
Acked-by: Grant Likely <grant.likely@secretlab.ca>
Acked-by: Wolfram Sang <w.sang@pengutronix.de>
Acked-by: Sean MacLennan <smaclennan@pikatech.com>
Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>
2009-05-12 16:33:12 -06:00
|
|
|
unsigned active_low : 1;
|
|
|
|
unsigned retain_state_suspended : 1;
|
|
|
|
unsigned default_state : 2;
|
|
|
|
/* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
|
2007-02-27 12:49:53 -07:00
|
|
|
};
|
2010-05-22 04:54:55 -06:00
|
|
|
#define LEDS_GPIO_DEFSTATE_OFF 0
|
|
|
|
#define LEDS_GPIO_DEFSTATE_ON 1
|
|
|
|
#define LEDS_GPIO_DEFSTATE_KEEP 2
|
2007-02-27 12:49:53 -07:00
|
|
|
|
|
|
|
struct gpio_led_platform_data {
|
|
|
|
int num_leds;
|
2011-03-22 17:30:17 -06:00
|
|
|
const struct gpio_led *leds;
|
2010-05-22 04:54:55 -06:00
|
|
|
|
|
|
|
#define GPIO_LED_NO_BLINK_LOW 0 /* No blink GPIO state low */
|
|
|
|
#define GPIO_LED_NO_BLINK_HIGH 1 /* No blink GPIO state high */
|
2011-03-22 17:30:17 -06:00
|
|
|
#define GPIO_LED_BLINK 2 /* Please, blink */
|
2010-05-22 04:54:55 -06:00
|
|
|
int (*gpio_blink_set)(unsigned gpio, int state,
|
2008-03-09 17:48:25 -06:00
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off);
|
2007-02-27 12:49:53 -07:00
|
|
|
};
|
|
|
|
|
2011-05-24 18:13:29 -06:00
|
|
|
struct platform_device *gpio_led_register_device(
|
|
|
|
int id, const struct gpio_led_platform_data *pdata);
|
2007-02-27 12:49:53 -07:00
|
|
|
|
2006-03-31 03:31:04 -07:00
|
|
|
#endif /* __LINUX_LEDS_H_INCLUDED */
|