blob: 3bce44893021365a999724a9aff0cf17d462a95f [file] [log] [blame]
Richard Purdiec72a1d62006-03-31 02:31:04 -08001/*
2 * LED Class Core
3 *
4 * Copyright 2005-2006 Openedhand Ltd.
5 *
6 * Author: Richard Purdie <rpurdie@openedhand.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 */
13
14#include <linux/kernel.h>
Jacek Anaszewski04713302014-08-07 05:10:22 -070015#include <linux/leds.h>
Richard Purdiec72a1d62006-03-31 02:31:04 -080016#include <linux/list.h>
17#include <linux/module.h>
Jacek Anaszewski04713302014-08-07 05:10:22 -070018#include <linux/mutex.h>
Richard Purdie72f8da32007-12-31 23:09:44 +000019#include <linux/rwsem.h>
Richard Purdiec72a1d62006-03-31 02:31:04 -080020#include "leds.h"
21
Richard Purdie72f8da32007-12-31 23:09:44 +000022DECLARE_RWSEM(leds_list_lock);
Richard Purdiec72a1d62006-03-31 02:31:04 -080023EXPORT_SYMBOL_GPL(leds_list_lock);
Németh Márton4d404fd2008-03-09 20:59:57 +000024
25LIST_HEAD(leds_list);
26EXPORT_SYMBOL_GPL(leds_list);
Bryan Wua403d932012-03-23 15:02:14 -070027
Heiner Kallweitd4887af2016-02-16 20:21:56 +010028static int __led_set_brightness(struct led_classdev *led_cdev,
29 enum led_brightness value)
30{
31 if (!led_cdev->brightness_set)
32 return -ENOTSUPP;
33
34 led_cdev->brightness_set(led_cdev, value);
35
36 return 0;
37}
38
39static int __led_set_brightness_blocking(struct led_classdev *led_cdev,
40 enum led_brightness value)
41{
42 if (!led_cdev->brightness_set_blocking)
43 return -ENOTSUPP;
44
45 return led_cdev->brightness_set_blocking(led_cdev, value);
46}
47
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020048static void led_timer_function(unsigned long data)
49{
50 struct led_classdev *led_cdev = (void *)data;
51 unsigned long brightness;
52 unsigned long delay;
53
54 if (!led_cdev->blink_delay_on || !led_cdev->blink_delay_off) {
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +020055 led_set_brightness_nosleep(led_cdev, LED_OFF);
Tony Makkiel7cfe7492016-05-18 17:22:45 +010056 led_cdev->flags &= ~LED_BLINK_SW;
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020057 return;
58 }
59
60 if (led_cdev->flags & LED_BLINK_ONESHOT_STOP) {
Tony Makkiel7cfe7492016-05-18 17:22:45 +010061 led_cdev->flags &= ~(LED_BLINK_ONESHOT_STOP | LED_BLINK_SW);
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020062 return;
63 }
64
65 brightness = led_get_brightness(led_cdev);
66 if (!brightness) {
67 /* Time to switch the LED on. */
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020068 brightness = led_cdev->blink_brightness;
69 delay = led_cdev->blink_delay_on;
70 } else {
71 /* Store the current brightness value to be able
72 * to restore it when the delay_off period is over.
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +020073 * Do it only if there is no pending blink brightness
74 * change, to avoid overwriting the new value.
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020075 */
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +020076 if (!(led_cdev->flags & LED_BLINK_BRIGHTNESS_CHANGE))
77 led_cdev->blink_brightness = brightness;
78 else
79 led_cdev->flags &= ~LED_BLINK_BRIGHTNESS_CHANGE;
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020080 brightness = LED_OFF;
81 delay = led_cdev->blink_delay_off;
82 }
83
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +020084 led_set_brightness_nosleep(led_cdev, brightness);
Jacek Anaszewski757b06a2015-09-28 14:38:04 +020085
86 /* Return in next iteration if led is in one-shot mode and we are in
87 * the final blink state so that the led is toggled each delay_on +
88 * delay_off milliseconds in worst case.
89 */
90 if (led_cdev->flags & LED_BLINK_ONESHOT) {
91 if (led_cdev->flags & LED_BLINK_INVERT) {
92 if (brightness)
93 led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
94 } else {
95 if (!brightness)
96 led_cdev->flags |= LED_BLINK_ONESHOT_STOP;
97 }
98 }
99
100 mod_timer(&led_cdev->blink_timer, jiffies + msecs_to_jiffies(delay));
101}
102
103static void set_brightness_delayed(struct work_struct *ws)
104{
105 struct led_classdev *led_cdev =
106 container_of(ws, struct led_classdev, set_brightness_work);
Jacek Anaszewski1afcadf2015-10-19 09:04:01 +0200107 int ret = 0;
Jacek Anaszewski757b06a2015-09-28 14:38:04 +0200108
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200109 if (led_cdev->flags & LED_BLINK_DISABLE) {
110 led_cdev->delayed_set_value = LED_OFF;
111 led_stop_software_blink(led_cdev);
112 led_cdev->flags &= ~LED_BLINK_DISABLE;
113 }
Jacek Anaszewski757b06a2015-09-28 14:38:04 +0200114
Heiner Kallweitd4887af2016-02-16 20:21:56 +0100115 ret = __led_set_brightness(led_cdev, led_cdev->delayed_set_value);
116 if (ret == -ENOTSUPP)
117 ret = __led_set_brightness_blocking(led_cdev,
118 led_cdev->delayed_set_value);
Heiner Kallweitd84d80f2016-01-22 21:43:48 +0100119 if (ret < 0 &&
120 /* LED HW might have been unplugged, therefore don't warn */
121 !(ret == -ENODEV && (led_cdev->flags & LED_UNREGISTERING) &&
122 (led_cdev->flags & LED_HW_PLUGGABLE)))
Jacek Anaszewski1afcadf2015-10-19 09:04:01 +0200123 dev_err(led_cdev->dev,
124 "Setting an LED's brightness failed (%d)\n", ret);
Jacek Anaszewski757b06a2015-09-28 14:38:04 +0200125}
126
Bryan Wua403d932012-03-23 15:02:14 -0700127static void led_set_software_blink(struct led_classdev *led_cdev,
128 unsigned long delay_on,
129 unsigned long delay_off)
130{
131 int current_brightness;
132
133 current_brightness = led_get_brightness(led_cdev);
134 if (current_brightness)
135 led_cdev->blink_brightness = current_brightness;
136 if (!led_cdev->blink_brightness)
137 led_cdev->blink_brightness = led_cdev->max_brightness;
138
Bryan Wua403d932012-03-23 15:02:14 -0700139 led_cdev->blink_delay_on = delay_on;
140 led_cdev->blink_delay_off = delay_off;
141
Stefan Sørensen8d82fef2014-02-04 00:11:42 -0800142 /* never on - just set to off */
143 if (!delay_on) {
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200144 led_set_brightness_nosleep(led_cdev, LED_OFF);
Bryan Wua403d932012-03-23 15:02:14 -0700145 return;
Stefan Sørensen8d82fef2014-02-04 00:11:42 -0800146 }
Bryan Wua403d932012-03-23 15:02:14 -0700147
148 /* never off - just set to brightness */
149 if (!delay_off) {
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200150 led_set_brightness_nosleep(led_cdev,
151 led_cdev->blink_brightness);
Bryan Wua403d932012-03-23 15:02:14 -0700152 return;
153 }
154
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100155 led_cdev->flags |= LED_BLINK_SW;
Jiri Kosina90673592014-09-02 02:03:12 -0700156 mod_timer(&led_cdev->blink_timer, jiffies + 1);
Bryan Wua403d932012-03-23 15:02:14 -0700157}
158
159
Bryan Wu20c0e6b2012-06-15 22:15:27 +0800160static void led_blink_setup(struct led_classdev *led_cdev,
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800161 unsigned long *delay_on,
162 unsigned long *delay_off)
Bryan Wua403d932012-03-23 15:02:14 -0700163{
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800164 if (!(led_cdev->flags & LED_BLINK_ONESHOT) &&
165 led_cdev->blink_set &&
Bryan Wua403d932012-03-23 15:02:14 -0700166 !led_cdev->blink_set(led_cdev, delay_on, delay_off))
167 return;
168
169 /* blink with 1 Hz as default if nothing specified */
170 if (!*delay_on && !*delay_off)
171 *delay_on = *delay_off = 500;
172
173 led_set_software_blink(led_cdev, *delay_on, *delay_off);
174}
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800175
Jacek Anaszewski757b06a2015-09-28 14:38:04 +0200176void led_init_core(struct led_classdev *led_cdev)
177{
178 INIT_WORK(&led_cdev->set_brightness_work, set_brightness_delayed);
179
180 setup_timer(&led_cdev->blink_timer, led_timer_function,
181 (unsigned long)led_cdev);
182}
183EXPORT_SYMBOL_GPL(led_init_core);
184
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800185void led_blink_set(struct led_classdev *led_cdev,
186 unsigned long *delay_on,
187 unsigned long *delay_off)
188{
Jiri Kosina90673592014-09-02 02:03:12 -0700189 del_timer_sync(&led_cdev->blink_timer);
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800190
191 led_cdev->flags &= ~LED_BLINK_ONESHOT;
192 led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
193
194 led_blink_setup(led_cdev, delay_on, delay_off);
195}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200196EXPORT_SYMBOL_GPL(led_blink_set);
Bryan Wua403d932012-03-23 15:02:14 -0700197
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800198void led_blink_set_oneshot(struct led_classdev *led_cdev,
199 unsigned long *delay_on,
200 unsigned long *delay_off,
201 int invert)
202{
203 if ((led_cdev->flags & LED_BLINK_ONESHOT) &&
Jiri Kosina90673592014-09-02 02:03:12 -0700204 timer_pending(&led_cdev->blink_timer))
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800205 return;
206
207 led_cdev->flags |= LED_BLINK_ONESHOT;
208 led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
209
210 if (invert)
211 led_cdev->flags |= LED_BLINK_INVERT;
212 else
213 led_cdev->flags &= ~LED_BLINK_INVERT;
214
215 led_blink_setup(led_cdev, delay_on, delay_off);
216}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200217EXPORT_SYMBOL_GPL(led_blink_set_oneshot);
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800218
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800219void led_stop_software_blink(struct led_classdev *led_cdev)
Bryan Wua403d932012-03-23 15:02:14 -0700220{
Jiri Kosina90673592014-09-02 02:03:12 -0700221 del_timer_sync(&led_cdev->blink_timer);
Fabio Baltieri43786482012-06-07 03:12:34 +0800222 led_cdev->blink_delay_on = 0;
223 led_cdev->blink_delay_off = 0;
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100224 led_cdev->flags &= ~LED_BLINK_SW;
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800225}
226EXPORT_SYMBOL_GPL(led_stop_software_blink);
227
228void led_set_brightness(struct led_classdev *led_cdev,
229 enum led_brightness brightness)
230{
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200231 /*
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100232 * If software blink is active, delay brightness setting
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200233 * until the next timer tick.
234 */
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100235 if (led_cdev->flags & LED_BLINK_SW) {
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200236 /*
237 * If we need to disable soft blinking delegate this to the
238 * work queue task to avoid problems in case we are called
239 * from hard irq context.
240 */
241 if (brightness == LED_OFF) {
242 led_cdev->flags |= LED_BLINK_DISABLE;
Stas Sergeev76931ed2015-05-14 08:24:02 -0700243 schedule_work(&led_cdev->set_brightness_work);
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200244 } else {
245 led_cdev->flags |= LED_BLINK_BRIGHTNESS_CHANGE;
246 led_cdev->blink_brightness = brightness;
247 }
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800248 return;
249 }
Fabio Baltieri43786482012-06-07 03:12:34 +0800250
Jacek Anaszewski13ae79b2015-10-07 11:10:43 +0200251 led_set_brightness_nosleep(led_cdev, brightness);
Bryan Wua403d932012-03-23 15:02:14 -0700252}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200253EXPORT_SYMBOL_GPL(led_set_brightness);
Jacek Anaszewski3ef7de52014-08-20 06:41:55 -0700254
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200255void led_set_brightness_nopm(struct led_classdev *led_cdev,
256 enum led_brightness value)
257{
258 /* Use brightness_set op if available, it is guaranteed not to sleep */
Heiner Kallweitd4887af2016-02-16 20:21:56 +0100259 if (!__led_set_brightness(led_cdev, value))
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200260 return;
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200261
262 /* If brightness setting can sleep, delegate it to a work queue task */
263 led_cdev->delayed_set_value = value;
264 schedule_work(&led_cdev->set_brightness_work);
265}
266EXPORT_SYMBOL_GPL(led_set_brightness_nopm);
267
268void led_set_brightness_nosleep(struct led_classdev *led_cdev,
269 enum led_brightness value)
270{
271 led_cdev->brightness = min(value, led_cdev->max_brightness);
272
273 if (led_cdev->flags & LED_SUSPENDED)
274 return;
275
276 led_set_brightness_nopm(led_cdev, led_cdev->brightness);
277}
278EXPORT_SYMBOL_GPL(led_set_brightness_nosleep);
279
Jacek Anaszewski13ae79b2015-10-07 11:10:43 +0200280int led_set_brightness_sync(struct led_classdev *led_cdev,
281 enum led_brightness value)
282{
283 if (led_cdev->blink_delay_on || led_cdev->blink_delay_off)
284 return -EBUSY;
285
286 led_cdev->brightness = min(value, led_cdev->max_brightness);
287
288 if (led_cdev->flags & LED_SUSPENDED)
289 return 0;
290
Heiner Kallweitd4887af2016-02-16 20:21:56 +0100291 return __led_set_brightness_blocking(led_cdev, led_cdev->brightness);
Jacek Anaszewski13ae79b2015-10-07 11:10:43 +0200292}
293EXPORT_SYMBOL_GPL(led_set_brightness_sync);
294
Jacek Anaszewski3ef7de52014-08-20 06:41:55 -0700295int led_update_brightness(struct led_classdev *led_cdev)
296{
297 int ret = 0;
298
299 if (led_cdev->brightness_get) {
300 ret = led_cdev->brightness_get(led_cdev);
301 if (ret >= 0) {
302 led_cdev->brightness = ret;
303 return 0;
304 }
305 }
306
307 return ret;
308}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200309EXPORT_SYMBOL_GPL(led_update_brightness);
Jacek Anaszewskiacd899e2014-09-22 08:21:04 -0700310
311/* Caller must ensure led_cdev->led_access held */
312void led_sysfs_disable(struct led_classdev *led_cdev)
313{
314 lockdep_assert_held(&led_cdev->led_access);
315
316 led_cdev->flags |= LED_SYSFS_DISABLE;
317}
318EXPORT_SYMBOL_GPL(led_sysfs_disable);
319
320/* Caller must ensure led_cdev->led_access held */
321void led_sysfs_enable(struct led_classdev *led_cdev)
322{
323 lockdep_assert_held(&led_cdev->led_access);
324
325 led_cdev->flags &= ~LED_SYSFS_DISABLE;
326}
327EXPORT_SYMBOL_GPL(led_sysfs_enable);