led-class: always implement blinking
Subsystems (3)
Johannes Berg
maintainerRFC 1/1 led-class: always implement blinking
From: Johannes Berg <[email protected]>
Currently, blinking LEDs can be awkward because it is not guaranteed that all LEDs implement blinking. The trigger that wants it to blink then needs to implement its own timer solution. Rather than require that, make the core always implement LED "blinkability" with a timer implementation in the core. The timer trigger then becomes a very trivial one, and all code using LEDs can rely on them to be able to blink.
--- drivers/leds/led-class.c | 78 +++++++++++++++++++++++++++ drivers/leds/led-triggers.c | 2 drivers/leds/ledtrig-timer.c | 124 ++++--------------------------------------- include/linux/leds.h | 5 + 4 files changed, 97 insertions(+), 112 deletions(-)
drivers/leds/ledtrig-timer.c +12 -112
@@ -12,73 +12,25 @@*/ #include <linux/module.h> -#include <linux/jiffies.h> #include <linux/kernel.h> #include <linux/init.h> -#include <linux/list.h> -#include <linux/spinlock.h> #include <linux/device.h> -#include <linux/sysdev.h> -#include <linux/timer.h> #include <linux/ctype.h> #include <linux/leds.h> -#include <linux/slab.h> #include "leds.h" -struct timer_trig_data { -int brightness_on;/* LED brightness during "on" period. -* (LED_OFF < brightness_on <= LED_FULL) -*/ -unsigned long delay_on;/* milliseconds on */ -unsigned long delay_off;/* milliseconds off */ -struct timer_list timer; -}; - -static void led_timer_function (unsigned long data) -{ -struct led_classdev *led_cdev = (struct led_classdev *) data; -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long brightness; -unsigned long delay; - -if (!timer_data->delay_on || !timer_data->delay_off) { -led_set_brightness (led_cdev,LED_OFF ); -return ; - } - - brightness =led_get_brightness (led_cdev); -if (!brightness) { -/* Time to switch the LED on. */ - brightness = timer_data->brightness_on; - delay = timer_data->delay_on; - }else { -/* Store the current brightness value to be able -* to restore it when the delay_off period is over. -*/ - timer_data->brightness_on = brightness; - brightness =LED_OFF ; - delay = timer_data->delay_off; - } - -led_set_brightness (led_cdev, brightness); - -mod_timer (&timer_data->timer, jiffies +msecs_to_jiffies (delay)); -} -static ssize_t led_delay_on_show (struct device *dev,struct device_attribute *attr,char *buf) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_on); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_on); }static ssize_t led_delay_on_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -88,21 +40,8 @@ static ssize_t led_delay_on_store(struct count++;if (count == size) { -if (timer_data->delay_on != state) { -/* the new value differs from the previous */ - timer_data->delay_on = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } + led_cdev->blink_set (led_cdev, &state, + &led_cdev->blink_delay_off); ret = count; }
@@ -113,16 +52,14 @@ static ssize_t led_delay_off_show(struct struct device_attribute *attr, char *buf) { struct led_classdev *led_cdev = dev_get_drvdata(dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_off); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_off); }static ssize_t led_delay_off_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -132,21 +69,8 @@ static ssize_t led_delay_off_store(struc count++;if (count == size) { -if (timer_data->delay_off != state) { -/* the new value differs from the previous */ - timer_data->delay_off = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } + led_cdev->blink_set (led_cdev, &led_cdev->blink_delay_on, + &state); ret = count; }
@@ -158,60 +82,36 @@ static DEVICE_ATTR(delay_off, 0644, led_static void timer_trig_activate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data;int rc; - timer_data =kzalloc (sizeof (struct timer_trig_data ),GFP_KERNEL ); -if (!timer_data) -return ; - - timer_data->brightness_on =led_get_brightness (led_cdev); -if (timer_data->brightness_on ==LED_OFF ) - timer_data->brightness_on = led_cdev->max_brightness; - led_cdev->trigger_data = timer_data; - -init_timer (&timer_data->timer); - timer_data->timer.function = led_timer_function; - timer_data->timer.data = (unsigned long ) led_cdev; + led_cdev->trigger_data =NULL ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_on);if (rc) - goto err_out; +return ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_off);if (rc) goto err_out_delayon; -/* If there is hardware support for blinking, start one -* user friendly blink rate chosen by the driver. -*/ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off); + led_cdev->trigger_data = (void *)1 ;return ; err_out_delayon:device_remove_file (led_cdev->dev, &dev_attr_delay_on); -err_out: - led_cdev->trigger_data =NULL ; -kfree (timer_data); }static void timer_trig_deactivate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data = led_cdev->trigger_data;unsigned long on =0 , off =0 ; -if (timer_data) { +if (led_cdev->trigger_data) {device_remove_file (led_cdev->dev, &dev_attr_delay_on);device_remove_file (led_cdev->dev, &dev_attr_delay_off); -del_timer_sync (&timer_data->timer); -kfree (timer_data); } -/* If there is hardware support for blinking, stop it */ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, &on, &off); +/* Stop blinking */ + led_cdev->blink_set (led_cdev, &on, &off); }static struct led_trigger timer_led_trigger = {
drivers/leds/led-class.c +78 -0
102 lines not on this page · raw message
drivers/leds/led-triggers.c +2 -0
@@ -103,6 +103,7 @@ EXPORT_SYMBOL_GPL(led_trigger_show);void led_trigger_set (struct led_classdev *led_cdev,struct led_trigger *trigger) {unsigned long flags; +unsigned long on =0 , off =0 ;/* Remove any existing trigger */ if (led_cdev->trigger) {
@@ -113,6 +114,7 @@ void led_trigger_set(struct led_classdevif (led_cdev->trigger->deactivate) led_cdev->trigger->deactivate (led_cdev); led_cdev->trigger =NULL ; + led_cdev->blink_set (led_cdev, &on, &off);led_set_brightness (led_cdev,LED_OFF ); }if (trigger) {
include/linux/leds.h +5 -0
@@ -15,6 +15,7 @@#include <linux/list.h> #include <linux/spinlock.h> #include <linux/rwsem.h> +#include <linux/timer.h> struct device ;/*
@@ -57,6 +58,10 @@ struct led_classdev {struct list_head node;/* LED Device list */ const char *default_trigger;/* Trigger to use */ +unsigned long blink_delay_on, blink_delay_off; +struct timer_list blink_timer; +int blink_brightness; +#ifdef CONFIG_LEDS_TRIGGERS /* Protects the trigger data below */ struct rw_semaphore trigger_lock;
Johannes Berg
maintainerQuoted 10 lines · Johannes Berg
From: Johannes Berg <[email protected]>
Currently, blinking LEDs can be awkward because it is not guaranteed that all LEDs implement blinking. The trigger that wants it to blink then needs to implement its own timer solution. Rather than require that, make the core always implement LED "blinkability" with a timer implementation in the core. The timer trigger then becomes a very trivial one, and all code using LEDs can rely on them to be able to blink.
No comments mean it's good to go in?
johannes
Quoted 25 lines · On Fri, 20 Aug 2010 11:21:42 +0200 Johannes Berg <[email protected]>…
drivers/leds/led-class.c +25
-0+static int led_blink_set (struct led_classdev *led_cdev, +unsigned long *delay_on,unsigned long *delay_off) +{ +int current_brightness; + + current_brightness =led_get_brightness (led_cdev); +if (current_brightness) + led_cdev->blink_brightness = current_brightness; +if (!led_cdev->blink_brightness) + led_cdev->blink_brightness = led_cdev->max_brightness; + +if (*delay_on == led_cdev->blink_delay_on && + *delay_off == led_cdev->blink_delay_off) +return 0 ; + +/* deactivate previous settings */ +del_timer_sync (&led_cdev->blink_timer); + + led_cdev->blink_delay_on = *delay_on; + led_cdev->blink_delay_off = *delay_off; + +/* never on - don't blink */ +if (!*delay_on) +return 0 ; +
drivers/leds/led-class.c static struct device_attribute led_class · line 148
Quoted 10 lines
drivers/leds/led-class.c +10
-0+/* never off - just set to brightness */ +if (!*delay_off) { +led_set_brightness (led_cdev, led_cdev->blink_brightness); +return 0 ; + } + +mod_timer (&led_cdev->blink_timer, jiffies +1 ); + +return 0 ; +}
delay_on and delay_off could have been pass-by-value rather than pass-by-reference? That would clean up some gunk in callers, too.
If there was some reason for doing it with pass-by-reference then that reason should have been documented!
Johannes Berg
maintainerQuoted 19 lines · Andrew Morton
drivers/leds/led-class.c static struct device_attribute led_class · line 133
Quoted 12 lines · On Fri, 20 Aug 2010 11:21:42 +0200 Johannes Berg <[email protected]>…
drivers/leds/led-class.c +11
-0+static int led_blink_set (struct led_classdev *led_cdev, +unsigned long *delay_on,unsigned long *delay_off) + if (*delay_on == led_cdev->blink_delay_on && + *delay_off == led_cdev->blink_delay_off) + return 0; + +/* deactivate previous settings */ + del_timer_sync(&led_cdev->blink_timer); + + led_cdev->blink_delay_on = *delay_on; + led_cdev->blink_delay_off = *delay_off;
delay_onanddelay_offcould have been pass-by-value rather than pass-by-reference? That would clean up some gunk in callers, too.
Quoted 2 lines
If there was some reason for doing it with pass-by-reference then that reason should have been documented!
Well, this function gets assigned to led_cdev->blink_set(), which is a function pointer that takes pass-by-reference arguments. The comment there says:
/* Activate hardware accelerated blink, delays are in
* miliseconds and if none is provided then a sensible default
* should be chosen. The call can adjust the timings if it can't
* match the values specified exactly. */
int (*blink_set)(struct led_classdev *led_cdev,
unsigned long *delay_on, unsigned long *delay_off);
but the software implementation doesn't adjust the timings, of course. I suppose the "adjust the timings" was also meant to update the values.
johannes
Johannes Berg
maintainerQuoted 12 lines · Johannes Berg
Well, this function gets assigned to
led_cdev->blink_set(), which is a function pointer that takes pass-by-reference arguments. The comment there says:/* Activate hardware accelerated blink, delays are in
* miliseconds and if none is provided then a sensible default
* should be chosen. The call can adjust the timings if it can't
* match the values specified exactly. */
int (*blink_set)(structled_classdev*led_cdev,
unsigned long*delay_on, unsigned long*delay_off);
Quoted 2 lines
but the software implementation doesn't adjust the timings, of course. I suppose the "adjust the timings" was also meant to update the values.
But I should update this and the other documentation ... and also provide a wrapper, because blink_set() is allowed to fail, in which software fallback should be used.
johannes
Quoted 35 lines · Johannes Berg
Quoted 19 lines · Andrew Morton
drivers/leds/led-class.c static struct device_attribute led_class · line 133
Quoted 12 lines · On Fri, 20 Aug 2010 11:21:42 +0200 Johannes Berg <[email protected]>…
drivers/leds/led-class.c +11
-0+static int led_blink_set (struct led_classdev *led_cdev, +unsigned long *delay_on,unsigned long *delay_off) + if (*delay_on == led_cdev->blink_delay_on && + *delay_off == led_cdev->blink_delay_off) + return 0; + +/* deactivate previous settings */ + del_timer_sync(&led_cdev->blink_timer); + + led_cdev->blink_delay_on = *delay_on; + led_cdev->blink_delay_off = *delay_off;
delay_onanddelay_offcould have been pass-by-value rather than pass-by-reference? That would clean up some gunk in callers, too.Quoted 2 lines
If there was some reason for doing it with pass-by-reference then that reason should have been documented!
Well, this function gets assigned to
led_cdev->blink_set(), which is a function pointer that takes pass-by-reference arguments. The comment there says:/* Activate hardware accelerated blink, delays are in
* miliseconds and if none is provided then a sensible default
* should be chosen. The call can adjust the timings if it can't
* match the values specified exactly. */
int (*blink_set)(structled_classdev*led_cdev,
unsigned long*delay_on, unsigned long*delay_off);
Quoted 2 lines
but the software implementation doesn't adjust the timings, of course. I suppose the "adjust the timings" was also meant to update the values.
The idea was that hardware fallbacks would let the caller know what values it had actually fallen back to. The software fallback using timers is generic so doesn't need to change the values.
I've been meaning to look more closely at the patch but I haven't got to it yet, sorry :(.
Richard
Johannes Berg
maintainerQuoted 15 lines · Richard Purdie
Quoted 12 lines
Well, this function gets assigned to
led_cdev->blink_set(), which is a function pointer that takes pass-by-reference arguments. The comment there says:/* Activate hardware accelerated blink, delays are in
* miliseconds and if none is provided then a sensible default
* should be chosen. The call can adjust the timings if it can't
* match the values specified exactly. */
int (*blink_set)(structled_classdev*led_cdev,
unsigned long*delay_on, unsigned long*delay_off);Quoted 2 lines
but the software implementation doesn't adjust the timings, of course. I suppose the "adjust the timings" was also meant to update the values.
Quoted 6 lines
The idea was that hardware fallbacks would let the caller know what values it had actually fallen back to. The software fallback using timers is generic so doesn't need to change the values.
I've been meaning to look more closely at the patch but I haven't got to it yet, sorry :(.
Right. But I actually ran into problems here. I had to add another "blink_stop" software function, because even though the _internal_ code in led-class.c currently assumes calling blink_set(0, 0) will stop blinking, the documentation says that then it should chose a "user-friendly" blinking speed... So there are bugs in the current implementation, and not all LEDs implement this either.
Additionally, blink_set() may return an error, in which case software fallback should be used.
I solved this yesterday in a new version of my patch by adding new API
void led_classdev_blink_set(*dev, *on, *off)
that will use blink_set() and then fall back to software.
HOWEVER, if you use that, then just doing brightness_set(dev, LED_OFF) will not turn off blinking because we cannot hook into that from the software blinking implementation. There are two ways to solve this:
a) provide a wrapper for brightness_set() as well, that will disable software blink, and should be used in preference of calling the function pointer directly, it may be an inline.
b) provide a function led_classdev_blink_stop() that will turn off the LED and stop the blinking
Which one would you prefer?
johannes
Johannes Berg
maintainerPATCH v2 1/1 led-class: always implement blinking
In reply to Richard PurdieFrom: Johannes Berg <[email protected]>
Currently, blinking LEDs can be awkward because it is not guaranteed that all LEDs implement blinking. The trigger that wants it to blink then needs to implement its own timer solution.
Rather than require that, add led_blink_set() API that triggers can use. This function will attempt to use hw blinking, but if that fails implements a timer for it. To stop blinking again, brightness_set() also needs to be wrapped into API that will stop the software blink.
As a result of this, the timer trigger becomes a very trivial one, and hopefully we can finally see triggers using blinking as well because it's always easy to use.
---
v2: - update documentation
- use documented way of turning blinking off by setting brightness to 0 rather than by setting delays to (0, 0)
- add API to start blinking, set brightness (the latter will also stop sw blinking)
Documentation/leds-class.txt | 19 +++--- drivers/leds/led-class.c | 105 ++++++++++++++++++++++++++++++++++++ drivers/leds/led-triggers.c | 2 drivers/leds/ledtrig-timer.c | 124 +++---------------------------------------- include/linux/leds.h | 47 ++++++++++++++-- 5 files changed, 169 insertions(+), 128 deletions(-)
drivers/leds/ledtrig-timer.c +10 -114
@@ -12,73 +12,25 @@*/ #include <linux/module.h> -#include <linux/jiffies.h> #include <linux/kernel.h> #include <linux/init.h> -#include <linux/list.h> -#include <linux/spinlock.h> #include <linux/device.h> -#include <linux/sysdev.h> -#include <linux/timer.h> #include <linux/ctype.h> #include <linux/leds.h> -#include <linux/slab.h> #include "leds.h" -struct timer_trig_data { -int brightness_on;/* LED brightness during "on" period. -* (LED_OFF < brightness_on <= LED_FULL) -*/ -unsigned long delay_on;/* milliseconds on */ -unsigned long delay_off;/* milliseconds off */ -struct timer_list timer; -}; - -static void led_timer_function (unsigned long data) -{ -struct led_classdev *led_cdev = (struct led_classdev *) data; -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long brightness; -unsigned long delay; - -if (!timer_data->delay_on || !timer_data->delay_off) { -led_set_brightness (led_cdev,LED_OFF ); -return ; - } - - brightness =led_get_brightness (led_cdev); -if (!brightness) { -/* Time to switch the LED on. */ - brightness = timer_data->brightness_on; - delay = timer_data->delay_on; - }else { -/* Store the current brightness value to be able -* to restore it when the delay_off period is over. -*/ - timer_data->brightness_on = brightness; - brightness =LED_OFF ; - delay = timer_data->delay_off; - } - -led_set_brightness (led_cdev, brightness); - -mod_timer (&timer_data->timer, jiffies +msecs_to_jiffies (delay)); -} -static ssize_t led_delay_on_show (struct device *dev,struct device_attribute *attr,char *buf) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_on); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_on); }static ssize_t led_delay_on_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -88,21 +40,7 @@ static ssize_t led_delay_on_store(struct count++;if (count == size) { -if (timer_data->delay_on != state) { -/* the new value differs from the previous */ - timer_data->delay_on = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } +led_blink_set (led_cdev, &state, &led_cdev->blink_delay_off); ret = count; }
@@ -113,16 +51,14 @@ static ssize_t led_delay_off_show(struct struct device_attribute *attr, char *buf) { struct led_classdev *led_cdev = dev_get_drvdata(dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_off); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_off); }static ssize_t led_delay_off_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -132,21 +68,7 @@ static ssize_t led_delay_off_store(struc count++;if (count == size) { -if (timer_data->delay_off != state) { -/* the new value differs from the previous */ - timer_data->delay_off = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } +led_blink_set (led_cdev, &led_cdev->blink_delay_on, &state); ret = count; }
@@ -158,60 +80,34 @@ static DEVICE_ATTR(delay_off, 0644, led_static void timer_trig_activate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data;int rc; - timer_data =kzalloc (sizeof (struct timer_trig_data ),GFP_KERNEL ); -if (!timer_data) -return ; - - timer_data->brightness_on =led_get_brightness (led_cdev); -if (timer_data->brightness_on ==LED_OFF ) - timer_data->brightness_on = led_cdev->max_brightness; - led_cdev->trigger_data = timer_data; - -init_timer (&timer_data->timer); - timer_data->timer.function = led_timer_function; - timer_data->timer.data = (unsigned long ) led_cdev; + led_cdev->trigger_data =NULL ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_on);if (rc) - goto err_out; +return ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_off);if (rc) goto err_out_delayon; -/* If there is hardware support for blinking, start one -* user friendly blink rate chosen by the driver. -*/ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off); + led_cdev->trigger_data = (void *)1 ;return ; err_out_delayon:device_remove_file (led_cdev->dev, &dev_attr_delay_on); -err_out: - led_cdev->trigger_data =NULL ; -kfree (timer_data); }static void timer_trig_deactivate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long on =0 , off =0 ; - -if (timer_data) { +if (led_cdev->trigger_data) {device_remove_file (led_cdev->dev, &dev_attr_delay_on);device_remove_file (led_cdev->dev, &dev_attr_delay_off); -del_timer_sync (&timer_data->timer); -kfree (timer_data); } -/* If there is hardware support for blinking, stop it */ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, &on, &off); +/* Stop blinking */ +led_brightness_set (led_cdev,LED_OFF ); }static struct led_trigger timer_led_trigger = {
drivers/leds/led-class.c +104 -1
135 lines not on this page · raw message
drivers/leds/led-triggers.c +1 -1
@@ -113,7 +113,7 @@ void led_trigger_set(struct led_classdevif (led_cdev->trigger->deactivate) led_cdev->trigger->deactivate (led_cdev); led_cdev->trigger =NULL ; -led_set_brightness (led_cdev,LED_OFF ); +led_brightness_set (led_cdev,LED_OFF ); }if (trigger) {write_lock_irqsave (&trigger->leddev_list_lock, flags);
include/linux/leds.h +43 -4
71 lines not on this page · raw message
Documentation/leds-class.txt +11 -8
@@ -60,15 +60,18 @@ Hardware accelerated blink of LEDs Some LEDs can be programmed to blink without any CPU interaction. To support this feature, a LED driver can optionally implement the -blink_set() function (see <linux/leds.h>). If implemented, triggers can -attempt to use it before falling back to software timers. The blink_set() -function should return 0 if the blink setting is supported, or -EINVAL -otherwise, which means that LED blinking will be handled by software. +blink_set() function (see <linux/leds.h>). To set an LED to blinking, +however, it is better to use use the API function led_blink_set(), +as it will check and implement software fallback if necessary. -The blink_set() function should choose a user friendly blinking -value if it is called with *delay_on==0 && *delay_off==0 parameters. In -this case the driver should give back the chosen value through delay_on -and delay_off parameters to the leds subsystem. +To turn off blinking again, use the API function led_brightness_set() +as that will not just set the LED brightness but also stop any software +timers that may have been required for blinking. + +The blink_set() function should choose a user friendly blinking value +if it is called with *delay_on==0 && *delay_off==0 parameters. In this +case the driver should give back the chosen value through delay_on and +delay_off parameters to the leds subsystem. Setting the brightness to zero with brightness_set() callback function should completely turn off the LED and cancel the previously programmed
Johannes Berg
maintainerPATCH v3 1/1 led-class: always implement blinking
From: Johannes Berg <[email protected]>
Currently, blinking LEDs can be awkward because it is not guaranteed that all LEDs implement blinking. The trigger that wants it to blink then needs to implement its own timer solution.
Rather than require that, add led_blink_set() API that triggers can use. This function will attempt to use hw blinking, but if that fails implements a timer for it. To stop blinking again, brightness_set() also needs to be wrapped into API that will stop the software blink.
As a result of this, the timer trigger becomes a very trivial one, and hopefully we can finally see triggers using blinking as well because it's always easy to use.
---
v2: - update documentation
- use documented way of turning blinking off by setting brightness to 0 rather than by setting delays to (0, 0)
- add API to start blinking, set brightness (the latter will also stop sw blinking)
v3: - make LEDS_CLASS a bool rather than tristate
because LEDS_TRIGGERS now depends on symbols it exports
Documentation/leds-class.txt | 19 +++--- drivers/leds/Kconfig | 2 drivers/leds/led-class.c | 105 ++++++++++++++++++++++++++++++++++++ drivers/leds/led-triggers.c | 2 drivers/leds/ledtrig-timer.c | 124 +++---------------------------------------- include/linux/leds.h | 47 ++++++++++++++-- 6 files changed, 170 insertions(+), 129 deletions(-)
drivers/leds/ledtrig-timer.c +10 -114
@@ -12,73 +12,25 @@*/ #include <linux/module.h> -#include <linux/jiffies.h> #include <linux/kernel.h> #include <linux/init.h> -#include <linux/list.h> -#include <linux/spinlock.h> #include <linux/device.h> -#include <linux/sysdev.h> -#include <linux/timer.h> #include <linux/ctype.h> #include <linux/leds.h> -#include <linux/slab.h> #include "leds.h" -struct timer_trig_data { -int brightness_on;/* LED brightness during "on" period. -* (LED_OFF < brightness_on <= LED_FULL) -*/ -unsigned long delay_on;/* milliseconds on */ -unsigned long delay_off;/* milliseconds off */ -struct timer_list timer; -}; - -static void led_timer_function (unsigned long data) -{ -struct led_classdev *led_cdev = (struct led_classdev *) data; -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long brightness; -unsigned long delay; - -if (!timer_data->delay_on || !timer_data->delay_off) { -led_set_brightness (led_cdev,LED_OFF ); -return ; - } - - brightness =led_get_brightness (led_cdev); -if (!brightness) { -/* Time to switch the LED on. */ - brightness = timer_data->brightness_on; - delay = timer_data->delay_on; - }else { -/* Store the current brightness value to be able -* to restore it when the delay_off period is over. -*/ - timer_data->brightness_on = brightness; - brightness =LED_OFF ; - delay = timer_data->delay_off; - } - -led_set_brightness (led_cdev, brightness); - -mod_timer (&timer_data->timer, jiffies +msecs_to_jiffies (delay)); -} -static ssize_t led_delay_on_show (struct device *dev,struct device_attribute *attr,char *buf) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_on); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_on); }static ssize_t led_delay_on_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -88,21 +40,7 @@ static ssize_t led_delay_on_store(struct count++;if (count == size) { -if (timer_data->delay_on != state) { -/* the new value differs from the previous */ - timer_data->delay_on = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } +led_blink_set (led_cdev, &state, &led_cdev->blink_delay_off); ret = count; }
@@ -113,16 +51,14 @@ static ssize_t led_delay_off_show(struct struct device_attribute *attr, char *buf) { struct led_classdev *led_cdev = dev_get_drvdata(dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_off); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_off); }static ssize_t led_delay_off_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -132,21 +68,7 @@ static ssize_t led_delay_off_store(struc count++;if (count == size) { -if (timer_data->delay_off != state) { -/* the new value differs from the previous */ - timer_data->delay_off = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } +led_blink_set (led_cdev, &led_cdev->blink_delay_on, &state); ret = count; }
@@ -158,60 +80,34 @@ static DEVICE_ATTR(delay_off, 0644, led_static void timer_trig_activate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data;int rc; - timer_data =kzalloc (sizeof (struct timer_trig_data ),GFP_KERNEL ); -if (!timer_data) -return ; - - timer_data->brightness_on =led_get_brightness (led_cdev); -if (timer_data->brightness_on ==LED_OFF ) - timer_data->brightness_on = led_cdev->max_brightness; - led_cdev->trigger_data = timer_data; - -init_timer (&timer_data->timer); - timer_data->timer.function = led_timer_function; - timer_data->timer.data = (unsigned long ) led_cdev; + led_cdev->trigger_data =NULL ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_on);if (rc) - goto err_out; +return ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_off);if (rc) goto err_out_delayon; -/* If there is hardware support for blinking, start one -* user friendly blink rate chosen by the driver. -*/ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off); + led_cdev->trigger_data = (void *)1 ;return ; err_out_delayon:device_remove_file (led_cdev->dev, &dev_attr_delay_on); -err_out: - led_cdev->trigger_data =NULL ; -kfree (timer_data); }static void timer_trig_deactivate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long on =0 , off =0 ; - -if (timer_data) { +if (led_cdev->trigger_data) {device_remove_file (led_cdev->dev, &dev_attr_delay_on);device_remove_file (led_cdev->dev, &dev_attr_delay_off); -del_timer_sync (&timer_data->timer); -kfree (timer_data); } -/* If there is hardware support for blinking, stop it */ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, &on, &off); +/* Stop blinking */ +led_brightness_set (led_cdev,LED_OFF ); }static struct led_trigger timer_led_trigger = {
drivers/leds/led-class.c +104 -1
135 lines not on this page · raw message
drivers/leds/led-triggers.c +1 -1
@@ -113,7 +113,7 @@ void led_trigger_set(struct led_classdevif (led_cdev->trigger->deactivate) led_cdev->trigger->deactivate (led_cdev); led_cdev->trigger =NULL ; -led_set_brightness (led_cdev,LED_OFF ); +led_brightness_set (led_cdev,LED_OFF ); }if (trigger) {write_lock_irqsave (&trigger->leddev_list_lock, flags);
include/linux/leds.h +43 -4
71 lines not on this page · raw message
Documentation/leds-class.txt +11 -8
@@ -60,15 +60,18 @@ Hardware accelerated blink of LEDs Some LEDs can be programmed to blink without any CPU interaction. To support this feature, a LED driver can optionally implement the -blink_set() function (see <linux/leds.h>). If implemented, triggers can -attempt to use it before falling back to software timers. The blink_set() -function should return 0 if the blink setting is supported, or -EINVAL -otherwise, which means that LED blinking will be handled by software. +blink_set() function (see <linux/leds.h>). To set an LED to blinking, +however, it is better to use use the API function led_blink_set(), +as it will check and implement software fallback if necessary. -The blink_set() function should choose a user friendly blinking -value if it is called with *delay_on==0 && *delay_off==0 parameters. In -this case the driver should give back the chosen value through delay_on -and delay_off parameters to the leds subsystem. +To turn off blinking again, use the API function led_brightness_set() +as that will not just set the LED brightness but also stop any software +timers that may have been required for blinking. + +The blink_set() function should choose a user friendly blinking value +if it is called with *delay_on==0 && *delay_off==0 parameters. In this +case the driver should give back the chosen value through delay_on and +delay_off parameters to the leds subsystem. Setting the brightness to zero with brightness_set() callback function should completely turn off the LED and cancel the previously programmed
drivers/leds/Kconfig +1 -1
@@ -10,7 +10,7 @@ menuconfig NEW_LEDS if NEW_LEDS config LEDS_CLASS - tristate "LED Class Support" + bool "LED Class Support" help This option enables the led sysfs class in /sys/class/leds. You'll need this to do anything useful with LEDs. If unsure, say N.
Quoted 16 lines · On Wed, 22 Sep 2010 15:53:58 +0200 Johannes Berg <[email protected]>…
Currently, blinking LEDs can be awkward because it is not guaranteed that all LEDs implement blinking. The trigger that wants it to blink then needs to implement its own timer solution.
Rather than require that, add
led_blink_set()API that triggers can use. This function will attempt to use hw blinking, but if that fails implements a timer for it. To stop blinking again,brightness_set()also needs to be wrapped into API that will stop the software blink.As a result of this, the timer trigger becomes a very trivial one, and hopefully we can finally see triggers using blinking as well because it's always easy to use.
Signed-off-by Johannes Berg <[email protected]>
Quoted 10 lines
---
v2: - update documentation
- use documented way of turning blinking off by setting brightness to 0 rather than by setting delays to (0, 0)
- add API to start blinking, set brightness (the latter will also stop sw blinking)
v3: - makeLEDS_CLASSa bool rather than tristate
becauseLEDS_TRIGGERSnow depends on symbols it exports
`make oldconfig' says
boolean symbol LEDS_CLASS tested for 'm'? test forced to 'n'
Johannes Berg
maintainerQuoted 7 lines · Andrew Morton
Quoted 3 lines
v3: - make
LEDS_CLASSa bool rather than tristate
becauseLEDS_TRIGGERSnow depends on symbols it exports`make oldconfig' says
boolean symbol
LEDS_CLASStested for 'm'? test forced to 'n'
Thanks, that must be from
comment "rt2x00 leds support disabled due to modularized LEDS_CLASS and built-in rt2x00"
depends on RT2X00_LIB=y && LEDS_CLASS=m
New patch below.
johannes
Subject: led-class: always implement blinking
From: Johannes Berg <[email protected]>
Currently, blinking LEDs can be awkward because it is not guaranteed that all LEDs implement blinking. The trigger that wants it to blink then needs to implement its own timer solution.
Rather than require that, add led_blink_set() API that triggers can use. This function will attempt to use hw blinking, but if that fails implements a timer for it. To stop blinking again, brightness_set() also needs to be wrapped into API that will stop the software blink.
As a result of this, the timer trigger becomes a very trivial one, and hopefully we can finally see triggers using blinking as well because it's always easy to use.
---
v2: - update documentation
- use documented way of turning blinking off by setting brightness to 0 rather than by setting delays to (0, 0)
- add API to start blinking, set brightness (the latter will also stop sw blinking)
v3: - make LEDS_CLASS a bool rather than tristate
because LEDS_TRIGGERS now depends on symbols it exports
v4: - remove LEDS_CLASS=m comparison from rt2x00
Documentation/leds-class.txt | 19 +++-- drivers/leds/Kconfig | 2 drivers/leds/led-class.c | 105 ++++++++++++++++++++++++++++++ drivers/leds/led-triggers.c | 2 drivers/leds/ledtrig-timer.c | 124 ++---------------------------------- drivers/net/wireless/rt2x00/Kconfig | 3 include/linux/leds.h | 47 ++++++++++++- 7 files changed, 170 insertions(+), 132 deletions(-)
drivers/leds/ledtrig-timer.c +10 -114
@@ -12,73 +12,25 @@*/ #include <linux/module.h> -#include <linux/jiffies.h> #include <linux/kernel.h> #include <linux/init.h> -#include <linux/list.h> -#include <linux/spinlock.h> #include <linux/device.h> -#include <linux/sysdev.h> -#include <linux/timer.h> #include <linux/ctype.h> #include <linux/leds.h> -#include <linux/slab.h> #include "leds.h" -struct timer_trig_data { -int brightness_on;/* LED brightness during "on" period. -* (LED_OFF < brightness_on <= LED_FULL) -*/ -unsigned long delay_on;/* milliseconds on */ -unsigned long delay_off;/* milliseconds off */ -struct timer_list timer; -}; - -static void led_timer_function (unsigned long data) -{ -struct led_classdev *led_cdev = (struct led_classdev *) data; -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long brightness; -unsigned long delay; - -if (!timer_data->delay_on || !timer_data->delay_off) { -led_set_brightness (led_cdev,LED_OFF ); -return ; - } - - brightness =led_get_brightness (led_cdev); -if (!brightness) { -/* Time to switch the LED on. */ - brightness = timer_data->brightness_on; - delay = timer_data->delay_on; - }else { -/* Store the current brightness value to be able -* to restore it when the delay_off period is over. -*/ - timer_data->brightness_on = brightness; - brightness =LED_OFF ; - delay = timer_data->delay_off; - } - -led_set_brightness (led_cdev, brightness); - -mod_timer (&timer_data->timer, jiffies +msecs_to_jiffies (delay)); -} -static ssize_t led_delay_on_show (struct device *dev,struct device_attribute *attr,char *buf) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_on); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_on); }static ssize_t led_delay_on_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -88,21 +40,7 @@ static ssize_t led_delay_on_store(struct count++;if (count == size) { -if (timer_data->delay_on != state) { -/* the new value differs from the previous */ - timer_data->delay_on = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } +led_blink_set (led_cdev, &state, &led_cdev->blink_delay_off); ret = count; }
@@ -113,16 +51,14 @@ static ssize_t led_delay_off_show(struct struct device_attribute *attr, char *buf) { struct led_classdev *led_cdev = dev_get_drvdata(dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data; -return sprintf (buf,"%lu\n" , timer_data->delay_off); +return sprintf (buf,"%lu\n" , led_cdev->blink_delay_off); }static ssize_t led_delay_off_store (struct device *dev,struct device_attribute *attr,const char *buf,size_t size) {struct led_classdev *led_cdev =dev_get_drvdata (dev); -struct timer_trig_data *timer_data = led_cdev->trigger_data;int ret = -EINVAL ;char *after;unsigned long state =simple_strtoul (buf, &after,10 );
@@ -132,21 +68,7 @@ static ssize_t led_delay_off_store(struc count++;if (count == size) { -if (timer_data->delay_off != state) { -/* the new value differs from the previous */ - timer_data->delay_off = state; - -/* deactivate previous settings */ -del_timer_sync (&timer_data->timer); - -/* try to activate hardware acceleration, if any */ -if (!led_cdev->blink_set || - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off)) { -/* no hardware acceleration, blink via timer */ -mod_timer (&timer_data->timer, jiffies +1 ); - } - } +led_blink_set (led_cdev, &led_cdev->blink_delay_on, &state); ret = count; }
@@ -158,60 +80,34 @@ static DEVICE_ATTR(delay_off, 0644, led_static void timer_trig_activate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data;int rc; - timer_data =kzalloc (sizeof (struct timer_trig_data ),GFP_KERNEL ); -if (!timer_data) -return ; - - timer_data->brightness_on =led_get_brightness (led_cdev); -if (timer_data->brightness_on ==LED_OFF ) - timer_data->brightness_on = led_cdev->max_brightness; - led_cdev->trigger_data = timer_data; - -init_timer (&timer_data->timer); - timer_data->timer.function = led_timer_function; - timer_data->timer.data = (unsigned long ) led_cdev; + led_cdev->trigger_data =NULL ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_on);if (rc) - goto err_out; +return ; rc =device_create_file (led_cdev->dev, &dev_attr_delay_off);if (rc) goto err_out_delayon; -/* If there is hardware support for blinking, start one -* user friendly blink rate chosen by the driver. -*/ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, - &timer_data->delay_on, &timer_data->delay_off); + led_cdev->trigger_data = (void *)1 ;return ; err_out_delayon:device_remove_file (led_cdev->dev, &dev_attr_delay_on); -err_out: - led_cdev->trigger_data =NULL ; -kfree (timer_data); }static void timer_trig_deactivate (struct led_classdev *led_cdev) { -struct timer_trig_data *timer_data = led_cdev->trigger_data; -unsigned long on =0 , off =0 ; - -if (timer_data) { +if (led_cdev->trigger_data) {device_remove_file (led_cdev->dev, &dev_attr_delay_on);device_remove_file (led_cdev->dev, &dev_attr_delay_off); -del_timer_sync (&timer_data->timer); -kfree (timer_data); } -/* If there is hardware support for blinking, stop it */ -if (led_cdev->blink_set) - led_cdev->blink_set (led_cdev, &on, &off); +/* Stop blinking */ +led_brightness_set (led_cdev,LED_OFF ); }static struct led_trigger timer_led_trigger = {
drivers/leds/led-class.c +104 -1
135 lines not on this page · raw message
drivers/leds/led-triggers.c +1 -1
@@ -113,7 +113,7 @@ void led_trigger_set(struct led_classdevif (led_cdev->trigger->deactivate) led_cdev->trigger->deactivate (led_cdev); led_cdev->trigger =NULL ; -led_set_brightness (led_cdev,LED_OFF ); +led_brightness_set (led_cdev,LED_OFF ); }if (trigger) {write_lock_irqsave (&trigger->leddev_list_lock, flags);
include/linux/leds.h +43 -4
71 lines not on this page · raw message
Documentation/leds-class.txt +11 -8
@@ -60,15 +60,18 @@ Hardware accelerated blink of LEDs Some LEDs can be programmed to blink without any CPU interaction. To support this feature, a LED driver can optionally implement the -blink_set() function (see <linux/leds.h>). If implemented, triggers can -attempt to use it before falling back to software timers. The blink_set() -function should return 0 if the blink setting is supported, or -EINVAL -otherwise, which means that LED blinking will be handled by software. +blink_set() function (see <linux/leds.h>). To set an LED to blinking, +however, it is better to use use the API function led_blink_set(), +as it will check and implement software fallback if necessary. -The blink_set() function should choose a user friendly blinking -value if it is called with *delay_on==0 && *delay_off==0 parameters. In -this case the driver should give back the chosen value through delay_on -and delay_off parameters to the leds subsystem. +To turn off blinking again, use the API function led_brightness_set() +as that will not just set the LED brightness but also stop any software +timers that may have been required for blinking. + +The blink_set() function should choose a user friendly blinking value +if it is called with *delay_on==0 && *delay_off==0 parameters. In this +case the driver should give back the chosen value through delay_on and +delay_off parameters to the leds subsystem. Setting the brightness to zero with brightness_set() callback function should completely turn off the LED and cancel the previously programmed
drivers/leds/Kconfig +1 -1
@@ -10,7 +10,7 @@ menuconfig NEW_LEDS if NEW_LEDS config LEDS_CLASS - tristate "LED Class Support" + bool "LED Class Support" help This option enables the led sysfs class in /sys/class/leds. You'll need this to do anything useful with LEDs. If unsure, say N.
drivers/net/wireless/rt2x00/Kconfig +0 -3
@@ -221,9 +221,6 @@ config RT2X00_LIB_LEDS boolean default y if (RT2X00_LIB=y && LEDS_CLASS=y) || (RT2X00_LIB=m && LEDS_CLASS!=n) -comment "rt2x00 leds support disabled due to modularized LEDS_CLASS and built-in rt2x00" - depends on RT2X00_LIB=y && LEDS_CLASS=m - config RT2X00_LIB_DEBUGFS bool "Ralink debugfs support" depends on RT2X00_LIB && MAC80211_DEBUGFS