334 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * LEDs driver for GPIOs4 *5 * Copyright (C) 2007 8D Technologies inc.6 * Raphael Assenat <raph@8d.com>7 * Copyright (C) 2008 Freescale Semiconductor, Inc.8 */9#include <linux/container_of.h>10#include <linux/device.h>11#include <linux/err.h>12#include <linux/gpio.h>13#include <linux/gpio/consumer.h>14#include <linux/leds.h>15#include <linux/mod_devicetable.h>16#include <linux/module.h>17#include <linux/overflow.h>18#include <linux/pinctrl/consumer.h>19#include <linux/platform_device.h>20#include <linux/property.h>21#include <linux/slab.h>22#include <linux/types.h>23 24#include "leds.h"25 26struct gpio_led_data {27 struct led_classdev cdev;28 struct gpio_desc *gpiod;29 u8 can_sleep;30 u8 blinking;31 gpio_blink_set_t platform_gpio_blink_set;32};33 34static inline struct gpio_led_data *35 cdev_to_gpio_led_data(struct led_classdev *led_cdev)36{37 return container_of(led_cdev, struct gpio_led_data, cdev);38}39 40static void gpio_led_set(struct led_classdev *led_cdev,41 enum led_brightness value)42{43 struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev);44 int level;45 46 if (value == LED_OFF)47 level = 0;48 else49 level = 1;50 51 if (led_dat->blinking) {52 led_dat->platform_gpio_blink_set(led_dat->gpiod, level,53 NULL, NULL);54 led_dat->blinking = 0;55 } else {56 if (led_dat->can_sleep)57 gpiod_set_value_cansleep(led_dat->gpiod, level);58 else59 gpiod_set_value(led_dat->gpiod, level);60 }61}62 63static int gpio_led_set_blocking(struct led_classdev *led_cdev,64 enum led_brightness value)65{66 gpio_led_set(led_cdev, value);67 return 0;68}69 70static int gpio_blink_set(struct led_classdev *led_cdev,71 unsigned long *delay_on, unsigned long *delay_off)72{73 struct gpio_led_data *led_dat = cdev_to_gpio_led_data(led_cdev);74 75 led_dat->blinking = 1;76 return led_dat->platform_gpio_blink_set(led_dat->gpiod, GPIO_LED_BLINK,77 delay_on, delay_off);78}79 80static int create_gpio_led(const struct gpio_led *template,81 struct gpio_led_data *led_dat, struct device *parent,82 struct fwnode_handle *fwnode, gpio_blink_set_t blink_set)83{84 struct led_init_data init_data = {};85 struct pinctrl *pinctrl;86 int ret, state;87 88 led_dat->cdev.default_trigger = template->default_trigger;89 led_dat->can_sleep = gpiod_cansleep(led_dat->gpiod);90 if (!led_dat->can_sleep)91 led_dat->cdev.brightness_set = gpio_led_set;92 else93 led_dat->cdev.brightness_set_blocking = gpio_led_set_blocking;94 led_dat->blinking = 0;95 if (blink_set) {96 led_dat->platform_gpio_blink_set = blink_set;97 led_dat->cdev.blink_set = gpio_blink_set;98 }99 if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP) {100 state = gpiod_get_value_cansleep(led_dat->gpiod);101 if (state < 0)102 return state;103 } else {104 state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);105 }106 led_dat->cdev.brightness = state;107 led_dat->cdev.max_brightness = 1;108 if (!template->retain_state_suspended)109 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;110 if (template->panic_indicator)111 led_dat->cdev.flags |= LED_PANIC_INDICATOR;112 if (template->retain_state_shutdown)113 led_dat->cdev.flags |= LED_RETAIN_AT_SHUTDOWN;114 115 ret = gpiod_direction_output(led_dat->gpiod, state);116 if (ret < 0)117 return ret;118 119 if (template->name) {120 led_dat->cdev.name = template->name;121 ret = devm_led_classdev_register(parent, &led_dat->cdev);122 } else {123 init_data.fwnode = fwnode;124 ret = devm_led_classdev_register_ext(parent, &led_dat->cdev,125 &init_data);126 }127 128 if (ret)129 return ret;130 131 pinctrl = devm_pinctrl_get_select_default(led_dat->cdev.dev);132 ret = PTR_ERR_OR_ZERO(pinctrl);133 /* pinctrl-%d not present, not an error */134 if (ret == -ENODEV)135 ret = 0;136 if (ret) {137 dev_warn(led_dat->cdev.dev, "Failed to select %pfw pinctrl: %d\n",138 fwnode, ret);139 }140 141 return ret;142}143 144struct gpio_leds_priv {145 int num_leds;146 struct gpio_led_data leds[] __counted_by(num_leds);147};148 149static struct gpio_leds_priv *gpio_leds_create(struct device *dev)150{151 struct fwnode_handle *child;152 struct gpio_leds_priv *priv;153 int count, used, ret;154 155 count = device_get_child_node_count(dev);156 if (!count)157 return ERR_PTR(-ENODEV);158 159 priv = devm_kzalloc(dev, struct_size(priv, leds, count), GFP_KERNEL);160 if (!priv)161 return ERR_PTR(-ENOMEM);162 priv->num_leds = count;163 used = 0;164 165 device_for_each_child_node(dev, child) {166 struct gpio_led_data *led_dat = &priv->leds[used];167 struct gpio_led led = {};168 169 /*170 * Acquire gpiod from DT with uninitialized label, which171 * will be updated after LED class device is registered,172 * Only then the final LED name is known.173 */174 led.gpiod = devm_fwnode_gpiod_get(dev, child, NULL, GPIOD_ASIS,175 NULL);176 if (IS_ERR(led.gpiod)) {177 dev_err_probe(dev, PTR_ERR(led.gpiod), "Failed to get GPIO '%pfw'\n",178 child);179 fwnode_handle_put(child);180 return ERR_CAST(led.gpiod);181 }182 183 led_dat->gpiod = led.gpiod;184 185 led.default_state = led_init_default_state_get(child);186 187 if (fwnode_property_present(child, "retain-state-suspended"))188 led.retain_state_suspended = 1;189 if (fwnode_property_present(child, "retain-state-shutdown"))190 led.retain_state_shutdown = 1;191 if (fwnode_property_present(child, "panic-indicator"))192 led.panic_indicator = 1;193 194 ret = create_gpio_led(&led, led_dat, dev, child, NULL);195 if (ret < 0) {196 fwnode_handle_put(child);197 return ERR_PTR(ret);198 }199 /* Set gpiod label to match the corresponding LED name. */200 gpiod_set_consumer_name(led_dat->gpiod,201 led_dat->cdev.dev->kobj.name);202 used++;203 }204 priv->num_leds = used;205 206 return priv;207}208 209static const struct of_device_id of_gpio_leds_match[] = {210 { .compatible = "gpio-leds", },211 {},212};213 214MODULE_DEVICE_TABLE(of, of_gpio_leds_match);215 216static struct gpio_desc *gpio_led_get_gpiod(struct device *dev, int idx,217 const struct gpio_led *template)218{219 struct gpio_desc *gpiod;220 unsigned long flags = GPIOF_OUT_INIT_LOW;221 int ret;222 223 /*224 * This means the LED does not come from the device tree225 * or ACPI, so let's try just getting it by index from the226 * device, this will hit the board file, if any and get227 * the GPIO from there.228 */229 gpiod = devm_gpiod_get_index_optional(dev, NULL, idx, GPIOD_OUT_LOW);230 if (IS_ERR(gpiod))231 return gpiod;232 if (gpiod) {233 gpiod_set_consumer_name(gpiod, template->name);234 return gpiod;235 }236 237 /*238 * This is the legacy code path for platform code that239 * still uses GPIO numbers. Ultimately we would like to get240 * rid of this block completely.241 */242 243 /* skip leds that aren't available */244 if (!gpio_is_valid(template->gpio))245 return ERR_PTR(-ENOENT);246 247 if (template->active_low)248 flags |= GPIOF_ACTIVE_LOW;249 250 ret = devm_gpio_request_one(dev, template->gpio, flags,251 template->name);252 if (ret < 0)253 return ERR_PTR(ret);254 255 gpiod = gpio_to_desc(template->gpio);256 if (!gpiod)257 return ERR_PTR(-EINVAL);258 259 return gpiod;260}261 262static int gpio_led_probe(struct platform_device *pdev)263{264 struct device *dev = &pdev->dev;265 struct gpio_led_platform_data *pdata = dev_get_platdata(dev);266 struct gpio_leds_priv *priv;267 int i, ret;268 269 if (pdata && pdata->num_leds) {270 priv = devm_kzalloc(dev, struct_size(priv, leds, pdata->num_leds), GFP_KERNEL);271 if (!priv)272 return -ENOMEM;273 274 priv->num_leds = pdata->num_leds;275 for (i = 0; i < priv->num_leds; i++) {276 const struct gpio_led *template = &pdata->leds[i];277 struct gpio_led_data *led_dat = &priv->leds[i];278 279 if (template->gpiod)280 led_dat->gpiod = template->gpiod;281 else282 led_dat->gpiod =283 gpio_led_get_gpiod(dev, i, template);284 if (IS_ERR(led_dat->gpiod)) {285 dev_info(dev, "Skipping unavailable LED gpio %d (%s)\n",286 template->gpio, template->name);287 continue;288 }289 290 ret = create_gpio_led(template, led_dat, dev, NULL,291 pdata->gpio_blink_set);292 if (ret < 0)293 return ret;294 }295 } else {296 priv = gpio_leds_create(dev);297 if (IS_ERR(priv))298 return PTR_ERR(priv);299 }300 301 platform_set_drvdata(pdev, priv);302 303 return 0;304}305 306static void gpio_led_shutdown(struct platform_device *pdev)307{308 struct gpio_leds_priv *priv = platform_get_drvdata(pdev);309 int i;310 311 for (i = 0; i < priv->num_leds; i++) {312 struct gpio_led_data *led = &priv->leds[i];313 314 if (!(led->cdev.flags & LED_RETAIN_AT_SHUTDOWN))315 gpio_led_set(&led->cdev, LED_OFF);316 }317}318 319static struct platform_driver gpio_led_driver = {320 .probe = gpio_led_probe,321 .shutdown = gpio_led_shutdown,322 .driver = {323 .name = "leds-gpio",324 .of_match_table = of_gpio_leds_match,325 },326};327 328module_platform_driver(gpio_led_driver);329 330MODULE_AUTHOR("Raphael Assenat <raph@8d.com>, Trent Piepho <tpiepho@freescale.com>");331MODULE_DESCRIPTION("GPIO LED driver");332MODULE_LICENSE("GPL");333MODULE_ALIAS("platform:leds-gpio");334