2 * LEDs driver for GPIOs
4 * Copyright (C) 2007 8D Technologies inc.
5 * Raphael Assenat <raph@8d.com>
6 * Copyright (C) 2008 Freescale Semiconductor, Inc.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/platform_device.h>
16 #include <linux/leds.h>
17 #include <linux/workqueue.h>
21 struct gpio_led_data
{
22 struct led_classdev cdev
;
24 struct work_struct work
;
28 int (*platform_gpio_blink_set
)(unsigned gpio
,
29 unsigned long *delay_on
, unsigned long *delay_off
);
32 static void gpio_led_work(struct work_struct
*work
)
34 struct gpio_led_data
*led_dat
=
35 container_of(work
, struct gpio_led_data
, work
);
37 gpio_set_value_cansleep(led_dat
->gpio
, led_dat
->new_level
);
40 static void gpio_led_set(struct led_classdev
*led_cdev
,
41 enum led_brightness value
)
43 struct gpio_led_data
*led_dat
=
44 container_of(led_cdev
, struct gpio_led_data
, cdev
);
52 if (led_dat
->active_low
)
55 /* Setting GPIOs with I2C/etc requires a task context, and we don't
56 * seem to have a reliable way to know if we're already in one; so
57 * let's just assume the worst.
59 if (led_dat
->can_sleep
) {
60 led_dat
->new_level
= level
;
61 schedule_work(&led_dat
->work
);
63 gpio_set_value(led_dat
->gpio
, level
);
66 static int gpio_blink_set(struct led_classdev
*led_cdev
,
67 unsigned long *delay_on
, unsigned long *delay_off
)
69 struct gpio_led_data
*led_dat
=
70 container_of(led_cdev
, struct gpio_led_data
, cdev
);
72 return led_dat
->platform_gpio_blink_set(led_dat
->gpio
, delay_on
, delay_off
);
75 static int __devinit
create_gpio_led(const struct gpio_led
*template,
76 struct gpio_led_data
*led_dat
, struct device
*parent
,
77 int (*blink_set
)(unsigned, unsigned long *, unsigned long *))
81 /* skip leds that aren't available */
82 if (!gpio_is_valid(template->gpio
)) {
83 printk(KERN_INFO
"Skipping unavilable LED gpio %d (%s)\n",
84 template->gpio
, template->name
);
88 ret
= gpio_request(template->gpio
, template->name
);
92 led_dat
->cdev
.name
= template->name
;
93 led_dat
->cdev
.default_trigger
= template->default_trigger
;
94 led_dat
->gpio
= template->gpio
;
95 led_dat
->can_sleep
= gpio_cansleep(template->gpio
);
96 led_dat
->active_low
= template->active_low
;
98 led_dat
->platform_gpio_blink_set
= blink_set
;
99 led_dat
->cdev
.blink_set
= gpio_blink_set
;
101 led_dat
->cdev
.brightness_set
= gpio_led_set
;
102 if (template->default_state
== LEDS_GPIO_DEFSTATE_KEEP
)
103 state
= !!gpio_get_value(led_dat
->gpio
) ^ led_dat
->active_low
;
105 state
= (template->default_state
== LEDS_GPIO_DEFSTATE_ON
);
106 led_dat
->cdev
.brightness
= state
? LED_FULL
: LED_OFF
;
107 if (!template->retain_state_suspended
)
108 led_dat
->cdev
.flags
|= LED_CORE_SUSPENDRESUME
;
110 ret
= gpio_direction_output(led_dat
->gpio
, led_dat
->active_low
^ state
);
114 INIT_WORK(&led_dat
->work
, gpio_led_work
);
116 ret
= led_classdev_register(parent
, &led_dat
->cdev
);
122 gpio_free(led_dat
->gpio
);
126 static void delete_gpio_led(struct gpio_led_data
*led
)
128 if (!gpio_is_valid(led
->gpio
))
130 led_classdev_unregister(&led
->cdev
);
131 cancel_work_sync(&led
->work
);
132 gpio_free(led
->gpio
);
135 #ifdef CONFIG_LEDS_GPIO_PLATFORM
136 static int __devinit
gpio_led_probe(struct platform_device
*pdev
)
138 struct gpio_led_platform_data
*pdata
= pdev
->dev
.platform_data
;
139 struct gpio_led_data
*leds_data
;
145 leds_data
= kzalloc(sizeof(struct gpio_led_data
) * pdata
->num_leds
,
150 for (i
= 0; i
< pdata
->num_leds
; i
++) {
151 ret
= create_gpio_led(&pdata
->leds
[i
], &leds_data
[i
],
152 &pdev
->dev
, pdata
->gpio_blink_set
);
157 platform_set_drvdata(pdev
, leds_data
);
162 for (i
= i
- 1; i
>= 0; i
--)
163 delete_gpio_led(&leds_data
[i
]);
170 static int __devexit
gpio_led_remove(struct platform_device
*pdev
)
173 struct gpio_led_platform_data
*pdata
= pdev
->dev
.platform_data
;
174 struct gpio_led_data
*leds_data
;
176 leds_data
= platform_get_drvdata(pdev
);
178 for (i
= 0; i
< pdata
->num_leds
; i
++)
179 delete_gpio_led(&leds_data
[i
]);
186 static struct platform_driver gpio_led_driver
= {
187 .probe
= gpio_led_probe
,
188 .remove
= __devexit_p(gpio_led_remove
),
191 .owner
= THIS_MODULE
,
195 MODULE_ALIAS("platform:leds-gpio");
196 #endif /* CONFIG_LEDS_GPIO_PLATFORM */
198 /* Code to create from OpenFirmware platform devices */
199 #ifdef CONFIG_LEDS_GPIO_OF
200 #include <linux/of_platform.h>
201 #include <linux/of_gpio.h>
203 struct gpio_led_of_platform_data
{
205 struct gpio_led_data led_data
[];
208 static int __devinit
of_gpio_leds_probe(struct of_device
*ofdev
,
209 const struct of_device_id
*match
)
211 struct device_node
*np
= ofdev
->node
, *child
;
213 struct gpio_led_of_platform_data
*pdata
;
216 /* count LEDs defined by this device, so we know how much to allocate */
217 for_each_child_of_node(np
, child
)
220 return 0; /* or ENODEV? */
222 pdata
= kzalloc(sizeof(*pdata
) + sizeof(struct gpio_led_data
) * count
,
227 memset(&led
, 0, sizeof(led
));
228 for_each_child_of_node(np
, child
) {
229 enum of_gpio_flags flags
;
232 led
.gpio
= of_get_gpio_flags(child
, 0, &flags
);
233 led
.active_low
= flags
& OF_GPIO_ACTIVE_LOW
;
234 led
.name
= of_get_property(child
, "label", NULL
) ? : child
->name
;
235 led
.default_trigger
=
236 of_get_property(child
, "linux,default-trigger", NULL
);
237 state
= of_get_property(child
, "default-state", NULL
);
239 if (!strcmp(state
, "keep"))
240 led
.default_state
= LEDS_GPIO_DEFSTATE_KEEP
;
241 else if(!strcmp(state
, "on"))
242 led
.default_state
= LEDS_GPIO_DEFSTATE_ON
;
244 led
.default_state
= LEDS_GPIO_DEFSTATE_OFF
;
247 ret
= create_gpio_led(&led
, &pdata
->led_data
[pdata
->num_leds
++],
255 dev_set_drvdata(&ofdev
->dev
, pdata
);
260 for (count
= pdata
->num_leds
- 2; count
>= 0; count
--)
261 delete_gpio_led(&pdata
->led_data
[count
]);
268 static int __devexit
of_gpio_leds_remove(struct of_device
*ofdev
)
270 struct gpio_led_of_platform_data
*pdata
= dev_get_drvdata(&ofdev
->dev
);
273 for (i
= 0; i
< pdata
->num_leds
; i
++)
274 delete_gpio_led(&pdata
->led_data
[i
]);
278 dev_set_drvdata(&ofdev
->dev
, NULL
);
283 static const struct of_device_id of_gpio_leds_match
[] = {
284 { .compatible
= "gpio-leds", },
288 static struct of_platform_driver of_gpio_leds_driver
= {
290 .name
= "of_gpio_leds",
291 .owner
= THIS_MODULE
,
293 .match_table
= of_gpio_leds_match
,
294 .probe
= of_gpio_leds_probe
,
295 .remove
= __devexit_p(of_gpio_leds_remove
),
299 static int __init
gpio_led_init(void)
303 #ifdef CONFIG_LEDS_GPIO_PLATFORM
304 ret
= platform_driver_register(&gpio_led_driver
);
308 #ifdef CONFIG_LEDS_GPIO_OF
309 ret
= of_register_platform_driver(&of_gpio_leds_driver
);
311 #ifdef CONFIG_LEDS_GPIO_PLATFORM
313 platform_driver_unregister(&gpio_led_driver
);
319 static void __exit
gpio_led_exit(void)
321 #ifdef CONFIG_LEDS_GPIO_PLATFORM
322 platform_driver_unregister(&gpio_led_driver
);
324 #ifdef CONFIG_LEDS_GPIO_OF
325 of_unregister_platform_driver(&of_gpio_leds_driver
);
329 module_init(gpio_led_init
);
330 module_exit(gpio_led_exit
);
332 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
333 MODULE_DESCRIPTION("GPIO LED driver");
334 MODULE_LICENSE("GPL");