Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * One-shot LED Trigger
4 *
5 * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
6 *
7 * Based on ledtrig-timer.c by Richard Purdie <rpurdie@openedhand.com>
8 */
9
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/device.h>
14#include <linux/ctype.h>
15#include <linux/slab.h>
16#include <linux/leds.h>
17#include "../leds.h"
18
19#define DEFAULT_DELAY 100
20
21struct oneshot_trig_data {
22 unsigned int invert;
23};
24
25static ssize_t led_shot(struct device *dev,
26 struct device_attribute *attr, const char *buf, size_t size)
27{
28 struct led_classdev *led_cdev = led_trigger_get_led(dev);
29 struct oneshot_trig_data *oneshot_data = led_trigger_get_drvdata(dev);
30
31 led_blink_set_oneshot(led_cdev,
32 &led_cdev->blink_delay_on, &led_cdev->blink_delay_off,
33 oneshot_data->invert);
34
35 /* content is ignored */
36 return size;
37}
38static ssize_t led_invert_show(struct device *dev,
39 struct device_attribute *attr, char *buf)
40{
41 struct oneshot_trig_data *oneshot_data = led_trigger_get_drvdata(dev);
42
43 return sprintf(buf, "%u\n", oneshot_data->invert);
44}
45
46static ssize_t led_invert_store(struct device *dev,
47 struct device_attribute *attr, const char *buf, size_t size)
48{
49 struct led_classdev *led_cdev = led_trigger_get_led(dev);
50 struct oneshot_trig_data *oneshot_data = led_trigger_get_drvdata(dev);
51 unsigned long state;
52 int ret;
53
54 ret = kstrtoul(buf, 0, &state);
55 if (ret)
56 return ret;
57
58 oneshot_data->invert = !!state;
59
60 if (oneshot_data->invert)
61 led_set_brightness_nosleep(led_cdev, LED_FULL);
62 else
63 led_set_brightness_nosleep(led_cdev, LED_OFF);
64
65 return size;
66}
67
68static ssize_t led_delay_on_show(struct device *dev,
69 struct device_attribute *attr, char *buf)
70{
71 struct led_classdev *led_cdev = led_trigger_get_led(dev);
72
73 return sprintf(buf, "%lu\n", led_cdev->blink_delay_on);
74}
75
76static ssize_t led_delay_on_store(struct device *dev,
77 struct device_attribute *attr, const char *buf, size_t size)
78{
79 struct led_classdev *led_cdev = led_trigger_get_led(dev);
80 unsigned long state;
81 int ret;
82
83 ret = kstrtoul(buf, 0, &state);
84 if (ret)
85 return ret;
86
87 led_cdev->blink_delay_on = state;
88
89 return size;
90}
91
92static ssize_t led_delay_off_show(struct device *dev,
93 struct device_attribute *attr, char *buf)
94{
95 struct led_classdev *led_cdev = led_trigger_get_led(dev);
96
97 return sprintf(buf, "%lu\n", led_cdev->blink_delay_off);
98}
99
100static ssize_t led_delay_off_store(struct device *dev,
101 struct device_attribute *attr, const char *buf, size_t size)
102{
103 struct led_classdev *led_cdev = led_trigger_get_led(dev);
104 unsigned long state;
105 int ret;
106
107 ret = kstrtoul(buf, 0, &state);
108 if (ret)
109 return ret;
110
111 led_cdev->blink_delay_off = state;
112
113 return size;
114}
115
116static DEVICE_ATTR(delay_on, 0644, led_delay_on_show, led_delay_on_store);
117static DEVICE_ATTR(delay_off, 0644, led_delay_off_show, led_delay_off_store);
118static DEVICE_ATTR(invert, 0644, led_invert_show, led_invert_store);
119static DEVICE_ATTR(shot, 0200, NULL, led_shot);
120
121static struct attribute *oneshot_trig_attrs[] = {
122 &dev_attr_delay_on.attr,
123 &dev_attr_delay_off.attr,
124 &dev_attr_invert.attr,
125 &dev_attr_shot.attr,
126 NULL
127};
128ATTRIBUTE_GROUPS(oneshot_trig);
129
130static void pattern_init(struct led_classdev *led_cdev)
131{
132 u32 *pattern;
133 unsigned int size = 0;
134
135 pattern = led_get_default_pattern(led_cdev, &size);
136 if (!pattern)
137 goto out_default;
138
139 if (size != 2) {
140 dev_warn(led_cdev->dev,
141 "Expected 2 but got %u values for delays pattern\n",
142 size);
143 goto out_default;
144 }
145
146 led_cdev->blink_delay_on = pattern[0];
147 led_cdev->blink_delay_off = pattern[1];
148 kfree(pattern);
149
150 return;
151
152out_default:
153 kfree(pattern);
154 led_cdev->blink_delay_on = DEFAULT_DELAY;
155 led_cdev->blink_delay_off = DEFAULT_DELAY;
156}
157
158static int oneshot_trig_activate(struct led_classdev *led_cdev)
159{
160 struct oneshot_trig_data *oneshot_data;
161
162 oneshot_data = kzalloc(sizeof(*oneshot_data), GFP_KERNEL);
163 if (!oneshot_data)
164 return -ENOMEM;
165
166 led_set_trigger_data(led_cdev, oneshot_data);
167
168 if (led_cdev->flags & LED_INIT_DEFAULT_TRIGGER) {
169 pattern_init(led_cdev);
170 /*
171 * Mark as initialized even on pattern_init() error because
172 * any consecutive call to it would produce the same error.
173 */
174 led_cdev->flags &= ~LED_INIT_DEFAULT_TRIGGER;
175 }
176
177 return 0;
178}
179
180static void oneshot_trig_deactivate(struct led_classdev *led_cdev)
181{
182 struct oneshot_trig_data *oneshot_data = led_get_trigger_data(led_cdev);
183
184 kfree(oneshot_data);
185
186 /* Stop blinking */
187 led_set_brightness(led_cdev, LED_OFF);
188}
189
190static struct led_trigger oneshot_led_trigger = {
191 .name = "oneshot",
192 .activate = oneshot_trig_activate,
193 .deactivate = oneshot_trig_deactivate,
194 .groups = oneshot_trig_groups,
195};
196module_led_trigger(oneshot_led_trigger);
197
198MODULE_AUTHOR("Fabio Baltieri <fabio.baltieri@gmail.com>");
199MODULE_DESCRIPTION("One-shot LED trigger");
200MODULE_LICENSE("GPL v2");
1/*
2 * One-shot LED Trigger
3 *
4 * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
5 *
6 * Based on ledtrig-timer.c by 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/module.h>
15#include <linux/kernel.h>
16#include <linux/init.h>
17#include <linux/device.h>
18#include <linux/ctype.h>
19#include <linux/slab.h>
20#include <linux/leds.h>
21#include "../leds.h"
22
23#define DEFAULT_DELAY 100
24
25struct oneshot_trig_data {
26 unsigned int invert;
27};
28
29static ssize_t led_shot(struct device *dev,
30 struct device_attribute *attr, const char *buf, size_t size)
31{
32 struct led_classdev *led_cdev = dev_get_drvdata(dev);
33 struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
34
35 led_blink_set_oneshot(led_cdev,
36 &led_cdev->blink_delay_on, &led_cdev->blink_delay_off,
37 oneshot_data->invert);
38
39 /* content is ignored */
40 return size;
41}
42static ssize_t led_invert_show(struct device *dev,
43 struct device_attribute *attr, char *buf)
44{
45 struct led_classdev *led_cdev = dev_get_drvdata(dev);
46 struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
47
48 return sprintf(buf, "%u\n", oneshot_data->invert);
49}
50
51static ssize_t led_invert_store(struct device *dev,
52 struct device_attribute *attr, const char *buf, size_t size)
53{
54 struct led_classdev *led_cdev = dev_get_drvdata(dev);
55 struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
56 unsigned long state;
57 int ret;
58
59 ret = kstrtoul(buf, 0, &state);
60 if (ret)
61 return ret;
62
63 oneshot_data->invert = !!state;
64
65 if (oneshot_data->invert)
66 led_set_brightness_nosleep(led_cdev, LED_FULL);
67 else
68 led_set_brightness_nosleep(led_cdev, LED_OFF);
69
70 return size;
71}
72
73static ssize_t led_delay_on_show(struct device *dev,
74 struct device_attribute *attr, char *buf)
75{
76 struct led_classdev *led_cdev = dev_get_drvdata(dev);
77
78 return sprintf(buf, "%lu\n", led_cdev->blink_delay_on);
79}
80
81static ssize_t led_delay_on_store(struct device *dev,
82 struct device_attribute *attr, const char *buf, size_t size)
83{
84 struct led_classdev *led_cdev = dev_get_drvdata(dev);
85 unsigned long state;
86 int ret;
87
88 ret = kstrtoul(buf, 0, &state);
89 if (ret)
90 return ret;
91
92 led_cdev->blink_delay_on = state;
93
94 return size;
95}
96static ssize_t led_delay_off_show(struct device *dev,
97 struct device_attribute *attr, char *buf)
98{
99 struct led_classdev *led_cdev = dev_get_drvdata(dev);
100
101 return sprintf(buf, "%lu\n", led_cdev->blink_delay_off);
102}
103
104static ssize_t led_delay_off_store(struct device *dev,
105 struct device_attribute *attr, const char *buf, size_t size)
106{
107 struct led_classdev *led_cdev = dev_get_drvdata(dev);
108 unsigned long state;
109 int ret;
110
111 ret = kstrtoul(buf, 0, &state);
112 if (ret)
113 return ret;
114
115 led_cdev->blink_delay_off = state;
116
117 return size;
118}
119
120static DEVICE_ATTR(delay_on, 0644, led_delay_on_show, led_delay_on_store);
121static DEVICE_ATTR(delay_off, 0644, led_delay_off_show, led_delay_off_store);
122static DEVICE_ATTR(invert, 0644, led_invert_show, led_invert_store);
123static DEVICE_ATTR(shot, 0200, NULL, led_shot);
124
125static void oneshot_trig_activate(struct led_classdev *led_cdev)
126{
127 struct oneshot_trig_data *oneshot_data;
128 int rc;
129
130 oneshot_data = kzalloc(sizeof(*oneshot_data), GFP_KERNEL);
131 if (!oneshot_data)
132 return;
133
134 led_cdev->trigger_data = oneshot_data;
135
136 rc = device_create_file(led_cdev->dev, &dev_attr_delay_on);
137 if (rc)
138 goto err_out_trig_data;
139 rc = device_create_file(led_cdev->dev, &dev_attr_delay_off);
140 if (rc)
141 goto err_out_delayon;
142 rc = device_create_file(led_cdev->dev, &dev_attr_invert);
143 if (rc)
144 goto err_out_delayoff;
145 rc = device_create_file(led_cdev->dev, &dev_attr_shot);
146 if (rc)
147 goto err_out_invert;
148
149 led_cdev->blink_delay_on = DEFAULT_DELAY;
150 led_cdev->blink_delay_off = DEFAULT_DELAY;
151
152 led_cdev->activated = true;
153
154 return;
155
156err_out_invert:
157 device_remove_file(led_cdev->dev, &dev_attr_invert);
158err_out_delayoff:
159 device_remove_file(led_cdev->dev, &dev_attr_delay_off);
160err_out_delayon:
161 device_remove_file(led_cdev->dev, &dev_attr_delay_on);
162err_out_trig_data:
163 kfree(led_cdev->trigger_data);
164}
165
166static void oneshot_trig_deactivate(struct led_classdev *led_cdev)
167{
168 struct oneshot_trig_data *oneshot_data = led_cdev->trigger_data;
169
170 if (led_cdev->activated) {
171 device_remove_file(led_cdev->dev, &dev_attr_delay_on);
172 device_remove_file(led_cdev->dev, &dev_attr_delay_off);
173 device_remove_file(led_cdev->dev, &dev_attr_invert);
174 device_remove_file(led_cdev->dev, &dev_attr_shot);
175 kfree(oneshot_data);
176 led_cdev->activated = false;
177 }
178
179 /* Stop blinking */
180 led_set_brightness(led_cdev, LED_OFF);
181}
182
183static struct led_trigger oneshot_led_trigger = {
184 .name = "oneshot",
185 .activate = oneshot_trig_activate,
186 .deactivate = oneshot_trig_deactivate,
187};
188
189static int __init oneshot_trig_init(void)
190{
191 return led_trigger_register(&oneshot_led_trigger);
192}
193
194static void __exit oneshot_trig_exit(void)
195{
196 led_trigger_unregister(&oneshot_led_trigger);
197}
198
199module_init(oneshot_trig_init);
200module_exit(oneshot_trig_exit);
201
202MODULE_AUTHOR("Fabio Baltieri <fabio.baltieri@gmail.com>");
203MODULE_DESCRIPTION("One-shot LED trigger");
204MODULE_LICENSE("GPL v2");