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 gpio_blink_set_t platform_gpio_blink_set
;
32 static inline struct gpio_led_data
*
33 cdev_to_gpio_led_data(struct led_classdev
*led_cdev
)
35 return container_of(led_cdev
, struct gpio_led_data
, cdev
);
38 static void gpio_led_set(struct led_classdev
*led_cdev
,
39 enum led_brightness value
)
41 struct gpio_led_data
*led_dat
= cdev_to_gpio_led_data(led_cdev
);
49 if (led_dat
->blinking
) {
50 led_dat
->platform_gpio_blink_set(led_dat
->gpiod
, level
,
52 led_dat
->blinking
= 0;
53 } else if (led_dat
->cdev
.flags
& SET_GPIO_INPUT
) {
54 gpiod_direction_input(led_dat
->gpiod
);
55 led_dat
->cdev
.flags
&= ~SET_GPIO_INPUT
;
56 } else if (led_dat
->cdev
.flags
& SET_GPIO_OUTPUT
) {
57 gpiod_direction_output(led_dat
->gpiod
, level
);
58 led_dat
->cdev
.flags
&= ~SET_GPIO_OUTPUT
;
60 if (led_dat
->can_sleep
||
61 (led_dat
->cdev
.flags
& (SET_GPIO_INPUT
| SET_GPIO_OUTPUT
) ))
62 gpiod_set_value_cansleep(led_dat
->gpiod
, level
);
64 gpiod_set_value(led_dat
->gpiod
, level
);
68 static int gpio_led_set_blocking(struct led_classdev
*led_cdev
,
69 enum led_brightness value
)
71 gpio_led_set(led_cdev
, value
);
75 static enum led_brightness
gpio_led_get(struct led_classdev
*led_cdev
)
77 struct gpio_led_data
*led_dat
=
78 container_of(led_cdev
, struct gpio_led_data
, cdev
);
79 return gpiod_get_value_cansleep(led_dat
->gpiod
) ? LED_FULL
: LED_OFF
;
82 static int gpio_blink_set(struct led_classdev
*led_cdev
,
83 unsigned long *delay_on
, unsigned long *delay_off
)
85 struct gpio_led_data
*led_dat
= cdev_to_gpio_led_data(led_cdev
);
87 led_dat
->blinking
= 1;
88 return led_dat
->platform_gpio_blink_set(led_dat
->gpiod
, GPIO_LED_BLINK
,
92 static int create_gpio_led(const struct gpio_led
*template,
93 struct gpio_led_data
*led_dat
, struct device
*parent
,
94 struct device_node
*np
, gpio_blink_set_t blink_set
)
98 led_dat
->gpiod
= template->gpiod
;
99 if (!led_dat
->gpiod
) {
101 * This is the legacy code path for platform code that
102 * still uses GPIO numbers. Ultimately we would like to get
103 * rid of this block completely.
105 unsigned long flags
= GPIOF_OUT_INIT_LOW
;
107 /* skip leds that aren't available */
108 if (!gpio_is_valid(template->gpio
)) {
109 dev_info(parent
, "Skipping unavailable LED gpio %d (%s)\n",
110 template->gpio
, template->name
);
114 if (template->active_low
)
115 flags
|= GPIOF_ACTIVE_LOW
;
117 ret
= devm_gpio_request_one(parent
, template->gpio
, flags
,
122 led_dat
->gpiod
= gpio_to_desc(template->gpio
);
127 led_dat
->cdev
.name
= template->name
;
128 led_dat
->cdev
.default_trigger
= template->default_trigger
;
129 led_dat
->can_sleep
= gpiod_cansleep(led_dat
->gpiod
);
130 if (!led_dat
->can_sleep
)
131 led_dat
->cdev
.brightness_set
= gpio_led_set
;
133 led_dat
->cdev
.brightness_set_blocking
= gpio_led_set_blocking
;
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_get
= gpio_led_get
;
140 if (template->default_state
== LEDS_GPIO_DEFSTATE_KEEP
) {
141 state
= gpiod_get_value_cansleep(led_dat
->gpiod
);
145 state
= (template->default_state
== LEDS_GPIO_DEFSTATE_ON
);
147 led_dat
->cdev
.brightness
= state
? LED_FULL
: LED_OFF
;
148 if (!template->retain_state_suspended
)
149 led_dat
->cdev
.flags
|= LED_CORE_SUSPENDRESUME
;
150 if (template->panic_indicator
)
151 led_dat
->cdev
.flags
|= LED_PANIC_INDICATOR
;
153 ret
= gpiod_direction_output(led_dat
->gpiod
, state
);
157 return devm_of_led_classdev_register(parent
, np
, &led_dat
->cdev
);
160 struct gpio_leds_priv
{
162 struct gpio_led_data leds
[];
165 static inline int sizeof_gpio_leds_priv(int num_leds
)
167 return sizeof(struct gpio_leds_priv
) +
168 (sizeof(struct gpio_led_data
) * num_leds
);
171 static struct gpio_leds_priv
*gpio_leds_create(struct platform_device
*pdev
)
173 struct device
*dev
= &pdev
->dev
;
174 struct fwnode_handle
*child
;
175 struct gpio_leds_priv
*priv
;
178 count
= device_get_child_node_count(dev
);
180 return ERR_PTR(-ENODEV
);
182 priv
= devm_kzalloc(dev
, sizeof_gpio_leds_priv(count
), GFP_KERNEL
);
184 return ERR_PTR(-ENOMEM
);
186 device_for_each_child_node(dev
, child
) {
187 struct gpio_led_data
*led_dat
= &priv
->leds
[priv
->num_leds
];
188 struct gpio_led led
= {};
189 const char *state
= NULL
;
190 struct device_node
*np
= to_of_node(child
);
192 ret
= fwnode_property_read_string(child
, "label", &led
.name
);
193 if (ret
&& IS_ENABLED(CONFIG_OF
) && np
)
196 fwnode_handle_put(child
);
197 return ERR_PTR(-EINVAL
);
200 led
.gpiod
= devm_fwnode_get_gpiod_from_child(dev
, NULL
, child
,
203 if (IS_ERR(led
.gpiod
)) {
204 fwnode_handle_put(child
);
205 return ERR_CAST(led
.gpiod
);
208 fwnode_property_read_string(child
, "linux,default-trigger",
209 &led
.default_trigger
);
211 if (!fwnode_property_read_string(child
, "default-state",
213 if (!strcmp(state
, "keep"))
214 led
.default_state
= LEDS_GPIO_DEFSTATE_KEEP
;
215 else if (!strcmp(state
, "on"))
216 led
.default_state
= LEDS_GPIO_DEFSTATE_ON
;
218 led
.default_state
= LEDS_GPIO_DEFSTATE_OFF
;
221 if (fwnode_property_present(child
, "retain-state-suspended"))
222 led
.retain_state_suspended
= 1;
223 if (fwnode_property_present(child
, "panic-indicator"))
224 led
.panic_indicator
= 1;
226 ret
= create_gpio_led(&led
, led_dat
, dev
, np
, NULL
);
228 fwnode_handle_put(child
);
231 led_dat
->cdev
.dev
->of_node
= np
;
238 static const struct of_device_id of_gpio_leds_match
[] = {
239 { .compatible
= "gpio-leds", },
243 MODULE_DEVICE_TABLE(of
, of_gpio_leds_match
);
245 static int gpio_led_probe(struct platform_device
*pdev
)
247 struct gpio_led_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
248 struct gpio_leds_priv
*priv
;
251 if (pdata
&& pdata
->num_leds
) {
252 priv
= devm_kzalloc(&pdev
->dev
,
253 sizeof_gpio_leds_priv(pdata
->num_leds
),
258 priv
->num_leds
= pdata
->num_leds
;
259 for (i
= 0; i
< priv
->num_leds
; i
++) {
260 ret
= create_gpio_led(&pdata
->leds
[i
], &priv
->leds
[i
],
262 pdata
->gpio_blink_set
);
267 priv
= gpio_leds_create(pdev
);
269 return PTR_ERR(priv
);
272 platform_set_drvdata(pdev
, priv
);
277 static void gpio_led_shutdown(struct platform_device
*pdev
)
279 struct gpio_leds_priv
*priv
= platform_get_drvdata(pdev
);
282 for (i
= 0; i
< priv
->num_leds
; i
++) {
283 struct gpio_led_data
*led
= &priv
->leds
[i
];
285 gpio_led_set(&led
->cdev
, LED_OFF
);
289 static struct platform_driver gpio_led_driver
= {
290 .probe
= gpio_led_probe
,
291 .shutdown
= gpio_led_shutdown
,
294 .of_match_table
= of_gpio_leds_match
,
298 module_platform_driver(gpio_led_driver
);
300 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
301 MODULE_DESCRIPTION("GPIO LED driver");
302 MODULE_LICENSE("GPL");
303 MODULE_ALIAS("platform:leds-gpio");