1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED |
4 | * |
5 | * Copyright (C) 2010 LaCie |
6 | * |
7 | * Author: Simon Guinot <sguinot@lacie.com> |
8 | * |
9 | * Based on leds-gpio.c by Raphael Assenat <raph@8d.com> |
10 | */ |
11 | |
12 | #include <linux/kernel.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/gpio/consumer.h> |
16 | #include <linux/leds.h> |
17 | #include <linux/module.h> |
18 | #include <linux/of.h> |
19 | #include "leds.h" |
20 | |
21 | enum ns2_led_modes { |
22 | NS_V2_LED_OFF, |
23 | NS_V2_LED_ON, |
24 | NS_V2_LED_SATA, |
25 | }; |
26 | |
27 | /* |
28 | * If the size of this structure or types of its members is changed, |
29 | * the filling of array modval in function ns2_led_register must be changed |
30 | * accordingly. |
31 | */ |
32 | struct ns2_led_modval { |
33 | u32 mode; |
34 | u32 cmd_level; |
35 | u32 slow_level; |
36 | } __packed; |
37 | |
38 | /* |
39 | * The Network Space v2 dual-GPIO LED is wired to a CPLD. Three different LED |
40 | * modes are available: off, on and SATA activity blinking. The LED modes are |
41 | * controlled through two GPIOs (command and slow): each combination of values |
42 | * for the command/slow GPIOs corresponds to a LED mode. |
43 | */ |
44 | |
45 | struct ns2_led { |
46 | struct led_classdev cdev; |
47 | struct gpio_desc *cmd; |
48 | struct gpio_desc *slow; |
49 | bool can_sleep; |
50 | unsigned char sata; /* True when SATA mode active. */ |
51 | rwlock_t rw_lock; /* Lock GPIOs. */ |
52 | int num_modes; |
53 | struct ns2_led_modval *modval; |
54 | }; |
55 | |
56 | static int ns2_led_get_mode(struct ns2_led *led, enum ns2_led_modes *mode) |
57 | { |
58 | int i; |
59 | int cmd_level; |
60 | int slow_level; |
61 | |
62 | cmd_level = gpiod_get_value_cansleep(desc: led->cmd); |
63 | slow_level = gpiod_get_value_cansleep(desc: led->slow); |
64 | |
65 | for (i = 0; i < led->num_modes; i++) { |
66 | if (cmd_level == led->modval[i].cmd_level && |
67 | slow_level == led->modval[i].slow_level) { |
68 | *mode = led->modval[i].mode; |
69 | return 0; |
70 | } |
71 | } |
72 | |
73 | return -EINVAL; |
74 | } |
75 | |
76 | static void ns2_led_set_mode(struct ns2_led *led, enum ns2_led_modes mode) |
77 | { |
78 | int i; |
79 | unsigned long flags; |
80 | |
81 | for (i = 0; i < led->num_modes; i++) |
82 | if (mode == led->modval[i].mode) |
83 | break; |
84 | |
85 | if (i == led->num_modes) |
86 | return; |
87 | |
88 | write_lock_irqsave(&led->rw_lock, flags); |
89 | |
90 | if (!led->can_sleep) { |
91 | gpiod_set_value(desc: led->cmd, value: led->modval[i].cmd_level); |
92 | gpiod_set_value(desc: led->slow, value: led->modval[i].slow_level); |
93 | goto exit_unlock; |
94 | } |
95 | |
96 | gpiod_set_value_cansleep(desc: led->cmd, value: led->modval[i].cmd_level); |
97 | gpiod_set_value_cansleep(desc: led->slow, value: led->modval[i].slow_level); |
98 | |
99 | exit_unlock: |
100 | write_unlock_irqrestore(&led->rw_lock, flags); |
101 | } |
102 | |
103 | static void ns2_led_set(struct led_classdev *led_cdev, |
104 | enum led_brightness value) |
105 | { |
106 | struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); |
107 | enum ns2_led_modes mode; |
108 | |
109 | if (value == LED_OFF) |
110 | mode = NS_V2_LED_OFF; |
111 | else if (led->sata) |
112 | mode = NS_V2_LED_SATA; |
113 | else |
114 | mode = NS_V2_LED_ON; |
115 | |
116 | ns2_led_set_mode(led, mode); |
117 | } |
118 | |
119 | static int ns2_led_set_blocking(struct led_classdev *led_cdev, |
120 | enum led_brightness value) |
121 | { |
122 | ns2_led_set(led_cdev, value); |
123 | return 0; |
124 | } |
125 | |
126 | static ssize_t ns2_led_sata_store(struct device *dev, |
127 | struct device_attribute *attr, |
128 | const char *buff, size_t count) |
129 | { |
130 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
131 | struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); |
132 | int ret; |
133 | unsigned long enable; |
134 | |
135 | ret = kstrtoul(s: buff, base: 10, res: &enable); |
136 | if (ret < 0) |
137 | return ret; |
138 | |
139 | enable = !!enable; |
140 | |
141 | if (led->sata == enable) |
142 | goto exit; |
143 | |
144 | led->sata = enable; |
145 | |
146 | if (!led_get_brightness(led_cdev)) |
147 | goto exit; |
148 | |
149 | if (enable) |
150 | ns2_led_set_mode(led, mode: NS_V2_LED_SATA); |
151 | else |
152 | ns2_led_set_mode(led, mode: NS_V2_LED_ON); |
153 | |
154 | exit: |
155 | return count; |
156 | } |
157 | |
158 | static ssize_t ns2_led_sata_show(struct device *dev, |
159 | struct device_attribute *attr, char *buf) |
160 | { |
161 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
162 | struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); |
163 | |
164 | return sprintf(buf, fmt: "%d\n" , led->sata); |
165 | } |
166 | |
167 | static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store); |
168 | |
169 | static struct attribute *ns2_led_attrs[] = { |
170 | &dev_attr_sata.attr, |
171 | NULL |
172 | }; |
173 | ATTRIBUTE_GROUPS(ns2_led); |
174 | |
175 | static int ns2_led_register(struct device *dev, struct fwnode_handle *node, |
176 | struct ns2_led *led) |
177 | { |
178 | struct led_init_data init_data = {}; |
179 | struct ns2_led_modval *modval; |
180 | enum ns2_led_modes mode; |
181 | int nmodes, ret; |
182 | |
183 | led->cmd = devm_fwnode_gpiod_get_index(dev, child: node, con_id: "cmd" , index: 0, flags: GPIOD_ASIS, |
184 | label: fwnode_get_name(fwnode: node)); |
185 | if (IS_ERR(ptr: led->cmd)) |
186 | return PTR_ERR(ptr: led->cmd); |
187 | |
188 | led->slow = devm_fwnode_gpiod_get_index(dev, child: node, con_id: "slow" , index: 0, |
189 | flags: GPIOD_ASIS, |
190 | label: fwnode_get_name(fwnode: node)); |
191 | if (IS_ERR(ptr: led->slow)) |
192 | return PTR_ERR(ptr: led->slow); |
193 | |
194 | ret = fwnode_property_count_u32(fwnode: node, propname: "modes-map" ); |
195 | if (ret < 0 || ret % 3) { |
196 | dev_err(dev, "Missing or malformed modes-map for %pfw\n" , node); |
197 | return -EINVAL; |
198 | } |
199 | |
200 | nmodes = ret / 3; |
201 | modval = devm_kcalloc(dev, n: nmodes, size: sizeof(*modval), GFP_KERNEL); |
202 | if (!modval) |
203 | return -ENOMEM; |
204 | |
205 | fwnode_property_read_u32_array(fwnode: node, propname: "modes-map" , val: (void *)modval, |
206 | nval: nmodes * 3); |
207 | |
208 | rwlock_init(&led->rw_lock); |
209 | |
210 | led->cdev.blink_set = NULL; |
211 | led->cdev.flags |= LED_CORE_SUSPENDRESUME; |
212 | led->cdev.groups = ns2_led_groups; |
213 | led->can_sleep = gpiod_cansleep(desc: led->cmd) || gpiod_cansleep(desc: led->slow); |
214 | if (led->can_sleep) |
215 | led->cdev.brightness_set_blocking = ns2_led_set_blocking; |
216 | else |
217 | led->cdev.brightness_set = ns2_led_set; |
218 | led->num_modes = nmodes; |
219 | led->modval = modval; |
220 | |
221 | ret = ns2_led_get_mode(led, mode: &mode); |
222 | if (ret < 0) |
223 | return ret; |
224 | |
225 | /* Set LED initial state. */ |
226 | led->sata = (mode == NS_V2_LED_SATA) ? 1 : 0; |
227 | led->cdev.brightness = (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL; |
228 | |
229 | init_data.fwnode = node; |
230 | |
231 | ret = devm_led_classdev_register_ext(parent: dev, led_cdev: &led->cdev, init_data: &init_data); |
232 | if (ret) |
233 | dev_err(dev, "Failed to register LED for node %pfw\n" , node); |
234 | |
235 | return ret; |
236 | } |
237 | |
238 | static int ns2_led_probe(struct platform_device *pdev) |
239 | { |
240 | struct device *dev = &pdev->dev; |
241 | struct fwnode_handle *child; |
242 | struct ns2_led *leds; |
243 | int count; |
244 | int ret; |
245 | |
246 | count = device_get_child_node_count(dev); |
247 | if (!count) |
248 | return -ENODEV; |
249 | |
250 | leds = devm_kcalloc(dev, n: count, size: sizeof(*leds), GFP_KERNEL); |
251 | if (!leds) |
252 | return -ENOMEM; |
253 | |
254 | device_for_each_child_node(dev, child) { |
255 | ret = ns2_led_register(dev, node: child, led: leds++); |
256 | if (ret) { |
257 | fwnode_handle_put(fwnode: child); |
258 | return ret; |
259 | } |
260 | } |
261 | |
262 | return 0; |
263 | } |
264 | |
265 | static const struct of_device_id of_ns2_leds_match[] = { |
266 | { .compatible = "lacie,ns2-leds" , }, |
267 | {}, |
268 | }; |
269 | MODULE_DEVICE_TABLE(of, of_ns2_leds_match); |
270 | |
271 | static struct platform_driver ns2_led_driver = { |
272 | .probe = ns2_led_probe, |
273 | .driver = { |
274 | .name = "leds-ns2" , |
275 | .of_match_table = of_ns2_leds_match, |
276 | }, |
277 | }; |
278 | |
279 | module_platform_driver(ns2_led_driver); |
280 | |
281 | MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>" ); |
282 | MODULE_DESCRIPTION("Network Space v2 LED driver" ); |
283 | MODULE_LICENSE("GPL" ); |
284 | MODULE_ALIAS("platform:leds-ns2" ); |
285 | |