![Timo Teräs](/assets/img/avatar_default.png)
This reverts commita99d76f
(leds: leds-gpio: use gpio_request_one) and commit2d7c22f
(leds: leds-gpio: set devm_gpio_request_one() flags param correctly) which was a fix of the first one. The conversion to devm_gpio_request in commite3b1d44c
(leds: leds-gpio: use devm_gpio_request_one) is not reverted. The problem is that gpio_cansleep() and gpio_get_value_cansleep() calls can crash if the gpio is not first reserved. Incidentally this same bug existed earlier and was fixed similarly in commitd95cbe61
(leds: Fix potential leds-gpio oops). But the OOPS is real. It happens when GPIOs are provided by module which is not yet loaded. So this fixes the following BUG during my ALIX boot (3.9.2-vanilla): BUG: unable to handle kernel NULL pointer dereference at 0000004c IP: [<c11287d6>] __gpio_cansleep+0xe/0x1a *pde = 00000000 Oops: 0000 [#1] SMP Modules linked in: leds_gpio(+) via_rhine mii cs5535_mfd mfd_core geode_rng rng_core geode_aes isofs nls_utf8 nls_cp437 vfat fat ata_generic pata_amd pata_cs5536 pata_acpi libata ehci_pci ehci_hcd ohci_hcd usb_storage usbcore usb_common sd_mod scsi_mod squashfs loop Pid: 881, comm: modprobe Not tainted 3.9.2 #1-Alpine EIP: 0060:[<c11287d6>] EFLAGS: 00010282 CPU: 0 EIP is at __gpio_cansleep+0xe/0x1a EAX: 00000000 EBX: cf364018 ECX: c132b8b9 EDX: 00000000 ESI: c13993a4 EDI: c1399370 EBP: cded9dbc ESP: cded9dbc DS: 007b ES: 007b FS: 00d8 GS: 0033 SS: 0068 CR0: 8005003b CR2: 0000004c CR3: 0f0c4000 CR4: 00000090 DR0: 00000000 DR1: 00000000 DR2: 00000000 DR3: 00000000 DR6: ffff0ff0 DR7: 00000400 Process modprobe (pid: 881, ti=cded8000 task=cf094aa0 task.ti=cded8000) Stack: cded9de0 d09471cb 00000000 c1399260 cf364014 00000000 c1399260 c1399254 d0949014 cded9df4 c118cd59 c1399260 d0949014 d0949014 cded9e08 c118ba47 c1399260 d0949014 c1399294 cded9e1c c118bb75 cded9e24 d0949014 00000000 Call Trace: [<d09471cb>] gpio_led_probe+0xba/0x203 [leds_gpio] [<c118cd59>] platform_drv_probe+0x26/0x48 [<c118ba47>] driver_probe_device+0x75/0x15c [<c118bb75>] __driver_attach+0x47/0x63 [<c118a727>] bus_for_each_dev+0x3c/0x66 [<c118b6f9>] driver_attach+0x14/0x16 [<c118bb2e>] ? driver_probe_device+0x15c/0x15c [<c118b3d5>] bus_add_driver+0xbd/0x1bc [<d08b4000>] ? 0xd08b3fff [<d08b4000>] ? 0xd08b3fff [<c118bffc>] driver_register+0x74/0xec [<d08b4000>] ? 0xd08b3fff [<c118c8e8>] platform_driver_register+0x38/0x3a [<d08b400d>] gpio_led_driver_init+0xd/0x1000 [leds_gpio] [<c100116c>] do_one_initcall+0x6b/0x10f [<d08b4000>] ? 0xd08b3fff [<c105e918>] load_module+0x1631/0x1907 [<c10975d6>] ? insert_vmalloc_vmlist+0x14/0x43 [<c1098d5b>] ? __vmalloc_node_range+0x13e/0x15f [<c105ec50>] sys_init_module+0x62/0x77 [<c1257888>] syscall_call+0x7/0xb EIP: [<c11287d6>] __gpio_cansleep+0xe/0x1a SS:ESP 0068:cded9dbc CR2: 000000000000004c ---[ end trace 5308fb20d2514822 ]--- Signed-off-by: Timo Teräs <timo.teras@iki.f> Cc: Sachin Kamat <sachin.kamat@linaro.org> Cc: Raphael Assenat <raph@8d.com> Cc: Trent Piepho <tpiepho@freescale.com> Cc: Javier Martinez Canillas <javier.martinez@collabora.co.uk> Cc: Arnaud Patard <arnaud.patard@rtp-net.org> Cc: Ezequiel Garcia <ezequiel.garcia@free-electrons.com> Acked-by: Jingoo Han <jg1.han@samsung.com> Signed-off-by: Bryan Wu <cooloney@gmail.com>
306 lines
7.7 KiB
C
306 lines
7.7 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/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/leds.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/workqueue.h>
|
|
#include <linux/module.h>
|
|
#include <linux/pinctrl/consumer.h>
|
|
#include <linux/err.h>
|
|
|
|
struct gpio_led_data {
|
|
struct led_classdev cdev;
|
|
unsigned gpio;
|
|
struct work_struct work;
|
|
u8 new_level;
|
|
u8 can_sleep;
|
|
u8 active_low;
|
|
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) {
|
|
led_dat->platform_gpio_blink_set(led_dat->gpio,
|
|
led_dat->new_level,
|
|
NULL, NULL);
|
|
led_dat->blinking = 0;
|
|
} else
|
|
gpio_set_value_cansleep(led_dat->gpio, 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;
|
|
|
|
if (led_dat->active_low)
|
|
level = !level;
|
|
|
|
/* 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) {
|
|
led_dat->platform_gpio_blink_set(led_dat->gpio, level,
|
|
NULL, NULL);
|
|
led_dat->blinking = 0;
|
|
} else
|
|
gpio_set_value(led_dat->gpio, 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);
|
|
|
|
led_dat->blinking = 1;
|
|
return led_dat->platform_gpio_blink_set(led_dat->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;
|
|
|
|
led_dat->gpio = -1;
|
|
|
|
/* 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;
|
|
}
|
|
|
|
ret = devm_gpio_request(parent, template->gpio, template->name);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
led_dat->cdev.name = template->name;
|
|
led_dat->cdev.default_trigger = template->default_trigger;
|
|
led_dat->gpio = template->gpio;
|
|
led_dat->can_sleep = gpio_cansleep(template->gpio);
|
|
led_dat->active_low = template->active_low;
|
|
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 = !!gpio_get_value_cansleep(led_dat->gpio) ^ led_dat->active_low;
|
|
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 = gpio_direction_output(led_dat->gpio, led_dat->active_low ^ state);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
INIT_WORK(&led_dat->work, gpio_led_work);
|
|
|
|
ret = led_classdev_register(parent, &led_dat->cdev);
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void delete_gpio_led(struct gpio_led_data *led)
|
|
{
|
|
if (!gpio_is_valid(led->gpio))
|
|
return;
|
|
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_child_count(np);
|
|
if (!count)
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
for_each_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_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;
|
|
}
|
|
|
|
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", },
|
|
{},
|
|
};
|
|
#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 = pdev->dev.platform_data;
|
|
struct gpio_leds_priv *priv;
|
|
struct pinctrl *pinctrl;
|
|
int i, ret = 0;
|
|
|
|
pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
|
|
if (IS_ERR(pinctrl))
|
|
dev_warn(&pdev->dev,
|
|
"pins are not configured from the driver\n");
|
|
|
|
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]);
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
|
|
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");
|