1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs |
4 | * |
5 | * Copyright (C) 2010 LaCie |
6 | * |
7 | * Author: Simon Guinot <sguinot@lacie.com> |
8 | */ |
9 | |
10 | #include <linux/module.h> |
11 | #include <linux/irq.h> |
12 | #include <linux/slab.h> |
13 | #include <linux/spinlock.h> |
14 | #include <linux/platform_device.h> |
15 | #include <linux/gpio/consumer.h> |
16 | #include <linux/leds.h> |
17 | #include <linux/of.h> |
18 | #include <linux/of_platform.h> |
19 | |
20 | struct netxbig_gpio_ext { |
21 | struct gpio_desc **addr; |
22 | int num_addr; |
23 | struct gpio_desc **data; |
24 | int num_data; |
25 | struct gpio_desc *enable; |
26 | }; |
27 | |
28 | enum netxbig_led_mode { |
29 | NETXBIG_LED_OFF, |
30 | NETXBIG_LED_ON, |
31 | NETXBIG_LED_SATA, |
32 | NETXBIG_LED_TIMER1, |
33 | NETXBIG_LED_TIMER2, |
34 | NETXBIG_LED_MODE_NUM, |
35 | }; |
36 | |
37 | #define NETXBIG_LED_INVALID_MODE NETXBIG_LED_MODE_NUM |
38 | |
39 | struct netxbig_led_timer { |
40 | unsigned long delay_on; |
41 | unsigned long delay_off; |
42 | enum netxbig_led_mode mode; |
43 | }; |
44 | |
45 | struct netxbig_led { |
46 | const char *name; |
47 | const char *default_trigger; |
48 | int mode_addr; |
49 | int *mode_val; |
50 | int bright_addr; |
51 | int bright_max; |
52 | }; |
53 | |
54 | struct netxbig_led_platform_data { |
55 | struct netxbig_gpio_ext *gpio_ext; |
56 | struct netxbig_led_timer *timer; |
57 | int num_timer; |
58 | struct netxbig_led *leds; |
59 | int num_leds; |
60 | }; |
61 | |
62 | /* |
63 | * GPIO extension bus. |
64 | */ |
65 | |
66 | static DEFINE_SPINLOCK(gpio_ext_lock); |
67 | |
68 | static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr) |
69 | { |
70 | int pin; |
71 | |
72 | for (pin = 0; pin < gpio_ext->num_addr; pin++) |
73 | gpiod_set_value(desc: gpio_ext->addr[pin], value: (addr >> pin) & 1); |
74 | } |
75 | |
76 | static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data) |
77 | { |
78 | int pin; |
79 | |
80 | for (pin = 0; pin < gpio_ext->num_data; pin++) |
81 | gpiod_set_value(desc: gpio_ext->data[pin], value: (data >> pin) & 1); |
82 | } |
83 | |
84 | static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext) |
85 | { |
86 | /* Enable select is done on the raising edge. */ |
87 | gpiod_set_value(desc: gpio_ext->enable, value: 0); |
88 | gpiod_set_value(desc: gpio_ext->enable, value: 1); |
89 | } |
90 | |
91 | static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext, |
92 | int addr, int value) |
93 | { |
94 | unsigned long flags; |
95 | |
96 | spin_lock_irqsave(&gpio_ext_lock, flags); |
97 | gpio_ext_set_addr(gpio_ext, addr); |
98 | gpio_ext_set_data(gpio_ext, data: value); |
99 | gpio_ext_enable_select(gpio_ext); |
100 | spin_unlock_irqrestore(lock: &gpio_ext_lock, flags); |
101 | } |
102 | |
103 | /* |
104 | * Class LED driver. |
105 | */ |
106 | |
107 | struct netxbig_led_data { |
108 | struct netxbig_gpio_ext *gpio_ext; |
109 | struct led_classdev cdev; |
110 | int mode_addr; |
111 | int *mode_val; |
112 | int bright_addr; |
113 | struct netxbig_led_timer *timer; |
114 | int num_timer; |
115 | enum netxbig_led_mode mode; |
116 | int sata; |
117 | spinlock_t lock; |
118 | }; |
119 | |
120 | static int netxbig_led_get_timer_mode(enum netxbig_led_mode *mode, |
121 | unsigned long delay_on, |
122 | unsigned long delay_off, |
123 | struct netxbig_led_timer *timer, |
124 | int num_timer) |
125 | { |
126 | int i; |
127 | |
128 | for (i = 0; i < num_timer; i++) { |
129 | if (timer[i].delay_on == delay_on && |
130 | timer[i].delay_off == delay_off) { |
131 | *mode = timer[i].mode; |
132 | return 0; |
133 | } |
134 | } |
135 | return -EINVAL; |
136 | } |
137 | |
138 | static int netxbig_led_blink_set(struct led_classdev *led_cdev, |
139 | unsigned long *delay_on, |
140 | unsigned long *delay_off) |
141 | { |
142 | struct netxbig_led_data *led_dat = |
143 | container_of(led_cdev, struct netxbig_led_data, cdev); |
144 | enum netxbig_led_mode mode; |
145 | int mode_val; |
146 | int ret; |
147 | |
148 | /* Look for a LED mode with the requested timer frequency. */ |
149 | ret = netxbig_led_get_timer_mode(mode: &mode, delay_on: *delay_on, delay_off: *delay_off, |
150 | timer: led_dat->timer, num_timer: led_dat->num_timer); |
151 | if (ret < 0) |
152 | return ret; |
153 | |
154 | mode_val = led_dat->mode_val[mode]; |
155 | if (mode_val == NETXBIG_LED_INVALID_MODE) |
156 | return -EINVAL; |
157 | |
158 | spin_lock_irq(lock: &led_dat->lock); |
159 | |
160 | gpio_ext_set_value(gpio_ext: led_dat->gpio_ext, addr: led_dat->mode_addr, value: mode_val); |
161 | led_dat->mode = mode; |
162 | |
163 | spin_unlock_irq(lock: &led_dat->lock); |
164 | |
165 | return 0; |
166 | } |
167 | |
168 | static void netxbig_led_set(struct led_classdev *led_cdev, |
169 | enum led_brightness value) |
170 | { |
171 | struct netxbig_led_data *led_dat = |
172 | container_of(led_cdev, struct netxbig_led_data, cdev); |
173 | enum netxbig_led_mode mode; |
174 | int mode_val; |
175 | int set_brightness = 1; |
176 | unsigned long flags; |
177 | |
178 | spin_lock_irqsave(&led_dat->lock, flags); |
179 | |
180 | if (value == LED_OFF) { |
181 | mode = NETXBIG_LED_OFF; |
182 | set_brightness = 0; |
183 | } else { |
184 | if (led_dat->sata) |
185 | mode = NETXBIG_LED_SATA; |
186 | else if (led_dat->mode == NETXBIG_LED_OFF) |
187 | mode = NETXBIG_LED_ON; |
188 | else /* Keep 'timer' mode. */ |
189 | mode = led_dat->mode; |
190 | } |
191 | mode_val = led_dat->mode_val[mode]; |
192 | |
193 | gpio_ext_set_value(gpio_ext: led_dat->gpio_ext, addr: led_dat->mode_addr, value: mode_val); |
194 | led_dat->mode = mode; |
195 | /* |
196 | * Note that the brightness register is shared between all the |
197 | * SATA LEDs. So, change the brightness setting for a single |
198 | * SATA LED will affect all the others. |
199 | */ |
200 | if (set_brightness) |
201 | gpio_ext_set_value(gpio_ext: led_dat->gpio_ext, |
202 | addr: led_dat->bright_addr, value); |
203 | |
204 | spin_unlock_irqrestore(lock: &led_dat->lock, flags); |
205 | } |
206 | |
207 | static ssize_t sata_store(struct device *dev, |
208 | struct device_attribute *attr, |
209 | const char *buff, size_t count) |
210 | { |
211 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
212 | struct netxbig_led_data *led_dat = |
213 | container_of(led_cdev, struct netxbig_led_data, cdev); |
214 | unsigned long enable; |
215 | enum netxbig_led_mode mode; |
216 | int mode_val; |
217 | int ret; |
218 | |
219 | ret = kstrtoul(s: buff, base: 10, res: &enable); |
220 | if (ret < 0) |
221 | return ret; |
222 | |
223 | enable = !!enable; |
224 | |
225 | spin_lock_irq(lock: &led_dat->lock); |
226 | |
227 | if (led_dat->sata == enable) { |
228 | ret = count; |
229 | goto exit_unlock; |
230 | } |
231 | |
232 | if (led_dat->mode != NETXBIG_LED_ON && |
233 | led_dat->mode != NETXBIG_LED_SATA) |
234 | mode = led_dat->mode; /* Keep modes 'off' and 'timer'. */ |
235 | else if (enable) |
236 | mode = NETXBIG_LED_SATA; |
237 | else |
238 | mode = NETXBIG_LED_ON; |
239 | |
240 | mode_val = led_dat->mode_val[mode]; |
241 | if (mode_val == NETXBIG_LED_INVALID_MODE) { |
242 | ret = -EINVAL; |
243 | goto exit_unlock; |
244 | } |
245 | |
246 | gpio_ext_set_value(gpio_ext: led_dat->gpio_ext, addr: led_dat->mode_addr, value: mode_val); |
247 | led_dat->mode = mode; |
248 | led_dat->sata = enable; |
249 | |
250 | ret = count; |
251 | |
252 | exit_unlock: |
253 | spin_unlock_irq(lock: &led_dat->lock); |
254 | |
255 | return ret; |
256 | } |
257 | |
258 | static ssize_t sata_show(struct device *dev, |
259 | struct device_attribute *attr, char *buf) |
260 | { |
261 | struct led_classdev *led_cdev = dev_get_drvdata(dev); |
262 | struct netxbig_led_data *led_dat = |
263 | container_of(led_cdev, struct netxbig_led_data, cdev); |
264 | |
265 | return sprintf(buf, fmt: "%d\n" , led_dat->sata); |
266 | } |
267 | |
268 | static DEVICE_ATTR_RW(sata); |
269 | |
270 | static struct attribute *netxbig_led_attrs[] = { |
271 | &dev_attr_sata.attr, |
272 | NULL |
273 | }; |
274 | ATTRIBUTE_GROUPS(netxbig_led); |
275 | |
276 | static int create_netxbig_led(struct platform_device *pdev, |
277 | struct netxbig_led_platform_data *pdata, |
278 | struct netxbig_led_data *led_dat, |
279 | const struct netxbig_led *template) |
280 | { |
281 | spin_lock_init(&led_dat->lock); |
282 | led_dat->gpio_ext = pdata->gpio_ext; |
283 | led_dat->cdev.name = template->name; |
284 | led_dat->cdev.default_trigger = template->default_trigger; |
285 | led_dat->cdev.blink_set = netxbig_led_blink_set; |
286 | led_dat->cdev.brightness_set = netxbig_led_set; |
287 | /* |
288 | * Because the GPIO extension bus don't allow to read registers |
289 | * value, there is no way to probe the LED initial state. |
290 | * So, the initial sysfs LED value for the "brightness" and "sata" |
291 | * attributes are inconsistent. |
292 | * |
293 | * Note that the initial LED state can't be reconfigured. |
294 | * The reason is that the LED behaviour must stay uniform during |
295 | * the whole boot process (bootloader+linux). |
296 | */ |
297 | led_dat->sata = 0; |
298 | led_dat->cdev.brightness = LED_OFF; |
299 | led_dat->cdev.max_brightness = template->bright_max; |
300 | led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME; |
301 | led_dat->mode_addr = template->mode_addr; |
302 | led_dat->mode_val = template->mode_val; |
303 | led_dat->bright_addr = template->bright_addr; |
304 | led_dat->timer = pdata->timer; |
305 | led_dat->num_timer = pdata->num_timer; |
306 | /* |
307 | * If available, expose the SATA activity blink capability through |
308 | * a "sata" sysfs attribute. |
309 | */ |
310 | if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE) |
311 | led_dat->cdev.groups = netxbig_led_groups; |
312 | |
313 | return devm_led_classdev_register(parent: &pdev->dev, led_cdev: &led_dat->cdev); |
314 | } |
315 | |
316 | /** |
317 | * netxbig_gpio_ext_remove() - Clean up GPIO extension data |
318 | * @data: managed resource data to clean up |
319 | * |
320 | * Since we pick GPIO descriptors from another device than the device our |
321 | * driver is probing to, we need to register a specific callback to free |
322 | * these up using managed resources. |
323 | */ |
324 | static void netxbig_gpio_ext_remove(void *data) |
325 | { |
326 | struct netxbig_gpio_ext *gpio_ext = data; |
327 | int i; |
328 | |
329 | for (i = 0; i < gpio_ext->num_addr; i++) |
330 | gpiod_put(desc: gpio_ext->addr[i]); |
331 | for (i = 0; i < gpio_ext->num_data; i++) |
332 | gpiod_put(desc: gpio_ext->data[i]); |
333 | gpiod_put(desc: gpio_ext->enable); |
334 | } |
335 | |
336 | /** |
337 | * netxbig_gpio_ext_get() - Obtain GPIO extension device data |
338 | * @dev: main LED device |
339 | * @gpio_ext_dev: the GPIO extension device |
340 | * @gpio_ext: the data structure holding the GPIO extension data |
341 | * |
342 | * This function walks the subdevice that only contain GPIO line |
343 | * handles in the device tree and obtains the GPIO descriptors from that |
344 | * device. |
345 | */ |
346 | static int netxbig_gpio_ext_get(struct device *dev, |
347 | struct device *gpio_ext_dev, |
348 | struct netxbig_gpio_ext *gpio_ext) |
349 | { |
350 | struct gpio_desc **addr, **data; |
351 | int num_addr, num_data; |
352 | struct gpio_desc *gpiod; |
353 | int ret; |
354 | int i; |
355 | |
356 | ret = gpiod_count(dev: gpio_ext_dev, con_id: "addr" ); |
357 | if (ret < 0) { |
358 | dev_err(dev, |
359 | "Failed to count GPIOs in DT property addr-gpios\n" ); |
360 | return ret; |
361 | } |
362 | num_addr = ret; |
363 | addr = devm_kcalloc(dev, n: num_addr, size: sizeof(*addr), GFP_KERNEL); |
364 | if (!addr) |
365 | return -ENOMEM; |
366 | |
367 | /* |
368 | * We cannot use devm_ managed resources with these GPIO descriptors |
369 | * since they are associated with the "GPIO extension device" which |
370 | * does not probe any driver. The device tree parser will however |
371 | * populate a platform device for it so we can anyway obtain the |
372 | * GPIO descriptors from the device. |
373 | */ |
374 | for (i = 0; i < num_addr; i++) { |
375 | gpiod = gpiod_get_index(dev: gpio_ext_dev, con_id: "addr" , idx: i, |
376 | flags: GPIOD_OUT_LOW); |
377 | if (IS_ERR(ptr: gpiod)) |
378 | return PTR_ERR(ptr: gpiod); |
379 | gpiod_set_consumer_name(desc: gpiod, name: "GPIO extension addr" ); |
380 | addr[i] = gpiod; |
381 | } |
382 | gpio_ext->addr = addr; |
383 | gpio_ext->num_addr = num_addr; |
384 | |
385 | ret = gpiod_count(dev: gpio_ext_dev, con_id: "data" ); |
386 | if (ret < 0) { |
387 | dev_err(dev, |
388 | "Failed to count GPIOs in DT property data-gpios\n" ); |
389 | return ret; |
390 | } |
391 | num_data = ret; |
392 | data = devm_kcalloc(dev, n: num_data, size: sizeof(*data), GFP_KERNEL); |
393 | if (!data) |
394 | return -ENOMEM; |
395 | |
396 | for (i = 0; i < num_data; i++) { |
397 | gpiod = gpiod_get_index(dev: gpio_ext_dev, con_id: "data" , idx: i, |
398 | flags: GPIOD_OUT_LOW); |
399 | if (IS_ERR(ptr: gpiod)) |
400 | return PTR_ERR(ptr: gpiod); |
401 | gpiod_set_consumer_name(desc: gpiod, name: "GPIO extension data" ); |
402 | data[i] = gpiod; |
403 | } |
404 | gpio_ext->data = data; |
405 | gpio_ext->num_data = num_data; |
406 | |
407 | gpiod = gpiod_get(dev: gpio_ext_dev, con_id: "enable" , flags: GPIOD_OUT_LOW); |
408 | if (IS_ERR(ptr: gpiod)) { |
409 | dev_err(dev, |
410 | "Failed to get GPIO from DT property enable-gpio\n" ); |
411 | return PTR_ERR(ptr: gpiod); |
412 | } |
413 | gpiod_set_consumer_name(desc: gpiod, name: "GPIO extension enable" ); |
414 | gpio_ext->enable = gpiod; |
415 | |
416 | return devm_add_action_or_reset(dev, netxbig_gpio_ext_remove, gpio_ext); |
417 | } |
418 | |
419 | static int netxbig_leds_get_of_pdata(struct device *dev, |
420 | struct netxbig_led_platform_data *pdata) |
421 | { |
422 | struct device_node *np = dev_of_node(dev); |
423 | struct device_node *gpio_ext_np; |
424 | struct platform_device *gpio_ext_pdev; |
425 | struct device *gpio_ext_dev; |
426 | struct device_node *child; |
427 | struct netxbig_gpio_ext *gpio_ext; |
428 | struct netxbig_led_timer *timers; |
429 | struct netxbig_led *leds, *led; |
430 | int num_timers; |
431 | int num_leds = 0; |
432 | int ret; |
433 | int i; |
434 | |
435 | /* GPIO extension */ |
436 | gpio_ext_np = of_parse_phandle(np, phandle_name: "gpio-ext" , index: 0); |
437 | if (!gpio_ext_np) { |
438 | dev_err(dev, "Failed to get DT handle gpio-ext\n" ); |
439 | return -EINVAL; |
440 | } |
441 | gpio_ext_pdev = of_find_device_by_node(np: gpio_ext_np); |
442 | if (!gpio_ext_pdev) { |
443 | dev_err(dev, "Failed to find platform device for gpio-ext\n" ); |
444 | return -ENODEV; |
445 | } |
446 | gpio_ext_dev = &gpio_ext_pdev->dev; |
447 | |
448 | gpio_ext = devm_kzalloc(dev, size: sizeof(*gpio_ext), GFP_KERNEL); |
449 | if (!gpio_ext) { |
450 | of_node_put(node: gpio_ext_np); |
451 | ret = -ENOMEM; |
452 | goto put_device; |
453 | } |
454 | ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext); |
455 | of_node_put(node: gpio_ext_np); |
456 | if (ret) |
457 | goto put_device; |
458 | pdata->gpio_ext = gpio_ext; |
459 | |
460 | /* Timers (optional) */ |
461 | ret = of_property_count_u32_elems(np, propname: "timers" ); |
462 | if (ret > 0) { |
463 | if (ret % 3) { |
464 | ret = -EINVAL; |
465 | goto put_device; |
466 | } |
467 | |
468 | num_timers = ret / 3; |
469 | timers = devm_kcalloc(dev, n: num_timers, size: sizeof(*timers), |
470 | GFP_KERNEL); |
471 | if (!timers) { |
472 | ret = -ENOMEM; |
473 | goto put_device; |
474 | } |
475 | for (i = 0; i < num_timers; i++) { |
476 | u32 tmp; |
477 | |
478 | of_property_read_u32_index(np, propname: "timers" , index: 3 * i, |
479 | out_value: &timers[i].mode); |
480 | if (timers[i].mode >= NETXBIG_LED_MODE_NUM) { |
481 | ret = -EINVAL; |
482 | goto put_device; |
483 | } |
484 | of_property_read_u32_index(np, propname: "timers" , |
485 | index: 3 * i + 1, out_value: &tmp); |
486 | timers[i].delay_on = tmp; |
487 | of_property_read_u32_index(np, propname: "timers" , |
488 | index: 3 * i + 2, out_value: &tmp); |
489 | timers[i].delay_off = tmp; |
490 | } |
491 | pdata->timer = timers; |
492 | pdata->num_timer = num_timers; |
493 | } |
494 | |
495 | /* LEDs */ |
496 | num_leds = of_get_available_child_count(np); |
497 | if (!num_leds) { |
498 | dev_err(dev, "No LED subnodes found in DT\n" ); |
499 | ret = -ENODEV; |
500 | goto put_device; |
501 | } |
502 | |
503 | leds = devm_kcalloc(dev, n: num_leds, size: sizeof(*leds), GFP_KERNEL); |
504 | if (!leds) { |
505 | ret = -ENOMEM; |
506 | goto put_device; |
507 | } |
508 | |
509 | led = leds; |
510 | for_each_available_child_of_node(np, child) { |
511 | const char *string; |
512 | int *mode_val; |
513 | int num_modes; |
514 | |
515 | ret = of_property_read_u32(np: child, propname: "mode-addr" , |
516 | out_value: &led->mode_addr); |
517 | if (ret) |
518 | goto err_node_put; |
519 | |
520 | ret = of_property_read_u32(np: child, propname: "bright-addr" , |
521 | out_value: &led->bright_addr); |
522 | if (ret) |
523 | goto err_node_put; |
524 | |
525 | ret = of_property_read_u32(np: child, propname: "max-brightness" , |
526 | out_value: &led->bright_max); |
527 | if (ret) |
528 | goto err_node_put; |
529 | |
530 | mode_val = |
531 | devm_kcalloc(dev, |
532 | n: NETXBIG_LED_MODE_NUM, size: sizeof(*mode_val), |
533 | GFP_KERNEL); |
534 | if (!mode_val) { |
535 | ret = -ENOMEM; |
536 | goto err_node_put; |
537 | } |
538 | |
539 | for (i = 0; i < NETXBIG_LED_MODE_NUM; i++) |
540 | mode_val[i] = NETXBIG_LED_INVALID_MODE; |
541 | |
542 | ret = of_property_count_u32_elems(np: child, propname: "mode-val" ); |
543 | if (ret < 0 || ret % 2) { |
544 | ret = -EINVAL; |
545 | goto err_node_put; |
546 | } |
547 | num_modes = ret / 2; |
548 | if (num_modes > NETXBIG_LED_MODE_NUM) { |
549 | ret = -EINVAL; |
550 | goto err_node_put; |
551 | } |
552 | |
553 | for (i = 0; i < num_modes; i++) { |
554 | int mode; |
555 | int val; |
556 | |
557 | of_property_read_u32_index(np: child, |
558 | propname: "mode-val" , index: 2 * i, out_value: &mode); |
559 | of_property_read_u32_index(np: child, |
560 | propname: "mode-val" , index: 2 * i + 1, out_value: &val); |
561 | if (mode >= NETXBIG_LED_MODE_NUM) { |
562 | ret = -EINVAL; |
563 | goto err_node_put; |
564 | } |
565 | mode_val[mode] = val; |
566 | } |
567 | led->mode_val = mode_val; |
568 | |
569 | if (!of_property_read_string(np: child, propname: "label" , out_string: &string)) |
570 | led->name = string; |
571 | else |
572 | led->name = child->name; |
573 | |
574 | if (!of_property_read_string(np: child, |
575 | propname: "linux,default-trigger" , out_string: &string)) |
576 | led->default_trigger = string; |
577 | |
578 | led++; |
579 | } |
580 | |
581 | pdata->leds = leds; |
582 | pdata->num_leds = num_leds; |
583 | |
584 | return 0; |
585 | |
586 | err_node_put: |
587 | of_node_put(node: child); |
588 | put_device: |
589 | put_device(dev: gpio_ext_dev); |
590 | return ret; |
591 | } |
592 | |
593 | static const struct of_device_id of_netxbig_leds_match[] = { |
594 | { .compatible = "lacie,netxbig-leds" , }, |
595 | {}, |
596 | }; |
597 | MODULE_DEVICE_TABLE(of, of_netxbig_leds_match); |
598 | |
599 | static int netxbig_led_probe(struct platform_device *pdev) |
600 | { |
601 | struct netxbig_led_platform_data *pdata; |
602 | struct netxbig_led_data *leds_data; |
603 | int i; |
604 | int ret; |
605 | |
606 | pdata = devm_kzalloc(dev: &pdev->dev, size: sizeof(*pdata), GFP_KERNEL); |
607 | if (!pdata) |
608 | return -ENOMEM; |
609 | ret = netxbig_leds_get_of_pdata(dev: &pdev->dev, pdata); |
610 | if (ret) |
611 | return ret; |
612 | |
613 | leds_data = devm_kcalloc(dev: &pdev->dev, |
614 | n: pdata->num_leds, size: sizeof(*leds_data), |
615 | GFP_KERNEL); |
616 | if (!leds_data) |
617 | return -ENOMEM; |
618 | |
619 | for (i = 0; i < pdata->num_leds; i++) { |
620 | ret = create_netxbig_led(pdev, pdata, |
621 | led_dat: &leds_data[i], template: &pdata->leds[i]); |
622 | if (ret < 0) |
623 | return ret; |
624 | } |
625 | |
626 | return 0; |
627 | } |
628 | |
629 | static struct platform_driver netxbig_led_driver = { |
630 | .probe = netxbig_led_probe, |
631 | .driver = { |
632 | .name = "leds-netxbig" , |
633 | .of_match_table = of_netxbig_leds_match, |
634 | }, |
635 | }; |
636 | |
637 | module_platform_driver(netxbig_led_driver); |
638 | |
639 | MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>" ); |
640 | MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards" ); |
641 | MODULE_LICENSE("GPL" ); |
642 | MODULE_ALIAS("platform:leds-netxbig" ); |
643 | |