OpenWrt

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 3  →  ?path2? @ 4
/branches/gl-inet/target/linux/ar71xx/files/drivers/leds/leds-nu801.c
@@ -0,0 +1,396 @@
/*
* LED driver for NU801
*
* Kevin Paul Herbert
* Copyright (c) 2012, Meraki, 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/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/leds-nu801.h>
 
#include <linux/gpio.h>
#include <linux/of_gpio.h>
 
#define MAX_NAME_LENGTH 24
#define NUM_COLORS 3
 
static const char * const led_nu801_colors[] = { "blue", "green", "red" };
 
struct led_nu801_led_data {
struct led_classdev cdev;
struct led_nu801_data *controller;
enum led_brightness level;
char name[MAX_NAME_LENGTH];
};
 
struct led_nu801_data {
unsigned cki;
unsigned sdi;
int lei;
struct delayed_work work;
struct led_nu801_led_data *led_chain;
int num_leds;
const char *device_name;
const char *name;
u32 ndelay;
atomic_t pending;
};
 
static void led_nu801_work(struct work_struct *work)
{
struct led_nu801_data *controller =
container_of(work, struct led_nu801_data, work.work);
struct led_nu801_led_data *led;
u16 bit;
u16 brightness;
int index;
 
for (index = 0; index < controller->num_leds; index++) {
led = &controller->led_chain[index];
brightness = led->level << 8; /* To do: gamma correction */
for (bit = 0x8000; bit; bit = bit >> 1) {
gpio_set_value(controller->sdi,
(brightness & bit) != 0);
gpio_set_value(controller->cki, 1);
if (unlikely(((index == (controller->num_leds - 1)) &&
(bit == 1) &&
(controller->lei < 0)))) {
udelay(600);
} else {
ndelay(controller->ndelay);
}
gpio_set_value(controller->cki, 0);
ndelay(controller->ndelay);
}
}
if (controller->lei >= 0) {
gpio_set_value(controller->lei, 1);
ndelay(controller->ndelay);
gpio_set_value(controller->lei, 0);
}
atomic_set(&controller->pending, 1);
}
 
static void led_nu801_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
struct led_nu801_led_data *led_dat =
container_of(led_cdev, struct led_nu801_led_data, cdev);
struct led_nu801_data *controller = led_dat->controller;
 
if (led_dat->level != value) {
led_dat->level = value;
if (atomic_dec_and_test(&controller->pending))
schedule_delayed_work(&led_dat->controller->work,
(HZ/1000) + 1);
}
}
 
static int led_nu801_create(struct led_nu801_data *controller,
struct device *parent,
int index,
enum led_brightness brightness,
#ifdef CONFIG_LEDS_TRIGGERS
const char *default_trigger,
#endif
const char *color)
{
struct led_nu801_led_data *led = &controller->led_chain[index];
int ret;
 
scnprintf(led->name, sizeof(led->name), "%s:%s:%s%d",
controller->device_name, color, controller->name,
(controller->num_leds - (index + 1)) / NUM_COLORS);
led->cdev.name = led->name;
led->cdev.brightness_set = led_nu801_set;
#ifdef CONFIG_LEDS_TRIGGERS
led->cdev.default_trigger = default_trigger;
#endif
led->level = brightness;
led->controller = controller;
ret = led_classdev_register(parent, &led->cdev);
if (ret < 0)
goto err;
 
return 0;
 
err:
kfree(led);
return ret;
}
 
static int
led_nu801_create_chain(const struct led_nu801_template *template,
struct led_nu801_data *controller,
struct device *parent)
{
int ret;
int index;
 
controller->cki = template->cki;
controller->sdi = template->sdi;
controller->lei = template->lei;
controller->num_leds = template->num_leds * 3;
controller->device_name = template->device_name;
controller->name = template->name;
controller->ndelay = template->ndelay;
atomic_set(&controller->pending, 1);
 
controller->led_chain = kzalloc(sizeof(struct led_nu801_led_data) *
controller->num_leds, GFP_KERNEL);
 
if (!controller->led_chain)
return -ENOMEM;
 
ret = gpio_request(controller->cki, template->name);
if (ret < 0)
goto err_free_chain;
 
ret = gpio_request(controller->sdi, template->name);
if (ret < 0)
goto err_ret_cki;
 
if (controller->lei >= 0) {
ret = gpio_request(controller->lei, template->name);
if (ret < 0)
goto err_ret_sdi;
ret = gpio_direction_output(controller->lei, 0);
if (ret < 0)
goto err_ret_lei;
}
 
ret = gpio_direction_output(controller->cki, 0);
if (ret < 0)
goto err_ret_lei;
 
ret = gpio_direction_output(controller->sdi, 0);
if (ret < 0)
goto err_ret_lei;
 
for (index = 0; index < controller->num_leds; index++) {
ret = led_nu801_create(controller, parent, index,
template->init_brightness
[index % NUM_COLORS],
#ifdef CONFIG_LEDS_TRIGGERS
template->default_trigger,
#endif
template->led_colors[index % NUM_COLORS] ?
template->led_colors[index % NUM_COLORS] :
led_nu801_colors[index % NUM_COLORS]);
if (ret < 0)
goto err_ret_sdi;
}
 
INIT_DELAYED_WORK(&controller->work, led_nu801_work);
schedule_delayed_work(&controller->work, 0);
 
return 0;
 
err_ret_lei:
if (controller->lei >= 0)
gpio_free(controller->lei);
err_ret_sdi:
gpio_free(controller->sdi);
err_ret_cki:
gpio_free(controller->cki);
err_free_chain:
kfree(controller->led_chain);
 
return ret;
}
 
static void led_nu801_delete_chain(struct led_nu801_data *controller)
{
struct led_nu801_led_data *led_chain;
struct led_nu801_led_data *led;
int index;
int num_leds;
 
led_chain = controller->led_chain;
controller->led_chain = 0;
num_leds = controller->num_leds;
controller->num_leds = 0;
cancel_delayed_work_sync(&controller->work);
 
for (index = 0; index < num_leds; index++) {
led = &led_chain[index];
led_classdev_unregister(&led->cdev);
}
 
gpio_free(controller->cki);
gpio_free(controller->sdi);
if (controller->lei >= 0)
gpio_free(controller->lei);
 
kfree(led_chain);
}
 
static struct led_nu801_data *
leds_nu801_create_of(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node, *child;
struct led_nu801_data *controllers;
int count = 0, ret;
int i = 0;
 
for_each_child_of_node(np, child)
count++;
if (!count)
return NULL;
 
controllers = kzalloc(sizeof(struct led_nu801_data) * count,
GFP_KERNEL);
if (!controllers)
return NULL;
 
for_each_child_of_node(np, child) {
const char *state;
struct led_nu801_template template = {};
struct device_node *colors;
int jj;
 
template.cki = of_get_named_gpio_flags(child, "cki", 0, NULL);
template.sdi = of_get_named_gpio_flags(child, "sdi", 0, NULL);
if (of_find_property(child, "lei", NULL)) {
template.lei = of_get_named_gpio_flags(child, "lei",
0, NULL);
} else {
template.lei = -1;
}
of_property_read_u32(child, "ndelay", &template.ndelay);
of_property_read_u32(child, "num_leds", &template.num_leds);
template.name = of_get_property(child, "label", NULL) ? :
child->name;
template.default_trigger = of_get_property(child,
"default-trigger", NULL);
 
jj = 0;
for_each_child_of_node(child, colors) {
template.led_colors[jj] = of_get_property(colors,
"label", NULL);
state = of_get_property(colors, "state", NULL);
if (!strncmp(state, "off", 3))
template.init_brightness[jj] = LED_OFF;
else if (!strncmp(state, "half", 4))
template.init_brightness[jj] = LED_HALF;
else if (!strncmp(state, "full", 4))
template.init_brightness[jj] = LED_FULL;
jj++;
}
 
ret = led_nu801_create_chain(&template,
&controllers[i],
&pdev->dev);
if (ret < 0)
goto err;
i++;
}
 
return controllers;
 
err:
for (i = i - 1; i >= 0; i--)
led_nu801_delete_chain(&controllers[i]);
kfree(controllers);
return NULL;
}
 
static int led_nu801_probe(struct platform_device *pdev)
{
struct led_nu801_platform_data *pdata = pdev->dev.platform_data;
struct led_nu801_data *controllers;
int i, ret = 0;
 
if (!(pdata && pdata->num_controllers)) {
controllers = leds_nu801_create_of(pdev);
if (!controllers)
return -ENODEV;
}
 
controllers = kzalloc(sizeof(struct led_nu801_data) *
pdata->num_controllers, GFP_KERNEL);
if (!controllers)
return -ENOMEM;
 
for (i = 0; i < pdata->num_controllers; i++) {
ret = led_nu801_create_chain(&pdata->template[i],
&controllers[i],
&pdev->dev);
if (ret < 0)
goto err;
}
 
platform_set_drvdata(pdev, controllers);
 
return 0;
 
err:
for (i = i - 1; i >= 0; i--)
led_nu801_delete_chain(&controllers[i]);
 
kfree(controllers);
 
return ret;
}
 
static int led_nu801_remove(struct platform_device *pdev)
{
int i;
struct led_nu801_platform_data *pdata = pdev->dev.platform_data;
struct led_nu801_data *controllers;
 
controllers = platform_get_drvdata(pdev);
 
for (i = 0; i < pdata->num_controllers; i++)
led_nu801_delete_chain(&controllers[i]);
 
kfree(controllers);
 
return 0;
}
 
static const struct of_device_id of_numen_leds_match[] = {
{ .compatible = "numen,leds-nu801", },
{},
};
MODULE_DEVICE_TABLE(of, of_pwm_leds_match);
 
static struct platform_driver led_nu801_driver = {
.probe = led_nu801_probe,
.remove = led_nu801_remove,
.driver = {
.name = "leds-nu801",
.owner = THIS_MODULE,
.of_match_table = of_numen_leds_match,
},
};
 
static int __init led_nu801_init(void)
{
return platform_driver_register(&led_nu801_driver);
}
 
static void __exit led_nu801_exit(void)
{
platform_driver_unregister(&led_nu801_driver);
}
 
module_init(led_nu801_init);
module_exit(led_nu801_exit);
 
MODULE_AUTHOR("Kevin Paul Herbert <kph@meraki.net>");
MODULE_DESCRIPTION("NU801 LED driver");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:leds-nu801");
/branches/gl-inet/target/linux/ar71xx/files/drivers/leds/leds-rb750.c
@@ -0,0 +1,144 @@
/*
* LED driver for the RouterBOARD 750
*
* Copyright (C) 2010 Gabor Juhos <juhosg@openwrt.org>
*
* 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/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/slab.h>
 
#include <asm/mach-ath79/mach-rb750.h>
 
#define DRV_NAME "leds-rb750"
 
struct rb750_led_dev {
struct led_classdev cdev;
u32 mask;
int active_low;
void (*latch_change)(u32 clear, u32 set);
};
 
struct rb750_led_drvdata {
struct rb750_led_dev *led_devs;
int num_leds;
};
 
static inline struct rb750_led_dev *to_rbled(struct led_classdev *led_cdev)
{
return (struct rb750_led_dev *)container_of(led_cdev,
struct rb750_led_dev, cdev);
}
 
static void rb750_led_brightness_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
struct rb750_led_dev *rbled = to_rbled(led_cdev);
int level;
 
level = (value == LED_OFF) ? 0 : 1;
level ^= rbled->active_low;
 
if (level)
rbled->latch_change(0, rbled->mask);
else
rbled->latch_change(rbled->mask, 0);
}
 
static int rb750_led_probe(struct platform_device *pdev)
{
struct rb750_led_platform_data *pdata;
struct rb750_led_drvdata *drvdata;
int ret = 0;
int i;
 
pdata = pdev->dev.platform_data;
if (!pdata)
return -EINVAL;
 
drvdata = kzalloc(sizeof(struct rb750_led_drvdata) +
sizeof(struct rb750_led_dev) * pdata->num_leds,
GFP_KERNEL);
if (!drvdata)
return -ENOMEM;
 
drvdata->num_leds = pdata->num_leds;
drvdata->led_devs = (struct rb750_led_dev *) &drvdata[1];
 
for (i = 0; i < drvdata->num_leds; i++) {
struct rb750_led_dev *rbled = &drvdata->led_devs[i];
struct rb750_led_data *led_data = &pdata->leds[i];
 
rbled->cdev.name = led_data->name;
rbled->cdev.default_trigger = led_data->default_trigger;
rbled->cdev.brightness_set = rb750_led_brightness_set;
rbled->cdev.brightness = LED_OFF;
 
rbled->mask = led_data->mask;
rbled->active_low = !!led_data->active_low;
rbled->latch_change = pdata->latch_change;
 
ret = led_classdev_register(&pdev->dev, &rbled->cdev);
if (ret)
goto err;
}
 
platform_set_drvdata(pdev, drvdata);
return 0;
 
err:
for (i = i - 1; i >= 0; i--)
led_classdev_unregister(&drvdata->led_devs[i].cdev);
 
kfree(drvdata);
return ret;
}
 
static int rb750_led_remove(struct platform_device *pdev)
{
struct rb750_led_drvdata *drvdata;
int i;
 
drvdata = platform_get_drvdata(pdev);
for (i = 0; i < drvdata->num_leds; i++)
led_classdev_unregister(&drvdata->led_devs[i].cdev);
 
kfree(drvdata);
return 0;
}
 
static struct platform_driver rb750_led_driver = {
.probe = rb750_led_probe,
.remove = rb750_led_remove,
.driver = {
.name = DRV_NAME,
.owner = THIS_MODULE,
},
};
 
MODULE_ALIAS("platform:leds-rb750");
 
static int __init rb750_led_init(void)
{
return platform_driver_register(&rb750_led_driver);
}
 
static void __exit rb750_led_exit(void)
{
platform_driver_unregister(&rb750_led_driver);
}
 
module_init(rb750_led_init);
module_exit(rb750_led_exit);
 
MODULE_DESCRIPTION(DRV_NAME);
MODULE_DESCRIPTION("LED driver for the RouterBOARD 750");
MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
MODULE_LICENSE("GPL v2");
/branches/gl-inet/target/linux/ar71xx/files/drivers/leds/leds-wndr3700-usb.c
@@ -0,0 +1,76 @@
/*
* USB LED driver for the NETGEAR WNDR3700
*
* Copyright (C) 2009 Gabor Juhos <juhosg@openwrt.org>
*
* 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/leds.h>
#include <linux/module.h>
#include <linux/platform_device.h>
 
#include <asm/mach-ath79/ar71xx_regs.h>
#include <asm/mach-ath79/ath79.h>
 
#define DRIVER_NAME "wndr3700-led-usb"
 
static void wndr3700_usb_led_set(struct led_classdev *cdev,
enum led_brightness brightness)
{
if (brightness)
ath79_device_reset_clear(AR71XX_RESET_GE1_PHY);
else
ath79_device_reset_set(AR71XX_RESET_GE1_PHY);
}
 
static enum led_brightness wndr3700_usb_led_get(struct led_classdev *cdev)
{
return ath79_device_reset_get(AR71XX_RESET_GE1_PHY) ? LED_OFF : LED_FULL;
}
 
static struct led_classdev wndr3700_usb_led = {
.name = "netgear:green:usb",
.brightness_set = wndr3700_usb_led_set,
.brightness_get = wndr3700_usb_led_get,
};
 
static int wndr3700_usb_led_probe(struct platform_device *pdev)
{
return led_classdev_register(&pdev->dev, &wndr3700_usb_led);
}
 
static int wndr3700_usb_led_remove(struct platform_device *pdev)
{
led_classdev_unregister(&wndr3700_usb_led);
return 0;
}
 
static struct platform_driver wndr3700_usb_led_driver = {
.probe = wndr3700_usb_led_probe,
.remove = wndr3700_usb_led_remove,
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
},
};
 
static int __init wndr3700_usb_led_init(void)
{
return platform_driver_register(&wndr3700_usb_led_driver);
}
 
static void __exit wndr3700_usb_led_exit(void)
{
platform_driver_unregister(&wndr3700_usb_led_driver);
}
 
module_init(wndr3700_usb_led_init);
module_exit(wndr3700_usb_led_exit);
 
MODULE_DESCRIPTION("USB LED driver for the NETGEAR WNDR3700");
MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:" DRIVER_NAME);