diff options
Diffstat (limited to 'drivers/leds/leds-gpio.c')
| -rw-r--r-- | drivers/leds/leds-gpio.c | 345 |
1 files changed, 345 insertions, 0 deletions
diff --git a/drivers/leds/leds-gpio.c b/drivers/leds/leds-gpio.c new file mode 100644 index 000000000..dbb84949c --- /dev/null +++ b/drivers/leds/leds-gpio.c @@ -0,0 +1,345 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * LEDs driver for GPIOs + * + * Copyright (C) 2007 8D Technologies inc. + * Raphael Assenat <raph@8d.com> + * Copyright (C) 2008 Freescale Semiconductor, Inc. + */ +#include <linux/container_of.h> +#include <linux/device.h> +#include <linux/err.h> +#include <linux/gpio/consumer.h> +#include <linux/gpio/legacy.h> +#include <linux/leds.h> +#include <linux/module.h> +#include <linux/overflow.h> +#include <linux/pinctrl/consumer.h> +#include <linux/platform_device.h> +#include <linux/property.h> +#include <linux/slab.h> +#include <linux/types.h> + +struct gpio_led_data { + struct led_classdev cdev; + struct gpio_desc *gpiod; + u8 can_sleep; + u8 blinking; + gpio_blink_set_t platform_gpio_blink_set; +}; + +static inline struct gpio_led_data * + cdev_to_gpio_led_data(struct led_classdev *led_cdev) +{ + return container_of(led_cdev, struct gpio_led_data, cdev); +} + +static void gpio_led_set(struct led_classdev *led_cdev, + enum led_brightness value) +{ + struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev); + int level; + + if (value == LED_OFF) + level = 0; + else + level = 1; + + if (led_dat->blinking) { + led_dat->platform_gpio_blink_set(led_dat->gpiod, level, + NULL, NULL); + led_dat->blinking = 0; + } else { + if (led_dat->can_sleep) + gpiod_set_value_cansleep(led_dat->gpiod, level); + else + gpiod_set_value(led_dat->gpiod, level); + } +} + +static int gpio_led_set_blocking(struct led_classdev *led_cdev, + enum led_brightness value) +{ + gpio_led_set(led_cdev, value); + return 0; +} + +static int gpio_blink_set(struct led_classdev *led_cdev, + unsigned long *delay_on, unsigned long *delay_off) +{ + struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev); + + led_dat->blinking = 1; + return led_dat->platform_gpio_blink_set(led_dat->gpiod, GPIO_LED_BLINK, + delay_on, delay_off); +} + +static int create_gpio_led(const struct gpio_led *template, + struct gpio_led_data *led_dat, struct device *parent, + struct fwnode_handle *fwnode, gpio_blink_set_t blink_set) +{ + struct led_init_data init_data = {}; + struct pinctrl *pinctrl; + int ret, state; + + led_dat->cdev.default_trigger = template->default_trigger; + led_dat->can_sleep = gpiod_cansleep(led_dat->gpiod); + if (!led_dat->can_sleep) + led_dat->cdev.brightness_set = gpio_led_set; + else + led_dat->cdev.brightness_set_blocking = gpio_led_set_blocking; + led_dat->blinking = 0; + if (blink_set) { + led_dat->platform_gpio_blink_set = blink_set; + led_dat->cdev.blink_set = gpio_blink_set; + } + if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP) { + state = gpiod_get_value_cansleep(led_dat->gpiod); + if (state < 0) + return state; + } else { + state = (template->default_state == LEDS_GPIO_DEFSTATE_ON); + } + led_dat->cdev.brightness = state; + led_dat->cdev.max_brightness = 1; + if (!template->retain_state_suspended) + led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME; + if (template->panic_indicator) + led_dat->cdev.flags |= LED_PANIC_INDICATOR; + if (template->retain_state_shutdown) + led_dat->cdev.flags |= LED_RETAIN_AT_SHUTDOWN; + + ret = gpiod_direction_output(led_dat->gpiod, state); + if (ret < 0) + return ret; + + if (template->name) { + led_dat->cdev.name = template->name; + ret = devm_led_classdev_register(parent, &led_dat->cdev); + } else { + init_data.fwnode = fwnode; + ret = devm_led_classdev_register_ext(parent, &led_dat->cdev, + &init_data); + } + + if (ret) + return ret; + + pinctrl = devm_pinctrl_get_select_default(led_dat->cdev.dev); + ret = PTR_ERR_OR_ZERO(pinctrl); + /* pinctrl-%d not present, not an error */ + if (ret == -ENODEV) + ret = 0; + if (ret) { + dev_warn(led_dat->cdev.dev, "Failed to select %pfw pinctrl: %d\n", + fwnode, ret); + } + + return ret; +} + +struct gpio_leds_priv { + int num_leds; + struct gpio_led_data leds[] __counted_by(num_leds); +}; + +static struct gpio_leds_priv *gpio_leds_create(struct device *dev) +{ + struct gpio_leds_priv *priv; + int count, used, ret; + + count = device_get_child_node_count(dev); + if (!count) + return ERR_PTR(-ENODEV); + + priv = devm_kzalloc(dev, struct_size(priv, leds, count), GFP_KERNEL); + if (!priv) + return ERR_PTR(-ENOMEM); + priv->num_leds = count; + used = 0; + + device_for_each_child_node_scoped(dev, child) { + struct gpio_led_data *led_dat = &priv->leds[used]; + struct gpio_led led = {}; + + /* + * Acquire gpiod from DT with uninitialized label, which + * will be updated after LED class device is registered, + * Only then the final LED name is known. + */ + led.gpiod = devm_fwnode_gpiod_get(dev, child, NULL, GPIOD_ASIS, + NULL); + if (IS_ERR(led.gpiod)) { + dev_err_probe(dev, PTR_ERR(led.gpiod), "Failed to get GPIO '%pfw'\n", + child); + return ERR_CAST(led.gpiod); + } + + led_dat->gpiod = led.gpiod; + + led.default_state = led_init_default_state_get(child); + + if (fwnode_property_present(child, "retain-state-suspended")) + led.retain_state_suspended = 1; + if (fwnode_property_present(child, "retain-state-shutdown")) + led.retain_state_shutdown = 1; + if (fwnode_property_present(child, "panic-indicator")) + led.panic_indicator = 1; + + ret = create_gpio_led(&led, led_dat, dev, child, NULL); + if (ret < 0) + return ERR_PTR(ret); + + /* Set gpiod label to match the corresponding LED name. */ + gpiod_set_consumer_name(led_dat->gpiod, + led_dat->cdev.dev->kobj.name); + used++; + } + priv->num_leds = used; + + return priv; +} + +static const struct of_device_id of_gpio_leds_match[] = { + { .compatible = "gpio-leds", }, + {}, +}; + +MODULE_DEVICE_TABLE(of, of_gpio_leds_match); + +static struct gpio_desc *gpio_led_get_gpiod(struct device *dev, int idx, + const struct gpio_led *template) +{ + struct gpio_desc *gpiod; + + /* + * This means the LED does not come from the device tree + * or ACPI, so let's try just getting it by index from the + * device, this will hit the board file, if any and get + * the GPIO from there. + */ + gpiod = devm_gpiod_get_index_optional(dev, NULL, idx, GPIOD_OUT_LOW); + if (IS_ERR(gpiod)) + return gpiod; + + gpiod_set_consumer_name(gpiod, template->name); + return gpiod; +} + +#ifdef CONFIG_GPIOLIB_LEGACY +/* + * This is the legacy code path for platform code that still uses + * GPIO numbers, mainly MIPS and SuperH board files. + * Ultimately we would like to get rid of this block completely. + * + * ppc44x-warp sets the template->gpiod directly instead of + * adding a lookup table or device properties. This is not + * much better. + */ +static struct gpio_desc *gpio_led_get_legacy_gpiod(struct device *dev, int idx, + const struct gpio_led *template) +{ + struct gpio_desc *gpiod; + int ret; + + if (template->gpiod) + return template->gpiod; + + /* skip leds that aren't available */ + if (!gpio_is_valid(template->gpio)) + return ERR_PTR(-ENOENT); + + ret = devm_gpio_request_one(dev, template->gpio, GPIOF_OUT_INIT_LOW, + template->name); + if (ret < 0) + return ERR_PTR(ret); + + gpiod = gpio_to_desc(template->gpio); + if (!gpiod) + return ERR_PTR(-EINVAL); + + if (template->active_low ^ gpiod_is_active_low(gpiod)) + gpiod_toggle_active_low(gpiod); + + return gpiod; +} +#else +static struct gpio_desc *gpio_led_get_legacy_gpiod(struct device *dev, int idx, + const struct gpio_led *template) +{ + return template->gpiod ?: ERR_PTR(-ENOENT); +} +#endif + +static int gpio_led_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct gpio_led_platform_data *pdata = dev_get_platdata(dev); + struct gpio_leds_priv *priv; + int i, ret; + + if (pdata && pdata->num_leds) { + priv = devm_kzalloc(dev, struct_size(priv, leds, pdata->num_leds), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->num_leds = pdata->num_leds; + for (i = 0; i < priv->num_leds; i++) { + const struct gpio_led *template = &pdata->leds[i]; + struct gpio_led_data *led_dat = &priv->leds[i]; + + led_dat->gpiod = gpio_led_get_gpiod(dev, i, template); + if (!led_dat->gpiod) + led_dat->gpiod = + gpio_led_get_legacy_gpiod(dev, i, template); + if (IS_ERR(led_dat->gpiod)) { + dev_info(dev, "Skipping unavailable LED gpio %s\n", + template->name); + led_dat->gpiod = NULL; + continue; + } + + ret = create_gpio_led(template, led_dat, dev, NULL, + pdata->gpio_blink_set); + if (ret < 0) + return ret; + } + } else { + priv = gpio_leds_create(dev); + if (IS_ERR(priv)) + return PTR_ERR(priv); + } + + platform_set_drvdata(pdev, priv); + + return 0; +} + +static void gpio_led_shutdown(struct platform_device *pdev) +{ + struct gpio_leds_priv *priv = platform_get_drvdata(pdev); + int i; + + for (i = 0; i < priv->num_leds; i++) { + struct gpio_led_data *led = &priv->leds[i]; + + if (!(led->cdev.flags & LED_RETAIN_AT_SHUTDOWN)) + gpio_led_set(&led->cdev, LED_OFF); + } +} + +static struct platform_driver gpio_led_driver = { + .probe = gpio_led_probe, + .shutdown = gpio_led_shutdown, + .driver = { + .name = "leds-gpio", + .of_match_table = of_gpio_leds_match, + }, +}; + +module_platform_driver(gpio_led_driver); + +MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>"); +MODULE_DESCRIPTION("GPIO LED driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:leds-gpio"); |