
GPIO descriptors are the preferred way over legacy GPIO numbers nowadays. Convert the driver to use GPIO descriptors internally but still allow passing legacy GPIO numbers from platform data to support existing platforms. Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com> Acked-by: Alexandre Courbot <acourbot@nvidia.com> Acked-by: Bryan Wu <cooloney@gmail.com> Acked-by: Arnd Bergmann <arnd@arndb.de> Acked-by: Grant Likely <grant.likely@linaro.org> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
311 lines
7.9 KiB
C
311 lines
7.9 KiB
C
/*
|
|
* LEDs driver for GPIOs
|
|
*
|
|
* Copyright (C) 2007 8D Technologies inc.
|
|
* Raphael Assenat <raph@8d.com>
|
|
* Copyright (C) 2008 Freescale Semiconductor, Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
*/
|
|
#include <linux/err.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/leds.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/workqueue.h>
|
|
|
|
struct gpio_led_data {
|
|
struct led_classdev cdev;
|
|
struct gpio_desc *gpiod;
|
|
struct work_struct work;
|
|
u8 new_level;
|
|
u8 can_sleep;
|
|
u8 blinking;
|
|
int (*platform_gpio_blink_set)(unsigned gpio, int state,
|
|
unsigned long *delay_on, unsigned long *delay_off);
|
|
};
|
|
|
|
static void gpio_led_work(struct work_struct *work)
|
|
{
|
|
struct gpio_led_data *led_dat =
|
|
container_of(work, struct gpio_led_data, work);
|
|
|
|
if (led_dat->blinking) {
|
|
int gpio = desc_to_gpio(led_dat->gpiod);
|
|
int level = led_dat->new_level;
|
|
|
|
if (gpiod_is_active_low(led_dat->gpiod))
|
|
level = !level;
|
|
|
|
led_dat->platform_gpio_blink_set(gpio, level, NULL, NULL);
|
|
led_dat->blinking = 0;
|
|
} else
|
|
gpiod_set_value_cansleep(led_dat->gpiod, led_dat->new_level);
|
|
}
|
|
|
|
static void gpio_led_set(struct led_classdev *led_cdev,
|
|
enum led_brightness value)
|
|
{
|
|
struct gpio_led_data *led_dat =
|
|
container_of(led_cdev, struct gpio_led_data, cdev);
|
|
int level;
|
|
|
|
if (value == LED_OFF)
|
|
level = 0;
|
|
else
|
|
level = 1;
|
|
|
|
/* Setting GPIOs with I2C/etc requires a task context, and we don't
|
|
* seem to have a reliable way to know if we're already in one; so
|
|
* let's just assume the worst.
|
|
*/
|
|
if (led_dat->can_sleep) {
|
|
led_dat->new_level = level;
|
|
schedule_work(&led_dat->work);
|
|
} else {
|
|
if (led_dat->blinking) {
|
|
int gpio = desc_to_gpio(led_dat->gpiod);
|
|
|
|
if (gpiod_is_active_low(led_dat->gpiod))
|
|
level = !level;
|
|
|
|
led_dat->platform_gpio_blink_set(gpio, level, NULL,
|
|
NULL);
|
|
led_dat->blinking = 0;
|
|
} else
|
|
gpiod_set_value(led_dat->gpiod, level);
|
|
}
|
|
}
|
|
|
|
static int gpio_blink_set(struct led_classdev *led_cdev,
|
|
unsigned long *delay_on, unsigned long *delay_off)
|
|
{
|
|
struct gpio_led_data *led_dat =
|
|
container_of(led_cdev, struct gpio_led_data, cdev);
|
|
int gpio = desc_to_gpio(led_dat->gpiod);
|
|
|
|
led_dat->blinking = 1;
|
|
return led_dat->platform_gpio_blink_set(gpio, 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,
|
|
int (*blink_set)(unsigned, int, unsigned long *, unsigned long *))
|
|
{
|
|
int ret, state;
|
|
|
|
if (!template->gpiod) {
|
|
unsigned long flags = 0;
|
|
|
|
/* skip leds that aren't available */
|
|
if (!gpio_is_valid(template->gpio)) {
|
|
dev_info(parent, "Skipping unavailable LED gpio %d (%s)\n",
|
|
template->gpio, template->name);
|
|
return 0;
|
|
}
|
|
|
|
if (template->active_low)
|
|
flags |= GPIOF_ACTIVE_LOW;
|
|
|
|
ret = devm_gpio_request_one(parent, template->gpio, flags,
|
|
template->name);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
led_dat->gpiod = gpio_to_desc(template->gpio);
|
|
if (IS_ERR(led_dat->gpiod))
|
|
return PTR_ERR(led_dat->gpiod);
|
|
}
|
|
|
|
led_dat->cdev.name = template->name;
|
|
led_dat->cdev.default_trigger = template->default_trigger;
|
|
led_dat->gpiod = template->gpiod;
|
|
led_dat->can_sleep = gpiod_cansleep(template->gpiod);
|
|
led_dat->blinking = 0;
|
|
if (blink_set) {
|
|
led_dat->platform_gpio_blink_set = blink_set;
|
|
led_dat->cdev.blink_set = gpio_blink_set;
|
|
}
|
|
led_dat->cdev.brightness_set = gpio_led_set;
|
|
if (template->default_state == LEDS_GPIO_DEFSTATE_KEEP)
|
|
state = !!gpiod_get_value_cansleep(led_dat->gpiod);
|
|
else
|
|
state = (template->default_state == LEDS_GPIO_DEFSTATE_ON);
|
|
led_dat->cdev.brightness = state ? LED_FULL : LED_OFF;
|
|
if (!template->retain_state_suspended)
|
|
led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
|
|
|
|
ret = gpiod_direction_output(led_dat->gpiod, state);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
INIT_WORK(&led_dat->work, gpio_led_work);
|
|
|
|
return led_classdev_register(parent, &led_dat->cdev);
|
|
}
|
|
|
|
static void delete_gpio_led(struct gpio_led_data *led)
|
|
{
|
|
led_classdev_unregister(&led->cdev);
|
|
cancel_work_sync(&led->work);
|
|
}
|
|
|
|
struct gpio_leds_priv {
|
|
int num_leds;
|
|
struct gpio_led_data leds[];
|
|
};
|
|
|
|
static inline int sizeof_gpio_leds_priv(int num_leds)
|
|
{
|
|
return sizeof(struct gpio_leds_priv) +
|
|
(sizeof(struct gpio_led_data) * num_leds);
|
|
}
|
|
|
|
/* Code to create from OpenFirmware platform devices */
|
|
#ifdef CONFIG_OF_GPIO
|
|
static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
|
|
{
|
|
struct device_node *np = pdev->dev.of_node, *child;
|
|
struct gpio_leds_priv *priv;
|
|
int count, ret;
|
|
|
|
/* count LEDs in this device, so we know how much to allocate */
|
|
count = of_get_available_child_count(np);
|
|
if (!count)
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
for_each_available_child_of_node(np, child)
|
|
if (of_get_gpio(child, 0) == -EPROBE_DEFER)
|
|
return ERR_PTR(-EPROBE_DEFER);
|
|
|
|
priv = devm_kzalloc(&pdev->dev, sizeof_gpio_leds_priv(count),
|
|
GFP_KERNEL);
|
|
if (!priv)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
for_each_available_child_of_node(np, child) {
|
|
struct gpio_led led = {};
|
|
enum of_gpio_flags flags;
|
|
const char *state;
|
|
|
|
led.gpio = of_get_gpio_flags(child, 0, &flags);
|
|
led.active_low = flags & OF_GPIO_ACTIVE_LOW;
|
|
led.name = of_get_property(child, "label", NULL) ? : child->name;
|
|
led.default_trigger =
|
|
of_get_property(child, "linux,default-trigger", NULL);
|
|
state = of_get_property(child, "default-state", NULL);
|
|
if (state) {
|
|
if (!strcmp(state, "keep"))
|
|
led.default_state = LEDS_GPIO_DEFSTATE_KEEP;
|
|
else if (!strcmp(state, "on"))
|
|
led.default_state = LEDS_GPIO_DEFSTATE_ON;
|
|
else
|
|
led.default_state = LEDS_GPIO_DEFSTATE_OFF;
|
|
}
|
|
|
|
if (of_get_property(child, "retain-state-suspended", NULL))
|
|
led.retain_state_suspended = 1;
|
|
|
|
ret = create_gpio_led(&led, &priv->leds[priv->num_leds++],
|
|
&pdev->dev, NULL);
|
|
if (ret < 0) {
|
|
of_node_put(child);
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
return priv;
|
|
|
|
err:
|
|
for (count = priv->num_leds - 2; count >= 0; count--)
|
|
delete_gpio_led(&priv->leds[count]);
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
|
|
static const struct of_device_id of_gpio_leds_match[] = {
|
|
{ .compatible = "gpio-leds", },
|
|
{},
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, of_gpio_leds_match);
|
|
#else /* CONFIG_OF_GPIO */
|
|
static struct gpio_leds_priv *gpio_leds_create_of(struct platform_device *pdev)
|
|
{
|
|
return ERR_PTR(-ENODEV);
|
|
}
|
|
#endif /* CONFIG_OF_GPIO */
|
|
|
|
static int gpio_led_probe(struct platform_device *pdev)
|
|
{
|
|
struct gpio_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
|
|
struct gpio_leds_priv *priv;
|
|
int i, ret = 0;
|
|
|
|
if (pdata && pdata->num_leds) {
|
|
priv = devm_kzalloc(&pdev->dev,
|
|
sizeof_gpio_leds_priv(pdata->num_leds),
|
|
GFP_KERNEL);
|
|
if (!priv)
|
|
return -ENOMEM;
|
|
|
|
priv->num_leds = pdata->num_leds;
|
|
for (i = 0; i < priv->num_leds; i++) {
|
|
ret = create_gpio_led(&pdata->leds[i],
|
|
&priv->leds[i],
|
|
&pdev->dev, pdata->gpio_blink_set);
|
|
if (ret < 0) {
|
|
/* On failure: unwind the led creations */
|
|
for (i = i - 1; i >= 0; i--)
|
|
delete_gpio_led(&priv->leds[i]);
|
|
return ret;
|
|
}
|
|
}
|
|
} else {
|
|
priv = gpio_leds_create_of(pdev);
|
|
if (IS_ERR(priv))
|
|
return PTR_ERR(priv);
|
|
}
|
|
|
|
platform_set_drvdata(pdev, priv);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int gpio_led_remove(struct platform_device *pdev)
|
|
{
|
|
struct gpio_leds_priv *priv = platform_get_drvdata(pdev);
|
|
int i;
|
|
|
|
for (i = 0; i < priv->num_leds; i++)
|
|
delete_gpio_led(&priv->leds[i]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver gpio_led_driver = {
|
|
.probe = gpio_led_probe,
|
|
.remove = gpio_led_remove,
|
|
.driver = {
|
|
.name = "leds-gpio",
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = of_match_ptr(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");
|