diff options
Diffstat (limited to 'packages/linux/linux-2.6.23')
5 files changed, 662 insertions, 22 deletions
diff --git a/packages/linux/linux-2.6.23/leds-cpu-activity-powerpc.patch b/packages/linux/linux-2.6.23/leds-cpu-activity-powerpc.patch new file mode 100644 index 0000000000..b377355815 --- /dev/null +++ b/packages/linux/linux-2.6.23/leds-cpu-activity-powerpc.patch @@ -0,0 +1,46 @@ +Index: linux-2.6.23/arch/powerpc/kernel/idle.c +=================================================================== +--- linux-2.6.23.orig/arch/powerpc/kernel/idle.c 2007-10-09 22:31:38.000000000 +0200 ++++ linux-2.6.23/arch/powerpc/kernel/idle.c 2007-12-05 11:34:39.000000000 +0100 +@@ -19,6 +19,7 @@ + * 2 of the License, or (at your option) any later version. + */ + ++#include <linux/leds.h> + #include <linux/sched.h> + #include <linux/kernel.h> + #include <linux/smp.h> +@@ -50,6 +51,12 @@ + __setup("powersave=off", powersave_off); + + /* ++ * CPU activity indicator. ++ */ ++void (*leds_idle)(int is_idle); ++EXPORT_SYMBOL(leds_idle); ++ ++/* + * The body of the idle task. + */ + void cpu_idle(void) +@@ -59,6 +66,8 @@ + + set_thread_flag(TIF_POLLING_NRFLAG); + while (1) { ++ if (leds_idle) ++ leds_idle(1); + while (!need_resched() && !cpu_should_die()) { + ppc64_runlatch_off(); + +@@ -92,8 +101,11 @@ + ppc64_runlatch_on(); + if (cpu_should_die()) + cpu_die(); ++ if (leds_idle) ++ leds_idle(0); + preempt_enable_no_resched(); + schedule(); ++ + preempt_disable(); + } + } diff --git a/packages/linux/linux-2.6.23/leds-cpu-activity.patch b/packages/linux/linux-2.6.23/leds-cpu-activity.patch new file mode 100644 index 0000000000..ebdf1abd81 --- /dev/null +++ b/packages/linux/linux-2.6.23/leds-cpu-activity.patch @@ -0,0 +1,554 @@ +Index: linux-2.6.23/drivers/leds/Kconfig +=================================================================== +--- linux-2.6.23.orig/drivers/leds/Kconfig 2007-12-05 12:00:28.000000000 +0100 ++++ linux-2.6.23/drivers/leds/Kconfig 2007-12-05 13:46:39.000000000 +0100 +@@ -123,6 +123,15 @@ + This allows LEDs to be controlled by a programmable timer + via sysfs. If unsure, say Y. + ++config LEDS_TRIGGER_CPU_ACTIVITY ++ tristate "LED CPU Activity Trigger" ++ depends on LEDS_TRIGGERS ++ help ++ This allows LEDs to be set to show cpu activity via sysfs. ++ The LED will blink when the cpu is active and stay steady ++ (on or off according to the trigger selected) when idle. ++ Platform support is needed for this to work. If unsure, say Y. ++ + config LEDS_TRIGGER_IDE_DISK + bool "LED IDE Disk Trigger" + depends on LEDS_TRIGGERS && BLK_DEV_IDEDISK +Index: linux-2.6.23/drivers/leds/ledtrig-cpu.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.23/drivers/leds/ledtrig-cpu.c 2007-12-05 12:00:28.000000000 +0100 +@@ -0,0 +1,502 @@ ++/* ++ * LEDs CPU activity trigger ++ * ++ * Author: John Bowler <jbowler@acm.org> ++ * ++ * Copyright (c) 2006 John Bowler ++ * ++ * Permission is hereby granted, free of charge, to any ++ * person obtaining a copy of this software and associated ++ * documentation files (the "Software"), to deal in the ++ * Software without restriction, including without ++ * limitation the rights to use, copy, modify, merge, ++ * publish, distribute, sublicense, and/or sell copies of ++ * the Software, and to permit persons to whom the ++ * Software is furnished to do so, subject to the ++ * following conditions: ++ * ++ * The above copyright notice and this permission notice ++ * shall be included in all copies or substantial portions ++ * of the Software. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ++ * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED ++ * TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A ++ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT ++ * SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ++ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ++ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR ++ * OTHER DEALINGS IN THE SOFTWARE. ++ * ++ */ ++ ++#include <linux/ctype.h> ++#include <linux/kernel.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/spinlock.h> ++#include <linux/timer.h> ++#include <linux/device.h> ++ ++#include <linux/leds.h> ++#include "leds.h" ++ ++//#include <linux/list.h> ++//#include <linux/sysdev.h> ++ ++ ++/* ++ * To simplify this the LED state is given for each case of ++ * CPU state - idle or active. The LED can be: ++ * ++ * off ++ * flash - slow for idle, fast (flicker) for active ++ * on ++ * ++ * This gives two useless states - off/off and on/on ++ */ ++typedef enum cpu_trigger_led_state { ++ cpu_led_off, ++ cpu_led_flash, ++ cpu_led_on, ++ cpu_led_invalid ++} cpu_trigger_led_state; ++ ++static const char *const cpu_trigger_names[] = { ++ "off", ++ "flash", ++ "on", ++ "invalid" ++}; ++ ++/* Forward declaration - this is called back when an LED property ++ * is changed. ++ */ ++static void leds_cpu_trigger_state_change(void); ++ ++/* ++ * These constants define the actual mark/space of the flashing ++ * in jiffies. msecs_to_jiffies rounds up and is compile time ++ * evaluable for constant arguments. Writing the ?: stuff below ++ * this way ensures the compiler doesn't think it needs to ++ * compile in the math of msecs_to_jiffies. ++ * ++ * These values have been determined by experiment to work well ++ * for the ready/status LED on a LinkSys NSLU2 (light piped) and ++ * for the user LED on a Loft (Gateway Avila variant) board where ++ * the LED was directly visible. Light Output Varies Everywhere. ++ */ ++#define LEDS_CPU_ACTIVE_MARK msecs_to_jiffies(40) ++#define LEDS_CPU_IDLE_MARK msecs_to_jiffies(800) ++#define LEDS_CPU_ACTIVE_SPACE msecs_to_jiffies(60) ++#define LEDS_CPU_IDLE_SPACE msecs_to_jiffies(800) ++ ++ ++/* ++ * Individual LEDs ------------------------------------------------------------ ++ */ ++struct cpu_trigger_data { ++ cpu_trigger_led_state active; /* Behaviour when the CPU is active. */ ++ cpu_trigger_led_state idle; /* Behaviour when the CPU is idle. */ ++}; ++ ++/* ++ * LED state change - called when the state of a single LED might ++ * have changed. Returns true if the LED is blinking. The argument ++ * is the blink state - the brightness of the blinking LED. ++ */ ++static int leds_cpu_trigger_led_state_change(struct led_classdev *led, ++ int is_active, enum led_brightness brightness) ++{ ++ int is_blinking = 0; ++ ++ struct cpu_trigger_data *data = led->trigger_data; ++ ++ /* Find the new brightness for the LED, if the LED is ++ * set to flash then the brightness passed in is the ++ * required value. ++ */ ++ if (likely(data != 0)) ++ switch (is_active ? data->active : data->idle) { ++ case cpu_led_off: brightness = LED_OFF; break; ++ case cpu_led_flash: is_blinking = 1; break; ++ case cpu_led_on: brightness = LED_FULL; break; ++ } ++ else ++ brightness = is_active ? LED_FULL : LED_OFF; ++ ++ led_set_brightness(led, brightness); ++ ++ return is_blinking; ++} ++ ++/* ++ * sysfs properties, the property is output at an list of the ++ * values with the current setting enclosed in [] ++ */ ++static ssize_t leds_cpu_trigger_show_prop(struct device *dev, ++ struct device_attribute *attr, char *buf, size_t where) ++{ ++ struct led_classdev *led = dev_get_drvdata(dev); ++ cpu_trigger_led_state item = cpu_led_invalid, i; ++ char *next; ++ ++ if (likely(led->trigger_data != 0)) ++ item = *(const cpu_trigger_led_state*)( ++ led->trigger_data + where); ++ ++ for (i=0, next=buf; i<cpu_led_invalid; ++i) { ++ const char *name = cpu_trigger_names[i]; ++ size_t len = strlen(name); ++ ++ if (i == item) ++ *next++ = '['; ++ memcpy(next, name, len); ++ next += len; ++ if (i == item) ++ *next++ = ']'; ++ *next++ = ' '; ++ } ++ ++ next[-1] = '\n'; ++ *next++ = 0; ++ ++ return next - buf; ++} ++ ++static ssize_t leds_cpu_trigger_show_active(struct device *dev, ++ struct device_attribute *attr, char *buf) ++{ ++ return leds_cpu_trigger_show_prop(dev, attr, buf, ++ offsetof(struct cpu_trigger_data, active)); ++} ++ ++static ssize_t leds_cpu_trigger_show_idle(struct device *dev, ++ struct device_attribute *attr, char *buf) ++{ ++ return leds_cpu_trigger_show_prop(dev, attr, buf, ++ offsetof(struct cpu_trigger_data, idle)); ++} ++ ++/* ++ * Any matching leading substring selects a property - so "onoffonoff" ++ * sets the property to off. ++ */ ++static ssize_t leds_cpu_trigger_store_prop(struct device *dev, ++ struct device_attribute *attr, const char *buf, ++ size_t size, size_t where) ++{ ++ size_t rc = 0; ++ cpu_trigger_led_state value = 0/*sic*/; ++ struct led_classdev *led; ++ ++ /* ignore space characters before the value. */ ++ while (rc < size && isspace(buf[rc])) ++ ++rc; ++ if (rc >= size) ++ return rc; ++ ++ /* look for a simple match against the trigger name, case ++ * sensitive. ++ */ ++ do { ++ const char *name = cpu_trigger_names[value]; ++ size_t len = strlen(name); ++ if (len <= size && memcmp(buf+rc, name, len) == 0) { ++ rc = len; ++ break; ++ } ++ if (++value >= cpu_led_invalid) ++ return -EINVAL; ++ } while (1); ++ ++ led = dev_get_drvdata(dev); ++ if (likely(led->trigger_data != 0)) ++ *(cpu_trigger_led_state*)( ++ led->trigger_data + where) = value; ++ ++ return rc; ++} ++ ++static ssize_t leds_cpu_trigger_store_active(struct device *dev, ++ struct device_attribute *attr, const char *buf, size_t size) ++{ ++ ssize_t rc = leds_cpu_trigger_store_prop(dev, attr, buf, size, ++ offsetof(struct cpu_trigger_data, active)); ++ /* ++ * At least one CPU must be active (otherwise who is doing this?) ++ * Call down into the global state below to cause an update ++ * to happen now. ++ */ ++ leds_cpu_trigger_state_change(); ++ return rc; ++} ++ ++static ssize_t leds_cpu_trigger_store_idle(struct device *dev, ++ struct device_attribute *attr, const char *buf, size_t size) ++{ ++ return leds_cpu_trigger_store_prop(dev, attr, buf, size, ++ offsetof(struct cpu_trigger_data, idle)); ++} ++ ++static DEVICE_ATTR(active, 0644, leds_cpu_trigger_show_active, ++ leds_cpu_trigger_store_active); ++ ++static DEVICE_ATTR(idle, 0644, leds_cpu_trigger_show_idle, ++ leds_cpu_trigger_store_idle); ++ ++/* ++ * Activate and deactivate are called on individual LEDs when the ++ * LED trigger property is changed. ++ */ ++static void leds_cpu_trigger_activate(struct led_classdev *led) ++{ ++ /* ++ * The initial setting of the trigger is simple CPU activity ++ * with the LED off for idle and on for active. Consequently ++ * there is no need to mess with the global state initially, ++ * we know the CPU is active at this moment! ++ */ ++ int rc; ++ struct cpu_trigger_data *data = kmalloc(sizeof *data, GFP_KERNEL); ++ if (unlikely(data == 0)) ++ return; ++ ++ data->active = cpu_led_on; ++ data->idle = cpu_led_off; ++ led->trigger_data = data; ++ ++ rc = device_create_file(led->dev, &dev_attr_active); ++ if (rc) ++ goto err_out; ++ rc = device_create_file(led->dev, &dev_attr_idle); ++ if (rc) ++ goto err_out_active; ++ ++ led_set_brightness(led, LED_FULL); ++ return; ++ ++err_out_active: ++ device_remove_file(led->dev, &dev_attr_active); ++err_out: ++ led->trigger_data = NULL; ++ kfree(data); ++} ++ ++static void leds_cpu_trigger_deactivate(struct led_classdev *led) ++{ ++ struct cpu_trigger_data *data = led->trigger_data; ++ if (likely(data != 0)) { ++ led_set_brightness(led, LED_OFF); ++ ++ device_remove_file(led->dev, &dev_attr_idle); ++ device_remove_file(led->dev, &dev_attr_active); ++ ++ led->trigger_data = 0; ++ kfree(data); ++ } ++} ++ ++ ++/* ++ * Global state -------------------------------------------------------------- ++ * ++ * This is global because the CPU state is global and we only need one timer to ++ * do this stuff. ++ */ ++typedef struct leds_cpu_trigger_data { ++ struct led_trigger trigger; /* the lock in here protects everything */ ++ struct timer_list timer; ++ unsigned long last_active_time; /* record of last jiffies */ ++ unsigned long last_idle_time; /* record of last jiffies */ ++ int count_active; /* number of active CPUs */ ++} leds_cpu_trigger_data; ++ ++/* ++ * Mark state - uses the current time (jiffies) to work out ++ * whether this is a mark or space. ++ */ ++static int leds_cpu_trigger_mark(struct leds_cpu_trigger_data *data, ++ unsigned long now) { ++ if (data->count_active > 0) { ++ unsigned long elapsed = now - data->last_active_time; ++ elapsed %= LEDS_CPU_ACTIVE_SPACE + LEDS_CPU_ACTIVE_MARK; ++ data->last_active_time = now - elapsed; ++ return elapsed > LEDS_CPU_ACTIVE_SPACE; ++ } else { ++ unsigned long elapsed = now - data->last_idle_time; ++ elapsed %= LEDS_CPU_IDLE_SPACE + LEDS_CPU_IDLE_MARK; ++ data->last_idle_time = now - elapsed; ++ return elapsed > LEDS_CPU_IDLE_SPACE; ++ } ++} ++ ++ ++/* ++ * State change - given information about the nature of the ++ * (possible) state change call up to each LED to adjust its ++ * state. Returns true if any LED is blinking. The lock ++ * must be held (a read lock is adequate). ++ */ ++static int leds_cpu_trigger_scan_leds(struct leds_cpu_trigger_data *data, ++ unsigned long now) ++{ ++ int blinking = 0; ++ const int active = data->count_active > 0; ++ const enum led_brightness brightness = ++ leds_cpu_trigger_mark(data, now) ? LED_FULL : LED_OFF; ++ struct list_head *entry; ++ ++ list_for_each(entry, &data->trigger.led_cdevs) { ++ struct led_classdev *led = ++ list_entry(entry, struct led_classdev, trig_list); ++ ++ blinking |= leds_cpu_trigger_led_state_change(led, ++ active, brightness); ++ } ++ ++ return blinking; ++} ++ ++/* ++ * Set the timer correctly according to the current state, the lock ++ * must be held for write. ++ */ ++static void leds_cpu_trigger_set_timer(struct leds_cpu_trigger_data *state, ++ unsigned long now) ++{ ++ unsigned long next; ++ if (state->count_active > 0) { ++ next = state->last_active_time; ++ if (now - next > LEDS_CPU_ACTIVE_SPACE) ++ next += LEDS_CPU_ACTIVE_MARK; ++ next += LEDS_CPU_ACTIVE_SPACE; ++ } else { ++ next = state->last_idle_time; ++ if (now - next > LEDS_CPU_IDLE_SPACE) ++ next += LEDS_CPU_IDLE_MARK; ++ next += LEDS_CPU_IDLE_SPACE; ++ } ++ mod_timer(&state->timer, next); ++} ++ ++/* ++ * The timer callback if the LED is currently flashing, the callback ++ * calls the state change function and, if that returns true, meaning ++ * that at least one LED is still blinking, the timer is restarted ++ * with the correct timeout. ++ */ ++static void leds_cpu_trigger_timer_callback(unsigned long data) ++{ ++ struct leds_cpu_trigger_data *state = ++ (struct leds_cpu_trigger_data *)data; ++ ++ write_lock(&state->trigger.leddev_list_lock); ++ { ++ unsigned long now = jiffies; ++ ++ /* If at least one LED is set to flash; set the timer ++ * again (this won't reset the timer set within the ++ * idle loop). ++ */ ++ if (leds_cpu_trigger_scan_leds(state, now)) ++ leds_cpu_trigger_set_timer(state, now); ++ } ++ write_unlock(&state->trigger.leddev_list_lock); ++} ++ ++ ++/* ++ * There is one global control structure, one timer and one set ++ * of state for active CPUs shared across all the LEDs. Individual ++ * LEDs say how this state to be handled. It is currently *not* ++ * possible to show per-cpu activity on individual LEDs, the code ++ * maintains a count of active CPUs and the state is only 'idle' ++ * if all CPUs are idle. ++ */ ++static struct leds_cpu_trigger_data leds_cpu_trigger = { ++ .trigger = { ++ .name = "cpu", ++ .activate = leds_cpu_trigger_activate, ++ .deactivate = leds_cpu_trigger_deactivate, ++ } , ++ .timer = TIMER_INITIALIZER(leds_cpu_trigger_timer_callback, 0, ++ (unsigned long)&leds_cpu_trigger), ++ .last_active_time = 0, ++ .last_idle_time = 0, ++ .count_active = 0, ++}; ++ ++/* ++ * State change - callback from an individual LED on a property change which ++ * might require a redisplay. ++ */ ++static void leds_cpu_trigger_state_change() { ++ write_lock(&leds_cpu_trigger.trigger.leddev_list_lock); ++ { ++ unsigned long now = jiffies; ++ ++ if (leds_cpu_trigger_scan_leds(&leds_cpu_trigger, now) && ++ !timer_pending(&leds_cpu_trigger.timer)) ++ leds_cpu_trigger_set_timer(&leds_cpu_trigger, now); ++ } ++ write_unlock(&leds_cpu_trigger.trigger.leddev_list_lock); ++} ++ ++/* ++ * Called from every CPU at the start and end of the idle loop. ++ * The active count is initially 0, even though CPUs are running, ++ * so the code below must check for the resultant underflow. ++ * ++ * If the idle behaviour is 'flash' then when the timer times out ++ * it will take the CPU out of idle, set the active state (which ++ * may also be flash), drop back into idle and reset the timer to ++ * the idle timeout... ++ */ ++static void leds_cpu_trigger_idle(int is_idle) ++{ ++ write_lock(&leds_cpu_trigger.trigger.leddev_list_lock); ++ if ((is_idle && leds_cpu_trigger.count_active > 0 && ++ --leds_cpu_trigger.count_active == 0) || ++ (!is_idle && leds_cpu_trigger.count_active < num_online_cpus() && ++ ++leds_cpu_trigger.count_active == 1)) { ++ unsigned long now = jiffies; ++ ++ /* State change - the system just became idle or active, ++ * call the del_timer first in an attempt to minimise ++ * getting a timer interrupt which will take us unnecessarily ++ * out of idle (this doesn't matter). ++ */ ++ del_timer(&leds_cpu_trigger.timer); ++ if (leds_cpu_trigger_scan_leds(&leds_cpu_trigger, now)) ++ leds_cpu_trigger_set_timer(&leds_cpu_trigger, now); ++ } ++ write_unlock(&leds_cpu_trigger.trigger.leddev_list_lock); ++} ++ ++/* ++ * Module init and exit - register the trigger, then store ++ * the idle callback in the arch-specific global. For this ++ * module to link (into the kernel) or load (into a running ++ * kernel) the architecture must define the leds_idle global. ++ */ ++static int __init leds_cpu_trigger_init(void) ++{ ++ int rc = led_trigger_register(&leds_cpu_trigger.trigger); ++ leds_idle = leds_cpu_trigger_idle; ++ return rc; ++} ++module_init(leds_cpu_trigger_init); ++ ++static void __exit leds_cpu_trigger_exit(void) ++{ ++ leds_idle = 0; ++ del_timer_sync(&leds_cpu_trigger.timer); ++ led_trigger_unregister(&leds_cpu_trigger.trigger); ++} ++module_exit(leds_cpu_trigger_exit); ++ ++MODULE_AUTHOR("John Bowler <jbowler@acm.org>"); ++MODULE_DESCRIPTION("CPU activity LED trigger"); ++MODULE_LICENSE("Dual MIT/GPL"); +Index: linux-2.6.23/drivers/leds/Makefile +=================================================================== +--- linux-2.6.23.orig/drivers/leds/Makefile 2007-12-05 12:00:28.000000000 +0100 ++++ linux-2.6.23/drivers/leds/Makefile 2007-12-05 12:00:28.000000000 +0100 +@@ -23,3 +23,4 @@ + obj-$(CONFIG_LEDS_TRIGGER_TIMER) += ledtrig-timer.o + obj-$(CONFIG_LEDS_TRIGGER_IDE_DISK) += ledtrig-ide-disk.o + obj-$(CONFIG_LEDS_TRIGGER_HEARTBEAT) += ledtrig-heartbeat.o ++obj-$(CONFIG_LEDS_TRIGGER_CPU_ACTIVITY) += ledtrig-cpu.o +Index: linux-2.6.23/include/linux/leds.h +=================================================================== +--- linux-2.6.23.orig/include/linux/leds.h 2007-10-09 22:31:38.000000000 +0200 ++++ linux-2.6.23/include/linux/leds.h 2007-12-05 12:00:28.000000000 +0100 +@@ -123,4 +123,13 @@ + }; + + ++/* ++ * CPU activity indication. ++ */ ++/* Idle callback - call with is_idle==1 at the start of the idle loop ++ * and with is_idle==0 at the end. This symbol must be defined by ++ * the arch core to be able to use LEDS_TRIGGER_CPU_ACTIVITY ++ */ ++extern void (*leds_idle)(int is_idle); ++ + #endif /* __LINUX_LEDS_H_INCLUDED */ diff --git a/packages/linux/linux-2.6.23/mpc8313e-rdb/defconfig b/packages/linux/linux-2.6.23/mpc8313e-rdb/defconfig index 6ac9151be6..2cd1cb3b1a 100644 --- a/packages/linux/linux-2.6.23/mpc8313e-rdb/defconfig +++ b/packages/linux/linux-2.6.23/mpc8313e-rdb/defconfig @@ -1,7 +1,7 @@ # # Automatically generated make config: don't edit # Linux kernel version: 2.6.23 -# Wed Nov 28 23:32:31 2007 +# Wed Dec 5 10:34:37 2007 # # CONFIG_PPC64 is not set @@ -1467,6 +1467,7 @@ CONFIG_LEDS_MPC8313E_RDB=m CONFIG_LEDS_TRIGGERS=y CONFIG_LEDS_TRIGGER_TIMER=m CONFIG_LEDS_TRIGGER_HEARTBEAT=m +CONFIG_LEDS_TRIGGER_CPU_ACTIVITY=m # CONFIG_INFINIBAND is not set # CONFIG_EDAC is not set CONFIG_RTC_LIB=y diff --git a/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-leds.patch b/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-leds.patch index d8a477af2a..56176c1095 100644 --- a/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-leds.patch +++ b/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-leds.patch @@ -1,6 +1,6 @@ diff -urN linux-2.6.23.orig/drivers/leds/Kconfig linux-2.6.23/drivers/leds/Kconfig --- linux-2.6.23.orig/drivers/leds/Kconfig 2007-10-09 22:31:38.000000000 +0200 -+++ linux-2.6.23/drivers/leds/Kconfig 2007-11-29 09:02:42.000000000 +0100 ++++ linux-2.6.23/drivers/leds/Kconfig 2007-12-03 11:08:06.000000000 +0100 @@ -101,6 +101,12 @@ outputs. To be useful the particular board must have LEDs and they must be connected to the GPIO lines. @@ -16,8 +16,8 @@ diff -urN linux-2.6.23.orig/drivers/leds/Kconfig linux-2.6.23/drivers/leds/Kconf config LEDS_TRIGGERS diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/drivers/leds/leds-mpc8313e-rdb.c --- linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c 1970-01-01 01:00:00.000000000 +0100 -+++ linux-2.6.23/drivers/leds/leds-mpc8313e-rdb.c 2007-11-29 09:02:42.000000000 +0100 -@@ -0,0 +1,128 @@ ++++ linux-2.6.23/drivers/leds/leds-mpc8313e-rdb.c 2007-12-03 11:08:36.000000000 +0100 +@@ -0,0 +1,127 @@ +/* + * drivers/leds/leds-mpc8313e-rdb.c + * Copyright (C) 2007 Leon Woestenberg <leon@sidebranch.com> @@ -38,18 +38,18 @@ diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/driver +#include <linux/err.h> +#include <asm/io.h> + -+int par_io_config_pin(u8 port, u8 pin, int dir, int open_drain, -+ int assignment, int has_irq); -+int par_io_data_set(u8 port, u8 pin, u8 val); ++#define LEDS_BASE 0xfa000000 ++#define LEDS_SIZE 0x2 + +static struct platform_dev *leds_pdev = NULL; +static struct resource *led_mem = NULL; -+static void *p = NULL; ++static void *led_io = NULL; ++static u8 led_state = 0; + +static void mpc8313leds_green_set(struct led_classdev *led_cdev, enum led_brightness value) +{ -+ int d = ioread16(p); -+ iowrite16(value?d&~1:d|1, p); ++ led_state = value ? led_state&~32 : led_state|32; ++ iowrite8(led_state, led_io); +} + +static struct led_classdev mpc8313_green_led = { @@ -59,8 +59,8 @@ diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/driver + +static void mpc8313leds_yellow_set(struct led_classdev *led_cdev, enum led_brightness value) +{ -+ int d = ioread16(p); -+ iowrite16(value?d&~2:d|2, p); ++ led_state = value ? led_state&~64 : led_state|64; ++ iowrite8(led_state, led_io); +} + +static struct led_classdev mpc8313_yellow_led = { @@ -70,8 +70,8 @@ diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/driver + +static void mpc8313leds_red_set(struct led_classdev *led_cdev, enum led_brightness value) +{ -+ int d = ioread16(p); -+ iowrite16(value?d&~4:d|4, p); ++ led_state = value ? led_state&~128 : led_state|128; ++ iowrite8(led_state, led_io); +} + +static struct led_classdev mpc8313_red_led = { @@ -117,12 +117,11 @@ diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/driver + +static int __init mpc8313leds_init(void) +{ -+ led_mem = request_mem_region(0xfa000000, 0x100, "mpc8313-leds"); -+ if (led_mem == NULL) return -ENOMEM; -+ p = ioremap(0xfa000000, 0x100); -+ if (p == NULL) ++ if (!(led_mem = request_mem_region(LEDS_BASE, LEDS_SIZE, "mpc8313-leds"))) ++ return -ENOMEM; ++ if (!(led_io = ioremap(LEDS_BASE, LEDS_SIZE))) + { -+ if (led_mem) release_mem_region(0xfa000000, 0x100); ++ release_mem_region(LEDS_BASE, LEDS_SIZE); + led_mem = NULL; + return -ENOMEM; + } @@ -133,7 +132,7 @@ diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/driver + +static void __exit mpc8313leds_exit(void) +{ -+ if (led_mem) release_mem_region(0xfa000000, 0x100); ++ if (led_mem) release_mem_region(LEDS_BASE, LEDS_SIZE); + led_mem = NULL; + platform_driver_unregister(&mpc8313leds_driver); + @@ -145,10 +144,10 @@ diff -urN linux-2.6.23.orig/drivers/leds/leds-mpc8313e-rdb.c linux-2.6.23/driver + +MODULE_AUTHOR("Leon Woestenberg <leon@sidebranch.com>"); +MODULE_DESCRIPTION("MPC8313E-RDB LED driver"); -+ ++MODULE_LICENSE("GPL"); diff -urN linux-2.6.23.orig/drivers/leds/Makefile linux-2.6.23/drivers/leds/Makefile --- linux-2.6.23.orig/drivers/leds/Makefile 2007-10-09 22:31:38.000000000 +0200 -+++ linux-2.6.23/drivers/leds/Makefile 2007-11-29 09:03:09.000000000 +0100 ++++ linux-2.6.23/drivers/leds/Makefile 2007-12-03 11:08:06.000000000 +0100 @@ -17,6 +17,7 @@ obj-$(CONFIG_LEDS_H1940) += leds-h1940.o obj-$(CONFIG_LEDS_COBALT) += leds-cobalt.o diff --git a/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-rtc.patch b/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-rtc.patch new file mode 100644 index 0000000000..4177a3d4a9 --- /dev/null +++ b/packages/linux/linux-2.6.23/mpc8313e-rdb/mpc8313e-rdb-rtc.patch @@ -0,0 +1,40 @@ +diff -urN linux-2.6.23.orig/arch/powerpc/boot/dts/mpc8313erdb.dts linux-2.6.23/arch/powerpc/boot/dts/mpc8313erdb.dts +--- linux-2.6.23.orig/arch/powerpc/boot/dts/mpc8313erdb.dts 2007-10-09 22:31:38.000000000 +0200 ++++ linux-2.6.23/arch/powerpc/boot/dts/mpc8313erdb.dts 2007-12-01 13:16:55.000000000 +0100 +@@ -54,12 +54,20 @@ + }; + + i2c@3000 { ++ #address-cells = <1>; ++ #size-cells = <0>; + device_type = "i2c"; + compatible = "fsl-i2c"; + reg = <3000 100>; + interrupts = <e 8>; + interrupt-parent = < &ipic >; + dfsrr; ++ ++ rtc@68 { ++ device_type = "rtc"; ++ compatible = "dallas,ds1339"; ++ reg = <68>; ++ }; + }; + + i2c@3100 { +diff -urN linux-2.6.23.orig/arch/powerpc/sysdev/fsl_soc.c linux-2.6.23/arch/powerpc/sysdev/fsl_soc.c +--- linux-2.6.23.orig/arch/powerpc/sysdev/fsl_soc.c 2007-10-09 22:31:38.000000000 +0200 ++++ linux-2.6.23/arch/powerpc/sysdev/fsl_soc.c 2007-12-01 13:08:30.000000000 +0100 +@@ -319,6 +319,12 @@ + {"ricoh,rs5c372b", "rtc-rs5c372", "rs5c372b",}, + {"ricoh,rv5c386", "rtc-rs5c372", "rv5c386",}, + {"ricoh,rv5c387a", "rtc-rs5c372", "rv5c387a",}, ++ {"dallas,ds1307", "rtc-ds1307", "ds1307",}, ++ {"dallas,ds1337", "rtc-ds1307", "ds1337",}, ++ {"dallas,ds1338", "rtc-ds1307", "ds1338",}, ++ {"dallas,ds1339", "rtc-ds1307", "ds1339",}, ++ {"dallas,ds1340", "rtc-ds1307", "ds1340",}, ++ {"stm,m41t00", "rtc-ds1307", "m41t00"}, + }; + + static int __init of_find_i2c_driver(struct device_node *node, struct i2c_board_info *info) |