drivers/leds/leds-gpio.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * LEDs driver for GPIOs
0004  *
0005  * Copyright (C) 2007 8D Technologies inc.
0006  * Raphael Assenat <raph@8d.com>
0007  * Copyright (C) 2008 Freescale Semiconductor, Inc.
0008  */
0009 #include <linux/err.h>
0010 #include <linux/gpio.h>
0011 #include <linux/gpio/consumer.h>
0012 #include <linux/kernel.h>
0013 #include <linux/leds.h>
0014 #include <linux/module.h>
0015 #include <linux/of.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/property.h>
0018 #include <linux/slab.h>
0019 #include "leds.h"
0020
0021 struct gpio_led_data {
0022     struct led_classdev cdev;
0023     struct gpio_desc *gpiod;
0024     u8 can_sleep;
0025     u8 blinking;
0026     gpio_blink_set_t platform_gpio_blink_set;
0027 };
0028
0029 static inline struct gpio_led_data *
0030             cdev_to_gpio_led_data(struct led_classdev *led_cdev)
0031 {
0032     return container_of(led_cdev, struct gpio_led_data, cdev);
0033 }
0034
0035 static void gpio_led_set(struct led_classdev *led_cdev,
0036     enum led_brightness value)
0037 {
0038     struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev);
0039     int level;
0040
0041     if (value == LED_OFF)
0042         level = 0;
0043     else
0044         level = 1;
0045
0046     if (led_dat->blinking) {
0047         led_dat->platform_gpio_blink_set(led_dat->gpiod, level,
0048                          NULL, NULL);
0049         led_dat->blinking = 0;
0050     } else {
0051         if (led_dat->can_sleep)
0052             gpiod_set_value_cansleep(led_dat->gpiod, level);
0053         else
0054             gpiod_set_value(led_dat->gpiod, level);
0055     }
0056 }
0057
0058 static int gpio_led_set_blocking(struct led_classdev *led_cdev,
0059     enum led_brightness value)
0060 {
0061     gpio_led_set(led_cdev, value);
0062     return 0;
0063 }
0064
0065 static int gpio_blink_set(struct led_classdev *led_cdev,
0066     unsigned long *delay_on, unsigned long *delay_off)
0067 {
0068     struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev);
0069
0070     led_dat->blinking = 1;
0071     return led_dat->platform_gpio_blink_set(led_dat->gpiod, GPIO_LED_BLINK,
0072                         delay_on, delay_off);
0073 }
0074
0075 static int create_gpio_led(const struct gpio_led *template,
0076     struct gpio_led_data *led_dat, struct device *parent,
0077     struct fwnode_handle *fwnode, gpio_blink_set_t blink_set)
0078 {
0079     struct led_init_data init_data = {};
0080     int ret, state;
0081
0082     led_dat->cdev.default_trigger = template->default_trigger;
0083     led_dat->can_sleep = gpiod_cansleep(led_dat->gpiod);
0084     if (!led_dat->can_sleep)
0085         led_dat->cdev.brightness_set = gpio_led_set;
0086     else
0087         led_dat->cdev.brightness_set_blocking = gpio_led_set_blocking;
0088     led_dat->blinking = 0;
0089     if (blink_set) {
0090         led_dat->platform_gpio_blink_set = blink_set;
0091         led_dat->cdev.blink_set = gpio_blink_set;
0092     }
0093     if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP) {
0094         state = gpiod_get_value_cansleep(led_dat->gpiod);
0095         if (state < 0)
0096             return state;
0097     } else {
0098         state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
0099     }
0100     led_dat->cdev.brightness = state;
0101     led_dat->cdev.max_brightness = 1;
0102     if (!template->retain_state_suspended)
0103         led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
0104     if (template->panic_indicator)
0105         led_dat->cdev.flags |= LED_PANIC_INDICATOR;
0106     if (template->retain_state_shutdown)
0107         led_dat->cdev.flags |= LED_RETAIN_AT_SHUTDOWN;
0108
0109     ret = gpiod_direction_output(led_dat->gpiod, state);
0110     if (ret < 0)
0111         return ret;
0112
0113     if (template->name) {
0114         led_dat->cdev.name = template->name;
0115         ret = devm_led_classdev_register(parent, &led_dat->cdev);
0116     } else {
0117         init_data.fwnode = fwnode;
0118         ret = devm_led_classdev_register_ext(parent, &led_dat->cdev,
0119                              &init_data);
0120     }
0121
0122     return ret;
0123 }
0124
0125 struct gpio_leds_priv {
0126     int num_leds;
0127     struct gpio_led_data leds[];
0128 };
0129
0130 static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
0131 {
0132     struct device *dev = &pdev->dev;
0133     struct fwnode_handle *child;
0134     struct gpio_leds_priv *priv;
0135     int count, ret;
0136
0137     count = device_get_child_node_count(dev);
0138     if (!count)
0139         return ERR_PTR(-ENODEV);
0140
0141     priv = devm_kzalloc(dev, struct_size(priv, leds, count), GFP_KERNEL);
0142     if (!priv)
0143         return ERR_PTR(-ENOMEM);
0144
0145     device_for_each_child_node(dev, child) {
0146         struct gpio_led_data *led_dat = &priv->leds[priv->num_leds];
0147         struct gpio_led led = {};
0148
0149         /*
0150          * Acquire gpiod from DT with uninitialized label, which
0151          * will be updated after LED class device is registered,
0152          * Only then the final LED name is known.
0153          */
0154         led.gpiod = devm_fwnode_get_gpiod_from_child(dev, NULL, child,
0155                                  GPIOD_ASIS,
0156                                  NULL);
0157         if (IS_ERR(led.gpiod)) {
0158             fwnode_handle_put(child);
0159             return ERR_CAST(led.gpiod);
0160         }
0161
0162         led_dat->gpiod = led.gpiod;
0163
0164         led.default_state = led_init_default_state_get(child);
0165
0166         if (fwnode_property_present(child, "retain-state-suspended"))
0167             led.retain_state_suspended = 1;
0168         if (fwnode_property_present(child, "retain-state-shutdown"))
0169             led.retain_state_shutdown = 1;
0170         if (fwnode_property_present(child, "panic-indicator"))
0171             led.panic_indicator = 1;
0172
0173         ret = create_gpio_led(&led, led_dat, dev, child, NULL);
0174         if (ret < 0) {
0175             fwnode_handle_put(child);
0176             return ERR_PTR(ret);
0177         }
0178         /* Set gpiod label to match the corresponding LED name. */
0179         gpiod_set_consumer_name(led_dat->gpiod,
0180                     led_dat->cdev.dev->kobj.name);
0181         priv->num_leds++;
0182     }
0183
0184     return priv;
0185 }
0186
0187 static const struct of_device_id of_gpio_leds_match[] = {
0188     { .compatible = "gpio-leds", },
0189     {},
0190 };
0191
0192 MODULE_DEVICE_TABLE(of, of_gpio_leds_match);
0193
0194 static struct gpio_desc *gpio_led_get_gpiod(struct device *dev, int idx,
0195                         const struct gpio_led *template)
0196 {
0197     struct gpio_desc *gpiod;
0198     unsigned long flags = GPIOF_OUT_INIT_LOW;
0199     int ret;
0200
0201     /*
0202      * This means the LED does not come from the device tree
0203      * or ACPI, so let's try just getting it by index from the
0204      * device, this will hit the board file, if any and get
0205      * the GPIO from there.
0206      */
0207     gpiod = devm_gpiod_get_index(dev, NULL, idx, GPIOD_OUT_LOW);
0208     if (!IS_ERR(gpiod)) {
0209         gpiod_set_consumer_name(gpiod, template->name);
0210         return gpiod;
0211     }
0212     if (PTR_ERR(gpiod) != -ENOENT)
0213         return gpiod;
0214
0215     /*
0216      * This is the legacy code path for platform code that
0217      * still uses GPIO numbers. Ultimately we would like to get
0218      * rid of this block completely.
0219      */
0220
0221     /* skip leds that aren't available */
0222     if (!gpio_is_valid(template->gpio))
0223         return ERR_PTR(-ENOENT);
0224
0225     if (template->active_low)
0226         flags |= GPIOF_ACTIVE_LOW;
0227
0228     ret = devm_gpio_request_one(dev, template->gpio, flags,
0229                     template->name);
0230     if (ret < 0)
0231         return ERR_PTR(ret);
0232
0233     gpiod = gpio_to_desc(template->gpio);
0234     if (!gpiod)
0235         return ERR_PTR(-EINVAL);
0236
0237     return gpiod;
0238 }
0239
0240 static int gpio_led_probe(struct platform_device *pdev)
0241 {
0242     struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
0243     struct gpio_leds_priv *priv;
0244     int i, ret = 0;
0245
0246     if (pdata && pdata->num_leds) {
0247         priv = devm_kzalloc(&pdev->dev, struct_size(priv, leds, pdata->num_leds),
0248                     GFP_KERNEL);
0249         if (!priv)
0250             return -ENOMEM;
0251
0252         priv->num_leds = pdata->num_leds;
0253         for (i = 0; i < priv->num_leds; i++) {
0254             const struct gpio_led *template = &pdata->leds[i];
0255             struct gpio_led_data *led_dat = &priv->leds[i];
0256
0257             if (template->gpiod)
0258                 led_dat->gpiod = template->gpiod;
0259             else
0260                 led_dat->gpiod =
0261                     gpio_led_get_gpiod(&pdev->dev,
0262                                i, template);
0263             if (IS_ERR(led_dat->gpiod)) {
0264                 dev_info(&pdev->dev, "Skipping unavailable LED gpio %d (%s)\n",
0265                      template->gpio, template->name);
0266                 continue;
0267             }
0268
0269             ret = create_gpio_led(template, led_dat,
0270                           &pdev->dev, NULL,
0271                           pdata->gpio_blink_set);
0272             if (ret < 0)
0273                 return ret;
0274         }
0275     } else {
0276         priv = gpio_leds_create(pdev);
0277         if (IS_ERR(priv))
0278             return PTR_ERR(priv);
0279     }
0280
0281     platform_set_drvdata(pdev, priv);
0282
0283     return 0;
0284 }
0285
0286 static void gpio_led_shutdown(struct platform_device *pdev)
0287 {
0288     struct gpio_leds_priv *priv = platform_get_drvdata(pdev);
0289     int i;
0290
0291     for (i = 0; i < priv->num_leds; i++) {
0292         struct gpio_led_data *led = &priv->leds[i];
0293
0294         if (!(led->cdev.flags & LED_RETAIN_AT_SHUTDOWN))
0295             gpio_led_set(&led->cdev, LED_OFF);
0296     }
0297 }
0298
0299 static struct platform_driver gpio_led_driver = {
0300     .probe      = gpio_led_probe,
0301     .shutdown   = gpio_led_shutdown,
0302     .driver     = {
0303         .name   = "leds-gpio",
0304         .of_match_table = of_gpio_leds_match,
0305     },
0306 };
0307
0308 module_platform_driver(gpio_led_driver);
0309
0310 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");
0311 MODULE_DESCRIPTION("GPIO LED driver");
0312 MODULE_LICENSE("GPL");
0313 MODULE_ALIAS("platform:leds-gpio");