forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376 
 kernel/drivers/leds/leds-ns2.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /*
23  * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED
34  *
....@@ -6,32 +7,33 @@
67  * Author: Simon Guinot <sguinot@lacie.com>
78  *
89  * Based on leds-gpio.c by Raphael Assenat <raph@8d.com>
9
- *
10
- * This program is free software; you can redistribute it and/or modify
11
- * it under the terms of the GNU General Public License as published by
12
- * the Free Software Foundation; either version 2 of the License, or
13
- * (at your option) any later version.
14
- *
15
- * This program is distributed in the hope that it will be useful,
16
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
- * GNU General Public License for more details.
19
- *
20
- * You should have received a copy of the GNU General Public License
21
- * along with this program; if not, write to the Free Software
22
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
2310  */
2411 
2512 #include <linux/kernel.h>
2613 #include <linux/platform_device.h>
2714 #include <linux/slab.h>
28
-#include <linux/gpio.h>
15
+#include <linux/gpio/consumer.h>
2916 #include <linux/leds.h>
3017 #include <linux/module.h>
31
-#include <linux/platform_data/leds-kirkwood-ns2.h>
3218 #include <linux/of.h>
33
-#include <linux/of_gpio.h>
3419 #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;
3537 
3638 /*
3739  * The Network Space v2 dual-GPIO LED is wired to a CPLD. Three different LED
....@@ -40,10 +42,10 @@
4042  * for the command/slow GPIOs corresponds to a LED mode.
4143  */
4244 
43
-struct ns2_led_data {
45
+struct ns2_led {
4446 	struct led_classdev	cdev;
45
-	unsigned int		cmd;
46
-	unsigned int		slow;
47
+	struct gpio_desc	*cmd;
48
+	struct gpio_desc	*slow;
4749 	bool			can_sleep;
4850 	unsigned char		sata; /* True when SATA mode active. */
4951 	rwlock_t		rw_lock; /* Lock GPIOs. */
....@@ -51,77 +53,67 @@
5153 	struct ns2_led_modval	*modval;
5254 };
5355 
54
-static int ns2_led_get_mode(struct ns2_led_data *led_dat,
55
-			    enum ns2_led_modes *mode)
56
+static int ns2_led_get_mode(struct ns2_led *led, enum ns2_led_modes *mode)
5657 {
5758 	int i;
58
-	int ret = -EINVAL;
5959 	int cmd_level;
6060 	int slow_level;
6161 
62
-	cmd_level = gpio_get_value_cansleep(led_dat->cmd);
63
-	slow_level = gpio_get_value_cansleep(led_dat->slow);
62
+	cmd_level = gpiod_get_value_cansleep(led->cmd);
63
+	slow_level = gpiod_get_value_cansleep(led->slow);
6464 
65
-	for (i = 0; i < led_dat->num_modes; i++) {
66
-		if (cmd_level == led_dat->modval[i].cmd_level &&
67
-		    slow_level == led_dat->modval[i].slow_level) {
68
-			*mode = led_dat->modval[i].mode;
69
-			ret = 0;
70
-			break;
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;
7170 		}
7271 	}
7372 
74
-	return ret;
73
+	return -EINVAL;
7574 }
7675 
77
-static void ns2_led_set_mode(struct ns2_led_data *led_dat,
78
-			     enum ns2_led_modes mode)
76
+static void ns2_led_set_mode(struct ns2_led *led, enum ns2_led_modes mode)
7977 {
8078 	int i;
81
-	bool found = false;
8279 	unsigned long flags;
8380 
84
-	for (i = 0; i < led_dat->num_modes; i++)
85
-		if (mode == led_dat->modval[i].mode) {
86
-			found = true;
81
+	for (i = 0; i < led->num_modes; i++)
82
+		if (mode == led->modval[i].mode)
8783 			break;
88
-		}
8984 
90
-	if (!found)
85
+	if (i == led->num_modes)
9186 		return;
9287 
93
-	write_lock_irqsave(&led_dat->rw_lock, flags);
88
+	write_lock_irqsave(&led->rw_lock, flags);
9489 
95
-	if (!led_dat->can_sleep) {
96
-		gpio_set_value(led_dat->cmd,
97
-			       led_dat->modval[i].cmd_level);
98
-		gpio_set_value(led_dat->slow,
99
-			       led_dat->modval[i].slow_level);
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);
10093 		goto exit_unlock;
10194 	}
10295 
103
-	gpio_set_value_cansleep(led_dat->cmd, led_dat->modval[i].cmd_level);
104
-	gpio_set_value_cansleep(led_dat->slow, led_dat->modval[i].slow_level);
96
+	gpiod_set_value_cansleep(led->cmd, led->modval[i].cmd_level);
97
+	gpiod_set_value_cansleep(led->slow, led->modval[i].slow_level);
10598 
10699 exit_unlock:
107
-	write_unlock_irqrestore(&led_dat->rw_lock, flags);
100
+	write_unlock_irqrestore(&led->rw_lock, flags);
108101 }
109102 
110103 static void ns2_led_set(struct led_classdev *led_cdev,
111104 			enum led_brightness value)
112105 {
113
-	struct ns2_led_data *led_dat =
114
-		container_of(led_cdev, struct ns2_led_data, cdev);
106
+	struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev);
115107 	enum ns2_led_modes mode;
116108 
117109 	if (value == LED_OFF)
118110 		mode = NS_V2_LED_OFF;
119
-	else if (led_dat->sata)
111
+	else if (led->sata)
120112 		mode = NS_V2_LED_SATA;
121113 	else
122114 		mode = NS_V2_LED_ON;
123115 
124
-	ns2_led_set_mode(led_dat, mode);
116
+	ns2_led_set_mode(led, mode);
125117 }
126118 
127119 static int ns2_led_set_blocking(struct led_classdev *led_cdev,
....@@ -136,8 +128,7 @@
136128 				  const char *buff, size_t count)
137129 {
138130 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
139
-	struct ns2_led_data *led_dat =
140
-		container_of(led_cdev, struct ns2_led_data, cdev);
131
+	struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev);
141132 	int ret;
142133 	unsigned long enable;
143134 
....@@ -147,18 +138,18 @@
147138 
148139 	enable = !!enable;
149140 
150
-	if (led_dat->sata == enable)
141
+	if (led->sata == enable)
151142 		goto exit;
152143 
153
-	led_dat->sata = enable;
144
+	led->sata = enable;
154145 
155146 	if (!led_get_brightness(led_cdev))
156147 		goto exit;
157148 
158149 	if (enable)
159
-		ns2_led_set_mode(led_dat, NS_V2_LED_SATA);
150
+		ns2_led_set_mode(led, NS_V2_LED_SATA);
160151 	else
161
-		ns2_led_set_mode(led_dat, NS_V2_LED_ON);
152
+		ns2_led_set_mode(led, NS_V2_LED_ON);
162153 
163154 exit:
164155 	return count;
....@@ -168,10 +159,9 @@
168159 				 struct device_attribute *attr, char *buf)
169160 {
170161 	struct led_classdev *led_cdev = dev_get_drvdata(dev);
171
-	struct ns2_led_data *led_dat =
172
-		container_of(led_cdev, struct ns2_led_data, cdev);
162
+	struct ns2_led *led = container_of(led_cdev, struct ns2_led, cdev);
173163 
174
-	return sprintf(buf, "%d\n", led_dat->sata);
164
+	return sprintf(buf, "%d\n", led->sata);
175165 }
176166 
177167 static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store);
....@@ -182,149 +172,92 @@
182172 };
183173 ATTRIBUTE_GROUPS(ns2_led);
184174 
185
-static int
186
-create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
187
-	       const struct ns2_led *template)
175
+static int ns2_led_register(struct device *dev, struct fwnode_handle *node,
176
+			    struct ns2_led *led)
188177 {
189
-	int ret;
178
+	struct led_init_data init_data = {};
179
+	struct ns2_led_modval *modval;
190180 	enum ns2_led_modes mode;
181
+	int nmodes, ret;
191182 
192
-	ret = devm_gpio_request_one(&pdev->dev, template->cmd,
193
-			gpio_get_value_cansleep(template->cmd) ?
194
-			GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
195
-			template->name);
196
-	if (ret) {
197
-		dev_err(&pdev->dev, "%s: failed to setup command GPIO\n",
198
-			template->name);
199
-		return ret;
183
+	led->cmd = devm_fwnode_gpiod_get_index(dev, node, "cmd", 0, GPIOD_ASIS,
184
+					       fwnode_get_name(node));
185
+	if (IS_ERR(led->cmd))
186
+		return PTR_ERR(led->cmd);
187
+
188
+	led->slow = devm_fwnode_gpiod_get_index(dev, node, "slow", 0,
189
+						GPIOD_ASIS,
190
+						fwnode_get_name(node));
191
+	if (IS_ERR(led->slow))
192
+		return PTR_ERR(led->slow);
193
+
194
+	ret = fwnode_property_count_u32(node, "modes-map");
195
+	if (ret < 0 || ret % 3) {
196
+		dev_err(dev, "Missing or malformed modes-map for %pfw\n", node);
197
+		return -EINVAL;
200198 	}
201199 
202
-	ret = devm_gpio_request_one(&pdev->dev, template->slow,
203
-			gpio_get_value_cansleep(template->slow) ?
204
-			GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
205
-			template->name);
206
-	if (ret) {
207
-		dev_err(&pdev->dev, "%s: failed to setup slow GPIO\n",
208
-			template->name);
209
-		return ret;
210
-	}
200
+	nmodes = ret / 3;
201
+	modval = devm_kcalloc(dev, nmodes, sizeof(*modval), GFP_KERNEL);
202
+	if (!modval)
203
+		return -ENOMEM;
211204 
212
-	rwlock_init(&led_dat->rw_lock);
205
+	fwnode_property_read_u32_array(node, "modes-map", (void *)modval,
206
+				       nmodes * 3);
213207 
214
-	led_dat->cdev.name = template->name;
215
-	led_dat->cdev.default_trigger = template->default_trigger;
216
-	led_dat->cdev.blink_set = NULL;
217
-	led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
218
-	led_dat->cdev.groups = ns2_led_groups;
219
-	led_dat->cmd = template->cmd;
220
-	led_dat->slow = template->slow;
221
-	led_dat->can_sleep = gpio_cansleep(led_dat->cmd) |
222
-				gpio_cansleep(led_dat->slow);
223
-	if (led_dat->can_sleep)
224
-		led_dat->cdev.brightness_set_blocking = ns2_led_set_blocking;
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;
225216 	else
226
-		led_dat->cdev.brightness_set = ns2_led_set;
227
-	led_dat->modval = template->modval;
228
-	led_dat->num_modes = template->num_modes;
217
+		led->cdev.brightness_set = ns2_led_set;
218
+	led->num_modes = nmodes;
219
+	led->modval = modval;
229220 
230
-	ret = ns2_led_get_mode(led_dat, &mode);
221
+	ret = ns2_led_get_mode(led, &mode);
231222 	if (ret < 0)
232223 		return ret;
233224 
234225 	/* Set LED initial state. */
235
-	led_dat->sata = (mode == NS_V2_LED_SATA) ? 1 : 0;
236
-	led_dat->cdev.brightness =
237
-		(mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL;
226
+	led->sata = (mode == NS_V2_LED_SATA) ? 1 : 0;
227
+	led->cdev.brightness = (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL;
238228 
239
-	ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
240
-	if (ret < 0)
241
-		return ret;
229
+	init_data.fwnode = node;
242230 
243
-	return 0;
231
+	ret = devm_led_classdev_register_ext(dev, &led->cdev, &init_data);
232
+	if (ret)
233
+		dev_err(dev, "Failed to register LED for node %pfw\n", node);
234
+
235
+	return ret;
244236 }
245237 
246
-static void delete_ns2_led(struct ns2_led_data *led_dat)
238
+static int ns2_led_probe(struct platform_device *pdev)
247239 {
248
-	led_classdev_unregister(&led_dat->cdev);
249
-}
240
+	struct device *dev = &pdev->dev;
241
+	struct fwnode_handle *child;
242
+	struct ns2_led *leds;
243
+	int count;
244
+	int ret;
250245 
251
-#ifdef CONFIG_OF_GPIO
252
-/*
253
- * Translate OpenFirmware node properties into platform_data.
254
- */
255
-static int
256
-ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
257
-{
258
-	struct device_node *np = dev->of_node;
259
-	struct device_node *child;
260
-	struct ns2_led *led, *leds;
261
-	int num_leds = 0;
262
-
263
-	num_leds = of_get_child_count(np);
264
-	if (!num_leds)
246
+	count = device_get_child_node_count(dev);
247
+	if (!count)
265248 		return -ENODEV;
266249 
267
-	leds = devm_kcalloc(dev, num_leds, sizeof(struct ns2_led),
268
-			    GFP_KERNEL);
250
+	leds = devm_kzalloc(dev, array_size(sizeof(*leds), count), GFP_KERNEL);
269251 	if (!leds)
270252 		return -ENOMEM;
271253 
272
-	led = leds;
273
-	for_each_child_of_node(np, child) {
274
-		const char *string;
275
-		int ret, i, num_modes;
276
-		struct ns2_led_modval *modval;
277
-
278
-		ret = of_get_named_gpio(child, "cmd-gpio", 0);
279
-		if (ret < 0)
254
+	device_for_each_child_node(dev, child) {
255
+		ret = ns2_led_register(dev, child, leds++);
256
+		if (ret) {
257
+			fwnode_handle_put(child);
280258 			return ret;
281
-		led->cmd = ret;
282
-		ret = of_get_named_gpio(child, "slow-gpio", 0);
283
-		if (ret < 0)
284
-			return ret;
285
-		led->slow = ret;
286
-		ret = of_property_read_string(child, "label", &string);
287
-		led->name = (ret == 0) ? string : child->name;
288
-		ret = of_property_read_string(child, "linux,default-trigger",
289
-					      &string);
290
-		if (ret == 0)
291
-			led->default_trigger = string;
292
-
293
-		ret = of_property_count_u32_elems(child, "modes-map");
294
-		if (ret < 0 || ret % 3) {
295
-			dev_err(dev,
296
-				"Missing or malformed modes-map property\n");
297
-			return -EINVAL;
298259 		}
299
-
300
-		num_modes = ret / 3;
301
-		modval = devm_kcalloc(dev,
302
-				      num_modes,
303
-				      sizeof(struct ns2_led_modval),
304
-				      GFP_KERNEL);
305
-		if (!modval)
306
-			return -ENOMEM;
307
-
308
-		for (i = 0; i < num_modes; i++) {
309
-			of_property_read_u32_index(child,
310
-						"modes-map", 3 * i,
311
-						(u32 *) &modval[i].mode);
312
-			of_property_read_u32_index(child,
313
-						"modes-map", 3 * i + 1,
314
-						(u32 *) &modval[i].cmd_level);
315
-			of_property_read_u32_index(child,
316
-						"modes-map", 3 * i + 2,
317
-						(u32 *) &modval[i].slow_level);
318
-		}
319
-
320
-		led->num_modes = num_modes;
321
-		led->modval = modval;
322
-
323
-		led++;
324260 	}
325
-
326
-	pdata->leds = leds;
327
-	pdata->num_leds = num_leds;
328261 
329262 	return 0;
330263 }
....@@ -334,83 +267,12 @@
334267 	{},
335268 };
336269 MODULE_DEVICE_TABLE(of, of_ns2_leds_match);
337
-#endif /* CONFIG_OF_GPIO */
338
-
339
-struct ns2_led_priv {
340
-	int num_leds;
341
-	struct ns2_led_data leds_data[];
342
-};
343
-
344
-static inline int sizeof_ns2_led_priv(int num_leds)
345
-{
346
-	return sizeof(struct ns2_led_priv) +
347
-		      (sizeof(struct ns2_led_data) * num_leds);
348
-}
349
-
350
-static int ns2_led_probe(struct platform_device *pdev)
351
-{
352
-	struct ns2_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
353
-	struct ns2_led_priv *priv;
354
-	int i;
355
-	int ret;
356
-
357
-#ifdef CONFIG_OF_GPIO
358
-	if (!pdata) {
359
-		pdata = devm_kzalloc(&pdev->dev,
360
-				     sizeof(struct ns2_led_platform_data),
361
-				     GFP_KERNEL);
362
-		if (!pdata)
363
-			return -ENOMEM;
364
-
365
-		ret = ns2_leds_get_of_pdata(&pdev->dev, pdata);
366
-		if (ret)
367
-			return ret;
368
-	}
369
-#else
370
-	if (!pdata)
371
-		return -EINVAL;
372
-#endif /* CONFIG_OF_GPIO */
373
-
374
-	priv = devm_kzalloc(&pdev->dev,
375
-			    sizeof_ns2_led_priv(pdata->num_leds), GFP_KERNEL);
376
-	if (!priv)
377
-		return -ENOMEM;
378
-	priv->num_leds = pdata->num_leds;
379
-
380
-	for (i = 0; i < priv->num_leds; i++) {
381
-		ret = create_ns2_led(pdev, &priv->leds_data[i],
382
-				     &pdata->leds[i]);
383
-		if (ret < 0) {
384
-			for (i = i - 1; i >= 0; i--)
385
-				delete_ns2_led(&priv->leds_data[i]);
386
-			return ret;
387
-		}
388
-	}
389
-
390
-	platform_set_drvdata(pdev, priv);
391
-
392
-	return 0;
393
-}
394
-
395
-static int ns2_led_remove(struct platform_device *pdev)
396
-{
397
-	int i;
398
-	struct ns2_led_priv *priv;
399
-
400
-	priv = platform_get_drvdata(pdev);
401
-
402
-	for (i = 0; i < priv->num_leds; i++)
403
-		delete_ns2_led(&priv->leds_data[i]);
404
-
405
-	return 0;
406
-}
407270 
408271 static struct platform_driver ns2_led_driver = {
409272 	.probe		= ns2_led_probe,
410
-	.remove		= ns2_led_remove,
411273 	.driver		= {
412274 		.name		= "leds-ns2",
413
-		.of_match_table	= of_match_ptr(of_ns2_leds_match),
275
+		.of_match_table	= of_ns2_leds_match,
414276 	},
415277 };
416278