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/err.h>
14 #include <linux/gpio.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/kernel.h>
17 #include <linux/leds.h>
18 #include <linux/module.h>
20 #include <linux/of_gpio.h>
21 #include <linux/of_platform.h>
22 #include <linux/platform_device.h>
23 #include <linux/slab.h>
24 #include <linux/workqueue.h>
26 struct gpio_led_data
{
27 struct led_classdev cdev
;
28 struct gpio_desc
*gpiod
;
29 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 int gpio
= desc_to_gpio(led_dat
->gpiod
);
44 int level
= led_dat
->new_level
;
46 if (gpiod_is_active_low(led_dat
->gpiod
))
49 led_dat
->platform_gpio_blink_set(gpio
, level
, NULL
, NULL
);
50 led_dat
->blinking
= 0;
52 gpiod_set_value_cansleep(led_dat
->gpiod
, led_dat
->new_level
);
55 static void gpio_led_set(struct led_classdev
*led_cdev
,
56 enum led_brightness value
)
58 struct gpio_led_data
*led_dat
=
59 container_of(led_cdev
, struct gpio_led_data
, cdev
);
67 /* Setting GPIOs with I2C/etc requires a task context, and we don't
68 * seem to have a reliable way to know if we're already in one; so
69 * let's just assume the worst.
71 if (led_dat
->can_sleep
) {
72 led_dat
->new_level
= level
;
73 schedule_work(&led_dat
->work
);
75 if (led_dat
->blinking
) {
76 int gpio
= desc_to_gpio(led_dat
->gpiod
);
78 if (gpiod_is_active_low(led_dat
->gpiod
))
81 led_dat
->platform_gpio_blink_set(gpio
, level
, NULL
,
83 led_dat
->blinking
= 0;
85 gpiod_set_value(led_dat
->gpiod
, level
);
89 static int gpio_blink_set(struct led_classdev
*led_cdev
,
90 unsigned long *delay_on
, unsigned long *delay_off
)
92 struct gpio_led_data
*led_dat
=
93 container_of(led_cdev
, struct gpio_led_data
, cdev
);
94 int gpio
= desc_to_gpio(led_dat
->gpiod
);
96 led_dat
->blinking
= 1;
97 return led_dat
->platform_gpio_blink_set(gpio
, GPIO_LED_BLINK
,
101 static int create_gpio_led(const struct gpio_led
*template,
102 struct gpio_led_data
*led_dat
, struct device
*parent
,
103 int (*blink_set
)(unsigned, int, unsigned long *, unsigned long *))
107 if (!template->gpiod
) {
108 unsigned long flags
= 0;
110 /* skip leds that aren't available */
111 if (!gpio_is_valid(template->gpio
)) {
112 dev_info(parent
, "Skipping unavailable LED gpio %d (%s)\n",
113 template->gpio
, template->name
);
117 if (template->active_low
)
118 flags
|= GPIOF_ACTIVE_LOW
;
120 ret
= devm_gpio_request_one(parent
, template->gpio
, flags
,
125 led_dat
->gpiod
= gpio_to_desc(template->gpio
);
126 if (IS_ERR(led_dat
->gpiod
))
127 return PTR_ERR(led_dat
->gpiod
);
130 led_dat
->cdev
.name
= template->name
;
131 led_dat
->cdev
.default_trigger
= template->default_trigger
;
132 led_dat
->gpiod
= template->gpiod
;
133 led_dat
->can_sleep
= gpiod_cansleep(template->gpiod
);
134 led_dat
->blinking
= 0;
136 led_dat
->platform_gpio_blink_set
= blink_set
;
137 led_dat
->cdev
.blink_set
= gpio_blink_set
;
139 led_dat
->cdev
.brightness_set
= gpio_led_set
;
140 if (template->default_state
== LEDS_GPIO_DEFSTATE_KEEP
)
141 state
= !!gpiod_get_value_cansleep(led_dat
->gpiod
);
143 state
= (template->default_state
== LEDS_GPIO_DEFSTATE_ON
);
144 led_dat
->cdev
.brightness
= state
? LED_FULL
: LED_OFF
;
145 if (!template->retain_state_suspended
)
146 led_dat
->cdev
.flags
|= LED_CORE_SUSPENDRESUME
;
148 ret
= gpiod_direction_output(led_dat
->gpiod
, state
);
152 INIT_WORK(&led_dat
->work
, gpio_led_work
);
154 return led_classdev_register(parent
, &led_dat
->cdev
);
157 static void delete_gpio_led(struct gpio_led_data
*led
)
159 led_classdev_unregister(&led
->cdev
);
160 cancel_work_sync(&led
->work
);
163 struct gpio_leds_priv
{
165 struct gpio_led_data leds
[];
168 static inline int sizeof_gpio_leds_priv(int num_leds
)
170 return sizeof(struct gpio_leds_priv
) +
171 (sizeof(struct gpio_led_data
) * num_leds
);
174 /* Code to create from OpenFirmware platform devices */
175 #ifdef CONFIG_OF_GPIO
176 static struct gpio_leds_priv
*gpio_leds_create_of(struct platform_device
*pdev
)
178 struct device_node
*np
= pdev
->dev
.of_node
, *child
;
179 struct gpio_leds_priv
*priv
;
182 /* count LEDs in this device, so we know how much to allocate */
183 count
= of_get_available_child_count(np
);
185 return ERR_PTR(-ENODEV
);
187 for_each_available_child_of_node(np
, child
)
188 if (of_get_gpio(child
, 0) == -EPROBE_DEFER
)
189 return ERR_PTR(-EPROBE_DEFER
);
191 priv
= devm_kzalloc(&pdev
->dev
, sizeof_gpio_leds_priv(count
),
194 return ERR_PTR(-ENOMEM
);
196 for_each_available_child_of_node(np
, child
) {
197 struct gpio_led led
= {};
198 enum of_gpio_flags flags
;
201 led
.gpio
= of_get_gpio_flags(child
, 0, &flags
);
202 led
.active_low
= flags
& OF_GPIO_ACTIVE_LOW
;
203 led
.name
= of_get_property(child
, "label", NULL
) ? : child
->name
;
204 led
.default_trigger
=
205 of_get_property(child
, "linux,default-trigger", NULL
);
206 state
= of_get_property(child
, "default-state", NULL
);
208 if (!strcmp(state
, "keep"))
209 led
.default_state
= LEDS_GPIO_DEFSTATE_KEEP
;
210 else if (!strcmp(state
, "on"))
211 led
.default_state
= LEDS_GPIO_DEFSTATE_ON
;
213 led
.default_state
= LEDS_GPIO_DEFSTATE_OFF
;
216 if (of_get_property(child
, "retain-state-suspended", NULL
))
217 led
.retain_state_suspended
= 1;
219 ret
= create_gpio_led(&led
, &priv
->leds
[priv
->num_leds
++],
230 for (count
= priv
->num_leds
- 2; count
>= 0; count
--)
231 delete_gpio_led(&priv
->leds
[count
]);
232 return ERR_PTR(-ENODEV
);
235 static const struct of_device_id of_gpio_leds_match
[] = {
236 { .compatible
= "gpio-leds", },
240 MODULE_DEVICE_TABLE(of
, of_gpio_leds_match
);
241 #else /* CONFIG_OF_GPIO */
242 static struct gpio_leds_priv
*gpio_leds_create_of(struct platform_device
*pdev
)
244 return ERR_PTR(-ENODEV
);
246 #endif /* CONFIG_OF_GPIO */
248 static int gpio_led_probe(struct platform_device
*pdev
)
250 struct gpio_led_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
251 struct gpio_leds_priv
*priv
;
254 if (pdata
&& pdata
->num_leds
) {
255 priv
= devm_kzalloc(&pdev
->dev
,
256 sizeof_gpio_leds_priv(pdata
->num_leds
),
261 priv
->num_leds
= pdata
->num_leds
;
262 for (i
= 0; i
< priv
->num_leds
; i
++) {
263 ret
= create_gpio_led(&pdata
->leds
[i
],
265 &pdev
->dev
, pdata
->gpio_blink_set
);
267 /* On failure: unwind the led creations */
268 for (i
= i
- 1; i
>= 0; i
--)
269 delete_gpio_led(&priv
->leds
[i
]);
274 priv
= gpio_leds_create_of(pdev
);
276 return PTR_ERR(priv
);
279 platform_set_drvdata(pdev
, priv
);
284 static int gpio_led_remove(struct platform_device
*pdev
)
286 struct gpio_leds_priv
*priv
= platform_get_drvdata(pdev
);
289 for (i
= 0; i
< priv
->num_leds
; i
++)
290 delete_gpio_led(&priv
->leds
[i
]);
295 static struct platform_driver gpio_led_driver
= {
296 .probe
= gpio_led_probe
,
297 .remove
= gpio_led_remove
,
300 .owner
= THIS_MODULE
,
301 .of_match_table
= of_match_ptr(of_gpio_leds_match
),
305 module_platform_driver(gpio_led_driver
);
307 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
308 MODULE_DESCRIPTION("GPIO LED driver");
309 MODULE_LICENSE("GPL");
310 MODULE_ALIAS("platform:leds-gpio");