Commit | Line | Data |
---|---|---|
24467832 SG |
1 | /* |
2 | * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs | |
3 | * | |
4 | * Copyright (C) 2010 LaCie | |
5 | * | |
6 | * Author: Simon Guinot <sguinot@lacie.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 as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 | */ | |
22 | ||
23 | #include <linux/module.h> | |
24467832 SG |
24 | #include <linux/irq.h> |
25 | #include <linux/slab.h> | |
26 | #include <linux/spinlock.h> | |
27 | #include <linux/platform_device.h> | |
28 | #include <linux/gpio.h> | |
2976b179 | 29 | #include <linux/of_gpio.h> |
24467832 | 30 | #include <linux/leds.h> |
c02cecb9 | 31 | #include <linux/platform_data/leds-kirkwood-netxbig.h> |
24467832 SG |
32 | |
33 | /* | |
34 | * GPIO extension bus. | |
35 | */ | |
36 | ||
37 | static DEFINE_SPINLOCK(gpio_ext_lock); | |
38 | ||
39 | static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr) | |
40 | { | |
41 | int pin; | |
42 | ||
43 | for (pin = 0; pin < gpio_ext->num_addr; pin++) | |
44 | gpio_set_value(gpio_ext->addr[pin], (addr >> pin) & 1); | |
45 | } | |
46 | ||
47 | static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data) | |
48 | { | |
49 | int pin; | |
50 | ||
51 | for (pin = 0; pin < gpio_ext->num_data; pin++) | |
52 | gpio_set_value(gpio_ext->data[pin], (data >> pin) & 1); | |
53 | } | |
54 | ||
55 | static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext) | |
56 | { | |
57 | /* Enable select is done on the raising edge. */ | |
58 | gpio_set_value(gpio_ext->enable, 0); | |
59 | gpio_set_value(gpio_ext->enable, 1); | |
60 | } | |
61 | ||
62 | static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext, | |
63 | int addr, int value) | |
64 | { | |
65 | unsigned long flags; | |
66 | ||
67 | spin_lock_irqsave(&gpio_ext_lock, flags); | |
68 | gpio_ext_set_addr(gpio_ext, addr); | |
69 | gpio_ext_set_data(gpio_ext, value); | |
70 | gpio_ext_enable_select(gpio_ext); | |
71 | spin_unlock_irqrestore(&gpio_ext_lock, flags); | |
72 | } | |
73 | ||
98ea1ea2 | 74 | static int gpio_ext_init(struct netxbig_gpio_ext *gpio_ext) |
24467832 SG |
75 | { |
76 | int err; | |
77 | int i; | |
78 | ||
79 | if (unlikely(!gpio_ext)) | |
80 | return -EINVAL; | |
81 | ||
82 | /* Configure address GPIOs. */ | |
83 | for (i = 0; i < gpio_ext->num_addr; i++) { | |
b96a573f AL |
84 | err = gpio_request_one(gpio_ext->addr[i], GPIOF_OUT_INIT_LOW, |
85 | "GPIO extension addr"); | |
24467832 SG |
86 | if (err) |
87 | goto err_free_addr; | |
24467832 SG |
88 | } |
89 | /* Configure data GPIOs. */ | |
90 | for (i = 0; i < gpio_ext->num_data; i++) { | |
b96a573f AL |
91 | err = gpio_request_one(gpio_ext->data[i], GPIOF_OUT_INIT_LOW, |
92 | "GPIO extension data"); | |
24467832 SG |
93 | if (err) |
94 | goto err_free_data; | |
24467832 SG |
95 | } |
96 | /* Configure "enable select" GPIO. */ | |
b96a573f AL |
97 | err = gpio_request_one(gpio_ext->enable, GPIOF_OUT_INIT_LOW, |
98 | "GPIO extension enable"); | |
24467832 SG |
99 | if (err) |
100 | goto err_free_data; | |
24467832 SG |
101 | |
102 | return 0; | |
103 | ||
104 | err_free_data: | |
105 | for (i = i - 1; i >= 0; i--) | |
106 | gpio_free(gpio_ext->data[i]); | |
107 | i = gpio_ext->num_addr; | |
108 | err_free_addr: | |
109 | for (i = i - 1; i >= 0; i--) | |
110 | gpio_free(gpio_ext->addr[i]); | |
111 | ||
112 | return err; | |
113 | } | |
114 | ||
b8cd742a | 115 | static void gpio_ext_free(struct netxbig_gpio_ext *gpio_ext) |
24467832 SG |
116 | { |
117 | int i; | |
118 | ||
119 | gpio_free(gpio_ext->enable); | |
120 | for (i = gpio_ext->num_addr - 1; i >= 0; i--) | |
121 | gpio_free(gpio_ext->addr[i]); | |
122 | for (i = gpio_ext->num_data - 1; i >= 0; i--) | |
123 | gpio_free(gpio_ext->data[i]); | |
124 | } | |
125 | ||
126 | /* | |
127 | * Class LED driver. | |
128 | */ | |
129 | ||
130 | struct netxbig_led_data { | |
131 | struct netxbig_gpio_ext *gpio_ext; | |
132 | struct led_classdev cdev; | |
133 | int mode_addr; | |
134 | int *mode_val; | |
135 | int bright_addr; | |
136 | int bright_max; | |
137 | struct netxbig_led_timer *timer; | |
138 | int num_timer; | |
139 | enum netxbig_led_mode mode; | |
140 | int sata; | |
141 | spinlock_t lock; | |
142 | }; | |
143 | ||
2976b179 SG |
144 | struct netxbig_led_priv { |
145 | struct netxbig_led_platform_data *pdata; | |
146 | struct netxbig_led_data leds_data[]; | |
147 | }; | |
148 | ||
24467832 SG |
149 | static int netxbig_led_get_timer_mode(enum netxbig_led_mode *mode, |
150 | unsigned long delay_on, | |
151 | unsigned long delay_off, | |
152 | struct netxbig_led_timer *timer, | |
153 | int num_timer) | |
154 | { | |
155 | int i; | |
156 | ||
157 | for (i = 0; i < num_timer; i++) { | |
158 | if (timer[i].delay_on == delay_on && | |
159 | timer[i].delay_off == delay_off) { | |
160 | *mode = timer[i].mode; | |
161 | return 0; | |
162 | } | |
163 | } | |
164 | return -EINVAL; | |
165 | } | |
166 | ||
167 | static int netxbig_led_blink_set(struct led_classdev *led_cdev, | |
168 | unsigned long *delay_on, | |
169 | unsigned long *delay_off) | |
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 ret; | |
176 | ||
177 | /* Look for a LED mode with the requested timer frequency. */ | |
178 | ret = netxbig_led_get_timer_mode(&mode, *delay_on, *delay_off, | |
179 | led_dat->timer, led_dat->num_timer); | |
180 | if (ret < 0) | |
181 | return ret; | |
182 | ||
183 | mode_val = led_dat->mode_val[mode]; | |
184 | if (mode_val == NETXBIG_LED_INVALID_MODE) | |
185 | return -EINVAL; | |
186 | ||
187 | spin_lock_irq(&led_dat->lock); | |
188 | ||
189 | gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val); | |
190 | led_dat->mode = mode; | |
191 | ||
192 | spin_unlock_irq(&led_dat->lock); | |
193 | ||
194 | return 0; | |
195 | } | |
196 | ||
197 | static void netxbig_led_set(struct led_classdev *led_cdev, | |
198 | enum led_brightness value) | |
199 | { | |
200 | struct netxbig_led_data *led_dat = | |
201 | container_of(led_cdev, struct netxbig_led_data, cdev); | |
202 | enum netxbig_led_mode mode; | |
203 | int mode_val, bright_val; | |
204 | int set_brightness = 1; | |
205 | unsigned long flags; | |
206 | ||
207 | spin_lock_irqsave(&led_dat->lock, flags); | |
208 | ||
209 | if (value == LED_OFF) { | |
210 | mode = NETXBIG_LED_OFF; | |
211 | set_brightness = 0; | |
212 | } else { | |
213 | if (led_dat->sata) | |
214 | mode = NETXBIG_LED_SATA; | |
215 | else if (led_dat->mode == NETXBIG_LED_OFF) | |
216 | mode = NETXBIG_LED_ON; | |
217 | else /* Keep 'timer' mode. */ | |
218 | mode = led_dat->mode; | |
219 | } | |
220 | mode_val = led_dat->mode_val[mode]; | |
221 | ||
222 | gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val); | |
223 | led_dat->mode = mode; | |
224 | /* | |
225 | * Note that the brightness register is shared between all the | |
226 | * SATA LEDs. So, change the brightness setting for a single | |
227 | * SATA LED will affect all the others. | |
228 | */ | |
229 | if (set_brightness) { | |
230 | bright_val = DIV_ROUND_UP(value * led_dat->bright_max, | |
231 | LED_FULL); | |
232 | gpio_ext_set_value(led_dat->gpio_ext, | |
233 | led_dat->bright_addr, bright_val); | |
234 | } | |
235 | ||
236 | spin_unlock_irqrestore(&led_dat->lock, flags); | |
237 | } | |
238 | ||
239 | static ssize_t netxbig_led_sata_store(struct device *dev, | |
240 | struct device_attribute *attr, | |
241 | const char *buff, size_t count) | |
242 | { | |
243 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
244 | struct netxbig_led_data *led_dat = | |
245 | container_of(led_cdev, struct netxbig_led_data, cdev); | |
246 | unsigned long enable; | |
247 | enum netxbig_led_mode mode; | |
248 | int mode_val; | |
249 | int ret; | |
250 | ||
7517611a | 251 | ret = kstrtoul(buff, 10, &enable); |
24467832 SG |
252 | if (ret < 0) |
253 | return ret; | |
254 | ||
255 | enable = !!enable; | |
256 | ||
257 | spin_lock_irq(&led_dat->lock); | |
258 | ||
259 | if (led_dat->sata == enable) { | |
260 | ret = count; | |
261 | goto exit_unlock; | |
262 | } | |
263 | ||
264 | if (led_dat->mode != NETXBIG_LED_ON && | |
265 | led_dat->mode != NETXBIG_LED_SATA) | |
266 | mode = led_dat->mode; /* Keep modes 'off' and 'timer'. */ | |
267 | else if (enable) | |
268 | mode = NETXBIG_LED_SATA; | |
269 | else | |
270 | mode = NETXBIG_LED_ON; | |
271 | ||
272 | mode_val = led_dat->mode_val[mode]; | |
273 | if (mode_val == NETXBIG_LED_INVALID_MODE) { | |
274 | ret = -EINVAL; | |
275 | goto exit_unlock; | |
276 | } | |
277 | ||
278 | gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val); | |
279 | led_dat->mode = mode; | |
280 | led_dat->sata = enable; | |
281 | ||
282 | ret = count; | |
283 | ||
284 | exit_unlock: | |
285 | spin_unlock_irq(&led_dat->lock); | |
286 | ||
287 | return ret; | |
288 | } | |
289 | ||
290 | static ssize_t netxbig_led_sata_show(struct device *dev, | |
291 | struct device_attribute *attr, char *buf) | |
292 | { | |
293 | struct led_classdev *led_cdev = dev_get_drvdata(dev); | |
294 | struct netxbig_led_data *led_dat = | |
295 | container_of(led_cdev, struct netxbig_led_data, cdev); | |
296 | ||
297 | return sprintf(buf, "%d\n", led_dat->sata); | |
298 | } | |
299 | ||
300 | static DEVICE_ATTR(sata, 0644, netxbig_led_sata_show, netxbig_led_sata_store); | |
301 | ||
588a6a99 JH |
302 | static struct attribute *netxbig_led_attrs[] = { |
303 | &dev_attr_sata.attr, | |
304 | NULL | |
305 | }; | |
306 | ATTRIBUTE_GROUPS(netxbig_led); | |
307 | ||
b8cd742a | 308 | static void delete_netxbig_led(struct netxbig_led_data *led_dat) |
24467832 | 309 | { |
24467832 SG |
310 | led_classdev_unregister(&led_dat->cdev); |
311 | } | |
312 | ||
2976b179 SG |
313 | static int create_netxbig_led(struct platform_device *pdev, int led, |
314 | struct netxbig_led_priv *priv) | |
24467832 | 315 | { |
2976b179 SG |
316 | struct netxbig_led_platform_data *pdata = priv->pdata; |
317 | struct netxbig_led_data *led_dat = &priv->leds_data[led]; | |
318 | const struct netxbig_led *template = &priv->pdata->leds[led]; | |
24467832 SG |
319 | |
320 | spin_lock_init(&led_dat->lock); | |
321 | led_dat->gpio_ext = pdata->gpio_ext; | |
322 | led_dat->cdev.name = template->name; | |
323 | led_dat->cdev.default_trigger = template->default_trigger; | |
324 | led_dat->cdev.blink_set = netxbig_led_blink_set; | |
325 | led_dat->cdev.brightness_set = netxbig_led_set; | |
326 | /* | |
327 | * Because the GPIO extension bus don't allow to read registers | |
328 | * value, there is no way to probe the LED initial state. | |
329 | * So, the initial sysfs LED value for the "brightness" and "sata" | |
330 | * attributes are inconsistent. | |
331 | * | |
332 | * Note that the initial LED state can't be reconfigured. | |
333 | * The reason is that the LED behaviour must stay uniform during | |
334 | * the whole boot process (bootloader+linux). | |
335 | */ | |
336 | led_dat->sata = 0; | |
337 | led_dat->cdev.brightness = LED_OFF; | |
338 | led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME; | |
339 | led_dat->mode_addr = template->mode_addr; | |
340 | led_dat->mode_val = template->mode_val; | |
341 | led_dat->bright_addr = template->bright_addr; | |
2976b179 | 342 | led_dat->bright_max = template->bright_max; |
24467832 SG |
343 | led_dat->timer = pdata->timer; |
344 | led_dat->num_timer = pdata->num_timer; | |
0c86ac2c SG |
345 | /* |
346 | * If available, expose the SATA activity blink capability through | |
347 | * a "sata" sysfs attribute. | |
348 | */ | |
349 | if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE) | |
350 | led_dat->cdev.groups = netxbig_led_groups; | |
24467832 | 351 | |
588a6a99 | 352 | return led_classdev_register(&pdev->dev, &led_dat->cdev); |
24467832 SG |
353 | } |
354 | ||
2976b179 SG |
355 | #ifdef CONFIG_OF_GPIO |
356 | static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np, | |
357 | struct netxbig_gpio_ext *gpio_ext) | |
358 | { | |
359 | int *addr, *data; | |
360 | int num_addr, num_data; | |
361 | int ret; | |
362 | int i; | |
363 | ||
364 | ret = of_gpio_named_count(np, "addr-gpios"); | |
365 | if (ret < 0) { | |
366 | dev_err(dev, | |
367 | "Failed to count GPIOs in DT property addr-gpios\n"); | |
368 | return ret; | |
369 | } | |
370 | num_addr = ret; | |
371 | addr = devm_kzalloc(dev, num_addr * sizeof(*addr), GFP_KERNEL); | |
372 | if (!addr) | |
373 | return -ENOMEM; | |
374 | ||
375 | for (i = 0; i < num_addr; i++) { | |
376 | ret = of_get_named_gpio(np, "addr-gpios", i); | |
377 | if (ret < 0) | |
378 | return ret; | |
379 | addr[i] = ret; | |
380 | } | |
381 | gpio_ext->addr = addr; | |
382 | gpio_ext->num_addr = num_addr; | |
383 | ||
384 | ret = of_gpio_named_count(np, "data-gpios"); | |
385 | if (ret < 0) { | |
386 | dev_err(dev, | |
387 | "Failed to count GPIOs in DT property data-gpios\n"); | |
388 | return ret; | |
389 | } | |
390 | num_data = ret; | |
391 | data = devm_kzalloc(dev, num_data * sizeof(*data), GFP_KERNEL); | |
392 | if (!data) | |
393 | return -ENOMEM; | |
394 | ||
395 | for (i = 0; i < num_data; i++) { | |
396 | ret = of_get_named_gpio(np, "data-gpios", i); | |
397 | if (ret < 0) | |
398 | return ret; | |
399 | data[i] = ret; | |
400 | } | |
401 | gpio_ext->data = data; | |
402 | gpio_ext->num_data = num_data; | |
403 | ||
404 | ret = of_get_named_gpio(np, "enable-gpio", 0); | |
405 | if (ret < 0) { | |
406 | dev_err(dev, | |
407 | "Failed to get GPIO from DT property enable-gpio\n"); | |
408 | return ret; | |
409 | } | |
410 | gpio_ext->enable = ret; | |
411 | ||
412 | return 0; | |
413 | } | |
414 | ||
415 | static int netxbig_leds_get_of_pdata(struct device *dev, | |
416 | struct netxbig_led_platform_data *pdata) | |
417 | { | |
418 | struct device_node *np = dev->of_node; | |
419 | struct device_node *gpio_ext_np; | |
420 | struct device_node *child; | |
421 | struct netxbig_gpio_ext *gpio_ext; | |
422 | struct netxbig_led_timer *timers; | |
423 | struct netxbig_led *leds, *led; | |
424 | int num_timers; | |
425 | int num_leds = 0; | |
426 | int ret; | |
427 | int i; | |
428 | ||
429 | /* GPIO extension */ | |
430 | gpio_ext_np = of_parse_phandle(np, "gpio-ext", 0); | |
431 | if (!gpio_ext_np) { | |
432 | dev_err(dev, "Failed to get DT handle gpio-ext\n"); | |
433 | return -EINVAL; | |
434 | } | |
435 | ||
436 | gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL); | |
437 | if (!gpio_ext) | |
438 | return -ENOMEM; | |
439 | ret = gpio_ext_get_of_pdata(dev, gpio_ext_np, gpio_ext); | |
440 | if (ret) | |
441 | return ret; | |
442 | of_node_put(gpio_ext_np); | |
443 | pdata->gpio_ext = gpio_ext; | |
444 | ||
445 | /* Timers (optional) */ | |
446 | ret = of_property_count_u32_elems(np, "timers"); | |
447 | if (ret > 0) { | |
448 | if (ret % 3) | |
449 | return -EINVAL; | |
450 | num_timers = ret / 3; | |
451 | timers = devm_kzalloc(dev, num_timers * sizeof(*timers), | |
452 | GFP_KERNEL); | |
453 | if (!timers) | |
454 | return -ENOMEM; | |
455 | for (i = 0; i < num_timers; i++) { | |
456 | u32 tmp; | |
457 | ||
458 | of_property_read_u32_index(np, "timers", 3 * i, | |
459 | &timers[i].mode); | |
460 | if (timers[i].mode >= NETXBIG_LED_MODE_NUM) | |
461 | return -EINVAL; | |
462 | of_property_read_u32_index(np, "timers", | |
463 | 3 * i + 1, &tmp); | |
464 | timers[i].delay_on = tmp; | |
465 | of_property_read_u32_index(np, "timers", | |
466 | 3 * i + 2, &tmp); | |
467 | timers[i].delay_off = tmp; | |
468 | } | |
469 | pdata->timer = timers; | |
470 | pdata->num_timer = num_timers; | |
471 | } | |
472 | ||
473 | /* LEDs */ | |
474 | num_leds = of_get_child_count(np); | |
475 | if (!num_leds) { | |
476 | dev_err(dev, "No LED subnodes found in DT\n"); | |
477 | return -ENODEV; | |
478 | } | |
479 | ||
480 | leds = devm_kzalloc(dev, num_leds * sizeof(*leds), GFP_KERNEL); | |
481 | if (!leds) | |
482 | return -ENOMEM; | |
483 | ||
484 | led = leds; | |
485 | for_each_child_of_node(np, child) { | |
486 | const char *string; | |
487 | int *mode_val; | |
488 | int num_modes; | |
489 | ||
490 | ret = of_property_read_u32(child, "mode-addr", | |
491 | &led->mode_addr); | |
492 | if (ret) | |
493 | goto err_node_put; | |
494 | ||
495 | ret = of_property_read_u32(child, "bright-addr", | |
496 | &led->bright_addr); | |
497 | if (ret) | |
498 | goto err_node_put; | |
499 | ||
500 | ret = of_property_read_u32(child, "max-brightness", | |
501 | &led->bright_max); | |
502 | if (ret) | |
503 | goto err_node_put; | |
504 | ||
505 | mode_val = | |
506 | devm_kzalloc(dev, | |
507 | NETXBIG_LED_MODE_NUM * sizeof(*mode_val), | |
508 | GFP_KERNEL); | |
509 | if (!mode_val) { | |
510 | ret = -ENOMEM; | |
511 | goto err_node_put; | |
512 | } | |
513 | ||
514 | for (i = 0; i < NETXBIG_LED_MODE_NUM; i++) | |
515 | mode_val[i] = NETXBIG_LED_INVALID_MODE; | |
516 | ||
517 | ret = of_property_count_u32_elems(child, "mode-val"); | |
518 | if (ret < 0 || ret % 2) { | |
519 | ret = -EINVAL; | |
520 | goto err_node_put; | |
521 | } | |
522 | num_modes = ret / 2; | |
523 | if (num_modes > NETXBIG_LED_MODE_NUM) { | |
524 | ret = -EINVAL; | |
525 | goto err_node_put; | |
526 | } | |
527 | ||
528 | for (i = 0; i < num_modes; i++) { | |
529 | int mode; | |
530 | int val; | |
531 | ||
532 | of_property_read_u32_index(child, | |
533 | "mode-val", 2 * i, &mode); | |
534 | of_property_read_u32_index(child, | |
535 | "mode-val", 2 * i + 1, &val); | |
536 | if (mode >= NETXBIG_LED_MODE_NUM) { | |
537 | ret = -EINVAL; | |
538 | goto err_node_put; | |
539 | } | |
540 | mode_val[mode] = val; | |
541 | } | |
542 | led->mode_val = mode_val; | |
543 | ||
544 | if (!of_property_read_string(child, "label", &string)) | |
545 | led->name = string; | |
546 | else | |
547 | led->name = child->name; | |
548 | ||
549 | if (!of_property_read_string(child, | |
550 | "linux,default-trigger", &string)) | |
551 | led->default_trigger = string; | |
552 | ||
553 | led++; | |
554 | } | |
555 | ||
556 | pdata->leds = leds; | |
557 | pdata->num_leds = num_leds; | |
558 | ||
559 | return 0; | |
560 | ||
561 | err_node_put: | |
562 | of_node_put(child); | |
563 | return ret; | |
564 | } | |
565 | ||
566 | static const struct of_device_id of_netxbig_leds_match[] = { | |
567 | { .compatible = "lacie,netxbig-leds", }, | |
568 | {}, | |
569 | }; | |
570 | #else | |
571 | static inline int | |
572 | netxbig_leds_get_of_pdata(struct device *dev, | |
573 | struct netxbig_led_platform_data *pdata) | |
574 | { | |
575 | return -ENODEV; | |
576 | } | |
577 | #endif /* CONFIG_OF_GPIO */ | |
578 | ||
98ea1ea2 | 579 | static int netxbig_led_probe(struct platform_device *pdev) |
24467832 | 580 | { |
87aae1ea | 581 | struct netxbig_led_platform_data *pdata = dev_get_platdata(&pdev->dev); |
2976b179 | 582 | struct netxbig_led_priv *priv; |
24467832 SG |
583 | int i; |
584 | int ret; | |
585 | ||
2976b179 SG |
586 | if (!pdata) { |
587 | pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); | |
588 | if (!pdata) | |
589 | return -ENOMEM; | |
590 | ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata); | |
591 | if (ret) | |
592 | return ret; | |
593 | } | |
24467832 | 594 | |
2976b179 SG |
595 | priv = devm_kzalloc(&pdev->dev, sizeof(*priv) + |
596 | pdata->num_leds * sizeof(struct netxbig_led_data), | |
597 | GFP_KERNEL); | |
598 | if (!priv) | |
24467832 | 599 | return -ENOMEM; |
2976b179 | 600 | priv->pdata = pdata; |
24467832 SG |
601 | |
602 | ret = gpio_ext_init(pdata->gpio_ext); | |
603 | if (ret < 0) | |
8095c385 | 604 | return ret; |
24467832 SG |
605 | |
606 | for (i = 0; i < pdata->num_leds; i++) { | |
2976b179 | 607 | ret = create_netxbig_led(pdev, i, priv); |
24467832 SG |
608 | if (ret < 0) |
609 | goto err_free_leds; | |
610 | } | |
2976b179 | 611 | platform_set_drvdata(pdev, priv); |
24467832 SG |
612 | |
613 | return 0; | |
614 | ||
615 | err_free_leds: | |
616 | for (i = i - 1; i >= 0; i--) | |
2976b179 | 617 | delete_netxbig_led(&priv->leds_data[i]); |
24467832 SG |
618 | |
619 | gpio_ext_free(pdata->gpio_ext); | |
24467832 SG |
620 | return ret; |
621 | } | |
622 | ||
678e8a6b | 623 | static int netxbig_led_remove(struct platform_device *pdev) |
24467832 | 624 | { |
2976b179 SG |
625 | struct netxbig_led_priv *priv = platform_get_drvdata(pdev); |
626 | struct netxbig_led_platform_data *pdata = priv->pdata; | |
24467832 SG |
627 | int i; |
628 | ||
24467832 | 629 | for (i = 0; i < pdata->num_leds; i++) |
2976b179 | 630 | delete_netxbig_led(&priv->leds_data[i]); |
24467832 SG |
631 | |
632 | gpio_ext_free(pdata->gpio_ext); | |
24467832 SG |
633 | |
634 | return 0; | |
635 | } | |
636 | ||
637 | static struct platform_driver netxbig_led_driver = { | |
638 | .probe = netxbig_led_probe, | |
df07cf81 | 639 | .remove = netxbig_led_remove, |
24467832 | 640 | .driver = { |
2976b179 SG |
641 | .name = "leds-netxbig", |
642 | .of_match_table = of_match_ptr(of_netxbig_leds_match), | |
24467832 SG |
643 | }, |
644 | }; | |
24467832 | 645 | |
892a8843 | 646 | module_platform_driver(netxbig_led_driver); |
24467832 SG |
647 | |
648 | MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); | |
649 | MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards"); | |
650 | MODULE_LICENSE("GPL"); | |
892a8843 | 651 | MODULE_ALIAS("platform:leds-netxbig"); |