Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
11efe71f SG |
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> | |
11efe71f SG |
10 | */ |
11 | ||
12 | #include <linux/kernel.h> | |
11efe71f SG |
13 | #include <linux/platform_device.h> |
14 | #include <linux/slab.h> | |
c7896490 | 15 | #include <linux/gpio/consumer.h> |
11efe71f | 16 | #include <linux/leds.h> |
54f4dedb | 17 | #include <linux/module.h> |
c68f46dd | 18 | #include <linux/of.h> |
4b90432d | 19 | #include "leds.h" |
11efe71f | 20 | |
c7896490 LW |
21 | enum ns2_led_modes { |
22 | NS_V2_LED_OFF, | |
23 | NS_V2_LED_ON, | |
24 | NS_V2_LED_SATA, | |
25 | }; | |
26 | ||
940cca1a MB |
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 | */ | |
c7896490 | 32 | struct ns2_led_modval { |
940cca1a MB |
33 | u32 mode; |
34 | u32 cmd_level; | |
35 | u32 slow_level; | |
36 | } __packed; | |
c7896490 | 37 | |
11efe71f | 38 | /* |
f7fafd08 VD |
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. | |
11efe71f SG |
43 | */ |
44 | ||
01026cec | 45 | struct ns2_led { |
11efe71f | 46 | struct led_classdev cdev; |
ccbbb117 LW |
47 | struct gpio_desc *cmd; |
48 | struct gpio_desc *slow; | |
4b90432d | 49 | bool can_sleep; |
11efe71f SG |
50 | unsigned char sata; /* True when SATA mode active. */ |
51 | rwlock_t rw_lock; /* Lock GPIOs. */ | |
f7fafd08 VD |
52 | int num_modes; |
53 | struct ns2_led_modval *modval; | |
11efe71f SG |
54 | }; |
55 | ||
a78bd8f3 | 56 | static int ns2_led_get_mode(struct ns2_led *led, enum ns2_led_modes *mode) |
11efe71f SG |
57 | { |
58 | int i; | |
11efe71f SG |
59 | int cmd_level; |
60 | int slow_level; | |
61 | ||
a78bd8f3 MB |
62 | cmd_level = gpiod_get_value_cansleep(led->cmd); |
63 | slow_level = gpiod_get_value_cansleep(led->slow); | |
11efe71f | 64 | |
a78bd8f3 MB |
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; | |
a2fc703c | 69 | return 0; |
11efe71f SG |
70 | } |
71 | } | |
72 | ||
a2fc703c | 73 | return -EINVAL; |
11efe71f SG |
74 | } |
75 | ||
a78bd8f3 | 76 | static void ns2_led_set_mode(struct ns2_led *led, enum ns2_led_modes mode) |
11efe71f SG |
77 | { |
78 | int i; | |
f539dfed | 79 | unsigned long flags; |
11efe71f | 80 | |
a78bd8f3 | 81 | for (i = 0; i < led->num_modes; i++) |
48b77cdc | 82 | if (mode == led->modval[i].mode) |
4b90432d | 83 | break; |
4b90432d | 84 | |
48b77cdc | 85 | if (i == led->num_modes) |
4b90432d SG |
86 | return; |
87 | ||
a78bd8f3 | 88 | write_lock_irqsave(&led->rw_lock, flags); |
4b90432d | 89 | |
a78bd8f3 MB |
90 | if (!led->can_sleep) { |
91 | gpiod_set_value(led->cmd, led->modval[i].cmd_level); | |
92 | gpiod_set_value(led->slow, led->modval[i].slow_level); | |
4b90432d | 93 | goto exit_unlock; |
11efe71f SG |
94 | } |
95 | ||
a78bd8f3 MB |
96 | gpiod_set_value_cansleep(led->cmd, led->modval[i].cmd_level); |
97 | gpiod_set_value_cansleep(led->slow, led->modval[i].slow_level); | |
4b90432d SG |
98 | |
99 | exit_unlock: | |
a78bd8f3 | 100 | write_unlock_irqrestore(&led->rw_lock, flags); |
11efe71f SG |
101 | } |
102 | ||
103 | static void ns2_led_set(struct led_classdev *led_cdev, | |
104 | enum led_brightness value) | |
105 | { | |
a78bd8f3 | 106 | struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); |
11efe71f SG |
107 | enum ns2_led_modes mode; |
108 | ||
109 | if (value == LED_OFF) | |
110 | mode = NS_V2_LED_OFF; | |
a78bd8f3 | 111 | else if (led->sata) |
11efe71f SG |
112 | mode = NS_V2_LED_SATA; |
113 | else | |
114 | mode = NS_V2_LED_ON; | |
115 | ||
a78bd8f3 | 116 | ns2_led_set_mode(led, mode); |
11efe71f SG |
117 | } |
118 | ||
c29e650b JA |
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 | ||
11efe71f SG |
126 | static ssize_t ns2_led_sata_store(struct device *dev, |
127 | struct device_attribute *attr, | |
128 | const char *buff, size_t count) | |
129 | { | |
e5971bbc | 130 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
a78bd8f3 | 131 | struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); |
11efe71f SG |
132 | int ret; |
133 | unsigned long enable; | |
11efe71f | 134 | |
3874350c | 135 | ret = kstrtoul(buff, 10, &enable); |
11efe71f SG |
136 | if (ret < 0) |
137 | return ret; | |
138 | ||
139 | enable = !!enable; | |
140 | ||
a78bd8f3 | 141 | if (led->sata == enable) |
4b90432d | 142 | goto exit; |
11efe71f | 143 | |
a78bd8f3 | 144 | led->sata = enable; |
4b90432d SG |
145 | |
146 | if (!led_get_brightness(led_cdev)) | |
147 | goto exit; | |
11efe71f | 148 | |
4b90432d | 149 | if (enable) |
a78bd8f3 | 150 | ns2_led_set_mode(led, NS_V2_LED_SATA); |
4b90432d | 151 | else |
a78bd8f3 | 152 | ns2_led_set_mode(led, NS_V2_LED_ON); |
11efe71f | 153 | |
4b90432d | 154 | exit: |
11efe71f SG |
155 | return count; |
156 | } | |
157 | ||
158 | static ssize_t ns2_led_sata_show(struct device *dev, | |
159 | struct device_attribute *attr, char *buf) | |
160 | { | |
e5971bbc | 161 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
a78bd8f3 | 162 | struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev); |
11efe71f | 163 | |
a78bd8f3 | 164 | return sprintf(buf, "%d\n", led->sata); |
11efe71f SG |
165 | } |
166 | ||
167 | static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store); | |
168 | ||
475f8548 JH |
169 | static struct attribute *ns2_led_attrs[] = { |
170 | &dev_attr_sata.attr, | |
171 | NULL | |
172 | }; | |
173 | ATTRIBUTE_GROUPS(ns2_led); | |
174 | ||
940cca1a | 175 | static int ns2_led_register(struct device *dev, struct fwnode_handle *node, |
a4a469b4 | 176 | struct ns2_led *led) |
f72deb71 | 177 | { |
f847ef54 | 178 | struct led_init_data init_data = {}; |
f72deb71 | 179 | struct ns2_led_modval *modval; |
a4a469b4 | 180 | enum ns2_led_modes mode; |
940cca1a | 181 | int nmodes, ret; |
f72deb71 | 182 | |
940cca1a MB |
183 | led->cmd = devm_fwnode_gpiod_get_index(dev, node, "cmd", 0, GPIOD_ASIS, |
184 | fwnode_get_name(node)); | |
f72deb71 MB |
185 | if (IS_ERR(led->cmd)) |
186 | return PTR_ERR(led->cmd); | |
187 | ||
940cca1a MB |
188 | led->slow = devm_fwnode_gpiod_get_index(dev, node, "slow", 0, |
189 | GPIOD_ASIS, | |
190 | fwnode_get_name(node)); | |
f72deb71 MB |
191 | if (IS_ERR(led->slow)) |
192 | return PTR_ERR(led->slow); | |
193 | ||
940cca1a | 194 | ret = fwnode_property_count_u32(node, "modes-map"); |
f72deb71 | 195 | if (ret < 0 || ret % 3) { |
940cca1a | 196 | dev_err(dev, "Missing or malformed modes-map for %pfw\n", node); |
f72deb71 MB |
197 | return -EINVAL; |
198 | } | |
199 | ||
200 | nmodes = ret / 3; | |
201 | modval = devm_kcalloc(dev, nmodes, sizeof(*modval), GFP_KERNEL); | |
202 | if (!modval) | |
203 | return -ENOMEM; | |
204 | ||
940cca1a MB |
205 | fwnode_property_read_u32_array(node, "modes-map", (void *)modval, |
206 | nmodes * 3); | |
f72deb71 | 207 | |
a4a469b4 MB |
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(led->cmd) || gpiod_cansleep(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; | |
f72deb71 MB |
218 | led->num_modes = nmodes; |
219 | led->modval = modval; | |
220 | ||
a4a469b4 MB |
221 | ret = ns2_led_get_mode(led, &mode); |
222 | if (ret < 0) | |
223 | return ret; | |
72052fcc | 224 | |
a4a469b4 MB |
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; | |
72052fcc | 228 | |
940cca1a | 229 | init_data.fwnode = node; |
f847ef54 MB |
230 | |
231 | ret = devm_led_classdev_register_ext(dev, &led->cdev, &init_data); | |
a4a469b4 | 232 | if (ret) |
940cca1a | 233 | dev_err(dev, "Failed to register LED for node %pfw\n", node); |
72052fcc | 234 | |
a4a469b4 | 235 | return ret; |
72052fcc SG |
236 | } |
237 | ||
98ea1ea2 | 238 | static int ns2_led_probe(struct platform_device *pdev) |
11efe71f | 239 | { |
b3f96922 | 240 | struct device *dev = &pdev->dev; |
940cca1a | 241 | struct fwnode_handle *child; |
01026cec | 242 | struct ns2_led *leds; |
a4a469b4 | 243 | int count; |
11efe71f SG |
244 | int ret; |
245 | ||
940cca1a | 246 | count = device_get_child_node_count(dev); |
a4a469b4 MB |
247 | if (!count) |
248 | return -ENODEV; | |
11efe71f | 249 | |
a4a469b4 | 250 | leds = devm_kzalloc(dev, array_size(sizeof(*leds), count), GFP_KERNEL); |
19d4deb7 | 251 | if (!leds) |
11efe71f SG |
252 | return -ENOMEM; |
253 | ||
940cca1a | 254 | device_for_each_child_node(dev, child) { |
a4a469b4 MB |
255 | ret = ns2_led_register(dev, child, leds++); |
256 | if (ret) { | |
940cca1a | 257 | fwnode_handle_put(child); |
a209f766 | 258 | return ret; |
a4a469b4 | 259 | } |
11efe71f SG |
260 | } |
261 | ||
11efe71f | 262 | return 0; |
11efe71f SG |
263 | } |
264 | ||
8fd8f942 MB |
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 | ||
11efe71f SG |
271 | static struct platform_driver ns2_led_driver = { |
272 | .probe = ns2_led_probe, | |
11efe71f | 273 | .driver = { |
72052fcc | 274 | .name = "leds-ns2", |
8fd8f942 | 275 | .of_match_table = of_ns2_leds_match, |
11efe71f SG |
276 | }, |
277 | }; | |
11efe71f | 278 | |
892a8843 | 279 | module_platform_driver(ns2_led_driver); |
11efe71f SG |
280 | |
281 | MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); | |
282 | MODULE_DESCRIPTION("Network Space v2 LED driver"); | |
283 | MODULE_LICENSE("GPL"); | |
892a8843 | 284 | MODULE_ALIAS("platform:leds-ns2"); |