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/gpio.h>
17 #include <linux/leds.h>
18 #include <linux/of_platform.h>
19 #include <linux/of_gpio.h>
20 #include <linux/slab.h>
21 #include <linux/workqueue.h>
22 #include <linux/module.h>
23 #include <linux/err.h>
25 struct gpio_led_data
{
26 struct led_classdev cdev
;
28 struct work_struct work
;
33 int (*platform_gpio_blink_set
)(unsigned gpio
, int state
,
34 unsigned long *delay_on
, unsigned long *delay_off
);
37 static void gpio_led_work(struct work_struct
*work
)
39 struct gpio_led_data
*led_dat
=
40 container_of(work
, struct gpio_led_data
, work
);
42 if (led_dat
->blinking
) {
43 led_dat
->platform_gpio_blink_set(led_dat
->gpio
,
46 led_dat
->blinking
= 0;
48 gpio_set_value_cansleep(led_dat
->gpio
, led_dat
->new_level
);
51 static void gpio_led_set(struct led_classdev
*led_cdev
,
52 enum led_brightness value
)
54 struct gpio_led_data
*led_dat
=
55 container_of(led_cdev
, struct gpio_led_data
, cdev
);
63 if (led_dat
->active_low
)
66 /* Setting GPIOs with I2C/etc requires a task context, and we don't
67 * seem to have a reliable way to know if we're already in one; so
68 * let's just assume the worst.
70 if (led_dat
->can_sleep
) {
71 led_dat
->new_level
= level
;
72 schedule_work(&led_dat
->work
);
74 if (led_dat
->blinking
) {
75 led_dat
->platform_gpio_blink_set(led_dat
->gpio
, level
,
77 led_dat
->blinking
= 0;
79 gpio_set_value(led_dat
->gpio
, level
);
83 static int gpio_blink_set(struct led_classdev
*led_cdev
,
84 unsigned long *delay_on
, unsigned long *delay_off
)
86 struct gpio_led_data
*led_dat
=
87 container_of(led_cdev
, struct gpio_led_data
, cdev
);
89 led_dat
->blinking
= 1;
90 return led_dat
->platform_gpio_blink_set(led_dat
->gpio
, GPIO_LED_BLINK
,
94 static int create_gpio_led(const struct gpio_led
*template,
95 struct gpio_led_data
*led_dat
, struct device
*parent
,
96 int (*blink_set
)(unsigned, int, unsigned long *, unsigned long *))
102 /* skip leds that aren't available */
103 if (!gpio_is_valid(template->gpio
)) {
104 dev_info(parent
, "Skipping unavailable LED gpio %d (%s)\n",
105 template->gpio
, template->name
);
109 ret
= devm_gpio_request(parent
, template->gpio
, template->name
);
113 led_dat
->cdev
.name
= template->name
;
114 led_dat
->cdev
.default_trigger
= template->default_trigger
;
115 led_dat
->gpio
= template->gpio
;
116 led_dat
->can_sleep
= gpio_cansleep(template->gpio
);
117 led_dat
->active_low
= template->active_low
;
118 led_dat
->blinking
= 0;
120 led_dat
->platform_gpio_blink_set
= blink_set
;
121 led_dat
->cdev
.blink_set
= gpio_blink_set
;
123 led_dat
->cdev
.brightness_set
= gpio_led_set
;
124 if (template->default_state
== LEDS_GPIO_DEFSTATE_KEEP
)
125 state
= !!gpio_get_value_cansleep(led_dat
->gpio
) ^ led_dat
->active_low
;
127 state
= (template->default_state
== LEDS_GPIO_DEFSTATE_ON
);
128 led_dat
->cdev
.brightness
= state
? LED_FULL
: LED_OFF
;
129 if (!template->retain_state_suspended
)
130 led_dat
->cdev
.flags
|= LED_CORE_SUSPENDRESUME
;
132 ret
= gpio_direction_output(led_dat
->gpio
, led_dat
->active_low
^ state
);
136 INIT_WORK(&led_dat
->work
, gpio_led_work
);
138 ret
= led_classdev_register(parent
, &led_dat
->cdev
);
145 static void delete_gpio_led(struct gpio_led_data
*led
)
147 if (!gpio_is_valid(led
->gpio
))
149 led_classdev_unregister(&led
->cdev
);
150 cancel_work_sync(&led
->work
);
153 struct gpio_leds_priv
{
155 struct gpio_led_data leds
[];
158 static inline int sizeof_gpio_leds_priv(int num_leds
)
160 return sizeof(struct gpio_leds_priv
) +
161 (sizeof(struct gpio_led_data
) * num_leds
);
164 /* Code to create from OpenFirmware platform devices */
165 #ifdef CONFIG_OF_GPIO
166 static struct gpio_leds_priv
*gpio_leds_create_of(struct platform_device
*pdev
)
168 struct device_node
*np
= pdev
->dev
.of_node
, *child
;
169 struct gpio_leds_priv
*priv
;
172 /* count LEDs in this device, so we know how much to allocate */
173 count
= of_get_child_count(np
);
175 return ERR_PTR(-ENODEV
);
177 for_each_child_of_node(np
, child
)
178 if (of_get_gpio(child
, 0) == -EPROBE_DEFER
)
179 return ERR_PTR(-EPROBE_DEFER
);
181 priv
= devm_kzalloc(&pdev
->dev
, sizeof_gpio_leds_priv(count
),
184 return ERR_PTR(-ENOMEM
);
186 for_each_child_of_node(np
, child
) {
187 struct gpio_led led
= {};
188 enum of_gpio_flags flags
;
191 led
.gpio
= of_get_gpio_flags(child
, 0, &flags
);
192 led
.active_low
= flags
& OF_GPIO_ACTIVE_LOW
;
193 led
.name
= of_get_property(child
, "label", NULL
) ? : child
->name
;
194 led
.default_trigger
=
195 of_get_property(child
, "linux,default-trigger", NULL
);
196 state
= of_get_property(child
, "default-state", NULL
);
198 if (!strcmp(state
, "keep"))
199 led
.default_state
= LEDS_GPIO_DEFSTATE_KEEP
;
200 else if (!strcmp(state
, "on"))
201 led
.default_state
= LEDS_GPIO_DEFSTATE_ON
;
203 led
.default_state
= LEDS_GPIO_DEFSTATE_OFF
;
206 ret
= create_gpio_led(&led
, &priv
->leds
[priv
->num_leds
++],
217 for (count
= priv
->num_leds
- 2; count
>= 0; count
--)
218 delete_gpio_led(&priv
->leds
[count
]);
219 return ERR_PTR(-ENODEV
);
222 static const struct of_device_id of_gpio_leds_match
[] = {
223 { .compatible
= "gpio-leds", },
226 #else /* CONFIG_OF_GPIO */
227 static struct gpio_leds_priv
*gpio_leds_create_of(struct platform_device
*pdev
)
229 return ERR_PTR(-ENODEV
);
231 #endif /* CONFIG_OF_GPIO */
234 static int gpio_led_probe(struct platform_device
*pdev
)
236 struct gpio_led_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
237 struct gpio_leds_priv
*priv
;
241 if (pdata
&& pdata
->num_leds
) {
242 priv
= devm_kzalloc(&pdev
->dev
,
243 sizeof_gpio_leds_priv(pdata
->num_leds
),
248 priv
->num_leds
= pdata
->num_leds
;
249 for (i
= 0; i
< priv
->num_leds
; i
++) {
250 ret
= create_gpio_led(&pdata
->leds
[i
],
252 &pdev
->dev
, pdata
->gpio_blink_set
);
254 /* On failure: unwind the led creations */
255 for (i
= i
- 1; i
>= 0; i
--)
256 delete_gpio_led(&priv
->leds
[i
]);
261 priv
= gpio_leds_create_of(pdev
);
263 return PTR_ERR(priv
);
266 platform_set_drvdata(pdev
, priv
);
271 static int gpio_led_remove(struct platform_device
*pdev
)
273 struct gpio_leds_priv
*priv
= platform_get_drvdata(pdev
);
276 for (i
= 0; i
< priv
->num_leds
; i
++)
277 delete_gpio_led(&priv
->leds
[i
]);
282 static struct platform_driver gpio_led_driver
= {
283 .probe
= gpio_led_probe
,
284 .remove
= gpio_led_remove
,
287 .owner
= THIS_MODULE
,
288 .of_match_table
= of_match_ptr(of_gpio_leds_match
),
292 module_platform_driver(gpio_led_driver
);
294 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
295 MODULE_DESCRIPTION("GPIO LED driver");
296 MODULE_LICENSE("GPL");
297 MODULE_ALIAS("platform:leds-gpio");