qi-hardware/openwrt-xburst
1
0
Fork 0
mirror of git://projects.qi-hardware.com/openwrt-xburst.git synced 2025-04-21 12:27:27 +03:00
Code Activity

[adm5120] switch to 2.6.23

Browse Source 
git-svn-id: svn://svn.openwrt.org/openwrt/trunk@9260 3c298f89-4303-0410-b956-a3cf2f4a3e73
This commit is contained in:
juhosg
2007-10-11 09:11:56 +00:00
parent 998820411b
commit 572b00c7f4
23 changed files with 58 additions and 1231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
target/linux/adm5120/files/drivers/leds/leds-adm5120.c
View File

@@ -29,13 +29,13 @@
#include <linux/leds.h>
#include <linux/err.h>
#include <linux/gpio_leds.h>
#include <linux/io.h>
#include <linux/leds.h>
#include <asm/bootinfo.h>
#include <asm/io.h>
#include <asm/gpio.h>
#include <asm/mach-adm5120/adm5120_info.h>
#include <adm5120_info.h>
#define NUM_LEDS_MAX 23
@@ -43,12 +43,13 @@
struct mach_data {
unsigned long machtype;
unsigned count;
struct gpio_led_platform_data *data;
unsigned nr_leds;
struct gpio_led *leds;
};
struct adm5120_leddev {
struct platform_device pdev;
struct gpio_led led;
struct gpio_led_platform_data pdata;
};
@@ -56,19 +57,17 @@ static int led_count = 0;
static struct adm5120_leddev *led_devs[NUM_LEDS_MAX];
#define LED_ARRAY(n) \
static struct gpio_led_platform_data \
n ## _leds [] __initdata =
static struct gpio_led n ## _leds [] __initdata =
#define LED_DATA(n,t,g,off,on) { \
#define LED_DATA(n,t,g,al) { \
.name = (n), \
.trigger = (t), \
.default_trigger = (t), \
.gpio = (g), \
.value_off = (off), \
.value_on = (on) \
.active_low = (al) \
}
#define LED_STD(g,n,t) LED_DATA((n),(t),(g), 0, 1)
#define LED_INV(g,n,t) LED_DATA((n),(t),(g), 1, 0)
#define LED_STD(g,n,t) LED_DATA((n),(t),(g), 0)
#define LED_INV(g,n,t) LED_DATA((n),(t),(g), 1)
/*
* Compex boards
@@ -218,8 +217,8 @@ LED_ARRAY(generic) {
#define MACH_DATA(m, n) { \
.machtype = (m), \
.count = ARRAY_SIZE(n ## _leds), \
.data = n ## _leds \
.nr_leds = ARRAY_SIZE(n ## _leds), \
.leds = n ## _leds \
}
static struct mach_data machines[] __initdata = {
@@ -250,7 +249,7 @@ static struct mach_data machines[] __initdata = {
};
static struct adm5120_leddev * __init
create_leddev(struct gpio_led_platform_data *data)
create_leddev(int id, struct gpio_led *led)
{
struct adm5120_leddev *p;
@@ -258,17 +257,21 @@ create_leddev(struct gpio_led_platform_data *data)
if (p == NULL)
return NULL;
memcpy(&p->pdata, data, sizeof(p->pdata));
memcpy(&p->led, led, sizeof(p->led));
p->pdev.name = "leds-gpio";
p->pdev.id = id;
p->pdev.dev.platform_data = &p->pdata;
p->pdata.num_leds=1;
p->pdata.leds = &p->led;
return p;
}
static void
destroy_leddev(struct adm5120_leddev *led)
destroy_leddev(struct adm5120_leddev *leddev)
{
if (led)
kfree(led);
if (leddev)
kfree(leddev);
}
static struct mach_data * __init
@@ -311,23 +314,21 @@ adm5120_leds_init(void)
goto err;
}
for (i=0; i < mach->count; i++) {
led_devs[i] = create_leddev(&mach->data[i]);
for (i=0; i < mach->nr_leds; i++) {
led_devs[i] = create_leddev(i, &mach->leds[i]);
if (led_devs[i] == NULL) {
ret = -ENOMEM;
goto err_destroy;
}
led_devs[i]->pdev.name = "gpio-led";
led_devs[i]->pdev.id = i;
}
for (i=0; i < mach->count; i++) {
for (i=0; i < mach->nr_leds; i++) {
ret = platform_device_register(&led_devs[i]->pdev);
if (ret)
goto err_unregister;
}
led_count = mach->count;
led_count = mach->nr_leds;
return 0;
err_unregister:

212
target/linux/adm5120/files/drivers/leds/leds-gpio.c
View File

@@ -1,212 +0,0 @@
/*
* $Id$
*
* Driver for LEDs connected to GPIO lines
*
* Copyright (C) 2007 OpenWrt.org
* Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
*
* This file was derived from:
* /drivers/led/leds-s3c24xx.c
* (c) 2006 Simtec Electronics, Ben Dooks <ben@simtec.co.uk>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/err.h>
#include <linux/gpio_leds.h>
#include <asm/io.h>
#include <asm/gpio.h>
#define DRV_NAME "gpio-led"
#define DRV_DESC "GPIO LEDs driver"
struct gpio_led_device {
struct led_classdev cdev;
struct gpio_led_platform_data *pdata;
};
static inline struct gpio_led_device *pdev_to_led(struct platform_device *dev)
{
return platform_get_drvdata(dev);
}
static inline struct gpio_led_device *class_to_led(struct led_classdev *led_cdev)
{
return container_of(led_cdev, struct gpio_led_device, cdev);
}
static void gpio_led_set(struct led_classdev *led_cdev,
enum led_brightness brightness)
{
struct gpio_led_device *led;
struct gpio_led_platform_data *pdata;
led = class_to_led(led_cdev);
pdata = led->pdata;
switch (brightness) {
case LED_FULL:
gpio_direction_output(pdata->gpio, pdata->value_on);
break;
case LED_OFF:
gpio_direction_output(pdata->gpio, pdata->value_off);
break;
default:
gpio_direction_output(pdata->gpio, brightness);
break;
}
}
static int __devinit gpio_led_probe(struct platform_device *dev)
{
struct gpio_led_platform_data *pdata;
struct gpio_led_device *led;
int ret;
pdata = dev->dev.platform_data;
if (pdata == NULL) {
dev_err(&dev->dev, "no platform data, id=%d\n", dev->id);
ret = -EINVAL;
goto err;
}
if (pdata->name == NULL) {
dev_err(&dev->dev, "no led name specified\n");
ret = -EINVAL;
goto err;
}
ret = gpio_request(pdata->gpio, pdata->name);
if (ret) {
dev_err(&dev->dev, "gpio_request failed\n");
goto err;
}
led = kzalloc(sizeof(*led), GFP_KERNEL);
if (led == NULL) {
dev_err(&dev->dev, "no memory for device");
ret = -ENOMEM;
goto err_free_gpio;
}
platform_set_drvdata(dev, led);
led->pdata = pdata;
led->cdev.name = pdata->name;
led->cdev.brightness_set = gpio_led_set;
#ifdef CONFIG_LEDS_TRIGGERS
led->cdev.default_trigger = pdata->trigger;
#endif
ret = led_classdev_register(&dev->dev, &led->cdev);
if (ret < 0) {
dev_err(&dev->dev, "led_classdev_register failed");
goto err_free_led;
}
return 0;
err_free_led:
kfree(led);
err_free_gpio:
gpio_free(pdata->gpio);
err:
return ret;
}
static int __devexit gpio_led_remove(struct platform_device *dev)
{
struct gpio_led_device *led;
struct gpio_led_platform_data *pdata;
pdata = dev->dev.platform_data;
led = pdev_to_led(dev);
led_classdev_unregister(&led->cdev);
kfree(led);
gpio_free(pdata->gpio);
return 0;
}
#ifdef CONFIG_PM
static int gpio_led_suspend(struct platform_device *dev,
pm_message_t state)
{
struct gpio_led_device *led;
led = pdev_to_led(dev);
led_classdev_suspend(&led->cdev);
return 0;
}
static int gpio_led_resume(struct platform_device *dev)
{
struct gpio_led_device *led;
led = pdev_to_led(dev);
led_classdev_resume(&led->cdev);
return 0;
}
#endif /* CONFIG_PM */
static struct platform_driver gpio_led_driver = {
.probe = gpio_led_probe,
.remove = __devexit_p(gpio_led_remove),
#ifdef CONFIG_PM
.suspend = gpio_led_suspend,
.resume = gpio_led_resume,
#endif
.driver = {
.name = DRV_NAME,
.owner = THIS_MODULE,
},
};
static int __init gpio_led_init(void)
{
int ret;
ret = platform_driver_register(&gpio_led_driver);
if (ret)
printk(KERN_ALERT DRV_DESC " register failed\n");
else
printk(KERN_INFO DRV_DESC " registered\n");
return ret;
}
static void __exit gpio_led_exit(void)
{
platform_driver_unregister(&gpio_led_driver);
}
module_init(gpio_led_init);
module_exit(gpio_led_exit);
MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");