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/platform_device.h>
21 #include <linux/property.h>
22 #include <linux/slab.h>
24 struct gpio_led_data
{
25 struct led_classdev cdev
;
26 struct gpio_desc
*gpiod
;
29 int (*platform_gpio_blink_set
)(struct gpio_desc
*desc
, int state
,
30 unsigned long *delay_on
, unsigned long *delay_off
);
33 static void gpio_led_set(struct led_classdev
*led_cdev
,
34 enum led_brightness value
)
36 struct gpio_led_data
*led_dat
=
37 container_of(led_cdev
, struct gpio_led_data
, cdev
);
45 if (led_dat
->blinking
) {
46 led_dat
->platform_gpio_blink_set(led_dat
->gpiod
, level
,
48 led_dat
->blinking
= 0;
50 if (led_dat
->can_sleep
)
51 gpiod_set_value_cansleep(led_dat
->gpiod
, level
);
53 gpiod_set_value(led_dat
->gpiod
, level
);
57 static int gpio_led_set_blocking(struct led_classdev
*led_cdev
,
58 enum led_brightness value
)
60 gpio_led_set(led_cdev
, value
);
64 static int gpio_blink_set(struct led_classdev
*led_cdev
,
65 unsigned long *delay_on
, unsigned long *delay_off
)
67 struct gpio_led_data
*led_dat
=
68 container_of(led_cdev
, struct gpio_led_data
, cdev
);
70 led_dat
->blinking
= 1;
71 return led_dat
->platform_gpio_blink_set(led_dat
->gpiod
, GPIO_LED_BLINK
,
75 static int create_gpio_led(const struct gpio_led
*template,
76 struct gpio_led_data
*led_dat
, struct device
*parent
,
77 int (*blink_set
)(struct gpio_desc
*, int, unsigned long *,
82 led_dat
->gpiod
= template->gpiod
;
83 if (!led_dat
->gpiod
) {
85 * This is the legacy code path for platform code that
86 * still uses GPIO numbers. Ultimately we would like to get
87 * rid of this block completely.
89 unsigned long flags
= GPIOF_OUT_INIT_LOW
;
91 /* skip leds that aren't available */
92 if (!gpio_is_valid(template->gpio
)) {
93 dev_info(parent
, "Skipping unavailable LED gpio %d (%s)\n",
94 template->gpio
, template->name
);
98 if (template->active_low
)
99 flags
|= GPIOF_ACTIVE_LOW
;
101 ret
= devm_gpio_request_one(parent
, template->gpio
, flags
,
106 led_dat
->gpiod
= gpio_to_desc(template->gpio
);
111 led_dat
->cdev
.name
= template->name
;
112 led_dat
->cdev
.default_trigger
= template->default_trigger
;
113 led_dat
->can_sleep
= gpiod_cansleep(led_dat
->gpiod
);
114 if (!led_dat
->can_sleep
)
115 led_dat
->cdev
.brightness_set
= gpio_led_set
;
117 led_dat
->cdev
.brightness_set_blocking
= gpio_led_set_blocking
;
118 led_dat
->blinking
= 0;
120 led_dat
->platform_gpio_blink_set
= blink_set
;
121 led_dat
->cdev
.blink_set
= gpio_blink_set
;
123 if (template->default_state
== LEDS_GPIO_DEFSTATE_KEEP
)
124 state
= !!gpiod_get_value_cansleep(led_dat
->gpiod
);
126 state
= (template->default_state
== LEDS_GPIO_DEFSTATE_ON
);
127 led_dat
->cdev
.brightness
= state
? LED_FULL
: LED_OFF
;
128 if (!template->retain_state_suspended
)
129 led_dat
->cdev
.flags
|= LED_CORE_SUSPENDRESUME
;
130 if (template->panic_indicator
)
131 led_dat
->cdev
.flags
|= LED_PANIC_INDICATOR
;
133 ret
= gpiod_direction_output(led_dat
->gpiod
, state
);
137 return led_classdev_register(parent
, &led_dat
->cdev
);
140 struct gpio_leds_priv
{
142 struct gpio_led_data leds
[];
145 static inline int sizeof_gpio_leds_priv(int num_leds
)
147 return sizeof(struct gpio_leds_priv
) +
148 (sizeof(struct gpio_led_data
) * num_leds
);
151 static struct gpio_leds_priv
*gpio_leds_create(struct platform_device
*pdev
)
153 struct device
*dev
= &pdev
->dev
;
154 struct fwnode_handle
*child
;
155 struct gpio_leds_priv
*priv
;
157 struct device_node
*np
;
159 count
= device_get_child_node_count(dev
);
161 return ERR_PTR(-ENODEV
);
163 priv
= devm_kzalloc(dev
, sizeof_gpio_leds_priv(count
), GFP_KERNEL
);
165 return ERR_PTR(-ENOMEM
);
167 device_for_each_child_node(dev
, child
) {
168 struct gpio_led led
= {};
169 const char *state
= NULL
;
171 led
.gpiod
= devm_get_gpiod_from_child(dev
, NULL
, child
);
172 if (IS_ERR(led
.gpiod
)) {
173 fwnode_handle_put(child
);
174 ret
= PTR_ERR(led
.gpiod
);
178 np
= to_of_node(child
);
180 if (fwnode_property_present(child
, "label")) {
181 fwnode_property_read_string(child
, "label", &led
.name
);
183 if (IS_ENABLED(CONFIG_OF
) && !led
.name
&& np
)
190 fwnode_property_read_string(child
, "linux,default-trigger",
191 &led
.default_trigger
);
193 if (!fwnode_property_read_string(child
, "default-state",
195 if (!strcmp(state
, "keep"))
196 led
.default_state
= LEDS_GPIO_DEFSTATE_KEEP
;
197 else if (!strcmp(state
, "on"))
198 led
.default_state
= LEDS_GPIO_DEFSTATE_ON
;
200 led
.default_state
= LEDS_GPIO_DEFSTATE_OFF
;
203 if (fwnode_property_present(child
, "retain-state-suspended"))
204 led
.retain_state_suspended
= 1;
205 if (fwnode_property_present(child
, "panic-indicator"))
206 led
.panic_indicator
= 1;
208 ret
= create_gpio_led(&led
, &priv
->leds
[priv
->num_leds
],
211 fwnode_handle_put(child
);
220 for (count
= priv
->num_leds
- 1; count
>= 0; count
--)
221 led_classdev_unregister(&priv
->leds
[count
].cdev
);
225 static const struct of_device_id of_gpio_leds_match
[] = {
226 { .compatible
= "gpio-leds", },
230 MODULE_DEVICE_TABLE(of
, of_gpio_leds_match
);
232 static int gpio_led_probe(struct platform_device
*pdev
)
234 struct gpio_led_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
235 struct gpio_leds_priv
*priv
;
238 if (pdata
&& pdata
->num_leds
) {
239 priv
= devm_kzalloc(&pdev
->dev
,
240 sizeof_gpio_leds_priv(pdata
->num_leds
),
245 priv
->num_leds
= pdata
->num_leds
;
246 for (i
= 0; i
< priv
->num_leds
; i
++) {
247 ret
= create_gpio_led(&pdata
->leds
[i
],
249 &pdev
->dev
, pdata
->gpio_blink_set
);
251 /* On failure: unwind the led creations */
252 for (i
= i
- 1; i
>= 0; i
--)
253 led_classdev_unregister(
254 &priv
->leds
[i
].cdev
);
259 priv
= gpio_leds_create(pdev
);
261 return PTR_ERR(priv
);
264 platform_set_drvdata(pdev
, priv
);
269 static int gpio_led_remove(struct platform_device
*pdev
)
271 struct gpio_leds_priv
*priv
= platform_get_drvdata(pdev
);
274 for (i
= 0; i
< priv
->num_leds
; i
++)
275 led_classdev_unregister(&priv
->leds
[i
].cdev
);
280 static void gpio_led_shutdown(struct platform_device
*pdev
)
282 struct gpio_leds_priv
*priv
= platform_get_drvdata(pdev
);
285 for (i
= 0; i
< priv
->num_leds
; i
++) {
286 struct gpio_led_data
*led
= &priv
->leds
[i
];
288 gpio_led_set(&led
->cdev
, LED_OFF
);
292 static struct platform_driver gpio_led_driver
= {
293 .probe
= gpio_led_probe
,
294 .remove
= gpio_led_remove
,
295 .shutdown
= gpio_led_shutdown
,
298 .of_match_table
= of_gpio_leds_match
,
302 module_platform_driver(gpio_led_driver
);
304 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
305 MODULE_DESCRIPTION("GPIO LED driver");
306 MODULE_LICENSE("GPL");
307 MODULE_ALIAS("platform:leds-gpio");