blob: 454ed4dc6ec1d2b93f2c0142c24b696e87f386d0 [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{
Jacek Anaszewski2d07d7d2018-03-19 20:23:18 +0100189 del_timer_sync(&led_cdev->blink_timer);
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800190
Jacek Anaszewskid1ef7ed2018-03-19 20:23:19 +0100191 led_cdev->flags &= ~LED_BLINK_SW;
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800192 led_cdev->flags &= ~LED_BLINK_ONESHOT;
193 led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
194
195 led_blink_setup(led_cdev, delay_on, delay_off);
196}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200197EXPORT_SYMBOL_GPL(led_blink_set);
Bryan Wua403d932012-03-23 15:02:14 -0700198
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800199void led_blink_set_oneshot(struct led_classdev *led_cdev,
200 unsigned long *delay_on,
201 unsigned long *delay_off,
202 int invert)
203{
204 if ((led_cdev->flags & LED_BLINK_ONESHOT) &&
Jiri Kosina90673592014-09-02 02:03:12 -0700205 timer_pending(&led_cdev->blink_timer))
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800206 return;
207
208 led_cdev->flags |= LED_BLINK_ONESHOT;
209 led_cdev->flags &= ~LED_BLINK_ONESHOT_STOP;
210
211 if (invert)
212 led_cdev->flags |= LED_BLINK_INVERT;
213 else
214 led_cdev->flags &= ~LED_BLINK_INVERT;
215
216 led_blink_setup(led_cdev, delay_on, delay_off);
217}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200218EXPORT_SYMBOL_GPL(led_blink_set_oneshot);
Fabio Baltieri5bb629c2012-05-27 07:19:22 +0800219
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800220void led_stop_software_blink(struct led_classdev *led_cdev)
Bryan Wua403d932012-03-23 15:02:14 -0700221{
Jiri Kosina90673592014-09-02 02:03:12 -0700222 del_timer_sync(&led_cdev->blink_timer);
Fabio Baltieri43786482012-06-07 03:12:34 +0800223 led_cdev->blink_delay_on = 0;
224 led_cdev->blink_delay_off = 0;
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100225 led_cdev->flags &= ~LED_BLINK_SW;
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800226}
227EXPORT_SYMBOL_GPL(led_stop_software_blink);
228
229void led_set_brightness(struct led_classdev *led_cdev,
230 enum led_brightness brightness)
231{
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200232 /*
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100233 * If software blink is active, delay brightness setting
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200234 * until the next timer tick.
235 */
Tony Makkiel7cfe7492016-05-18 17:22:45 +0100236 if (led_cdev->flags & LED_BLINK_SW) {
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200237 /*
238 * If we need to disable soft blinking delegate this to the
239 * work queue task to avoid problems in case we are called
240 * from hard irq context.
241 */
242 if (brightness == LED_OFF) {
243 led_cdev->flags |= LED_BLINK_DISABLE;
Stas Sergeev76931ed2015-05-14 08:24:02 -0700244 schedule_work(&led_cdev->set_brightness_work);
Jacek Anaszewskif1e80c02015-10-07 11:10:39 +0200245 } else {
246 led_cdev->flags |= LED_BLINK_BRIGHTNESS_CHANGE;
247 led_cdev->blink_brightness = brightness;
248 }
Fabio Baltierid23a22a2012-08-15 21:44:34 +0800249 return;
250 }
Fabio Baltieri43786482012-06-07 03:12:34 +0800251
Jacek Anaszewski13ae79b2015-10-07 11:10:43 +0200252 led_set_brightness_nosleep(led_cdev, brightness);
Bryan Wua403d932012-03-23 15:02:14 -0700253}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200254EXPORT_SYMBOL_GPL(led_set_brightness);
Jacek Anaszewski3ef7de52014-08-20 06:41:55 -0700255
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200256void led_set_brightness_nopm(struct led_classdev *led_cdev,
257 enum led_brightness value)
258{
259 /* Use brightness_set op if available, it is guaranteed not to sleep */
Heiner Kallweitd4887af2016-02-16 20:21:56 +0100260 if (!__led_set_brightness(led_cdev, value))
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200261 return;
Jacek Anaszewski81fe8e52015-10-07 11:10:41 +0200262
263 /* If brightness setting can sleep, delegate it to a work queue task */
264 led_cdev->delayed_set_value = value;
265 schedule_work(&led_cdev->set_brightness_work);
266}
267EXPORT_SYMBOL_GPL(led_set_brightness_nopm);
268
269void led_set_brightness_nosleep(struct led_classdev *led_cdev,
270 enum led_brightness value)
271{
272 led_cdev->brightness = min(value, led_cdev->max_brightness);
273
274 if (led_cdev->flags & LED_SUSPENDED)
275 return;
276
277 led_set_brightness_nopm(led_cdev, led_cdev->brightness);
278}
279EXPORT_SYMBOL_GPL(led_set_brightness_nosleep);
280
Jacek Anaszewski13ae79b2015-10-07 11:10:43 +0200281int led_set_brightness_sync(struct led_classdev *led_cdev,
282 enum led_brightness value)
283{
284 if (led_cdev->blink_delay_on || led_cdev->blink_delay_off)
285 return -EBUSY;
286
287 led_cdev->brightness = min(value, led_cdev->max_brightness);
288
289 if (led_cdev->flags & LED_SUSPENDED)
290 return 0;
291
Heiner Kallweitd4887af2016-02-16 20:21:56 +0100292 return __led_set_brightness_blocking(led_cdev, led_cdev->brightness);
Jacek Anaszewski13ae79b2015-10-07 11:10:43 +0200293}
294EXPORT_SYMBOL_GPL(led_set_brightness_sync);
295
Jacek Anaszewski3ef7de52014-08-20 06:41:55 -0700296int led_update_brightness(struct led_classdev *led_cdev)
297{
298 int ret = 0;
299
300 if (led_cdev->brightness_get) {
301 ret = led_cdev->brightness_get(led_cdev);
302 if (ret >= 0) {
303 led_cdev->brightness = ret;
304 return 0;
305 }
306 }
307
308 return ret;
309}
Jacek Anaszewski2806e2f2015-09-28 15:07:10 +0200310EXPORT_SYMBOL_GPL(led_update_brightness);
Jacek Anaszewskiacd899e2014-09-22 08:21:04 -0700311
312/* Caller must ensure led_cdev->led_access held */
313void led_sysfs_disable(struct led_classdev *led_cdev)
314{
315 lockdep_assert_held(&led_cdev->led_access);
316
317 led_cdev->flags |= LED_SYSFS_DISABLE;
318}
319EXPORT_SYMBOL_GPL(led_sysfs_disable);
320
321/* Caller must ensure led_cdev->led_access held */
322void led_sysfs_enable(struct led_classdev *led_cdev)
323{
324 lockdep_assert_held(&led_cdev->led_access);
325
326 led_cdev->flags &= ~LED_SYSFS_DISABLE;
327}
328EXPORT_SYMBOL_GPL(led_sysfs_enable);