ixp4xx-kernel: Initial version - patches need to be cleaned up to coexist with other ixp4xx machines, updated patchsets to match 2.6.15, removed some patches, and combined some others.

17 files changed, 7472 insertions, 0 deletions

diff --git a/packages/linux/ixp4xx-kernel/.mtn2git_empty b/packages/linux/ixp4xx-kernel/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/.mtn2git_empty
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty b/packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch b/packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch
new file mode 100644
index 0000000000..30d34952d5
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch
@@ -0,0 +1,91 @@
+http://www.arm.linux.org.uk/developer/patches/viewpatch.php?id=3218/1
+
+PAGE_SHIFT is undeclared in include/asm-arm/arch-ixp4xx/memory.h, identified by the following kernel compilation error:
+
+CC [M] sound/core/memory.o
+In file included from include/asm/memory.h:27,
+from include/asm/io.h:28,
+from sound/core/memory.c:24:
+include/asm/arch/memory.h: In function `__arch_adjust_zones':
+include/asm/arch/memory.h:28: error: `PAGE_SHIFT' undeclared (first use
+in this function)
+
+This patch replaces my previous attempt at fixing this problem (Patch 3214/1) and is based on the following feedback:
+
+Russell King wrote:
+> The error you see came up on SA1100. The best solution was to move
+> the __arch_adjust_zones() function out of line. I suggest ixp4xx
+> does the same.
+
+I have moved the function out of line into arch/arm/mach-ixp4xx/common-pci.c as suggested.
+
+Signed-off-by: Rod Whitby <rod@whitby.id.au>
+ 
+--- linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/memory.h~	2005-12-30 05:18:27.000000000 +1030
++++ linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/memory.h	2005-12-30 05:36:04.000000000 +1030
+@@ -16,31 +16,10 @@
+ 
+ #ifndef __ASSEMBLY__
+ 
+-/*
+- * Only first 64MB of memory can be accessed via PCI.
+- * We use GFP_DMA to allocate safe buffers to do map/unmap.
+- * This is really ugly and we need a better way of specifying
+- * DMA-capable regions of memory.
+- */
+-static inline void __arch_adjust_zones(int node, unsigned long *zone_size, 
+-	unsigned long *zhole_size) 
+-{
+-	unsigned int sz = SZ_64M >> PAGE_SHIFT;
+-
+-	/*
+-	 * Only adjust if > 64M on current system
+-	 */
+-	if (node || (zone_size[0] <= sz))
+-		return;
+-
+-	zone_size[1] = zone_size[0] - sz;
+-	zone_size[0] = sz;
+-	zhole_size[1] = zhole_size[0];
+-	zhole_size[0] = 0;
+-}
++void ixp4xx_adjust_zones(int node, unsigned long *size, unsigned long *holes);
+ 
+ #define arch_adjust_zones(node, size, holes) \
+-	__arch_adjust_zones(node, size, holes)
++	ixp4xx_adjust_zones(node, size, holes)
+ 
+ #define ISA_DMA_THRESHOLD (SZ_64M - 1)
+ 
+--- linux-2.6.15-rc7/arch/arm/mach-ixp4xx/common-pci.c~	2005-12-30 05:16:03.000000000 +1030
++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/common-pci.c	2005-12-30 05:43:55.000000000 +1030
+@@ -341,6 +341,29 @@ int dma_needs_bounce(struct device *dev,
+ 	return (dev->bus == &pci_bus_type ) && ((dma_addr + size) >= SZ_64M);
+ }
+ 
++/*
++ * Only first 64MB of memory can be accessed via PCI.
++ * We use GFP_DMA to allocate safe buffers to do map/unmap.
++ * This is really ugly and we need a better way of specifying
++ * DMA-capable regions of memory.
++ */
++void __init ixp4xx_adjust_zones(int node, unsigned long *zone_size, 
++	unsigned long *zhole_size) 
++{
++	unsigned int sz = SZ_64M >> PAGE_SHIFT;
++
++	/*
++	 * Only adjust if > 64M on current system
++	 */
++	if (node || (zone_size[0] <= sz))
++		return;
++
++	zone_size[1] = zone_size[0] - sz;
++	zone_size[0] = sz;
++	zhole_size[1] = zhole_size[0];
++	zhole_size[0] = 0;
++}
++
+ void __init ixp4xx_pci_preinit(void)
+ {  
+ 	unsigned long processor_id;
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch b/packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch
new file mode 100644
index 0000000000..077aa00816
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch
@@ -0,0 +1,77 @@
+drivers/mtd/redboot.c: recognise a foreign byte sex partition table
+
+The RedBoot boot loader writes flash partition tables containing native
+byte sex 32 bit values.  When booting an opposite byte sex kernel (e.g.  an
+LE kernel from BE RedBoot) the current MTD driver fails to handle the
+partition table and therefore is unable to generate the correct partition
+map for the flash.
+
+The patch recognises that the FIS directory (the partition table) is
+byte-reversed by examining the partition table size, which is known to be
+one erase block (this is an assumption made elsewhere in redboot.c).  If
+the size matches the erase block after byte swapping the value then
+byte-reversal is assumed, if not no further action is taken.  The patched
+code is fail safe; should redboot.c be changed to support a partition table
+with a modified size field the test will fail and the partition table will
+be assumed to have the host byte sex.
+
+If byte-reversal is detected the patch byte swaps the remainder of the 32
+bit fields in the copy of the table; this copy is then used to set up the
+MTD partition map.
+
+Signed-off-by: John Bowler <jbowler@acm.org>
+Signed-off-by: Andrew Morton <akpm@osdl.org>
+Modified slightly and
+Signed-off-by: David Woodhouse <dwmw2@infradead.org>
+
+Index: drivers/mtd/redboot.c
+===================================================================
+RCS file: /home/cvs/mtd/drivers/mtd/redboot.c,v
+retrieving revision 1.18
+retrieving revision 1.19
+diff -u -p -r1.18 -r1.19
+--- linux-2.6.15/drivers/mtd/redboot.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/mtd/redboot.c	1970-01-01 00:00:00.000000000 +0000
+@@ -1,5 +1,5 @@
+ /*
+- * $Id: redboot.c,v 1.18 2005/11/07 11:14:21 gleixner Exp $
++ * $Id: redboot.c,v 1.19 2005/12/01 10:03:51 dwmw2 Exp $
+  *
+  * Parse RedBoot-style Flash Image System (FIS) tables and
+  * produce a Linux partition array to match.
+@@ -89,8 +89,32 @@ static int parse_redboot_partitions(stru
+ 			i = numslots;
+ 			break;
+ 		}
+-		if (!memcmp(buf[i].name, "FIS directory", 14))
++		if (!memcmp(buf[i].name, "FIS directory", 14)) {
++			/* This is apparently the FIS directory entry for the
++			 * FIS directory itself.  The FIS directory size is
++			 * one erase block; if the buf[i].size field is
++			 * swab32(erasesize) then we know we are looking at
++			 * a byte swapped FIS directory - swap all the entries!
++			 * (NOTE: this is 'size' not 'data_length'; size is
++			 * the full size of the entry.)
++			 */
++			if (swab32(buf[i].size) == master->erasesize) {
++				int j;
++				for (j = 0; j < numslots && buf[j].name[0] != 0xff; ++j) {
++					/* The unsigned long fields were written with the
++					 * wrong byte sex, name and pad have no byte sex.
++					 */
++					swab32s(&buf[j].flash_base);
++					swab32s(&buf[j].mem_base);
++					swab32s(&buf[j].size);
++					swab32s(&buf[j].entry_point);
++					swab32s(&buf[j].data_length);
++					swab32s(&buf[j].desc_cksum);
++					swab32s(&buf[j].file_cksum);
++				}
++			}
+ 			break;
++		}
+ 	}
+ 	if (i == numslots) {
+ 		/* Didn't find it */
+
+
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch b/packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch
new file mode 100644
index 0000000000..09379031dd
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch
@@ -0,0 +1,13 @@
+--- linux-2.6.15/fs/jffs2/nodelist.h	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/fs/jffs2/nodelist.h	1970-01-01 00:00:00.000000000 +0000
+@@ -44,7 +44,9 @@
+ #define D2(x)
+ #endif
+ 
+-#define JFFS2_NATIVE_ENDIAN
++#undef JFFS2_NATIVE_ENDIAN
++#define JFFS2_BIG_ENDIAN 1
++#undef JFFS2_LITTLE_ENDIAN
+ 
+ /* Note we handle mode bits conversion from JFFS2 (i.e. Linux) to/from
+    whatever OS we're actually running on here too. */
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch b/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch
new file mode 100644
index 0000000000..feea3f2f8b
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch
@@ -0,0 +1,2719 @@
+--- linux-nslu2.orig/include/linux/rtc.h	2006-01-03 15:31:18.000000000 +0100
++++ linux-nslu2/include/linux/rtc.h	2006-01-03 15:34:24.000000000 +0100
+@@ -91,8 +91,81 @@ struct rtc_pll_info {
+ #define RTC_PLL_GET	_IOR('p', 0x11, struct rtc_pll_info)  /* Get PLL correction */
+ #define RTC_PLL_SET	_IOW('p', 0x12, struct rtc_pll_info)  /* Set PLL correction */
+ 
++/* interrupt flags */
++#define RTC_IRQF 0x80 /* any of the following is active */
++#define RTC_PF 0x40
++#define RTC_AF 0x20
++#define RTC_UF 0x10
++
+ #ifdef __KERNEL__
+ 
++#include <linux/device.h>
++#include <linux/seq_file.h>
++#include <linux/cdev.h>
++#include <linux/poll.h>
++
++struct rtc_class_ops {
++	int (*open)(struct device *);
++	void (*release)(struct device *);
++	int (*ioctl)(struct device *, unsigned int, unsigned long);
++	int (*read_time)(struct device *, struct rtc_time *);
++	int (*set_time)(struct device *, struct rtc_time *);
++	int (*read_alarm)(struct device *, struct rtc_wkalrm *);
++	int (*set_alarm)(struct device *, struct rtc_wkalrm *);
++	int (*proc)(struct device *, struct seq_file *);
++	int (*set_mmss)(struct device *, unsigned long secs);
++	int (*irq_set_state)(struct device *, int enabled);
++	int (*irq_set_freq)(struct device *, int freq);
++};
++
++#define RTC_DEVICE_NAME_SIZE 20
++struct rtc_task;
++
++struct rtc_device
++{
++	int id;
++	struct module *owner;
++	struct rw_semaphore lock;
++	struct class_device class_dev;
++	struct rtc_class_ops *ops;
++	char name[RTC_DEVICE_NAME_SIZE];
++
++	struct cdev char_dev;
++	struct semaphore char_sem;
++
++	unsigned long irq_data;
++	spinlock_t irq_lock;
++	wait_queue_head_t irq_queue;
++	struct fasync_struct *async_queue;
++
++	spinlock_t irq_task_lock;
++	struct rtc_task *irq_task;
++	int irq_freq;
++};
++#define to_rtc_device(d) container_of(d, struct rtc_device, class_dev)
++
++extern struct rtc_device *rtc_device_register(char *name,
++					struct device *dev,
++					struct rtc_class_ops *ops,
++					struct module *owner);
++extern void rtc_device_unregister(struct rtc_device *rdev);
++extern int rtc_interface_register(struct class_interface *intf);
++
++
++extern int rtc_month_days(unsigned int month, unsigned int year);
++extern int rtc_valid_tm(struct rtc_time *tm);
++extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time);
++extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm);
++
++extern int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm);
++extern int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm);
++extern int rtc_read_alarm(struct class_device *class_dev,
++				struct rtc_wkalrm *alrm);
++extern int rtc_set_alarm(struct class_device *class_dev,
++				struct rtc_wkalrm *alrm);
++extern void rtc_update_irq(struct class_device *class_dev,
++			unsigned long num, unsigned long events);
++
+ typedef struct rtc_task {
+ 	void (*func)(void *private_data);
+ 	void *private_data;
+--- linux-nslu2.orig/drivers/Kconfig	2006-01-03 15:31:19.000000000 +0100
++++ linux-nslu2/drivers/Kconfig	2006-01-04 01:27:31.000000000 +0100
+@@ -66,4 +66,6 @@ source "drivers/infiniband/Kconfig"
+ 
+ source "drivers/sn/Kconfig"
+ 
++source "drivers/rtc/Kconfig"
++
+ endmenu
+--- linux-nslu2.orig/drivers/Makefile	2006-01-03 15:33:32.000000000 +0100
++++ linux-nslu2/drivers/Makefile	2006-01-04 01:27:31.000000000 +0100
+@@ -54,6 +54,7 @@ obj-$(CONFIG_USB_GADGET)	+= usb/gadget/
+ obj-$(CONFIG_GAMEPORT)		+= input/gameport/
+ obj-$(CONFIG_INPUT)		+= input/
+ obj-$(CONFIG_I2O)		+= message/
++obj-y				+= rtc/
+ obj-$(CONFIG_I2C)		+= i2c/
+ obj-$(CONFIG_W1)		+= w1/
+ obj-$(CONFIG_HWMON)		+= hwmon/
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/class.c	2006-01-03 15:45:19.000000000 +0100
+@@ -0,0 +1,141 @@
++/*
++ * RTC subsystem, base class
++ *
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * class skeleton from drivers/hwmon/hwmon.c
++ *
++ * 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; version 2 of the License.
++*/
++
++#include <linux/module.h>
++#include <linux/rtc.h>
++#include <linux/kdev_t.h>
++#include <linux/idr.h>
++
++static DEFINE_IDR(rtc_idr);
++static DECLARE_MUTEX(idr_lock);
++struct class *rtc_class;
++
++static void rtc_device_release(struct class_device *class_dev)
++{
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++	down(&idr_lock);
++	idr_remove(&rtc_idr, rtc->id);
++	up(&idr_lock);
++	kfree(rtc);
++}
++
++/**
++ * rtc_device_register - register w/ RTC class
++ * @dev: the device to register
++ *
++ * rtc_device_unregister() must be called when the class device is no
++ * longer needed.
++ *
++ * Returns the pointer to the new struct class device.
++ */
++struct rtc_device *rtc_device_register(char *name, struct device *dev,
++					struct rtc_class_ops *ops,
++					struct module *owner)
++{
++	struct rtc_device *rtc;
++	int id, err;
++
++	if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) {
++		err = -ENOMEM;
++		goto exit;
++	}
++
++
++	down(&idr_lock);
++	err = idr_get_new(&rtc_idr, NULL, &id);
++	up(&idr_lock);
++
++	if (err < 0)
++		goto exit;
++
++	id = id & MAX_ID_MASK;
++
++	if ((rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL)) == NULL) {
++		err = -ENOMEM;
++		goto exit_idr;
++	}
++
++	rtc->id = id;
++	rtc->ops = ops;
++	rtc->owner = owner;
++	rtc->class_dev.dev = dev;
++	rtc->class_dev.class = rtc_class;
++	rtc->class_dev.release = rtc_device_release;
++
++	init_rwsem(&rtc->lock);
++	spin_lock_init(&rtc->irq_lock);
++	spin_lock_init(&rtc->irq_task_lock);
++
++	strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE);
++	snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id);
++
++	if ((err = class_device_register(&rtc->class_dev)))
++		goto exit_kfree;
++
++	dev_info(dev, "rtc core: registered %s as %s\n",
++			rtc->name, rtc->class_dev.class_id);
++
++	return rtc;
++
++exit_kfree:
++	kfree(rtc);
++
++exit_idr:
++	idr_remove(&rtc_idr, id);
++
++exit:
++	return ERR_PTR(err);
++}
++EXPORT_SYMBOL_GPL(rtc_device_register);
++
++
++/**
++ * rtc_device_unregister - removes the previously registered RTC class device
++ *
++ * @rtc: the RTC class device to destroy
++ */
++void rtc_device_unregister(struct rtc_device *rtc)
++{
++	down_write(&rtc->lock);
++	class_device_unregister(&rtc->class_dev);
++}
++EXPORT_SYMBOL_GPL(rtc_device_unregister);
++
++int rtc_interface_register(struct class_interface *intf)
++{
++	intf->class = rtc_class;
++	return class_interface_register(intf);
++}
++EXPORT_SYMBOL_GPL(rtc_interface_register);
++
++static int __init rtc_init(void)
++{
++	rtc_class = class_create(THIS_MODULE, "rtc");
++	if (IS_ERR(rtc_class)) {
++		printk(KERN_ERR "%s: couldn't create class\n", __FILE__);
++		return PTR_ERR(rtc_class);
++	}
++	return 0;
++}
++
++static void __exit rtc_exit(void)
++{
++	class_destroy(rtc_class);
++}
++
++module_init(rtc_init);
++module_exit(rtc_exit);
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towerteh.it>");
++MODULE_DESCRIPTION("RTC class support");
++MODULE_LICENSE("GPL");
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/Kconfig	2006-01-04 01:27:21.000000000 +0100
+@@ -0,0 +1,93 @@
++#
++# RTC class/drivers configuration
++#
++
++menu "Real Time Clock"
++
++config RTC_CLASS
++	tristate "RTC class"
++	depends on EXPERIMENTAL
++	default y
++	help
++	  Generic RTC class support. If you say yes here, you will
++ 	  be allowed to plug one or more RTCs to your system. You will
++	  probably want to enable one of more of the interfaces below.
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-class.
++
++comment "RTC interfaces"
++	depends on RTC_CLASS
++
++config RTC_INTF_SYSFS
++	tristate "sysfs"
++	depends on RTC_CLASS && SYSFS
++	default RTC_CLASS
++	help
++	  Say yes here if you want to use your RTC using the sysfs
++	  interface, /sys/class/rtc/rtcX .
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-sysfs.
++
++config RTC_INTF_PROC
++	tristate "proc"
++	depends on RTC_CLASS && PROC_FS
++	default RTC_CLASS
++	help
++	  Say yes here if you want to use your RTC using the proc
++	  interface, /proc/driver/rtc .
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-proc.
++
++config RTC_INTF_DEV
++	tristate "dev"
++	depends on RTC_CLASS
++	default RTC_CLASS
++	help
++	  Say yes here if you want to use your RTC using the dev
++	  interface, /dev/rtc .
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-dev.
++
++comment "RTC drivers"
++	depends on RTC_CLASS
++
++config RTC_DRV_X1205
++	tristate "Xicor/Intersil X1205 RTC chip"
++	depends on RTC_CLASS && I2C
++	help
++	  If you say yes here you get support for the
++	  Xicor/Intersil X1205 RTC chip.
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-x1205.
++
++config RTC_DRV_DS1672
++	tristate "Dallas/Maxim DS1672"
++	depends on RTC_CLASS && I2C
++	help
++	  If you say yes here you get support for the
++	  Dallas/Maxim DS1672 timekeeping chip.
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-ds1672.
++
++config RTC_DRV_TEST
++	tristate "Test driver/device"
++	depends on RTC_CLASS
++	help
++	  If you say yes here you get support for the
++	  RTC test driver. It's a software RTC which can be
++	  used to test the RTC subsystem APIs. It gets
++	  the time from the system clock.
++	  You want this driver only if you are doing development
++	  on the RTC subsystem. Please read the source code
++	  for further details.
++
++	  This driver can also be built as a module. If so, the module
++	  will be called rtc-test.
++
++endmenu
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/Makefile	2006-01-04 01:27:21.000000000 +0100
+@@ -0,0 +1,15 @@
++#
++# Makefile for RTC class/drivers.
++#
++
++obj-y				+= utils.o
++obj-$(CONFIG_RTC_CLASS)		+= rtc-core.o
++rtc-core-y			:= class.o interface.o
++obj-$(CONFIG_RTC_INTF_SYSFS)	+= rtc-sysfs.o
++obj-$(CONFIG_RTC_INTF_PROC)	+= rtc-proc.o
++obj-$(CONFIG_RTC_INTF_DEV)	+= rtc-dev.o
++
++obj-$(CONFIG_RTC_DRV_X1205)	+= rtc-x1205.o
++obj-$(CONFIG_RTC_DRV_TEST)	+= rtc-test.o
++obj-$(CONFIG_RTC_DRV_DS1672)	+= rtc-ds1672.o
++
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/interface.c	2006-01-03 15:34:24.000000000 +0100
+@@ -0,0 +1,189 @@
++/*
++ * RTC subsystem, interface functions
++ *
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * based on arch/arm/common/rtctime.c
++ *
++ * 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; version 2 of the License.
++*/
++
++#include <linux/rtc.h>
++
++extern struct class *rtc_class;
++
++int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm)
++{
++	int err = -EINVAL;
++	struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
++
++	if (ops->read_time) {
++		memset(tm, 0, sizeof(struct rtc_time));
++		err = ops->read_time(class_dev->dev, tm);
++	}
++	return err;
++}
++EXPORT_SYMBOL(rtc_read_time);
++
++int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm)
++{
++	int err;
++	struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
++
++	err = rtc_valid_tm(tm);
++	if (err == 0 && ops->set_time)
++		err = ops->set_time(class_dev->dev, tm);
++
++	return err;
++}
++EXPORT_SYMBOL(rtc_set_time);
++
++int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
++{
++	struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
++	int err = -EINVAL;
++
++	if (ops->read_alarm) {
++		memset(alarm, 0, sizeof(struct rtc_wkalrm));
++		err = ops->read_alarm(class_dev->dev, alarm);
++	}
++	return err;
++}
++EXPORT_SYMBOL(rtc_read_alarm);
++
++int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm)
++{
++	int err = -EINVAL;
++	struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
++
++	if (ops->set_alarm)
++		err = ops->set_alarm(class_dev->dev, alarm);
++	return err;
++}
++EXPORT_SYMBOL(rtc_set_alarm);
++
++void rtc_update_irq(struct class_device *class_dev,
++		unsigned long num, unsigned long events)
++{
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	spin_lock(&rtc->irq_lock);
++	rtc->irq_data = (rtc->irq_data + (num << 8)) | events;
++	spin_unlock(&rtc->irq_lock);
++
++	spin_lock(&rtc->irq_task_lock);
++	if (rtc->irq_task)
++		rtc->irq_task->func(rtc->irq_task->private_data);
++	spin_unlock(&rtc->irq_task_lock);
++
++	wake_up_interruptible(&rtc->irq_queue);
++	kill_fasync(&rtc->async_queue, SIGIO, POLL_IN);
++}
++EXPORT_SYMBOL(rtc_update_irq);
++
++struct class_device *rtc_open(char *name)
++{
++	struct class_device *class_dev = NULL,
++				*class_dev_tmp;
++
++	down(&rtc_class->sem);
++	list_for_each_entry(class_dev_tmp, &rtc_class->children, node) {
++		if (strncmp(class_dev_tmp->class_id, name, BUS_ID_SIZE) == 0) {
++			class_dev = class_dev_tmp;
++			break;
++		}
++	}
++	up(&rtc_class->sem);
++
++	return class_dev;
++}
++EXPORT_SYMBOL(rtc_open);
++
++void rtc_close(struct class_device *class_dev)
++{
++}
++EXPORT_SYMBOL(rtc_close);
++
++int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task)
++{
++	int retval = -EBUSY;
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	if (task == NULL || task->func == NULL)
++		return -EINVAL;
++
++	spin_lock(&rtc->irq_task_lock);
++	if (rtc->irq_task == NULL) {
++		rtc->irq_task = task;
++		retval = 0;
++	}
++	spin_unlock(&rtc->irq_task_lock);
++
++	return retval;
++}
++EXPORT_SYMBOL(rtc_irq_register);
++
++void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task)
++{
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	spin_lock(&rtc->irq_task_lock);
++	if (rtc->irq_task == task)
++		rtc->irq_task = NULL;
++	spin_unlock(&rtc->irq_task_lock);
++}
++EXPORT_SYMBOL(rtc_irq_unregister);
++
++int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int enabled)
++{
++	int err = 0;
++	unsigned long flags;
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	spin_lock_irqsave(&rtc->irq_task_lock, flags);
++	if (rtc->irq_task != task)
++		err = -ENXIO;
++	spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
++
++	if (err == 0)
++		err = rtc->ops->irq_set_state(class_dev->dev, enabled);
++
++	return err;
++}
++EXPORT_SYMBOL(rtc_irq_set_state);
++
++int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int freq)
++{
++	int err = 0, tmp = 0;
++	unsigned long flags;
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	/* allowed range is 2-8192 */
++	if (freq < 2 || freq > 8192)
++		return -EINVAL;
++
++/*	if ((freq > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
++		return -EACCES;
++*/
++	/* check if freq is a power of 2 */
++	while (freq > (1 << tmp))
++		tmp++;
++
++	if (freq != (1 << tmp))
++		return -EINVAL;
++
++	spin_lock_irqsave(&rtc->irq_task_lock, flags);
++	if (rtc->irq_task != task)
++		err = -ENXIO;
++	spin_unlock_irqrestore(&rtc->irq_task_lock, flags);
++
++	if (err == 0) {
++		if ((err = rtc->ops->irq_set_freq(class_dev->dev, freq)) == 0)
++			rtc->irq_freq = freq;
++	}
++	return err;
++
++}
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/utils.c	2006-01-03 15:34:24.000000000 +0100
+@@ -0,0 +1,97 @@
++/*
++ * RTC subsystem, utility functions
++ *
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * based on arch/arm/common/rtctime.c
++ *
++ * 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; version 2 of the License.
++*/
++
++#include <linux/rtc.h>
++
++static const unsigned char rtc_days_in_month[] = {
++	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
++};
++
++#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
++#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
++
++int rtc_month_days(unsigned int month, unsigned int year)
++{
++	return rtc_days_in_month[month] + (LEAP_YEAR(year) && month == 1);
++}
++EXPORT_SYMBOL(rtc_month_days);
++
++/*
++ * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
++ */
++void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
++{
++	int days, month, year;
++
++	days = time / 86400;
++	time -= days * 86400;
++
++	tm->tm_wday = (days + 4) % 7;
++
++	year = 1970 + days / 365;
++	days -= (year - 1970) * 365
++	        + LEAPS_THRU_END_OF(year - 1)
++	        - LEAPS_THRU_END_OF(1970 - 1);
++	if (days < 0) {
++		year -= 1;
++		days += 365 + LEAP_YEAR(year);
++	}
++	tm->tm_year = year - 1900;
++	tm->tm_yday = days + 1;
++
++	for (month = 0; month < 11; month++) {
++		int newdays;
++
++		newdays = days - rtc_month_days(month, year);
++		if (newdays < 0)
++			break;
++		days = newdays;
++	}
++	tm->tm_mon = month;
++	tm->tm_mday = days + 1;
++
++	tm->tm_hour = time / 3600;
++	time -= tm->tm_hour * 3600;
++	tm->tm_min = time / 60;
++	tm->tm_sec = time - tm->tm_min * 60;
++}
++EXPORT_SYMBOL(rtc_time_to_tm);
++
++/*
++ * Does the rtc_time represent a valid date/time?
++ */
++int rtc_valid_tm(struct rtc_time *tm)
++{
++	if (tm->tm_year < 70 ||
++	    tm->tm_mon >= 12 ||
++	    tm->tm_mday < 1 ||
++	    tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + 1900) ||
++	    tm->tm_hour >= 24 ||
++	    tm->tm_min >= 60 ||
++	    tm->tm_sec >= 60)
++		return -EINVAL;
++
++	return 0;
++}
++EXPORT_SYMBOL(rtc_valid_tm);
++
++/*
++ * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
++ */
++int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
++{
++	*time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
++		       tm->tm_hour, tm->tm_min, tm->tm_sec);
++	return 0;
++}
++EXPORT_SYMBOL(rtc_tm_to_time);
+--- linux-nslu2.orig/arch/arm/Kconfig	2006-01-04 01:27:04.000000000 +0100
++++ linux-nslu2/arch/arm/Kconfig	2006-01-04 01:27:31.000000000 +0100
+@@ -750,6 +750,8 @@ source "drivers/usb/Kconfig"
+ 
+ source "drivers/mmc/Kconfig"
+ 
++source "drivers/rtc/Kconfig"
++
+ endmenu
+ 
+ source "fs/Kconfig"
+--- linux-nslu2.orig/arch/arm/common/rtctime.c	2006-01-04 01:27:04.000000000 +0100
++++ linux-nslu2/arch/arm/common/rtctime.c	2006-01-04 01:27:09.000000000 +0100
+@@ -40,89 +40,6 @@ static struct rtc_ops *rtc_ops;
+ 
+ #define rtc_epoch 1900UL
+ 
+-static const unsigned char days_in_month[] = {
+-	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+-};
+-
+-#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
+-#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
+-
+-static int month_days(unsigned int month, unsigned int year)
+-{
+-	return days_in_month[month] + (LEAP_YEAR(year) && month == 1);
+-}
+-
+-/*
+- * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
+- */
+-void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
+-{
+-	int days, month, year;
+-
+-	days = time / 86400;
+-	time -= days * 86400;
+-
+-	tm->tm_wday = (days + 4) % 7;
+-
+-	year = 1970 + days / 365;
+-	days -= (year - 1970) * 365
+-	        + LEAPS_THRU_END_OF(year - 1)
+-	        - LEAPS_THRU_END_OF(1970 - 1);
+-	if (days < 0) {
+-		year -= 1;
+-		days += 365 + LEAP_YEAR(year);
+-	}
+-	tm->tm_year = year - 1900;
+-	tm->tm_yday = days + 1;
+-
+-	for (month = 0; month < 11; month++) {
+-		int newdays;
+-
+-		newdays = days - month_days(month, year);
+-		if (newdays < 0)
+-			break;
+-		days = newdays;
+-	}
+-	tm->tm_mon = month;
+-	tm->tm_mday = days + 1;
+-
+-	tm->tm_hour = time / 3600;
+-	time -= tm->tm_hour * 3600;
+-	tm->tm_min = time / 60;
+-	tm->tm_sec = time - tm->tm_min * 60;
+-}
+-EXPORT_SYMBOL(rtc_time_to_tm);
+-
+-/*
+- * Does the rtc_time represent a valid date/time?
+- */
+-int rtc_valid_tm(struct rtc_time *tm)
+-{
+-	if (tm->tm_year < 70 ||
+-	    tm->tm_mon >= 12 ||
+-	    tm->tm_mday < 1 ||
+-	    tm->tm_mday > month_days(tm->tm_mon, tm->tm_year + 1900) ||
+-	    tm->tm_hour >= 24 ||
+-	    tm->tm_min >= 60 ||
+-	    tm->tm_sec >= 60)
+-		return -EINVAL;
+-
+-	return 0;
+-}
+-EXPORT_SYMBOL(rtc_valid_tm);
+-
+-/*
+- * Convert Gregorian date to seconds since 01-01-1970 00:00:00.
+- */
+-int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time)
+-{
+-	*time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+-		       tm->tm_hour, tm->tm_min, tm->tm_sec);
+-
+-	return 0;
+-}
+-EXPORT_SYMBOL(rtc_tm_to_time);
+-
+ /*
+  * Calculate the next alarm time given the requested alarm time mask
+  * and the current time.
+@@ -141,13 +58,13 @@ void rtc_next_alarm_time(struct rtc_time
+ 	next->tm_sec = alrm->tm_sec;
+ }
+ 
+-static inline int rtc_read_time(struct rtc_ops *ops, struct rtc_time *tm)
++static inline int rtc_arm_read_time(struct rtc_ops *ops, struct rtc_time *tm)
+ {
+ 	memset(tm, 0, sizeof(struct rtc_time));
+ 	return ops->read_time(tm);
+ }
+ 
+-static inline int rtc_set_time(struct rtc_ops *ops, struct rtc_time *tm)
++static inline int rtc_arm_set_time(struct rtc_ops *ops, struct rtc_time *tm)
+ {
+ 	int ret;
+ 
+@@ -158,7 +75,7 @@ static inline int rtc_set_time(struct rt
+ 	return ret;
+ }
+ 
+-static inline int rtc_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
++static inline int rtc_arm_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
+ {
+ 	int ret = -EINVAL;
+ 	if (ops->read_alarm) {
+@@ -168,7 +85,7 @@ static inline int rtc_read_alarm(struct 
+ 	return ret;
+ }
+ 
+-static inline int rtc_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
++static inline int rtc_arm_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm)
+ {
+ 	int ret = -EINVAL;
+ 	if (ops->set_alarm)
+@@ -256,7 +173,7 @@ static int rtc_ioctl(struct inode *inode
+ 
+ 	switch (cmd) {
+ 	case RTC_ALM_READ:
+-		ret = rtc_read_alarm(ops, &alrm);
++		ret = rtc_arm_read_alarm(ops, &alrm);
+ 		if (ret)
+ 			break;
+ 		ret = copy_to_user(uarg, &alrm.time, sizeof(tm));
+@@ -278,11 +195,11 @@ static int rtc_ioctl(struct inode *inode
+ 		alrm.time.tm_wday = -1;
+ 		alrm.time.tm_yday = -1;
+ 		alrm.time.tm_isdst = -1;
+-		ret = rtc_set_alarm(ops, &alrm);
++		ret = rtc_arm_set_alarm(ops, &alrm);
+ 		break;
+ 
+ 	case RTC_RD_TIME:
+-		ret = rtc_read_time(ops, &tm);
++		ret = rtc_arm_read_time(ops, &tm);
+ 		if (ret)
+ 			break;
+ 		ret = copy_to_user(uarg, &tm, sizeof(tm));
+@@ -300,7 +217,7 @@ static int rtc_ioctl(struct inode *inode
+ 			ret = -EFAULT;
+ 			break;
+ 		}
+-		ret = rtc_set_time(ops, &tm);
++		ret = rtc_arm_set_time(ops, &tm);
+ 		break;
+ 
+ 	case RTC_EPOCH_SET:
+@@ -331,11 +248,11 @@ static int rtc_ioctl(struct inode *inode
+ 			ret = -EFAULT;
+ 			break;
+ 		}
+-		ret = rtc_set_alarm(ops, &alrm);
++		ret = rtc_arm_set_alarm(ops, &alrm);
+ 		break;
+ 
+ 	case RTC_WKALM_RD:
+-		ret = rtc_read_alarm(ops, &alrm);
++		ret = rtc_arm_read_alarm(ops, &alrm);
+ 		if (ret)
+ 			break;
+ 		ret = copy_to_user(uarg, &alrm, sizeof(alrm));
+@@ -425,7 +342,7 @@ static int rtc_read_proc(char *page, cha
+ 	struct rtc_time tm;
+ 	char *p = page;
+ 
+-	if (rtc_read_time(ops, &tm) == 0) {
++	if (rtc_arm_read_time(ops, &tm) == 0) {
+ 		p += sprintf(p,
+ 			"rtc_time\t: %02d:%02d:%02d\n"
+ 			"rtc_date\t: %04d-%02d-%02d\n"
+@@ -435,7 +352,7 @@ static int rtc_read_proc(char *page, cha
+ 			rtc_epoch);
+ 	}
+ 
+-	if (rtc_read_alarm(ops, &alrm) == 0) {
++	if (rtc_arm_read_alarm(ops, &alrm) == 0) {
+ 		p += sprintf(p, "alrm_time\t: ");
+ 		if ((unsigned int)alrm.time.tm_hour <= 24)
+ 			p += sprintf(p, "%02d:", alrm.time.tm_hour);
+--- linux-nslu2.orig/include/asm-arm/rtc.h	2006-01-04 01:27:04.000000000 +0100
++++ linux-nslu2/include/asm-arm/rtc.h	2006-01-04 01:27:09.000000000 +0100
+@@ -25,9 +25,6 @@ struct rtc_ops {
+ 	int		(*proc)(char *buf);
+ };
+ 
+-void rtc_time_to_tm(unsigned long, struct rtc_time *);
+-int rtc_tm_to_time(struct rtc_time *, unsigned long *);
+-int rtc_valid_tm(struct rtc_time *);
+ void rtc_next_alarm_time(struct rtc_time *, struct rtc_time *, struct rtc_time *);
+ void rtc_update(unsigned long, unsigned long);
+ int register_rtc(struct rtc_ops *);
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/rtc-sysfs.c	2006-01-04 01:27:12.000000000 +0100
+@@ -0,0 +1,125 @@
++/*
++ * RTC subsystem, sysfs interface
++ *
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * 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; version 2 of the License.
++*/
++
++#include <linux/module.h>
++#include <linux/rtc.h>
++
++/* device attributes */
++
++static ssize_t rtc_sysfs_show_name(struct class_device *dev, char *buf)
++{
++	return sprintf(buf, "%s\n", to_rtc_device(dev)->name);
++}
++static CLASS_DEVICE_ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL);
++
++static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf)
++{
++	ssize_t retval = 0;
++	struct rtc_device *rtc = to_rtc_device(dev);
++	struct rtc_time tm;
++
++	if (down_read_trylock(&rtc->lock) == 0)
++		return -ENODEV;
++
++	if (rtc_read_time(dev, &tm) == 0) {
++		retval = sprintf(buf, "%04d-%02d-%02d\n",
++			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
++	}
++
++	up_read(&rtc->lock);
++	return retval;
++}
++static CLASS_DEVICE_ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL);
++
++static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf)
++{
++	ssize_t retval = 0;
++	struct rtc_device *rtc = to_rtc_device(dev);
++	struct rtc_time tm;
++
++	if (down_read_trylock(&rtc->lock) == 0)
++		return -ENODEV;
++
++	if (rtc_read_time(dev, &tm) == 0) {
++		retval = sprintf(buf, "%02d:%02d:%02d\n",
++			tm.tm_hour, tm.tm_min, tm.tm_sec);
++	}
++
++	up_read(&rtc->lock);
++	return retval;
++}
++static CLASS_DEVICE_ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL);
++
++static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf)
++{
++	ssize_t retval = 0;
++	struct rtc_device *rtc = to_rtc_device(dev);
++	struct rtc_time tm;
++
++	if (down_read_trylock(&rtc->lock) == 0)
++		return -ENODEV;
++
++	if (rtc_read_time(dev, &tm) == 0) {
++		unsigned long time;
++		rtc_tm_to_time(&tm, &time);
++		retval = sprintf(buf, "%lu\n", time);
++	}
++
++	up_read(&rtc->lock);
++	return retval;
++}
++static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL);
++
++/* insertion/removal hooks */
++
++static int __devinit rtc_sysfs_add_device(struct class_device *class_dev,
++					   struct class_interface *class_intf)
++{
++	class_device_create_file(class_dev, &class_device_attr_name);
++	class_device_create_file(class_dev, &class_device_attr_date);
++	class_device_create_file(class_dev, &class_device_attr_time);
++	class_device_create_file(class_dev, &class_device_attr_since_epoch);
++	dev_info(class_dev->dev, "rtc intf: sysfs\n");
++	return 0;
++}
++
++static void rtc_sysfs_remove_device(struct class_device *class_dev,
++				      struct class_interface *class_intf)
++{
++	class_device_remove_file(class_dev, &class_device_attr_name);
++	class_device_remove_file(class_dev, &class_device_attr_date);
++	class_device_remove_file(class_dev, &class_device_attr_time);
++	class_device_remove_file(class_dev, &class_device_attr_since_epoch);
++}
++
++/* interface registration */
++
++struct class_interface rtc_sysfs_interface = {
++	.add = &rtc_sysfs_add_device,
++	.remove = &rtc_sysfs_remove_device,
++};
++
++static int __init rtc_sysfs_init(void)
++{
++	return rtc_interface_register(&rtc_sysfs_interface);
++}
++
++static void __exit rtc_sysfs_exit(void)
++{
++	class_interface_unregister(&rtc_sysfs_interface);
++}
++
++module_init(rtc_sysfs_init);
++module_exit(rtc_sysfs_exit);
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("RTC class sysfs interface");
++MODULE_LICENSE("GPL");
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/rtc-proc.c	2006-01-04 01:27:14.000000000 +0100
+@@ -0,0 +1,158 @@
++/*
++ * RTC subsystem, proc interface
++ *
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * based on arch/arm/common/rtctime.c
++ *
++ * 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; version 2 of the License.
++*/
++
++#include <linux/module.h>
++#include <linux/rtc.h>
++#include <linux/proc_fs.h>
++#include <linux/seq_file.h>
++
++static struct class_device *rtc_dev = NULL;
++static DECLARE_MUTEX(rtc_sem);
++
++static int rtc_proc_show(struct seq_file *seq, void *offset)
++{
++	struct class_device *class_dev = seq->private;
++	struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops;
++	struct rtc_wkalrm alrm;
++	struct rtc_time tm;
++
++	if (rtc_read_time(class_dev, &tm) == 0) {
++		seq_printf(seq,
++			"rtc_time\t: %02d:%02d:%02d\n"
++			"rtc_date\t: %04d-%02d-%02d\n",
++			tm.tm_hour, tm.tm_min, tm.tm_sec,
++			tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
++	}
++
++	if (rtc_read_alarm(class_dev, &alrm) == 0) {
++		seq_printf(seq, "alrm_time\t: ");
++		if ((unsigned int)alrm.time.tm_hour <= 24)
++			seq_printf(seq, "%02d:", alrm.time.tm_hour);
++		else
++			seq_printf(seq, "**:");
++		if ((unsigned int)alrm.time.tm_min <= 59)
++			seq_printf(seq, "%02d:", alrm.time.tm_min);
++		else
++			seq_printf(seq, "**:");
++		if ((unsigned int)alrm.time.tm_sec <= 59)
++			seq_printf(seq, "%02d\n", alrm.time.tm_sec);
++		else
++			seq_printf(seq, "**\n");
++
++		seq_printf(seq, "alrm_date\t: ");
++		if ((unsigned int)alrm.time.tm_year <= 200)
++			seq_printf(seq, "%04d-", alrm.time.tm_year + 1900);
++		else
++			seq_printf(seq, "****-");
++		if ((unsigned int)alrm.time.tm_mon <= 11)
++			seq_printf(seq, "%02d-", alrm.time.tm_mon + 1);
++		else
++			seq_printf(seq, "**-");
++		if ((unsigned int)alrm.time.tm_mday <= 31)
++			seq_printf(seq, "%02d\n", alrm.time.tm_mday);
++		else
++			seq_printf(seq, "**\n");
++		seq_printf(seq, "alrm_wakeup\t: %s\n",
++			     alrm.enabled ? "yes" : "no");
++		seq_printf(seq, "alrm_pending\t: %s\n",
++			     alrm.pending ? "yes" : "no");
++	}
++
++	if (ops->proc)
++		ops->proc(class_dev->dev, seq);
++
++	return 0;
++}
++
++static int rtc_proc_open(struct inode *inode, struct file *file)
++{
++	struct class_device *class_dev = PDE(inode)->data;
++
++	if (!try_module_get(THIS_MODULE))
++		return -ENODEV;
++
++	return single_open(file, rtc_proc_show, class_dev);
++}
++
++static int rtc_proc_release(struct inode *inode, struct file *file)
++{
++	int res = single_release(inode, file);
++	module_put(THIS_MODULE);
++	return res;
++}
++
++static struct file_operations rtc_proc_fops = {
++	.open		= rtc_proc_open,
++	.read		= seq_read,
++	.llseek		= seq_lseek,
++	.release	= rtc_proc_release,
++};
++
++static int rtc_proc_add_device(struct class_device *class_dev,
++					   struct class_interface *class_intf)
++{
++	down(&rtc_sem);
++	if (rtc_dev == NULL) {
++		struct proc_dir_entry *ent;
++
++		rtc_dev = class_dev;
++
++		if ((ent = create_proc_entry("driver/rtc", 0, NULL))) {
++			struct rtc_device *rtc = to_rtc_device(class_dev);
++
++			ent->proc_fops = &rtc_proc_fops;
++			ent->owner = rtc->owner;
++			ent->data = class_dev;
++
++			dev_info(class_dev->dev, "rtc intf: proc\n");
++		}
++		else
++			rtc_dev = NULL;
++	}
++	up(&rtc_sem);
++
++	return 0;
++}
++
++static void rtc_proc_remove_device(struct class_device *class_dev,
++					      struct class_interface *class_intf)
++{
++	down(&rtc_sem);
++	if (rtc_dev == class_dev) {
++		remove_proc_entry("driver/rtc", NULL);
++		rtc_dev = NULL;
++	}
++	up(&rtc_sem);
++}
++
++struct class_interface rtc_proc_interface = {
++	.add = &rtc_proc_add_device,
++	.remove = &rtc_proc_remove_device,
++};
++
++static int __init rtc_proc_init(void)
++{
++	return rtc_interface_register(&rtc_proc_interface);
++}
++
++static void __exit rtc_proc_exit(void)
++{
++	class_interface_unregister(&rtc_proc_interface);
++}
++
++module_init(rtc_proc_init);
++module_exit(rtc_proc_exit);
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("RTC class proc interface");
++MODULE_LICENSE("GPL");
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/rtc-dev.c	2006-01-04 01:27:15.000000000 +0100
+@@ -0,0 +1,372 @@
++/*
++ * RTC subsystem, dev interface
++ *
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * based on arch/arm/common/rtctime.c
++ *
++ * 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; version 2 of the License.
++*/
++
++#include <linux/module.h>
++#include <linux/rtc.h>
++
++static dev_t rtc_devt;
++
++#define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */
++
++static int rtc_dev_open(struct inode *inode, struct file *file)
++{
++	int err;
++	struct rtc_device *rtc = container_of(inode->i_cdev,
++					struct rtc_device, char_dev);
++	struct rtc_class_ops *ops = rtc->ops;
++
++	/* We keep the lock as long as the device is in use
++	 * and return immediately if busy
++	 */
++	if (down_trylock(&rtc->char_sem))
++		return -EBUSY;
++
++	file->private_data = &rtc->class_dev;
++
++	err = ops->open ? ops->open(rtc->class_dev.dev) : 0;
++	if (err == 0) {
++
++		spin_lock_irq(&rtc->irq_lock);
++		rtc->irq_data = 0;
++		spin_unlock_irq(&rtc->irq_lock);
++
++		return 0;
++	}
++
++	/* something has gone wrong, release the lock */
++	up(&rtc->char_sem);
++	return err;
++}
++
++
++static ssize_t
++rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
++{
++	struct rtc_device *rtc = to_rtc_device(file->private_data);
++
++	DECLARE_WAITQUEUE(wait, current);
++	unsigned long data;
++	ssize_t ret;
++
++	if (count < sizeof(unsigned long))
++		return -EINVAL;
++
++	add_wait_queue(&rtc->irq_queue, &wait);
++	do {
++		__set_current_state(TASK_INTERRUPTIBLE);
++
++		spin_lock_irq(&rtc->irq_lock);
++		data = rtc->irq_data;
++		rtc->irq_data = 0;
++		spin_unlock_irq(&rtc->irq_lock);
++
++		if (data != 0) {
++			ret = 0;
++			break;
++		}
++		if (file->f_flags & O_NONBLOCK) {
++			ret = -EAGAIN;
++			break;
++		}
++		if (signal_pending(current)) {
++			ret = -ERESTARTSYS;
++			break;
++		}
++		schedule();
++	} while (1);
++	set_current_state(TASK_RUNNING);
++	remove_wait_queue(&rtc->irq_queue, &wait);
++
++	if (ret == 0) {
++		ret = put_user(data, (unsigned long __user *)buf);
++		if (ret == 0)
++			ret = sizeof(unsigned long);
++	}
++	return ret;
++}
++
++static unsigned int rtc_dev_poll(struct file *file, poll_table *wait)
++{
++	struct rtc_device *rtc = to_rtc_device(file->private_data);
++	unsigned long data;
++
++	poll_wait(file, &rtc->irq_queue, wait);
++
++	spin_lock_irq(&rtc->irq_lock);
++	data = rtc->irq_data;
++	spin_unlock_irq(&rtc->irq_lock);
++
++	return data != 0 ? POLLIN | POLLRDNORM : 0;
++}
++
++static int rtc_dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
++		     unsigned long arg)
++{
++	int err = 0;
++	struct class_device *class_dev = file->private_data;
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++	struct rtc_class_ops *ops = rtc->ops;
++	struct rtc_time tm;
++	struct rtc_wkalrm alarm;
++	void __user *uarg = (void __user *) arg;
++
++	/* avoid conflicting IRQ users */
++	if (cmd == RTC_PIE_ON || cmd == RTC_PIE_OFF || cmd == RTC_IRQP_SET) {
++		spin_lock(&rtc->irq_task_lock);
++		if (rtc->irq_task)
++			err = -EBUSY;
++		spin_unlock(&rtc->irq_task_lock);
++
++		if (err < 0)
++			return err;
++	}
++
++	/* try the driver's ioctl interface */
++	if (ops->ioctl) {
++		err = ops->ioctl(class_dev->dev, cmd, arg);
++		if (err < 0 && err != -EINVAL)
++			return err;
++	}
++
++	/* if the driver does not provide the ioctl interface
++	 * or if that particular ioctl was not implemented
++	 * (-EINVAL), we will try to emulate here.
++	 */
++
++	switch (cmd) {
++	case RTC_ALM_READ:
++		if ((err = rtc_read_alarm(class_dev, &alarm)) < 0)
++			return err;
++
++		if ((err = copy_to_user(uarg, &alarm.time, sizeof(tm))))
++			return -EFAULT;
++		break;
++
++	case RTC_ALM_SET:
++		if ((err = copy_from_user(&alarm.time, uarg, sizeof(tm))))
++			return -EFAULT;
++
++		alarm.enabled = 0;
++		alarm.pending = 0;
++		alarm.time.tm_mday = -1;
++		alarm.time.tm_mon = -1;
++		alarm.time.tm_year = -1;
++		alarm.time.tm_wday = -1;
++		alarm.time.tm_yday = -1;
++		alarm.time.tm_isdst = -1;
++		err = rtc_set_alarm(class_dev, &alarm);
++		break;
++
++	case RTC_RD_TIME:
++		if ((err = rtc_read_time(class_dev, &tm)) < 0)
++			return err;
++
++		if ((err = copy_to_user(uarg, &tm, sizeof(tm))))
++			return -EFAULT;
++		break;
++
++	case RTC_SET_TIME:
++		if (!capable(CAP_SYS_TIME))
++			return -EACCES;
++
++		if ((err = copy_from_user(&tm, uarg, sizeof(tm))))
++			return -EFAULT;
++
++		err = rtc_set_time(class_dev, &tm);
++		break;
++#if 0
++	case RTC_EPOCH_SET:
++#ifndef rtc_epoch
++		/*
++		 * There were no RTC clocks before 1900.
++		 */
++		if (arg < 1900) {
++			err = -EINVAL;
++			break;
++		}
++		if (!capable(CAP_SYS_TIME)) {
++			err = -EACCES;
++			break;
++		}
++		rtc_epoch = arg;
++		err = 0;
++#endif
++		break;
++
++	case RTC_EPOCH_READ:
++		err = put_user(rtc_epoch, (unsigned long __user *)uarg);
++		break;
++#endif
++	case RTC_WKALM_SET:
++		if ((err = copy_from_user(&alarm, uarg, sizeof(alarm))))
++			return -EFAULT;
++
++		err = rtc_set_alarm(class_dev, &alarm);
++		break;
++
++	case RTC_WKALM_RD:
++		if ((err = rtc_read_alarm(class_dev, &alarm)) < 0)
++			return err;
++
++		if ((err = copy_to_user(uarg, &alarm, sizeof(alarm))))
++			return -EFAULT;
++		break;
++
++	default:
++		err = -EINVAL;
++		break;
++	}
++
++	return err;
++}
++
++static int rtc_dev_release(struct inode *inode, struct file *file)
++{
++	struct rtc_device *rtc = to_rtc_device(file->private_data);
++
++	if (rtc->ops->release)
++		rtc->ops->release(rtc->class_dev.dev);
++
++	spin_lock_irq(&rtc->irq_lock);
++	rtc->irq_data = 0;
++	spin_unlock_irq(&rtc->irq_lock);
++
++	up(&rtc->char_sem);
++	return 0;
++}
++
++static int rtc_dev_fasync(int fd, struct file *file, int on)
++{
++	struct rtc_device *rtc = to_rtc_device(file->private_data);
++	return fasync_helper(fd, file, on, &rtc->async_queue);
++}
++
++static struct file_operations rtc_dev_fops = {
++	.owner		= THIS_MODULE,
++	.llseek		= no_llseek,
++	.read		= rtc_dev_read,
++	.poll		= rtc_dev_poll,
++	.ioctl		= rtc_dev_ioctl,
++	.open		= rtc_dev_open,
++	.release	= rtc_dev_release,
++	.fasync		= rtc_dev_fasync,
++};
++
++static ssize_t rtc_dev_show_dev(struct class_device *class_dev, char *buf)
++{
++        return print_dev_t(buf, class_dev->devt);
++}
++static CLASS_DEVICE_ATTR(dev, S_IRUGO, rtc_dev_show_dev, NULL);
++
++/* insertion/removal hooks */
++
++static int rtc_dev_add_device(struct class_device *class_dev,
++				struct class_interface *class_intf)
++{
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	if (rtc->id >= RTC_DEV_MAX) {
++		dev_err(class_dev->dev, "too many RTCs\n");
++		return -EINVAL;
++	}
++
++	init_MUTEX(&rtc->char_sem);
++	spin_lock_init(&rtc->irq_lock);
++	init_waitqueue_head(&rtc->irq_queue);
++
++	cdev_init(&rtc->char_dev, &rtc_dev_fops);
++	rtc->char_dev.owner = rtc->owner;
++	class_dev->devt = MKDEV(MAJOR(rtc_devt), rtc->id);
++
++	if (cdev_add(&rtc->char_dev, class_dev->devt, 1)) {
++		cdev_del(&rtc->char_dev);
++
++		dev_err(class_dev->dev,
++			"failed to add char device %d:%d\n",
++			MAJOR(class_dev->devt),
++			MINOR(class_dev->devt));
++
++		class_dev->devt = MKDEV(0, 0);
++		return -ENODEV;
++	}
++
++	class_device_create_file(class_dev, &class_device_attr_dev);
++
++	dev_info(class_dev->dev, "rtc intf: dev (%d:%d)\n",
++		MAJOR(class_dev->devt),
++		MINOR(class_dev->devt));
++
++	kobject_hotplug(&class_dev->kobj, KOBJ_ADD);
++
++	return 0;
++}
++
++static void rtc_dev_remove_device(struct class_device *class_dev,
++					struct class_interface *class_intf)
++{
++	struct rtc_device *rtc = to_rtc_device(class_dev);
++
++	class_device_remove_file(class_dev, &class_device_attr_dev);
++
++	if (MAJOR(class_dev->devt)) {
++		dev_dbg(class_dev->dev, "removing char %d:%d\n",
++			MAJOR(class_dev->devt),
++			MINOR(class_dev->devt));
++		cdev_del(&rtc->char_dev);
++
++		kobject_hotplug(&class_dev->kobj, KOBJ_REMOVE);
++
++		class_dev->devt = MKDEV(0, 0);
++	}
++}
++
++/* interface registration */
++
++struct class_interface rtc_dev_interface = {
++	.add = &rtc_dev_add_device,
++	.remove = &rtc_dev_remove_device,
++};
++
++static int __init rtc_dev_init(void)
++{
++	int err;
++
++	if ((err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc")) < 0) {
++		printk(KERN_ERR "%s: failed to allocate char dev region\n",
++			__FILE__);
++		return err;
++	}
++
++	if ((err = rtc_interface_register(&rtc_dev_interface)) < 0) {
++		printk(KERN_ERR "%s: failed to register the interface\n",
++			__FILE__);
++		unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
++		return err;
++	}
++
++	return 0;
++}
++
++static void __exit rtc_dev_exit(void)
++{
++	class_interface_unregister(&rtc_dev_interface);
++
++	unregister_chrdev_region(rtc_devt, RTC_DEV_MAX);
++}
++
++module_init(rtc_dev_init);
++module_exit(rtc_dev_exit);
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("RTC class dev interface");
++MODULE_LICENSE("GPL");
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/rtc-x1205.c	2006-01-04 01:27:17.000000000 +0100
+@@ -0,0 +1,725 @@
++/*
++ * An i2c driver for the Xicor/Intersil X1205 RTC
++ * Copyright 2004 Karen Spearel
++ * Copyright 2005 Alessandro Zummo
++ *
++ * please send all reports to:
++ *	kas11 at tampabay dot rr dot com
++ *	a dot zummo at towertech dot it
++ *
++ * based on a lot of other RTC drivers.
++ *
++ * 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.
++ */
++
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/slab.h>
++#include <linux/err.h>
++#include <linux/i2c.h>
++#include <linux/string.h>
++#include <linux/bcd.h>
++#include <linux/rtc.h>
++#include <linux/delay.h>
++
++#define DRV_VERSION "1.0.5"
++
++/* Addresses to scan: none. This chip is located at
++ * 0x6f and uses a two bytes register addressing.
++ * Two bytes need to be written to read a single register,
++ * while most other chips just require one and take the second
++ * one as the data to be written. To prevent corrupting
++ * unknown chips, the user must explicitely set the probe parameter.
++ */
++
++static unsigned short normal_i2c[] = { I2C_CLIENT_END };
++
++/* Insmod parameters */
++I2C_CLIENT_INSMOD;
++I2C_CLIENT_MODULE_PARM(hctosys,
++	"Set the system time from the hardware clock upon initialization");
++
++/* offsets into CCR area */
++
++#define CCR_SEC			0
++#define CCR_MIN			1
++#define CCR_HOUR		2
++#define CCR_MDAY		3
++#define CCR_MONTH		4
++#define CCR_YEAR		5
++#define CCR_WDAY		6
++#define CCR_Y2K			7
++
++#define X1205_REG_SR		0x3F	/* status register */
++#define X1205_REG_Y2K		0x37
++#define X1205_REG_DW		0x36
++#define X1205_REG_YR		0x35
++#define X1205_REG_MO		0x34
++#define X1205_REG_DT		0x33
++#define X1205_REG_HR		0x32
++#define X1205_REG_MN		0x31
++#define X1205_REG_SC		0x30
++#define X1205_REG_DTR		0x13
++#define X1205_REG_ATR		0x12
++#define X1205_REG_INT		0x11
++#define X1205_REG_0		0x10
++#define X1205_REG_Y2K1		0x0F
++#define X1205_REG_DWA1		0x0E
++#define X1205_REG_YRA1		0x0D
++#define X1205_REG_MOA1		0x0C
++#define X1205_REG_DTA1		0x0B
++#define X1205_REG_HRA1		0x0A
++#define X1205_REG_MNA1		0x09
++#define X1205_REG_SCA1		0x08
++#define X1205_REG_Y2K0		0x07
++#define X1205_REG_DWA0		0x06
++#define X1205_REG_YRA0		0x05
++#define X1205_REG_MOA0		0x04
++#define X1205_REG_DTA0		0x03
++#define X1205_REG_HRA0		0x02
++#define X1205_REG_MNA0		0x01
++#define X1205_REG_SCA0		0x00
++
++#define X1205_CCR_BASE		0x30	/* Base address of CCR */
++#define X1205_ALM0_BASE		0x00	/* Base address of ALARM0 */
++
++#define X1205_SR_RTCF		0x01	/* Clock failure */
++#define X1205_SR_WEL		0x02	/* Write Enable Latch */
++#define X1205_SR_RWEL		0x04	/* Register Write Enable */
++
++#define X1205_DTR_DTR0		0x01
++#define X1205_DTR_DTR1		0x02
++#define X1205_DTR_DTR2		0x04
++
++#define X1205_HR_MIL		0x80	/* Set in ccr.hour for 24 hr mode */
++
++/* Prototypes */
++static int x1205_attach(struct i2c_adapter *adapter);
++static int x1205_detach(struct i2c_client *client);
++static int x1205_probe(struct i2c_adapter *adapter, int address, int kind);
++
++static struct i2c_driver x1205_driver = {
++	.owner		= THIS_MODULE,
++	.name		= "x1205",
++	.flags		= I2C_DF_NOTIFY,
++	.attach_adapter = &x1205_attach,
++	.detach_client	= &x1205_detach,
++};
++
++/*
++ * In the routines that deal directly with the x1205 hardware, we use
++ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
++ * Epoch is initialized as 2000. Time is set to UTC.
++ */
++static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
++				unsigned char reg_base)
++{
++	unsigned char dt_addr[2] = { 0, reg_base };
++
++	unsigned char buf[8];
++
++	struct i2c_msg msgs[] = {
++		{ client->addr, 0, 2, dt_addr },	/* setup read ptr */
++		{ client->addr, I2C_M_RD, 8, buf },	/* read date */
++	};
++
++	/* read date registers */
++	if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
++		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++		return -EIO;
++	}
++
++	dev_dbg(&client->dev,
++		"%s: raw read data - sec=%02x, min=%02x, hr=%02x, "
++		"mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n",
++		__FUNCTION__,
++		buf[0], buf[1], buf[2], buf[3],
++		buf[4], buf[5], buf[6], buf[7]);
++
++	tm->tm_sec = BCD2BIN(buf[CCR_SEC]);
++	tm->tm_min = BCD2BIN(buf[CCR_MIN]);
++	tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
++	tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
++	tm->tm_mon = BCD2BIN(buf[CCR_MONTH]) - 1; /* mon is 0-11 */
++	tm->tm_year = BCD2BIN(buf[CCR_YEAR])
++			+ (BCD2BIN(buf[CCR_Y2K]) * 100) - 1900;
++	tm->tm_wday = buf[CCR_WDAY];
++
++	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
++		"mday=%d, mon=%d, year=%d, wday=%d\n",
++		__FUNCTION__,
++		tm->tm_sec, tm->tm_min, tm->tm_hour,
++		tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++	return 0;
++}
++
++static int x1205_get_status(struct i2c_client *client, unsigned char *sr)
++{
++	static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
++
++	struct i2c_msg msgs[] = {
++		{ client->addr, 0, 2, sr_addr },	/* setup read ptr */
++		{ client->addr, I2C_M_RD, 1, sr },	/* read status */
++	};
++
++	/* read status register */
++	if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
++		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++		return -EIO;
++	}
++
++	return 0;
++}
++
++static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
++				int datetoo, u8 reg_base)
++{
++	int i, xfer;
++	unsigned char buf[8];
++
++	static const unsigned char wel[3] = { 0, X1205_REG_SR,
++						X1205_SR_WEL };
++
++	static const unsigned char rwel[3] = { 0, X1205_REG_SR,
++						X1205_SR_WEL | X1205_SR_RWEL };
++
++	static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
++
++	dev_dbg(&client->dev,
++		"%s: secs=%d, mins=%d, hours=%d\n",
++		__FUNCTION__,
++		tm->tm_sec, tm->tm_min, tm->tm_hour);
++
++	buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
++	buf[CCR_MIN] = BIN2BCD(tm->tm_min);
++
++	/* set hour and 24hr bit */
++	buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL;
++
++	/* should we also set the date? */
++	if (datetoo) {
++		dev_dbg(&client->dev,
++			"%s: mday=%d, mon=%d, year=%d, wday=%d\n",
++			__FUNCTION__,
++			tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++		buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
++
++		/* month, 1 - 12 */
++		buf[CCR_MONTH] = BIN2BCD(tm->tm_mon + 1);
++
++		/* year, since the rtc epoch*/
++		buf[CCR_YEAR] = BIN2BCD(tm->tm_year % 100);
++		buf[CCR_WDAY] = tm->tm_wday & 0x07;
++		buf[CCR_Y2K] = BIN2BCD(tm->tm_year / 100);
++	}
++
++	/* this sequence is required to unlock the chip */
++	xfer = i2c_master_send(client, wel, 3);
++	if (xfer != 3) {
++		dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
++		return -EIO;
++	}
++
++	xfer = i2c_master_send(client, rwel, 3);
++	if (xfer != 3) {
++		dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
++		return -EIO;
++	}
++
++	/* write register's data */
++	for (i = 0; i < (datetoo ? 8 : 3); i++) {
++		unsigned char rdata[3] = { 0, reg_base + i, buf[i] };
++
++		xfer = i2c_master_send(client, rdata, 3);
++		if (xfer != 3) {
++			dev_err(&client->dev,
++				"%s: xfer=%d addr=%02x, data=%02x\n",
++				__FUNCTION__,
++				 xfer, rdata[1], rdata[2]);
++			return -EIO;
++		}
++	};
++
++	/* disable further writes */
++	xfer = i2c_master_send(client, diswe, 3);
++	if (xfer != 3) {
++		dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
++		return -EIO;
++	}
++
++	return 0;
++}
++
++static int x1205_fix_osc(struct i2c_client *client)
++{
++	int err;
++	struct rtc_time tm;
++
++	tm.tm_hour = 0;
++	tm.tm_min = 0;
++	tm.tm_sec = 0;
++
++	if ((err = x1205_set_datetime(client, &tm, 0, X1205_CCR_BASE)) < 0)
++		dev_err(&client->dev,
++			"unable to restart the clock\n");
++
++	return err;
++}
++
++static int x1205_get_dtrim(struct i2c_client *client, int *trim)
++{
++	unsigned char dtr;
++	static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR };
++
++	struct i2c_msg msgs[] = {
++		{ client->addr, 0, 2, dtr_addr },	/* setup read ptr */
++		{ client->addr, I2C_M_RD, 1, &dtr }, 	/* read dtr */
++	};
++
++	/* read dtr register */
++	if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
++		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++		return -EIO;
++	}
++
++	dev_dbg(&client->dev, "%s: raw dtr=%x\n", __FUNCTION__, dtr);
++
++	*trim = 0;
++
++	if (dtr & X1205_DTR_DTR0)
++		*trim += 20;
++
++	if (dtr & X1205_DTR_DTR1)
++		*trim += 10;
++
++	if (dtr & X1205_DTR_DTR2)
++		*trim = -*trim;
++
++	return 0;
++}
++
++static int x1205_get_atrim(struct i2c_client *client, int *trim)
++{
++	s8 atr;
++	static unsigned char atr_addr[2] = { 0, X1205_REG_ATR };
++
++	struct i2c_msg msgs[] = {
++		{ client->addr, 0, 2, atr_addr },	/* setup read ptr */
++		{ client->addr, I2C_M_RD, 1, &atr }, 	/* read atr */
++	};
++
++	/* read atr register */
++	if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
++		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++		return -EIO;
++	}
++
++	dev_dbg(&client->dev, "%s: raw atr=%x\n", __FUNCTION__, atr);
++
++	/* atr is a two's complement value on 6 bits,
++	 * perform sign extension. The formula is
++	 * Catr = (atr * 0.25pF) + 11.00pF.
++	 */
++	if (atr & 0x20)
++		atr |= 0xC0;
++
++	dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __FUNCTION__, atr, atr);
++
++	*trim = (atr * 250) + 11000;
++
++	dev_dbg(&client->dev, "%s: real=%d\n", __FUNCTION__, *trim);
++
++	return 0;
++}
++
++static int x1205_hctosys(struct i2c_client *client)
++{
++	int err;
++
++	struct rtc_time tm;
++	struct timespec tv;
++	unsigned char sr;
++
++	if ((err = x1205_get_status(client, &sr)) < 0)
++		return err;
++
++	/* Don't set if we had a power failure */
++	if (sr & X1205_SR_RTCF)
++		return -EINVAL;
++
++	if ((err = x1205_get_datetime(client, &tm, X1205_CCR_BASE)) < 0)
++		return err;
++
++	/* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
++	 * whether it stores the most close value or the value with partial
++	 * seconds truncated. However, it is important that we use it to store
++	 * the truncated value. This is because otherwise it is necessary,
++	 * in an rtc sync function, to read both xtime.tv_sec and
++	 * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
++	 * of >32bits is not possible. So storing the most close value would
++	 * slow down the sync API. So here we have the truncated value and
++	 * the best guess is to add 0.5s.
++	 */
++
++	tv.tv_nsec = NSEC_PER_SEC >> 1;
++
++	rtc_tm_to_time(&tm, &tv.tv_sec);
++
++	do_settimeofday(&tv);
++
++	dev_info(&client->dev,
++		"setting the system clock to %d-%d-%d %d:%d:%d\n",
++		tm.tm_year + 1900, tm.tm_mon + 1,
++		tm.tm_mday, tm.tm_hour, tm.tm_min,
++		tm.tm_sec);
++
++	return 0;
++}
++
++struct x1205_limit
++{
++	unsigned char reg;
++	unsigned char mask;
++	unsigned char min;
++	unsigned char max;
++};
++
++static int x1205_validate_client(struct i2c_client *client)
++{
++	int i, xfer;
++
++	/* Probe array. We will read the register at the specified
++	 * address and check if the given bits are zero.
++	 */
++	static const unsigned char probe_zero_pattern[] = {
++		/* register, mask */
++		X1205_REG_SR,	0x18,
++		X1205_REG_DTR,	0xF8,
++		X1205_REG_ATR,	0xC0,
++		X1205_REG_INT,	0x18,
++		X1205_REG_0,	0xFF,
++	};
++
++	static const struct x1205_limit probe_limits_pattern[] = {
++		/* register, mask, min, max */
++		{ X1205_REG_Y2K,	0xFF,	19,	20	},
++		{ X1205_REG_DW,		0xFF,	0,	6	},
++		{ X1205_REG_YR,		0xFF,	0,	99	},
++		{ X1205_REG_MO,		0xFF,	0,	12	},
++		{ X1205_REG_DT,		0xFF,	0,	31	},
++		{ X1205_REG_HR,		0x7F,	0,	23	},
++		{ X1205_REG_MN,		0xFF,	0,	59	},
++		{ X1205_REG_SC,		0xFF,	0,	59	},
++		{ X1205_REG_Y2K1,	0xFF,	19,	20	},
++		{ X1205_REG_Y2K0,	0xFF,	19,	20	},
++	};
++
++	/* check that registers have bits a 0 where expected */
++	for (i = 0; i < ARRAY_SIZE(probe_zero_pattern); i += 2) {
++		unsigned char buf;
++
++		unsigned char addr[2] = { 0, probe_zero_pattern[i] };
++
++		struct i2c_msg msgs[2] = {
++			{ client->addr, 0, 2, addr },
++			{ client->addr, I2C_M_RD, 1, &buf },
++		};
++
++		xfer = i2c_transfer(client->adapter, msgs, 2);
++		if (xfer != 2) {
++			dev_err(&client->adapter->dev,
++				"%s: could not read register %x\n",
++				__FUNCTION__, addr[1]);
++
++			return -EIO;
++		}
++
++		if ((buf & probe_zero_pattern[i+1]) != 0) {
++			dev_err(&client->adapter->dev,
++				"%s: register=%02x, zero pattern=%d, value=%x\n",
++				__FUNCTION__, addr[1], i, buf);
++
++			return -ENODEV;
++		}
++	}
++
++	/* check limits (only registers with bcd values) */
++	for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) {
++		unsigned char reg, value;
++
++		unsigned char addr[2] = { 0, probe_limits_pattern[i].reg };
++
++		struct i2c_msg msgs[2] = {
++			{ client->addr, 0, 2, addr },
++			{ client->addr, I2C_M_RD, 1, &reg },
++		};
++
++		xfer = i2c_transfer(client->adapter, msgs, 2);
++
++		if (xfer != 2) {
++			dev_err(&client->adapter->dev,
++				"%s: could not read register %x\n",
++				__FUNCTION__, addr[1]);
++
++			return -EIO;
++		}
++
++		value = BCD2BIN(reg & probe_limits_pattern[i].mask);
++
++		if (value > probe_limits_pattern[i].max ||
++			value < probe_limits_pattern[i].min) {
++			dev_dbg(&client->adapter->dev,
++				"%s: register=%x, lim pattern=%d, value=%d\n",
++				__FUNCTION__, addr[1], i, value);
++
++			return -ENODEV;
++		}
++	}
++
++	return 0;
++}
++
++static int x1205_rtc_read_alarm(struct device *dev,
++	struct rtc_wkalrm *alrm)
++{
++	return x1205_get_datetime(to_i2c_client(dev),
++		&alrm->time, X1205_ALM0_BASE);
++}
++
++static int x1205_rtc_set_alarm(struct device *dev,
++	struct rtc_wkalrm *alrm)
++{
++	return x1205_set_datetime(to_i2c_client(dev),
++		&alrm->time, 1, X1205_ALM0_BASE);
++}
++
++static int x1205_rtc_read_time(struct device *dev,
++	struct rtc_time *tm)
++{
++	return x1205_get_datetime(to_i2c_client(dev),
++		tm, X1205_CCR_BASE);
++}
++
++static int x1205_rtc_set_time(struct device *dev,
++	struct rtc_time *tm)
++{
++	return x1205_set_datetime(to_i2c_client(dev),
++		tm, 1, X1205_CCR_BASE);
++}
++
++static int x1205_rtc_set_mmss(struct device *dev, unsigned long secs)
++{
++	int err;
++
++	struct rtc_time new_tm, old_tm;
++
++	if ((err = x1205_rtc_read_time(dev, &old_tm) == 0))
++		return err;
++
++	/* FIXME      xtime.tv_nsec = old_tm.tm_sec * 10000000; */
++	new_tm.tm_sec  = secs % 60;
++	secs /= 60;
++	new_tm.tm_min  = secs % 60;
++	secs /= 60;
++	new_tm.tm_hour = secs % 24;
++
++       /*
++	* avoid writing when we're going to change the day
++	* of the month.  We will retry in the next minute.
++	* This basically means that if the RTC must not drift
++	* by more than 1 minute in 11 minutes.
++	*/
++	if ((old_tm.tm_hour == 23 && old_tm.tm_min == 59) ||
++	    (new_tm.tm_hour == 23 && new_tm.tm_min == 59))
++		return 1;
++
++	return x1205_rtc_set_time(dev, &new_tm);
++}
++
++static int x1205_rtc_proc(struct device *dev, struct seq_file *seq)
++{
++	int err, dtrim, atrim;
++
++	seq_printf(seq, "24hr\t\t: yes\n");
++
++	err = x1205_get_dtrim(to_i2c_client(dev), &dtrim);
++	if (err == 0)
++		seq_printf(seq, "digital_trim\t: %d ppm\n", dtrim);
++
++	err = x1205_get_atrim(to_i2c_client(dev), &atrim);
++	if (err == 0)
++		seq_printf(seq, "analog_trim\t: %d.%02d pF\n",
++			atrim / 1000, atrim % 1000);
++	return 0;
++}
++
++static struct rtc_class_ops x1205_rtc_ops = {
++	.proc = x1205_rtc_proc,
++	.read_time = x1205_rtc_read_time,
++	.set_time = x1205_rtc_set_time,
++	.read_alarm = x1205_rtc_read_alarm,
++	.set_alarm = x1205_rtc_set_alarm,
++	.set_mmss = x1205_rtc_set_mmss,
++};
++
++static ssize_t x1205_sysfs_show_atrim(struct device *dev,
++				struct device_attribute *attr, char *buf)
++{
++	int atrim;
++
++        if (x1205_get_atrim(to_i2c_client(dev), &atrim) == 0) {
++                return sprintf(buf, "%d.%02d pF\n",
++                        atrim / 1000, atrim % 1000);        }
++        return 0;
++}
++static DEVICE_ATTR(atrim, S_IRUGO, x1205_sysfs_show_atrim, NULL);
++
++static ssize_t x1205_sysfs_show_dtrim(struct device *dev,
++				struct device_attribute *attr, char *buf)
++{
++	int dtrim;
++
++        if (x1205_get_dtrim(to_i2c_client(dev), &dtrim) == 0) {
++                return sprintf(buf, "%d ppm\n", dtrim);
++        }
++        return 0;
++}
++static DEVICE_ATTR(dtrim, S_IRUGO, x1205_sysfs_show_dtrim, NULL);
++
++
++static int x1205_attach(struct i2c_adapter *adapter)
++{
++	dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++
++	return i2c_probe(adapter, &addr_data, x1205_probe);
++}
++
++static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
++{
++	int err = 0;
++	unsigned char sr;
++	struct i2c_client *client;
++	struct rtc_device *rtc;
++
++	dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++
++	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
++		err = -ENODEV;
++		goto exit;
++	}
++
++	if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
++		err = -ENOMEM;
++		goto exit;
++	}
++
++	/* I2C client */
++	client->addr = address;
++	client->driver = &x1205_driver;
++	client->adapter	= adapter;
++
++	strlcpy(client->name, x1205_driver.name, I2C_NAME_SIZE);
++
++	/* Verify the chip is really an X1205 */
++	if (kind < 0) {
++		if (x1205_validate_client(client) < 0) {
++			err = -ENODEV;
++			goto exit_kfree;
++		}
++	}
++
++	/* Inform the i2c layer */
++	if ((err = i2c_attach_client(client)))
++		goto exit_kfree;
++
++	dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
++
++	rtc = rtc_device_register(x1205_driver.name, &client->dev,
++				&x1205_rtc_ops, THIS_MODULE);
++
++	if (IS_ERR(rtc)) {
++		err = PTR_ERR(rtc);
++		dev_err(&client->dev,
++			"unable to register the class device\n");
++		goto exit_detach;
++	}
++
++	i2c_set_clientdata(client, rtc);
++
++	/* Check for power failures and eventualy enable the osc */
++	if ((err = x1205_get_status(client, &sr)) == 0) {
++		if (sr & X1205_SR_RTCF) {
++			dev_err(&client->dev,
++				"power failure detected, "
++				"please set the clock\n");
++			udelay(50);
++			x1205_fix_osc(client);
++		}
++	}
++	else
++		dev_err(&client->dev, "couldn't read status\n");
++
++	/* If requested, set the system time */
++	if (hctosys) {
++		if ((err = x1205_hctosys(client)) < 0)
++			dev_err(&client->dev,
++				"unable to set the system clock\n");
++	}
++
++	device_create_file(&client->dev, &dev_attr_atrim);
++	device_create_file(&client->dev, &dev_attr_dtrim);
++
++	return 0;
++
++exit_detach:
++	i2c_detach_client(client);
++
++exit_kfree:
++	kfree(client);
++
++exit:
++	return err;
++}
++
++static int x1205_detach(struct i2c_client *client)
++{
++	int err;
++	struct rtc_device *rtc = i2c_get_clientdata(client);
++
++	dev_dbg(&client->dev, "%s\n", __FUNCTION__);
++
++ 	if (rtc)
++		rtc_device_unregister(rtc);
++
++	if ((err = i2c_detach_client(client)))
++		return err;
++
++	kfree(client);
++
++	return 0;
++}
++
++static int __init x1205_init(void)
++{
++	return i2c_add_driver(&x1205_driver);
++}
++
++static void __exit x1205_exit(void)
++{
++	i2c_del_driver(&x1205_driver);
++}
++
++MODULE_AUTHOR(
++	"Karen Spearel <kas11@tampabay.rr.com>, "
++	"Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("Xicor/Intersil X1205 RTC driver");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(x1205_init);
++module_exit(x1205_exit);
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/rtc-test.c	2006-01-04 01:27:19.000000000 +0100
+@@ -0,0 +1,189 @@
++/*
++ * An RTC test device/driver
++ * Copyright (C) 2005 Tower Technologies
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * 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.
++ */
++
++#include <linux/module.h>
++#include <linux/err.h>
++#include <linux/rtc.h>
++#include <linux/platform_device.h>
++
++static int test_rtc_read_alarm(struct device *dev,
++	struct rtc_wkalrm *alrm)
++{
++	return 0;
++}
++
++static int test_rtc_set_alarm(struct device *dev,
++	struct rtc_wkalrm *alrm)
++{
++	return 0;
++}
++
++static int test_rtc_read_time(struct device *dev,
++	struct rtc_time *tm)
++{
++	rtc_time_to_tm(get_seconds(), tm);
++	return 0;
++}
++
++static int test_rtc_set_time(struct device *dev,
++	struct rtc_time *tm)
++{
++	return 0;
++}
++
++static int test_rtc_set_mmss(struct device *dev, unsigned long secs)
++{
++	return 0;
++}
++
++static int test_rtc_proc(struct device *dev, struct seq_file *seq)
++{
++	struct platform_device *plat_dev = to_platform_device(dev);
++
++	seq_printf(seq, "24hr\t\t: yes\n");
++	seq_printf(seq, "test\t\t: yes\n");
++	seq_printf(seq, "id\t\t: %d\n", plat_dev->id);
++
++	return 0;
++}
++
++static int test_rtc_ioctl(struct device *dev, unsigned int cmd,
++	unsigned long arg)
++{
++	/* We do support interrupts, they're generated
++	 * using the sysfs interface.
++	 */
++	switch (cmd) {
++	case RTC_PIE_ON:
++	case RTC_PIE_OFF:
++	case RTC_UIE_ON:
++	case RTC_UIE_OFF:
++	case RTC_AIE_ON:
++	case RTC_AIE_OFF:
++		return 0;
++
++	default:
++		return -EINVAL;
++	}
++}
++
++static struct rtc_class_ops test_rtc_ops = {
++	.proc = test_rtc_proc,
++	.read_time = test_rtc_read_time,
++	.set_time = test_rtc_set_time,
++	.read_alarm = test_rtc_read_alarm,
++	.set_alarm = test_rtc_set_alarm,
++	.set_mmss = test_rtc_set_mmss,
++	.ioctl = test_rtc_ioctl,
++};
++
++static ssize_t test_irq_show(struct device *dev,
++				struct device_attribute *attr, char *buf)
++{
++	return sprintf(buf, "%d\n", 42);
++}
++static ssize_t test_irq_store(struct device *dev,
++				struct device_attribute *attr,
++				const char *buf, size_t count)
++{
++	int retval;
++	struct platform_device *plat_dev = to_platform_device(dev);
++	struct rtc_device *rtc = platform_get_drvdata(plat_dev);
++
++	retval = count;
++	if (strncmp(buf, "tick", 4) == 0)
++		rtc_update_irq(&rtc->class_dev, 1, RTC_PF | RTC_IRQF);
++	else if (strncmp(buf, "alarm", 5) == 0)
++		rtc_update_irq(&rtc->class_dev, 1, RTC_AF | RTC_IRQF);
++	else if (strncmp(buf, "update", 6) == 0)
++		rtc_update_irq(&rtc->class_dev, 1, RTC_UF | RTC_IRQF);
++	else
++		retval = -EINVAL;
++
++	return retval;
++}
++static DEVICE_ATTR(irq, S_IRUGO | S_IWUSR, test_irq_show, test_irq_store);
++
++static int test_probe(struct platform_device *plat_dev)
++{
++	int err;
++	struct rtc_device *rtc = rtc_device_register("test", &plat_dev->dev,
++						&test_rtc_ops, THIS_MODULE);
++	if (IS_ERR(rtc)) {
++		err = PTR_ERR(rtc);
++		dev_err(&plat_dev->dev,
++			"unable to register the class device\n");
++		return err;
++	}
++	device_create_file(&plat_dev->dev, &dev_attr_irq);
++
++	platform_set_drvdata(plat_dev, rtc);
++
++	return 0;
++}
++
++static int test_remove(struct platform_device *plat_dev)
++{
++	struct rtc_device *rtc = platform_get_drvdata(plat_dev);
++
++	rtc_device_unregister(rtc);
++	device_remove_file(&plat_dev->dev, &dev_attr_irq);
++
++	return 0;
++}
++
++static void test_release(struct device * dev)
++{
++}
++
++struct platform_device test_dev_zero = {
++	.name	= "rtc-test",
++	.id	= 0,
++	.dev.release = test_release,
++};
++
++struct platform_device test_dev_one = {
++	.name	= "rtc-test",
++	.id	= 1,
++	.dev.release = test_release,
++};
++
++struct platform_driver test_drv = {
++	.probe	= test_probe,
++	.remove = test_remove,
++	.driver = {
++		.name = "rtc-test",
++		.owner = THIS_MODULE,
++	},
++};
++
++static int __init test_init(void)
++{
++	platform_device_register(&test_dev_zero);
++	platform_device_register(&test_dev_one);
++	platform_driver_register(&test_drv);
++
++	return 0;
++}
++
++static void __exit test_exit(void)
++{
++	platform_driver_unregister(&test_drv);
++	platform_device_unregister(&test_dev_zero);
++	platform_device_unregister(&test_dev_one);
++}
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("RTC test driver/device");
++MODULE_LICENSE("GPL");
++
++module_init(test_init);
++module_exit(test_exit);
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nslu2/drivers/rtc/rtc-ds1672.c	2006-01-04 01:27:21.000000000 +0100
+@@ -0,0 +1,266 @@
++/*
++ * An rtc/i2c driver for the Dallas DS1672
++ * Copyright 2005 Alessandro Zummo
++ *
++ * 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.
++ */
++
++#include <linux/module.h>
++#include <linux/i2c.h>
++#include <linux/rtc.h>
++
++#define DRV_VERSION "0.1"
++
++/* Addresses to scan: none. This chip cannot be detected. */
++static unsigned short normal_i2c[] = { I2C_CLIENT_END };
++
++/* Insmod parameters */
++I2C_CLIENT_INSMOD;
++I2C_CLIENT_MODULE_PARM(hctosys,
++	"Set the system time from the hardware clock upon initialization");
++
++/* Registers */
++
++#define DS1672_REG_CNT_BASE	0
++#define DS1672_REG_CONTROL	4
++#define DS1672_REG_TRICKLE	5
++
++
++/* Prototypes */
++static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind);
++
++/*
++ * In the routines that deal directly with the ds1672 hardware, we use
++ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
++ * Epoch is initialized as 2000. Time is set to UTC.
++ */
++static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
++{
++	unsigned long time;
++	unsigned char buf[4];
++
++	dev_dbg(&client->dev,
++		"%s: raw read data - counters=%02x,%02x,%02x,%02x\n"
++		__FUNCTION__,
++		buf[0], buf[1], buf[2], buf[3]);
++
++	time = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
++
++	rtc_time_to_tm(time, tm);
++
++	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
++		"mday=%d, mon=%d, year=%d, wday=%d\n",
++		__FUNCTION__,
++		tm->tm_sec, tm->tm_min, tm->tm_hour,
++		tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++	return 0;
++}
++
++static int ds1672_set_mmss(struct i2c_client *client, unsigned long secs)
++{
++	int xfer;
++	unsigned char buf[5];
++
++	buf[0] = DS1672_REG_CNT_BASE;
++	buf[1] = secs & 0x000000FF;
++	buf[2] = (secs & 0x0000FF00) >> 8;
++	buf[3] = (secs & 0x00FF0000) >> 16;
++	buf[4] = (secs & 0xFF000000) >> 24;
++
++	xfer = i2c_master_send(client, buf, 5);
++	if (xfer != 5) {
++		dev_err(&client->dev, "%s: send: %d\n", __FUNCTION__, xfer);
++		return -EIO;
++	}
++
++	return 0;
++}
++
++static int ds1672_set_datetime(struct i2c_client *client, struct rtc_time *tm)
++{
++	unsigned long secs;
++
++	dev_dbg(&client->dev,
++		"%s: secs=%d, mins=%d, hours=%d, ",
++		"mday=%d, mon=%d, year=%d, wday=%d\n",
++		__FUNCTION__,
++		tm->tm_sec, tm->tm_min, tm->tm_hour,
++		tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++	rtc_tm_to_time(tm, &secs);
++
++	return ds1672_set_mmss(client, secs);
++}
++
++static int ds1672_hctosys(struct i2c_client *client)
++{
++	int err;
++	struct rtc_time tm;
++	struct timespec tv;
++
++	if ((err = ds1672_get_datetime(client, &tm)) != 0)
++		return err;
++
++	/* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
++	 * whether it stores the most close value or the value with partial
++	 * seconds truncated. However, it is important that we use it to store
++	 * the truncated value. This is because otherwise it is necessary,
++	 * in an rtc sync function, to read both xtime.tv_sec and
++	 * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
++	 * of >32bits is not possible. So storing the most close value would
++	 * slow down the sync API. So here we have the truncated value and
++	 * the best guess is to add 0.5s.
++	 */
++
++	tv.tv_nsec = NSEC_PER_SEC >> 1;
++
++	rtc_tm_to_time(&tm, &tv.tv_sec);
++
++	do_settimeofday(&tv);
++
++	dev_info(&client->dev,
++		"setting the system clock to %d-%02d-%02d %02d:%02d:%02d\n",
++		tm.tm_year + 1900, tm.tm_mon + 1,
++		tm.tm_mday, tm.tm_hour, tm.tm_min,
++		tm.tm_sec);
++
++	return 0;
++}
++
++static int ds1672_rtc_read_time(struct device *dev, struct rtc_time *tm)
++{
++	return ds1672_get_datetime(to_i2c_client(dev), tm);
++}
++
++static int ds1672_rtc_set_time(struct device *dev, struct rtc_time *tm)
++{
++	return ds1672_set_datetime(to_i2c_client(dev), tm);
++}
++
++static int ds1672_rtc_set_mmss(struct device *dev, unsigned long secs)
++{
++	return ds1672_set_mmss(to_i2c_client(dev), secs);
++}
++
++static struct rtc_class_ops ds1672_rtc_ops = {
++	.read_time = ds1672_rtc_read_time,
++	.set_time = ds1672_rtc_set_time,
++	.set_mmss = ds1672_rtc_set_mmss,
++};
++
++static int ds1672_attach(struct i2c_adapter *adapter)
++{
++	dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++
++	return i2c_probe(adapter, &addr_data, ds1672_probe);
++}
++
++static int ds1672_detach(struct i2c_client *client)
++{
++	int err;
++	struct rtc_device *rtc = i2c_get_clientdata(client);
++
++	dev_dbg(&client->dev, "%s\n", __FUNCTION__);
++
++ 	if (rtc)
++		rtc_device_unregister(rtc);
++
++	if ((err = i2c_detach_client(client)))
++		return err;
++
++	kfree(client);
++
++	return 0;
++}
++
++static struct i2c_driver ds1672_driver = {
++	.owner		= THIS_MODULE,
++	.name		= "ds1672",
++	.flags		= I2C_DF_NOTIFY,
++	.attach_adapter = &ds1672_attach,
++	.detach_client	= &ds1672_detach,
++};
++
++static int ds1672_probe(struct i2c_adapter *adapter, int address, int kind)
++{
++	int err = 0;
++	struct i2c_client *client;
++	struct rtc_device *rtc;
++
++	dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++
++	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
++		err = -ENODEV;
++		goto exit;
++	}
++
++	if (!(client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
++		err = -ENOMEM;
++		goto exit;
++	}
++
++	/* I2C client */
++	client->addr = address;
++	client->driver = &ds1672_driver;
++	client->adapter	= adapter;
++
++	strlcpy(client->name, ds1672_driver.name, I2C_NAME_SIZE);
++
++	/* Inform the i2c layer */
++	if ((err = i2c_attach_client(client)))
++		goto exit_kfree;
++
++	dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
++
++	rtc = rtc_device_register(ds1672_driver.name, &client->dev,
++				&ds1672_rtc_ops, THIS_MODULE);
++
++	if (IS_ERR(rtc)) {
++		err = PTR_ERR(rtc);
++		dev_err(&client->dev,
++			"unable to register the class device\n");
++		goto exit_detach;
++	}
++
++	i2c_set_clientdata(client, rtc);
++
++	/* If requested, set the system time */
++	if (hctosys) {
++		if ((err = ds1672_hctosys(client)) < 0)
++			dev_err(&client->dev,
++				"unable to set the system clock\n");
++	}
++
++	return 0;
++
++exit_detach:
++	i2c_detach_client(client);
++
++exit_kfree:
++	kfree(client);
++
++exit:
++	return err;
++}
++
++static int __init ds1672_init(void)
++{
++	return i2c_add_driver(&ds1672_driver);
++}
++
++static void __exit ds1672_exit(void)
++{
++	i2c_del_driver(&ds1672_driver);
++}
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("Dallas/Maxim DS1672 timekeeper driver");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++module_init(ds1672_init);
++module_exit(ds1672_exit);
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/50-nas100d-arch.patch b/packages/linux/ixp4xx-kernel/2.6.15/50-nas100d-arch.patch
new file mode 100644
index 0000000000..cb3eac2433
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/50-nas100d-arch.patch
@@ -0,0 +1,453 @@
+http://www.arm.linux.org.uk/developer/patches/viewpatch.php?id=3215/1
+
+Iomega NAS 100d (MACH_NAS100D) machine support 
+
+This patch adds support for a new arm/ixp4xx machine - the Iomega NAS
+100d network attached storage product. The NAS100D is a consumer
+device containing a 266MHz Intel IXP420 processor, 16MB of flash, 64MB
+of RAM, a 160Gb internal IDE hard disk, and 802.11b/g wireless on an
+Atheros mini-PCI card.
+
+Work on porting the latest 2.6.x kernel to this device is being done by
+the NSLU2-Linux project (the same team who maintains the port to the
+Linksys NSLU2 device). In particular, the majority of this patch was
+authored by Alessandro Zummo, based on the work done for MACH_NSLU2
+support by the NSLU2-Linux core team of developers.
+
+MACH_NAS100D (as implemented by this patch) can be enabled in jumbo
+ixp4xx kernels without any affect on the other machines supported by
+that kernel.
+
+This patch applies cleanly against 2.6.15-rc7 and should be trivial to
+apply to later kernel versions. It does not depend upon any other
+patches.
+
+Modified files (and number of lines inserted):
+arch/arm/mach-ixp4xx/Kconfig | 8
+arch/arm/mach-ixp4xx/Makefile | 1
+include/asm-arm/arch-ixp4xx/hardware.h | 1
+include/asm-arm/arch-ixp4xx/irqs.h | 9
+include/asm-arm/arch-ixp4xx/nas100d.h | 75
+arch/arm/mach-ixp4xx/nas100d-pci.c | 77
+arch/arm/mach-ixp4xx/nas100d-power.c | 69
+arch/arm/mach-ixp4xx/nas100d-setup.c | 133
+
+Signed-off-by: Rod Whitby <rod@whitby.id.au>
+Signed-off-by: Alessandro Zummo <a.zummo@towertech.it>
+ 
+--- linux-2.6.15-rc7/arch/arm/mach-ixp4xx/Kconfig	2005-12-27 22:29:00.000000000 +0100
++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/Kconfig	2005-12-27 22:29:52.000000000 +0100
+@@ -71,6 +71,14 @@ config ARCH_PRPMC1100
+ 	  PrPCM1100 Processor Mezanine Module. For more information on
+ 	  this platform, see <file:Documentation/arm/IXP4xx>.
+ 
++config MACH_NAS100D
++	bool
++	prompt "NAS100D"
++	help
++	  Say 'Y' here if you want your kernel to support Iomega's
++	  NAS 100d device. For more information on this platform,
++	  see http://www.nslu2-linux.org/wiki/NAS100d/HomePage
++
+ #
+ # Avila and IXDP share the same source for now. Will change in future
+ #
+--- linux-2.6.15-rc7/arch/arm/mach-ixp4xx/Makefile	2005-12-27 22:29:00.000000000 +0100
++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/Makefile	2005-12-27 22:30:37.000000000 +0100
+@@ -9,4 +9,5 @@ obj-$(CONFIG_MACH_IXDPG425)	+= ixdpg425-
+ obj-$(CONFIG_ARCH_ADI_COYOTE)	+= coyote-pci.o coyote-setup.o
+ obj-$(CONFIG_MACH_GTWX5715)	+= gtwx5715-pci.o gtwx5715-setup.o
+ obj-$(CONFIG_MACH_NSLU2)	+= nslu2-pci.o nslu2-setup.o nslu2-power.o
++obj-$(CONFIG_MACH_NAS100D)	+= nas100d-pci.o nas100d-setup.o nas100d-power.o
+ 
+--- linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/hardware.h	2005-12-27 22:29:18.000000000 +0100
++++ linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/hardware.h	2005-12-27 22:31:08.000000000 +0100
+@@ -45,5 +45,6 @@ extern unsigned int processor_id;
+ #include "coyote.h"
+ #include "prpmc1100.h"
+ #include "nslu2.h"
++#include "nas100d.h"
+ 
+ #endif  /* _ASM_ARCH_HARDWARE_H */
+--- linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/irqs.h	2005-12-27 22:29:18.000000000 +0100
++++ linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/irqs.h	2005-12-27 22:29:52.000000000 +0100
+@@ -100,4 +100,13 @@
+ #define        IRQ_NSLU2_PCI_INTB      IRQ_IXP4XX_GPIO10
+ #define        IRQ_NSLU2_PCI_INTC      IRQ_IXP4XX_GPIO9
+ 
++/*
++ * NAS100D board IRQs
++ */
++#define        IRQ_NAS100D_PCI_INTA    IRQ_IXP4XX_GPIO11
++#define        IRQ_NAS100D_PCI_INTB    IRQ_IXP4XX_GPIO10
++#define        IRQ_NAS100D_PCI_INTC    IRQ_IXP4XX_GPIO9
++#define        IRQ_NAS100D_PCI_INTD    IRQ_IXP4XX_GPIO8
++#define        IRQ_NAS100D_PCI_INTE    IRQ_IXP4XX_GPIO7
++
+ #endif
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/nas100d.h	2005-11-12 14:24:14.000000000 +0100
+@@ -0,0 +1,75 @@
++/*
++ * include/asm-arm/arch-ixp4xx/nas100d.h
++ *
++ * NAS100D platform specific definitions
++ *
++ * Copyright (c) 2005 Tower Technologies
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ *
++ * based on ixdp425.h:
++ *	Copyright 2004 (c) MontaVista, Software, Inc.
++ *
++ * This file is licensed under  the terms of the GNU General Public
++ * License version 2. This program is licensed "as is" without any
++ * warranty of any kind, whether express or implied.
++ */
++
++#ifndef __ASM_ARCH_HARDWARE_H__
++#error "Do not include this directly, instead #include <asm/hardware.h>"
++#endif
++
++#define NAS100D_FLASH_BASE	IXP4XX_EXP_BUS_CS0_BASE_PHYS
++#define NAS100D_FLASH_SIZE	IXP4XX_EXP_BUS_CSX_REGION_SIZE
++
++#define NAS100D_SDA_PIN		6
++#define NAS100D_SCL_PIN		5
++
++/*
++ * NAS100D PCI IRQs
++ */
++#define NAS100D_PCI_MAX_DEV	3
++#define NAS100D_PCI_IRQ_LINES	3
++
++
++/* PCI controller GPIO to IRQ pin mappings */
++#define NAS100D_PCI_INTA_PIN	11
++#define NAS100D_PCI_INTB_PIN	10
++#define NAS100D_PCI_INTC_PIN	9
++#define NAS100D_PCI_INTD_PIN	8
++#define NAS100D_PCI_INTE_PIN	7
++
++/* GPIO */
++
++#define NAS100D_GPIO0           0
++#define NAS100D_GPIO1           1
++#define NAS100D_GPIO2           2
++#define NAS100D_GPIO3           3
++#define NAS100D_GPIO4           4
++#define NAS100D_GPIO5           5
++#define NAS100D_GPIO6           6
++#define NAS100D_GPIO7           7
++#define NAS100D_GPIO8           8
++#define NAS100D_GPIO9           9
++#define NAS100D_GPIO10          10
++#define NAS100D_GPIO11          11
++#define NAS100D_GPIO12          12
++#define NAS100D_GPIO13          13
++#define NAS100D_GPIO14          14
++#define NAS100D_GPIO15          15
++
++
++/* Buttons */
++
++#define NAS100D_PB_GPIO         NAS100D_GPIO14
++#define NAS100D_RB_GPIO         NAS100D_GPIO4
++#define NAS100D_PO_GPIO         NAS100D_GPIO12   /* power off */
++
++#define NAS100D_PB_IRQ          IRQ_IXP4XX_GPIO14
++#define NAS100D_RB_IRQ          IRQ_IXP4XX_GPIO4
++
++/*
++#define NAS100D_PB_BM           (1L << NAS100D_PB_GPIO)
++#define NAS100D_PO_BM           (1L << NAS100D_PO_GPIO)
++#define NAS100D_RB_BM           (1L << NAS100D_RB_GPIO)
++*/
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/nas100d-pci.c	2005-11-12 14:24:14.000000000 +0100
+@@ -0,0 +1,77 @@
++/*
++ * arch/arm/mach-ixp4xx/nas100d-pci.c
++ *
++ * NAS 100d board-level PCI initialization
++ *
++ * based on ixdp425-pci.c:
++ *	Copyright (C) 2002 Intel Corporation.
++ *	Copyright (C) 2003-2004 MontaVista Software, Inc.
++ *
++ * Maintainer: http://www.nslu2-linux.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/config.h>
++#include <linux/pci.h>
++#include <linux/init.h>
++
++#include <asm/mach/pci.h>
++#include <asm/mach-types.h>
++
++void __init nas100d_pci_preinit(void)
++{
++	set_irq_type(IRQ_NAS100D_PCI_INTA, IRQT_LOW);
++	set_irq_type(IRQ_NAS100D_PCI_INTB, IRQT_LOW);
++	set_irq_type(IRQ_NAS100D_PCI_INTC, IRQT_LOW);
++	set_irq_type(IRQ_NAS100D_PCI_INTD, IRQT_LOW);
++	set_irq_type(IRQ_NAS100D_PCI_INTE, IRQT_LOW);
++
++	gpio_line_isr_clear(NAS100D_PCI_INTA_PIN);
++	gpio_line_isr_clear(NAS100D_PCI_INTB_PIN);
++	gpio_line_isr_clear(NAS100D_PCI_INTC_PIN);
++	gpio_line_isr_clear(NAS100D_PCI_INTD_PIN);
++	gpio_line_isr_clear(NAS100D_PCI_INTE_PIN);
++
++	ixp4xx_pci_preinit();
++}
++
++static int __init nas100d_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
++{
++	static int pci_irq_table[NAS100D_PCI_MAX_DEV][NAS100D_PCI_IRQ_LINES] =
++	{
++		{ IRQ_NAS100D_PCI_INTA, -1, -1 },
++		{ IRQ_NAS100D_PCI_INTB, -1, -1 },
++		{ IRQ_NAS100D_PCI_INTC, IRQ_NAS100D_PCI_INTD, IRQ_NAS100D_PCI_INTE },
++	};
++
++	int irq = -1;
++
++	if (slot >= 1 && slot <= NAS100D_PCI_MAX_DEV &&
++		pin >= 1 && pin <= NAS100D_PCI_IRQ_LINES)
++		irq = pci_irq_table[slot-1][pin-1];
++
++	return irq;
++}
++
++struct hw_pci __initdata nas100d_pci = {
++	.nr_controllers = 1,
++	.preinit	= nas100d_pci_preinit,
++	.swizzle	= pci_std_swizzle,
++	.setup		= ixp4xx_setup,
++	.scan		= ixp4xx_scan_bus,
++	.map_irq	= nas100d_map_irq,
++};
++
++int __init nas100d_pci_init(void)
++{
++	if (machine_is_nas100d())
++		pci_common_init(&nas100d_pci);
++
++	return 0;
++}
++
++subsys_initcall(nas100d_pci_init);
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/nas100d-power.c	2005-11-12 14:24:14.000000000 +0100
+@@ -0,0 +1,69 @@
++/*
++ * arch/arm/mach-ixp4xx/nas100d-power.c
++ *
++ * NAS 100d Power/Reset driver
++ *
++ * Copyright (C) 2005 Tower Technologies
++ *
++ * based on nas100d-io.c
++ *  Copyright (C) 2004 Karen Spearel
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Maintainers: http://www.nslu2-linux.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/module.h>
++#include <linux/reboot.h>
++#include <linux/interrupt.h>
++
++#include <asm/mach-types.h>
++
++extern void ctrl_alt_del(void);
++
++static irqreturn_t nas100d_reset_handler(int irq, void *dev_id, struct pt_regs *regs)
++{
++	/* Signal init to do the ctrlaltdel action, this will bypass init if
++	 * it hasn't started and do a kernel_restart.
++	 */
++	ctrl_alt_del();
++
++	return IRQ_HANDLED;
++}
++
++static int __init nas100d_power_init(void)
++{
++	if (!(machine_is_nas100d()))
++		return 0;
++
++	set_irq_type(NAS100D_RB_IRQ, IRQT_LOW);
++
++	gpio_line_isr_clear(NAS100D_RB_GPIO);
++
++	if (request_irq(NAS100D_RB_IRQ, &nas100d_reset_handler,
++		SA_INTERRUPT, "NAS100D reset button", NULL) < 0) {
++
++		printk(KERN_DEBUG "Reset Button IRQ %d not available\n",
++			NAS100D_RB_IRQ);
++
++		return -EIO;
++	}
++
++	return 0;
++}
++
++static void __exit nas100d_power_exit(void)
++{
++	free_irq(NAS100D_RB_IRQ, NULL);
++}
++
++module_init(nas100d_power_init);
++module_exit(nas100d_power_exit);
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("NAS100D Power/Reset driver");
++MODULE_LICENSE("GPL");
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/nas100d-setup.c	2005-11-12 14:24:14.000000000 +0100
+@@ -0,0 +1,133 @@
++/*
++ * arch/arm/mach-ixp4xx/nas100d-setup.c
++ *
++ * NAS 100d board-setup
++ *
++ * based ixdp425-setup.c:
++ *      Copyright (C) 2003-2004 MontaVista Software, Inc.
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Author: Rod Whitby <rod@whitby.id.au>
++ * Maintainers: http://www.nslu2-linux.org/
++ *
++ */
++
++#include <linux/kernel.h>
++#include <linux/serial.h>
++#include <linux/serial_8250.h>
++
++#include <asm/mach-types.h>
++#include <asm/mach/arch.h>
++#include <asm/mach/flash.h>
++
++static struct flash_platform_data nas100d_flash_data = {
++	.map_name		= "cfi_probe",
++	.width			= 2,
++};
++
++static struct resource nas100d_flash_resource = {
++	.start			= NAS100D_FLASH_BASE,
++	.end			= NAS100D_FLASH_BASE + NAS100D_FLASH_SIZE,
++	.flags			= IORESOURCE_MEM,
++};
++
++static struct platform_device nas100d_flash = {
++	.name			= "IXP4XX-Flash",
++	.id			= 0,
++	.dev.platform_data	= &nas100d_flash_data,
++	.num_resources		= 1,
++	.resource		= &nas100d_flash_resource,
++};
++
++static struct ixp4xx_i2c_pins nas100d_i2c_gpio_pins = {
++	.sda_pin		= NAS100D_SDA_PIN,
++	.scl_pin		= NAS100D_SCL_PIN,
++};
++
++static struct platform_device nas100d_i2c_controller = {
++	.name			= "IXP4XX-I2C",
++	.id			= 0,
++	.dev.platform_data	= &nas100d_i2c_gpio_pins,
++	.num_resources		= 0,
++};
++
++static struct resource nas100d_uart_resources[] = {
++	{
++		.start		= IXP4XX_UART1_BASE_PHYS,
++		.end		= IXP4XX_UART1_BASE_PHYS + 0x0fff,
++		.flags		= IORESOURCE_MEM,
++	},
++	{
++		.start		= IXP4XX_UART2_BASE_PHYS,
++		.end		= IXP4XX_UART2_BASE_PHYS + 0x0fff,
++		.flags		= IORESOURCE_MEM,
++	}
++};
++
++static struct plat_serial8250_port nas100d_uart_data[] = {
++	{
++		.mapbase	= IXP4XX_UART1_BASE_PHYS,
++		.membase	= (char *)IXP4XX_UART1_BASE_VIRT + REG_OFFSET,
++		.irq		= IRQ_IXP4XX_UART1,
++		.flags		= UPF_BOOT_AUTOCONF,
++		.iotype		= UPIO_MEM,
++		.regshift	= 2,
++		.uartclk	= IXP4XX_UART_XTAL,
++	},
++	{
++		.mapbase	= IXP4XX_UART2_BASE_PHYS,
++		.membase	= (char *)IXP4XX_UART2_BASE_VIRT + REG_OFFSET,
++		.irq		= IRQ_IXP4XX_UART2,
++		.flags		= UPF_BOOT_AUTOCONF,
++		.iotype		= UPIO_MEM,
++		.regshift	= 2,
++		.uartclk	= IXP4XX_UART_XTAL,
++	},
++	{ }
++};
++
++static struct platform_device nas100d_uart = {
++	.name			= "serial8250",
++	.id			= PLAT8250_DEV_PLATFORM,
++	.dev.platform_data	= nas100d_uart_data,
++	.num_resources		= 2,
++	.resource		= nas100d_uart_resources,
++};
++
++static struct platform_device *nas100d_devices[] __initdata = {
++	&nas100d_i2c_controller,
++	&nas100d_flash,
++	&nas100d_uart,
++};
++
++static void nas100d_power_off(void)
++{
++	/* This causes the box to drop the power and go dead. */
++
++	/* enable the pwr cntl gpio */
++	gpio_line_config(NAS100D_PO_GPIO, IXP4XX_GPIO_OUT);
++
++	/* do the deed */
++	gpio_line_set(NAS100D_PO_GPIO, IXP4XX_GPIO_HIGH);
++}
++
++static void __init nas100d_init(void)
++{
++	ixp4xx_sys_init();
++
++	pm_power_off = nas100d_power_off;
++
++	platform_add_devices(nas100d_devices, ARRAY_SIZE(nas100d_devices));
++}
++
++MACHINE_START(NAS100D, "Iomega NAS 100d")
++	/* Maintainer: www.nslu2-linux.org */
++	.phys_ram	= PHYS_OFFSET,
++	.phys_io	= IXP4XX_PERIPHERAL_BASE_PHYS,
++	.io_pg_offst	= ((IXP4XX_PERIPHERAL_BASE_VIRT) >> 18) & 0xFFFC,
++	.boot_params	= 0x00000100,
++	.map_io		= ixp4xx_map_io,
++	.init_irq	= ixp4xx_init_irq,
++	.timer          = &ixp4xx_timer,
++	.init_machine	= nas100d_init,
++MACHINE_END
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-i2c.patch b/packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-i2c.patch
new file mode 100644
index 0000000000..5dfed57c0e
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-i2c.patch
@@ -0,0 +1,531 @@
+ drivers/i2c/chips/Kconfig   |    9 
+ drivers/i2c/chips/Makefile  |    1 
+ drivers/i2c/chips/pcf8563.c |  466 ++++++++++++++++++++++++++++++++++++++++++++
+ include/linux/pcf8563.h     |   27 ++
+ 4 files changed, 503 insertions(+)
+
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nas100d/drivers/i2c/chips/pcf8563.c	2005-11-22 17:32:35.000000000 +0100
+@@ -0,0 +1,466 @@
++/*
++ * pcf8563.c - An i2c driver for the Philips PCF8563 RTC
++ * Copyright 2005 Tower Technologies
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Maintainers: http://www.nslu2-linux.org/
++ *
++ * based on the other drivers in this same directory.
++ *
++ * http://www.semiconductors.philips.com/acrobat/datasheets/PCF8563-04.pdf
++ *
++ * 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.
++ */
++
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/slab.h>
++#include <linux/i2c.h>
++#include <linux/string.h>
++#include <linux/bcd.h>
++#include <linux/rtc.h>
++#include <linux/list.h>
++
++#include <linux/pcf8563.h>
++
++#define DRV_VERSION "0.3.4"
++
++/* Addresses to scan */
++static unsigned short normal_i2c[] = { 0x51, I2C_CLIENT_END };
++
++/* Module parameters */
++I2C_CLIENT_INSMOD;
++I2C_CLIENT_MODULE_PARM(hctosys,
++	"Set the system time from the hardware clock upon initialization");
++
++#define PCF8563_REG_ST1		0x00 /* status */
++#define PCF8563_REG_ST2		0x01
++
++#define PCF8563_REG_SC		0x02 /* datetime */
++#define PCF8563_REG_MN		0x03
++#define PCF8563_REG_HR		0x04
++#define PCF8563_REG_DM		0x05
++#define PCF8563_REG_DW		0x06
++#define PCF8563_REG_MO		0x07
++#define PCF8563_REG_YR		0x08
++
++#define PCF8563_REG_AMN		0x09 /* alarm */
++#define PCF8563_REG_AHR		0x0A
++#define PCF8563_REG_ADM		0x0B
++#define PCF8563_REG_ADW		0x0C
++
++#define PCF8563_REG_CLKO	0x0D /* clock out */
++#define PCF8563_REG_TMRC	0x0E /* timer control */
++#define PCF8563_REG_TMR		0x0F /* timer */
++
++#define PCF8563_SC_LV		0x80 /* low voltage */
++#define PCF8563_MO_C		0x80 /* century */
++
++/* Prototypes */
++static int pcf8563_attach(struct i2c_adapter *adapter);
++static int pcf8563_detach(struct i2c_client *client);
++static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind);
++static int pcf8563_command(struct i2c_client *client, unsigned int cmd,
++	void *arg);
++
++static struct i2c_driver pcf8563_driver = {
++	.owner		= THIS_MODULE,
++	.name		= "pcf8563",
++	.flags		= I2C_DF_NOTIFY,
++	.attach_adapter = &pcf8563_attach,
++	.detach_client	= &pcf8563_detach,
++};
++
++struct pcf8563_data {
++	struct i2c_client client;
++	struct list_head list;
++};
++
++static const unsigned char days_in_mo[] =
++	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
++
++static LIST_HEAD(pcf8563_clients);
++
++/* Workaround until the I2C subsytem will allow to send
++ * commands to a specific client. This function will send the command
++ * to the first client.
++ */
++int pcf8563_do_command(unsigned int cmd, void *arg)
++{
++	struct list_head *walk;
++	struct list_head *tmp;
++	struct pcf8563_data *data;
++
++	list_for_each_safe(walk, tmp, &pcf8563_clients) {
++		data = list_entry(walk, struct pcf8563_data, list);
++		return pcf8563_command(&data->client, cmd, arg);
++	}
++
++	return -ENODEV;
++}
++
++#define is_leap(year) \
++	((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
++
++/* make sure the rtc_time values are in bounds */
++
++static int pcf8563_validate_tm(struct rtc_time *tm)
++{
++	int year = tm->tm_year + 1900;
++
++	if ((tm->tm_year < 70) || (tm->tm_year > 255))
++		return -EINVAL;
++
++	if ((tm->tm_mon > 11) || (tm->tm_mday == 0))
++		return -EINVAL;
++
++	if (tm->tm_mday > days_in_mo[tm->tm_mon]
++		+ ((tm->tm_mon == 1) && is_leap(year)))
++		return -EINVAL;
++
++	if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60))
++		return -EINVAL;
++
++	return 0;
++}
++
++/*
++ * In the routines that deal directly with the pcf8563 hardware, we use
++ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
++ */
++static int pcf8563_get_datetime(struct i2c_client *client, struct rtc_time *tm)
++{
++	unsigned char buf[13];
++	unsigned char addr = PCF8563_REG_ST1;
++
++	struct i2c_msg msgs[] = {
++		{ client->addr, 0, 1, &addr },	/* setup read ptr */
++		{ client->addr, I2C_M_RD, 13, buf },	/* read status + date */
++	};
++
++	/* read registers */
++	if ((i2c_transfer(client->adapter, msgs, 2)) != 2) {
++		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
++		return -EIO;
++	}
++
++	if (buf[PCF8563_REG_SC] & PCF8563_SC_LV)
++		dev_info(&client->dev,
++			"low voltage detected, date/time is not reliable.\n");
++
++	dev_dbg(&client->dev,
++		"%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
++		"mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
++		__FUNCTION__,
++		buf[0], buf[1], buf[2], buf[3],
++		buf[4], buf[5], buf[6], buf[7],
++		buf[8]);
++
++
++	tm->tm_sec = BCD2BIN(buf[PCF8563_REG_SC] & 0x7F);
++	tm->tm_min = BCD2BIN(buf[PCF8563_REG_MN] & 0x7F);
++	tm->tm_hour = BCD2BIN(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
++	tm->tm_mday = BCD2BIN(buf[PCF8563_REG_DM] & 0x3F);
++	tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
++	tm->tm_mon = BCD2BIN(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
++	tm->tm_year = BCD2BIN(buf[PCF8563_REG_YR])
++		+ (buf[PCF8563_REG_MO] & PCF8563_MO_C ? 100 : 0);
++
++	dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
++		"mday=%d, mon=%d, year=%d, wday=%d\n",
++		__FUNCTION__,
++		tm->tm_sec, tm->tm_min, tm->tm_hour,
++		tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++	if (pcf8563_validate_tm(tm) < 0) {
++		dev_err(&client->dev, "retrieved date/time is not valid.\n");
++		return -EINVAL;
++	}
++
++	return 0;
++}
++
++static int pcf8563_set_datetime(struct i2c_client *client, struct rtc_time *tm,
++				int datetoo)
++{
++	int i, err;
++	unsigned char buf[9];
++
++	/* check if all values in the tm struct are correct */
++	if ((err = pcf8563_validate_tm(tm)) < 0)
++		return err;
++
++	dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
++		"mday=%d, mon=%d, year=%d, wday=%d\n",
++		__FUNCTION__,
++		tm->tm_sec, tm->tm_min, tm->tm_hour,
++		tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++
++	/* hours, minutes and seconds */
++	buf[PCF8563_REG_SC] = BIN2BCD(tm->tm_sec);
++	buf[PCF8563_REG_MN] = BIN2BCD(tm->tm_min);
++	buf[PCF8563_REG_HR] = BIN2BCD(tm->tm_hour);
++
++	/* should we also set the date? */
++	if (datetoo) {
++		buf[PCF8563_REG_DM] = BIN2BCD(tm->tm_mday);
++
++		/* month, 1 - 12 */
++		buf[PCF8563_REG_MO] = BIN2BCD(tm->tm_mon + 1);
++
++		/* year and century */
++		buf[PCF8563_REG_YR] = BIN2BCD(tm->tm_year % 100);
++		if (tm->tm_year / 100)
++			buf[PCF8563_REG_MO] |= PCF8563_MO_C;
++
++		buf[PCF8563_REG_DW] = tm->tm_wday & 0x07;
++	}
++
++	/* write register's data */
++	for (i = 0; i < (datetoo ? 7 : 3); i++) {
++		unsigned char data[2] = { PCF8563_REG_SC + i,
++						buf[PCF8563_REG_SC + i] };
++
++		err = i2c_master_send(client, data, sizeof(data));
++		if (err != sizeof(data)) {
++			dev_err(&client->dev,
++				"%s: err=%d addr=%02x, data=%02x\n",
++				__FUNCTION__, err, data[0], data[1]);
++			return -EIO;
++		}
++	};
++
++	return 0;
++}
++
++static int pcf8563_hctosys(struct i2c_client *client)
++{
++	int err;
++
++	struct rtc_time tm;
++	struct timespec tv;
++
++	err = pcf8563_command(client, PCF8563_CMD_GETDATETIME, &tm);
++
++	if (err) {
++		dev_err(&client->dev,
++			"Unable to set the system clock\n");
++		return err;
++	}
++
++	/* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
++	 * whether it stores the most close value or the value with partial
++	 * seconds truncated. However, it is important that we use it to store
++	 * the truncated value. This is because otherwise it is necessary,
++	 * in an rtc sync function, to read both xtime.tv_sec and
++	 * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
++	 * of >32bits is not possible. So storing the most close value would
++	 * slow down the sync API. So here we have the truncated value and
++	 * the best guess is to add 0.5s.
++	 */
++
++	tv.tv_nsec = NSEC_PER_SEC >> 1;
++
++	/* WARNING: this is not the C library 'mktime' call, it is a built in
++	 * inline function from include/linux/time.h.  It expects (requires)
++	 * the month to be in the range 1-12
++	 */
++
++	tv.tv_sec  = mktime(tm.tm_year + 1900, tm.tm_mon + 1,
++				tm.tm_mday, tm.tm_hour,
++				tm.tm_min, tm.tm_sec);
++
++	do_settimeofday(&tv);
++
++	dev_info(&client->dev,
++		"setting the system clock to %d-%d-%d %d:%d:%d\n",
++		tm.tm_year + 1900, tm.tm_mon + 1,
++		tm.tm_mday, tm.tm_hour, tm.tm_min,
++		tm.tm_sec);
++
++	return 0;
++}
++
++struct pcf8563_limit
++{
++	unsigned char reg;
++	unsigned char mask;
++	unsigned char min;
++	unsigned char max;
++};
++
++static int pcf8563_validate_client(struct i2c_client *client)
++{
++	int i, xfer;
++
++	static const struct pcf8563_limit probe_limits_pattern[] = {
++		/* register, mask, min, max */
++		{ PCF8563_REG_SC,	0x7F,	0,	59	},
++		{ PCF8563_REG_MN,	0x7F,	0,	59	},
++		{ PCF8563_REG_HR,	0x3F,	0,	23	},
++		{ PCF8563_REG_DM,	0x3F,	0,	31	},
++		{ PCF8563_REG_MO,	0x1F,	0,	12	},
++		{ PCF8563_REG_YR,	0xFF,	0,	99	},
++	};
++
++	/* check limits (only registers with bcd values) */
++	for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) {
++		unsigned char addr, buf, value;
++
++		addr = probe_limits_pattern[i].reg;
++
++		struct i2c_msg msgs[2] = {
++			{ client->addr, 0, 2, &addr },
++			{ client->addr, I2C_M_RD, 1, &buf },
++		};
++
++		xfer = i2c_transfer(client->adapter, msgs, 2);
++
++		if (xfer != 2) {
++			dev_err(&client->adapter->dev,
++				"%s: could not read register %x\n",
++				__FUNCTION__, probe_limits_pattern[i].reg);
++
++			return -EIO;
++		}
++
++		value = BCD2BIN(buf & probe_limits_pattern[i].mask);
++
++		if (value > probe_limits_pattern[i].max ||
++			value < probe_limits_pattern[i].min) {
++			dev_dbg(&client->adapter->dev,
++				"%s: register=%x, lim pattern=%d, value=%d\n",
++				__FUNCTION__, probe_limits_pattern[i].reg, i, value);
++
++			return -ENODEV;
++		}
++	}
++
++	return 0;
++}
++
++static int pcf8563_attach(struct i2c_adapter *adapter)
++{
++	return i2c_probe(adapter, &addr_data, pcf8563_probe);
++}
++
++static int pcf8563_probe(struct i2c_adapter *adapter, int address, int kind)
++{
++	struct i2c_client *client;
++	struct pcf8563_data *data;
++
++	int err = 0;
++
++	dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
++
++	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
++		err = -ENODEV;
++		goto exit;
++	}
++
++	if (!(data = kzalloc(sizeof(struct pcf8563_data), GFP_KERNEL))) {
++		err = -ENOMEM;
++		goto exit;
++	}
++
++	client = &data->client;
++	client->addr = address;
++	client->driver = &pcf8563_driver;
++	client->adapter	= adapter;
++
++	strlcpy(client->name, pcf8563_driver.name, I2C_NAME_SIZE);
++
++	i2c_set_clientdata(client, data);
++
++	/* Verify the chip is really an PCF8563 */
++	if (kind < 0) {
++		if (pcf8563_validate_client(client) < 0) {
++			err = -ENODEV;
++			goto exit_kfree;
++		}
++	}
++
++	/* Inform the i2c layer */
++	if ((err = i2c_attach_client(client)))
++		goto exit_kfree;
++
++	list_add(&data->list, &pcf8563_clients);
++
++	dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
++
++	/* If requested, set the system time */
++	if (hctosys)
++		pcf8563_hctosys(client);
++
++	return 0;
++
++exit_kfree:
++	kfree(data);
++
++exit:
++	return err;
++}
++
++static int pcf8563_detach(struct i2c_client *client)
++{
++	int err;
++	struct pcf8563_data *data = i2c_get_clientdata(client);
++
++	if ((err = i2c_detach_client(client)))
++		return err;
++
++	list_del(&data->list);
++
++	kfree(data);
++
++	return 0;
++}
++
++static int pcf8563_command(struct i2c_client *client, unsigned int cmd,
++	void *param)
++{
++	if (param == NULL)
++		return -EINVAL;
++
++	if (!capable(CAP_SYS_TIME))
++		return -EACCES;
++
++	dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd);
++
++	switch (cmd) {
++	case PCF8563_CMD_GETDATETIME:
++		return pcf8563_get_datetime(client, param);
++
++	case PCF8563_CMD_SETTIME:
++		return pcf8563_set_datetime(client, param, 0);
++
++	case PCF8563_CMD_SETDATETIME:
++		return pcf8563_set_datetime(client, param, 1);
++
++	default:
++		return -EINVAL;
++	}
++}
++
++static int __init pcf8563_init(void)
++{
++	return i2c_add_driver(&pcf8563_driver);
++}
++
++static void __exit pcf8563_exit(void)
++{
++	i2c_del_driver(&pcf8563_driver);
++}
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("Philips PCF8563 RTC driver");
++MODULE_LICENSE("GPL");
++MODULE_VERSION(DRV_VERSION);
++
++EXPORT_SYMBOL_GPL(pcf8563_do_command);
++
++module_init(pcf8563_init);
++module_exit(pcf8563_exit);
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-nas100d/include/linux/pcf8563.h	2005-11-22 01:36:46.000000000 +0100
+@@ -0,0 +1,27 @@
++/*
++ * pcf8563.h - defines for drivers/i2c/chips/pcf8563.c
++ * Copyright 2005 Tower Technologies
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Maintainers: http://www.nslu2-linux.org/
++ *
++ * 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.
++ */
++
++#ifndef __LINUX_PCF8563_H__
++#define __LINUX_PCF8563_H__
++
++/* commands */
++
++#define PCF8563_CMD_GETDATETIME	0
++#define PCF8563_CMD_SETTIME	1
++#define PCF8563_CMD_SETDATETIME	2
++#define PCF8563_CMD_GETALARM	3
++#define PCF8563_CMD_SETALARM	4
++
++extern int pcf8563_do_command(unsigned int cmd, void *arg);
++
++#endif /* __LINUX_PCF8563_H__ */
+--- linux-nas100d.orig/drivers/i2c/chips/Kconfig	2005-11-21 22:01:31.000000000 +0100
++++ linux-nas100d/drivers/i2c/chips/Kconfig	2005-11-22 01:36:46.000000000 +0100
+@@ -135,4 +135,13 @@ config RTC_X1205_I2C
+ 	  This driver can also be built as a module. If so, the module
+ 	  will be called x1205.
+ 
++config RTC_PCF8563_I2C
++	tristate "Philips PCF8563 RTC"
++	depends on I2C && EXPERIMENTAL
++	help
++	  If you say yes here you get support for the Philips PCF8563
++	  Real Time Clock chip. This chip is used by the Iomega NAS100D.
++
++	  This driver can also be built as a module. If so, the module
++	  will be called pcf8563.
+ endmenu
+--- linux-nas100d.orig/drivers/i2c/chips/Makefile	2005-11-21 22:01:31.000000000 +0100
++++ linux-nas100d/drivers/i2c/chips/Makefile	2005-11-22 01:36:46.000000000 +0100
+@@ -14,6 +14,7 @@ obj-$(CONFIG_SENSORS_RTC8564)	+= rtc8564
+ obj-$(CONFIG_ISP1301_OMAP)	+= isp1301_omap.o
+ obj-$(CONFIG_TPS65010)		+= tps65010.o
+ obj-$(CONFIG_RTC_X1205_I2C)	+= x1205.o
++obj-$(CONFIG_RTC_PCF8563_I2C)	+= pcf8563.o
+ 
+ ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
+ EXTRA_CFLAGS += -DDEBUG
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-ide.patch b/packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-ide.patch
new file mode 100644
index 0000000000..fea83fbec7
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-ide.patch
@@ -0,0 +1,155 @@
+ drivers/ide/pci/aec62xx.c |   67 +++++++++++++++++++++++++++++++++++++++++++---
+ drivers/ide/setup-pci.c   |   12 +++++++-
+ 2 files changed, 75 insertions(+), 4 deletions(-)
+
+--- linux-nas100d.orig/drivers/ide/pci/aec62xx.c	2005-11-21 20:49:50.000000000 +0100
++++ linux-nas100d/drivers/ide/pci/aec62xx.c	2005-11-21 22:15:21.000000000 +0100
+@@ -145,6 +145,16 @@ static int aec6210_tune_chipset (ide_dri
+ 	unsigned long flags;
+ 
+ 	local_irq_save(flags);
++
++#ifdef CONFIG_MACH_NAS100D
++	printk(KERN_INFO "aec62xx: nas100d tuning\n");
++	pci_write_config_word(hwif->pci_dev, PCI_COMMAND, PCI_COMMAND_IO | PCI_COMMAND_MASTER);
++	pci_write_config_byte(hwif->pci_dev, PCI_LATENCY_TIMER, 0x80);
++	/* Enable burst mode & force 2 ports enable  */
++	pci_read_config_byte(hwif->pci_dev, 0x4a, &tmp0);
++	pci_write_config_byte(hwif->pci_dev, 0x4a, tmp0 | 0x80);
++#endif
++
+ 	/* 0x40|(2*drive->dn): Active, 0x41|(2*drive->dn): Recovery */
+ 	pci_read_config_word(dev, 0x40|(2*drive->dn), &d_conf);
+ 	tmp0 = pci_bus_clock_list(speed, BUSCLOCK(dev));
+@@ -206,9 +216,17 @@ static int config_chipset_for_dma (ide_d
+ {
+ 	u8 speed = ide_dma_speed(drive, aec62xx_ratemask(drive));	
+ 
++#ifdef CONFIG_MACH_NAS100D
++	ide_hwif_t *hwif= HWIF(drive);
++	u8 unit		= (drive->select.b.unit & 0x01);
++#endif
+ 	if (!(speed))
+ 		return 0;
+ 
++#ifdef CONFIG_MACH_NAS100D
++	outb((inb(hwif->dma_base+2) & ~(1<<(5+unit))), hwif->dma_base+2);
++#endif
++
+ 	(void) aec62xx_tune_chipset(drive, speed);
+ 	return ide_dma_enable(drive);
+ }
+@@ -299,6 +317,14 @@ static unsigned int __devinit init_chips
+ {
+ 	int bus_speed = system_bus_clock();
+ 
++#ifdef CONFIG_MACH_NAS100D
++	/* enable both ports */
++	byte tmp;
++	printk(KERN_INFO "%s: nas100d ports enable\n", name);
++	pci_read_config_byte(dev, 0x4a, &tmp);
++	pci_write_config_byte(dev, 0x4a, tmp | 0x06);
++#endif
++
+ 	if (dev->resource[PCI_ROM_RESOURCE].start) {
+ 		pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
+ 		printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name, dev->resource[PCI_ROM_RESOURCE].start);
+@@ -312,12 +338,35 @@ static unsigned int __devinit init_chips
+ 	return dev->irq;
+ }
+ 
++#ifdef CONFIG_MACH_NAS100D
++static void nas100d_insw (unsigned long port, u16 *addr, u32 count)
++{
++	while (count--)
++		*addr++ = __cpu_to_le16(inw(port));
++}
++
++static void nas100d_outw (u16 val, unsigned long port)
++{
++	u32 n, byte_enables, data;
++	n = port % 4;
++	byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
++	data = val << (8*n);
++	ixp4xx_pci_write(port, byte_enables | NP_CMD_IOWRITE, __le16_to_cpu(data));
++}
++#endif
++
+ static void __devinit init_hwif_aec62xx(ide_hwif_t *hwif)
+ {
+ 	hwif->autodma = 0;
+ 	hwif->tuneproc = &aec62xx_tune_drive;
+ 	hwif->speedproc = &aec62xx_tune_chipset;
+ 
++#ifdef CONFIG_MACH_NAS100D
++	printk(KERN_INFO "aec62xx: enabling nas100d iops\n");
++	hwif->OUTW = nas100d_outw;
++	hwif->INSW = nas100d_insw;
++#endif
++
+ 	if (hwif->pci_dev->device == PCI_DEVICE_ID_ARTOP_ATP850UF) {
+ 		hwif->serialized = hwif->channel;
+ 		hwif->no_dsc = 1;
+@@ -360,11 +409,18 @@ static void __devinit init_dma_aec62xx(i
+ 	} else {
+ 		u8 ata66	= 0;
+ 		pci_read_config_byte(hwif->pci_dev, 0x49, &ata66);
+-	        if (!(hwif->udma_four))
++		if (!(hwif->udma_four))
+ 			hwif->udma_four = (ata66&(hwif->channel?0x02:0x01))?0:1;
+ 	}
+ 
+ 	ide_setup_dma(hwif, dmabase, 8);
++#ifdef CONFIG_MACH_NAS100D
++	{
++		u8 dma_stat = hwif->INB(hwif->dma_status);
++		dma_stat |= (1 << 4);
++		hwif->OUTB(dma_stat, hwif->dma_status);
++	}
++#endif
+ }
+ 
+ static int __devinit init_setup_aec62xx(struct pci_dev *dev, ide_pci_device_t *d)
+@@ -427,6 +483,9 @@ static ide_pci_device_t aec62xx_chipsets
+ 		.init_dma	= init_dma_aec62xx,
+ 		.channels	= 2,
+ 		.autodma	= AUTODMA,
++#ifdef CONFIG_MACH_NAS100D
++		.enablebits	= {{0x4a,0x02,0x02}, {0x4a,0x04,0x04}},
++#endif
+ 		.bootable	= OFF_BOARD,
+ 	},{	/* 4 */
+ 		.name		= "AEC6X80R",
+@@ -454,6 +513,8 @@ static int __devinit aec62xx_init_one(st
+ {
+ 	ide_pci_device_t *d = &aec62xx_chipsets[id->driver_data];
+ 
++	printk(KERN_INFO "aec62xx: using config %lx\n", id->driver_data);
++
+ 	return d->init_setup(dev, d);
+ }
+ 
+--- linux-nas100d.orig/drivers/ide/setup-pci.c	2005-11-21 20:49:50.000000000 +0100
++++ linux-nas100d/drivers/ide/setup-pci.c	2005-11-21 22:01:22.000000000 +0100
+@@ -602,10 +602,20 @@ void ide_pci_setup_ports(struct pci_dev 
+ 		if ((d->flags & IDEPCI_FLAG_FORCE_PDC) &&
+ 		    (secondpdc++==1) && (port==1))
+ 			goto controller_ok;
+-			
++
+ 		if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
+ 		    (tmp & e->mask) != e->val))
++#ifdef CONFIG_MACH_NAS100D
++		{
++			pci_write_config_byte(dev, e->reg, tmp & ~0x01);
++#endif
+ 			continue;	/* port not enabled */
++#ifdef CONFIG_MACH_NAS100D
++		}
++		else
++			pci_write_config_byte(dev, e->reg, tmp & ~0x01);
++#endif
++
+ controller_ok:
+ 
+ 		if (d->channels	<= port)
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/60-nslu2-beeper.patch b/packages/linux/ixp4xx-kernel/2.6.15/60-nslu2-beeper.patch
new file mode 100644
index 0000000000..12fdc4d96e
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/60-nslu2-beeper.patch
@@ -0,0 +1,184 @@
+ drivers/input/misc/Kconfig     |   12 +++
+ drivers/input/misc/Makefile    |    1 
+ drivers/input/misc/nslu2spkr.c |  148 +++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 161 insertions(+)
+
+--- linux-2.6.15/drivers/input/misc/Kconfig	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/input/misc/Kconfig	1970-01-01 00:00:00.000000000 +0000
+@@ -40,6 +40,18 @@ config INPUT_M68K_BEEP
+ 	tristate "M68k Beeper support"
+ 	depends on M68K
+ 
++config INPUT_NSLU2_BEEPER
++	tristate "NSLU2 Beeper support"
++	depends on MACH_NSLU2
++	help
++	  Say Y here if you want the embedded beeper on the LinkSys NSLU2
++	  to be used for bells and whistles.
++
++	  If unsure, say Y.
++
++	  To compile this driver as a module, choose M here: the
++	  module will be called nslu2spkr.
++
+ config INPUT_UINPUT
+ 	tristate "User level driver support"
+ 	help
+--- linux-2.6.15/drivers/input/misc/Makefile	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/input/misc/Makefile	1970-01-01 00:00:00.000000000 +0000
+@@ -10,3 +10,4 @@ obj-$(CONFIG_INPUT_M68K_BEEP)		+= m68ksp
+ obj-$(CONFIG_INPUT_98SPKR)		+= 98spkr.o
+ obj-$(CONFIG_INPUT_UINPUT)		+= uinput.o
+ obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
++obj-$(CONFIG_INPUT_NSLU2_BEEPER)	+= nslu2spkr.o
+--- linux-2.6.15/drivers/input/misc/nslu2spkr.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/input/misc/nslu2spkr.c	1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,148 @@
++/*
++ * drivers/input/misc/nslu2spkr.c
++ *
++ * NSLU2 Beeper driver
++ *
++ * Copyright (C) 2005 Tower Technologies
++ *
++ * based on nslu2-io.c
++ *  Copyright (C) 2004 Karen Spearel
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Maintainers: http://www.nslu2-linux.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/config.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/input.h>
++#include <linux/delay.h>
++
++#include <asm/hardware.h>
++#include <asm/irq.h>
++#include <asm/mach-types.h>
++
++static unsigned int beep_on_startup = 1;
++module_param(beep_on_startup, bool, 0);
++MODULE_PARM_DESC(beep_on_startup, "Play a beep on module startup");
++
++DEFINE_SPINLOCK(beep_lock);
++
++static int nslu2_spkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
++{
++	unsigned int count = 0;
++	unsigned long flags;
++
++	if (type != EV_SND)
++		return -1;
++
++	switch (code) {
++		case SND_BELL:
++			if (value) value = 1000;
++		case SND_TONE:
++			break;
++		default:
++			return -1;
++	}
++
++	if (value > 20 && value < 32767)
++		count = (NSLU2_FREQ / (value*4)) - 1;
++
++	spin_lock_irqsave(&beep_lock, flags);
++
++	 if (count) {
++
++		gpio_line_config(NSLU2_GPIO_BUZZ, IXP4XX_GPIO_OUT);
++		gpio_line_set(NSLU2_GPIO_BUZZ, IXP4XX_GPIO_LOW);
++
++		*IXP4XX_OSRT2 = (count & ~IXP4XX_OST_RELOAD_MASK) | IXP4XX_OST_ENABLE;
++
++	} else {
++
++		gpio_line_config(NSLU2_GPIO_BUZZ, IXP4XX_GPIO_IN);
++		gpio_line_set(NSLU2_GPIO_BUZZ, IXP4XX_GPIO_HIGH);
++
++		*IXP4XX_OSRT2 = 0;
++	}
++
++	spin_unlock_irqrestore(&beep_lock, flags);
++
++	return 0;
++}
++
++static struct input_dev nslu2_spkr_dev = {
++	.phys		= "ixp420/gpio4",
++	.name		= "NSLU2 Beeper",
++	.evbit[0]	= BIT(EV_SND),
++	.sndbit[0]	= BIT(SND_BELL) | BIT(SND_TONE),
++	.event		= nslu2_spkr_event,
++	.id		= {
++		.bustype	= BUS_HOST,
++		.vendor		= 0x001f,
++		.product	= 0x0001,
++		.version	= 0x0100
++	}
++};
++
++static irqreturn_t nslu2_spkr_handler(int irq, void *dev_id, struct pt_regs *regs)
++{
++	/* clear interrupt */
++	*IXP4XX_OSST = IXP4XX_OSST_TIMER_2_PEND;
++
++	/* flip the beeper output */
++	*IXP4XX_GPIO_GPOUTR ^= NSLU2_BZ_BM;
++
++	return IRQ_HANDLED;
++}
++
++static int __init nslu2_spkr_init(void)
++{
++	if (!(machine_is_nslu2()))
++		return -ENODEV;
++
++	if (request_irq(IRQ_IXP4XX_TIMER2, &nslu2_spkr_handler,
++		SA_INTERRUPT | SA_TIMER, "nslu2-beeper", NULL < 0)) {
++
++		printk(KERN_INFO "NSLU2 beeper: IRQ %d not available\n",
++			IRQ_IXP4XX_TIMER2);
++
++		return -EIO;
++	}
++
++	input_register_device(&nslu2_spkr_dev);
++
++	/* do a little beep to tell the world we are alive */
++	if (beep_on_startup)
++	{
++		nslu2_spkr_event(NULL, EV_SND, SND_TONE, 440);
++		msleep(120);
++		nslu2_spkr_event(NULL, EV_SND, SND_TONE, 0);
++	}
++
++        printk(KERN_INFO "NSLU2: beeper\n");
++	return 0;
++}
++
++static void __exit nslu2_spkr_exit(void)
++{
++	input_unregister_device(&nslu2_spkr_dev);
++
++	disable_irq(IRQ_IXP4XX_TIMER2);
++
++	/* turn it off */
++	nslu2_spkr_event(NULL, EV_SND, SND_BELL, 0);
++
++	free_irq(IRQ_IXP4XX_TIMER2, NULL);
++}
++
++module_init(nslu2_spkr_init);
++module_exit(nslu2_spkr_exit);
++
++MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
++MODULE_DESCRIPTION("NSLU2 Beeper driver");
++MODULE_LICENSE("GPL");
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/75-nslu2-leds.patch b/packages/linux/ixp4xx-kernel/2.6.15/75-nslu2-leds.patch
new file mode 100644
index 0000000000..7497409e77
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/75-nslu2-leds.patch
@@ -0,0 +1,272 @@
+ arch/arm/Kconfig                  |    8 -
+ arch/arm/mach-ixp4xx/Makefile     |    4 
+ arch/arm/mach-ixp4xx/nslu2-leds.c |  223 ++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 232 insertions(+), 3 deletions(-)
+
+--- linux-2.6.15/arch/arm/Kconfig	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/Kconfig	1970-01-01 00:00:00.000000000 +0000
+@@ -418,7 +418,8 @@ config LEDS
+ 		   ARCH_EBSA285 || ARCH_IMX || ARCH_INTEGRATOR || \
+ 		   ARCH_LUBBOCK || MACH_MAINSTONE || ARCH_NETWINDER || \
+ 		   ARCH_OMAP || ARCH_P720T || ARCH_PXA_IDP || \
+-		   ARCH_SA1100 || ARCH_SHARK || ARCH_VERSATILE
++		   ARCH_SA1100 || ARCH_SHARK || ARCH_VERSATILE || \
++		   MACH_NSLU2
+ 	help
+ 	  If you say Y here, the LEDs on your machine will be used
+ 	  to provide useful information about your current system status.
+@@ -432,7 +433,7 @@ config LEDS
+ 
+ config LEDS_TIMER
+ 	bool "Timer LED" if (!ARCH_CDB89712 && !ARCH_OMAP) || \
+-			    MACH_OMAP_H2 || MACH_OMAP_PERSEUS2
++			    MACH_OMAP_H2 || MACH_OMAP_PERSEUS2 || MACH_NSLU2
+ 	depends on LEDS
+ 	default y if ARCH_EBSA110
+ 	help
+@@ -448,7 +449,8 @@ config LEDS_TIMER
+ 
+ config LEDS_CPU
+ 	bool "CPU usage LED" if (!ARCH_CDB89712 && !ARCH_EBSA110 && \
+-			!ARCH_OMAP) || MACH_OMAP_H2 || MACH_OMAP_PERSEUS2
++			!ARCH_OMAP) || MACH_OMAP_H2 || MACH_OMAP_PERSEUS2 \
++			|| MACH_NSLU2
+ 	depends on LEDS
+ 	help
+ 	  If you say Y here, the red LED will be used to give a good real
+--- linux-2.6.15/arch/arm/mach-ixp4xx/Makefile	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/Makefile	1970-01-01 00:00:00.000000000 +0000
+@@ -10,3 +10,7 @@ obj-$(CONFIG_ARCH_ADI_COYOTE)	+= coyote-
+ obj-$(CONFIG_MACH_GTWX5715)	+= gtwx5715-pci.o gtwx5715-setup.o
+ obj-$(CONFIG_MACH_NSLU2)	+= nslu2-pci.o nslu2-setup.o nslu2-power.o
+ 
++leds-$(CONFIG_MACH_NSLU2)	+= nslu2-leds.o
++obj-$(CONFIG_LEDS)		+= $(leds-y)
++
++
+--- linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-leds.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-leds.c	1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,223 @@
++/*
++ * arch/arm/mach-ixp4xx/nslu2-leds.c
++ *
++ * NSLU2 LEDs driver
++ *
++ * Copyright (C) 2005 Tower Technologies
++ *
++ * based on nslu2-io.c
++ *  Copyright (C) 2004 Karen Spearel
++ * and arch/arm/mach-footbridge/netwinder-leds.c
++ *  Copyright (C) 1998-1999 Russell King
++ *
++ * Author: Alessandro Zummo <a.zummo@towertech.it>
++ * Maintainers: http://www.nslu2-linux.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/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/spinlock.h>
++#include <linux/notifier.h>
++
++#include <asm/hardware.h>
++#include <asm/leds.h>
++#include <asm/mach-types.h>
++#include <asm/system.h>
++
++#define LED_STATE_ENABLED	0x01
++#define LED_STATE_CLAIMED	0x02
++#define LED_STATE_IDLE		0x04
++
++static unsigned char led_state;
++static unsigned int hw_led_state;
++
++#ifdef CONFIG_LEDS_TIMER
++static const unsigned long idle_seq[4] = {
++	NSLU2_LED_GRN_BM, 0,
++	NSLU2_LED_GRN_BM, 0,
++};
++
++static const unsigned long busy_seq[4] = {
++	NSLU2_LED_GRN_BM, 0,
++	NSLU2_LED_GRN_BM | NSLU2_LED_RED_BM, 0,
++};
++#endif
++
++static unsigned char led_count = 0;
++
++static DEFINE_SPINLOCK(leds_lock);
++extern spinlock_t gpio_lock;
++
++static void nslu2_leds_event(led_event_t evt)
++{
++	unsigned long flags;
++
++	spin_lock_irqsave(&leds_lock, flags);
++
++	switch (evt) {
++	case led_start:
++		/* Let's rock! Red led on, all others off. Remember
++		 * that disk1/disk2 works inverted.
++		 */
++		led_state = LED_STATE_ENABLED;
++		hw_led_state = NSLU2_LED_DISK1_BM | NSLU2_LED_DISK2_BM
++				| NSLU2_LED_RED_BM;
++		break;
++
++	case led_stop:
++		led_state &= ~LED_STATE_ENABLED;
++		break;
++
++	case led_claim:
++		/* The user claimed the interface, red and green off */
++		led_state |= LED_STATE_CLAIMED;
++		hw_led_state &= ~(NSLU2_LED_RED_BM | NSLU2_LED_GRN_BM);
++		break;
++
++	case led_release:
++		/* The user released the interface, preserve the last
++		 * status of the leds, except red/green.
++		 */
++		led_state &= ~LED_STATE_CLAIMED;
++		hw_led_state = *IXP4XX_GPIO_GPOUTR & 0x0000000C;
++		break;
++
++#ifdef CONFIG_LEDS_TIMER
++	case led_timer:
++		/* Pulse green led */
++		if (!(led_state & LED_STATE_CLAIMED))
++		{
++			/* clear red and green bits */
++			hw_led_state &= ~(NSLU2_LED_RED_BM | NSLU2_LED_GRN_BM);
++
++			/* copy the right sequence in */
++			if (led_state & LED_STATE_IDLE)
++				hw_led_state |= idle_seq[led_count % 4];
++			else
++				hw_led_state |= busy_seq[led_count % 4];
++
++			led_count++;
++		}
++		break;
++#endif
++
++#ifdef CONFIG_LEDS_CPU
++	case led_idle_start:
++		led_state |= LED_STATE_IDLE;
++#ifndef CONFIG_LEDS_TIMER
++		/* green on, red off */
++		hw_led_state |= NSLU2_LED_GRN_BM;
++		hw_led_state &= ~NSLU2_LED_RED_BM;
++#endif
++		break;
++
++	case led_idle_end:
++		led_state &= ~LED_STATE_IDLE;
++#ifndef CONFIG_LEDS_TIMER
++		/* green on, red on -> amber on */
++		hw_led_state |= NSLU2_LED_GRN_BM | NSLU2_LED_RED_BM;
++#endif
++		break;
++#endif /* CONFIG_LEDS_CPU */
++
++	case led_halted:
++		if (!(led_state & LED_STATE_CLAIMED))
++			hw_led_state |= NSLU2_LED_RED_BM;
++		break;
++
++	/* leds */
++
++	case led_green_on:
++		if (led_state & LED_STATE_CLAIMED)
++			hw_led_state |= NSLU2_LED_GRN_BM;
++		break;
++
++	case led_green_off:
++		if (led_state & LED_STATE_CLAIMED)
++			hw_led_state &= ~NSLU2_LED_GRN_BM;
++		break;
++
++	case led_amber_on:
++		if (led_state & LED_STATE_CLAIMED)
++			hw_led_state |= (NSLU2_LED_RED_BM | NSLU2_LED_GRN_BM);
++		break;
++
++	case led_amber_off:
++		if (led_state & LED_STATE_CLAIMED)
++			hw_led_state &= ~(NSLU2_LED_RED_BM | NSLU2_LED_GRN_BM);
++		break;
++
++	case led_red_on:
++		if (led_state & LED_STATE_CLAIMED)
++			hw_led_state |= NSLU2_LED_RED_BM;
++		break;
++
++	case led_red_off:
++		if (led_state & LED_STATE_CLAIMED)
++			hw_led_state &= ~NSLU2_LED_RED_BM;
++		break;
++
++	default:
++		break;
++	}
++
++	spin_unlock_irqrestore(&leds_lock, flags);
++
++	if  (led_state & LED_STATE_ENABLED) {
++		spin_lock_irqsave(&gpio_lock, flags);
++		*IXP4XX_GPIO_GPOUTR = (*IXP4XX_GPIO_GPOUTR & 0xFFFFFFF0) | hw_led_state;
++		spin_unlock_irqrestore(&gpio_lock, flags);
++	}
++}
++
++static int nslu2_leds_panic_event(struct notifier_block *this, unsigned long event,
++	void *ptr)
++{
++#ifdef CONFIG_LEDS_TIMER
++	leds_event(led_claim);
++#endif
++	leds_event(led_green_off);
++	leds_event(led_red_on);
++
++	return NOTIFY_DONE;
++}
++
++static struct notifier_block nslu2_leds_panic_block = {
++	.notifier_call	= nslu2_leds_panic_event,
++};
++
++static int __init nslu2_leds_init(void)
++{
++	if (!(machine_is_nslu2()))
++		return 0;
++
++	printk(KERN_INFO "NSLU2: leds\n");
++
++	/* register panic notifier */
++	notifier_chain_register(&panic_notifier_list, &nslu2_leds_panic_block);
++
++	/* enable gpio 0-3 */
++	gpio_line_config(NSLU2_LED_GRN, IXP4XX_GPIO_OUT);
++	gpio_line_config(NSLU2_LED_RED, IXP4XX_GPIO_OUT);
++	gpio_line_config(NSLU2_LED_DISK1, IXP4XX_GPIO_OUT);
++	gpio_line_config(NSLU2_LED_DISK2, IXP4XX_GPIO_OUT);
++
++	leds_event = nslu2_leds_event;
++
++	/* this will also initialize the leds to the
++	 * default state.
++	 */
++
++	leds_event(led_start);
++
++	return 0;
++}
++
++module_init(nslu2_leds_init);
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/80-nslu2-io.patch b/packages/linux/ixp4xx-kernel/2.6.15/80-nslu2-io.patch
new file mode 100644
index 0000000000..26031f6f00
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/80-nslu2-io.patch
@@ -0,0 +1,560 @@
+--- linux-2.6.15/arch/arm/mach-ixp4xx/Makefile	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/Makefile	1970-01-01 00:00:00.000000000 +0000
+@@ -8,5 +8,5 @@ obj-$(CONFIG_ARCH_IXDP4XX)	+= ixdp425-pc
+ obj-$(CONFIG_MACH_IXDPG425)	+= ixdpg425-pci.o coyote-setup.o
+ obj-$(CONFIG_ARCH_ADI_COYOTE)	+= coyote-pci.o coyote-setup.o
+ obj-$(CONFIG_MACH_GTWX5715)	+= gtwx5715-pci.o gtwx5715-setup.o
+-obj-$(CONFIG_MACH_NSLU2)	+= nslu2-pci.o nslu2-setup.o nslu2-power.o
++obj-$(CONFIG_MACH_NSLU2)	+= nslu2-pci.o nslu2-setup.o nslu2-power.o nslu2-io.o
+ 
+--- linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-io.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-io.c	1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,548 @@
++//=============================================================================
++//
++// n2-io.c version 0.1.7
++// Author: Karen Spearel <kas11 at tampabay.rr.com>
++// please report problems/bugs directly to the address above
++//
++// Boilerplate to be added "real soon now"...it is and has always been GPL'ed per
++// MODULE_LICENSE but is offered without warrantee of any sort..use at your own risk
++//
++// NOTE: THIS IS INCOMPLETE.  INCLUDED ONLY TO KEEP FROM BREAKING THE BUILD,
++// IT BEEPS AND SENDS A MESSAGE TO /proc/poweroff.  EVENTUALLY IT
++// WILL TALK TO THE n2_pbd DAEMON.  EVENTUALLY THE LED DRIVER
++// WILL TALK TO SOME USERLAND APP BUT ***NOT*** SET_LEDS.
++// 
++//=============================================================================
++//	GPIO		Function	State
++//	0		Red LED		Status		
++//	1		Green LED	Ready = 1
++//	2		Disk 2 LED	On = 0
++//	3		Disk 1 LED	On = 0
++//	4		Buzzer
++//	5		Power Button	Pressed = 1
++//	8		Power Down	Output = 1 powers down NSLU2
++//	12		Reset		Pressed = 0
++
++#include <linux/config.h>
++#include <linux/version.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/proc_fs.h>
++#include <linux/device.h>
++#include <linux/reboot.h>
++
++#include <asm/uaccess.h>
++#include <asm-arm/irq.h>
++#include <asm-arm/delay.h>
++
++/* Set this to 1 to output lots of debug messages. */
++#define NSLU2_IO_DEBUG 0
++
++#if NSLU2_IO_DEBUG
++#define nslu2_io_debug(args) printk args
++#else
++#define nslu2_io_debug(args) ((void)0)
++#endif
++
++#define VERSION			"0.1.7"
++
++#define	NSLU2BZ_MAJOR		62		//buzzer
++#define NSLU2LM_MAJOR		126
++
++
++#define NSLU2_BEEP_DUR_LONG	2000
++#define NSLU2_BEEP_DUR_MED	400
++#define NSLU2_BEEP_DUR_SHORT	100
++#define NSLU2_BEEP_PITCH_HIGH	250
++#define NSLU2_BEEP_PITCH_MED	500
++#define NSLU2_BEEP_PITCH_LOW	1000
++#define NSLU2_LONG_DELAY	30000
++
++#define NSLU2_BZ_BM		(1L << NSLU2_GPIO_BUZZ)
++
++// ioctls -- 'M" is used for sound cards...we don't got one so it seems safe
++
++#define NSLU2BZ_BEEP_STOP		_IO('M',0)       //stop multi-beep at end of audible
++#define NSLU2BZ_BEEP		_IO('M',1)       //one beep at current defaults
++#define NSLU2BZ_BEEPS		_IOW('M',3,long) //param beeps at current defaults
++#define NSLU2BZ_TONESET		_IOW('M',4,long) //set tone: range is high=250 to low=2000
++#define NSLU2BZ_ONTIME		_IOW('M',5,long) //ontime for multi-beeps in jiffies
++#define	NSLU2BZ_SILENTTIME		_IOW('M',6,long) //offtime for multi-beeps in jiffies
++#define NSLU2BZ_REPEATCNT		_IOW('M',7,long) //number of repeats for multi-beeps 0 = forever
++#define NSLU2BZ_COMBINED		_IOW('M',8,long) //combine all params in a long
++
++#define NSLU2LM_OFF		_IOW('M',32,long)
++#define NSLU2LM_ON			_IOW('M',33,long)
++#define NSLU2LM_BLINK		_IOW('M',34,long)
++#define NSLU2LM_ALT		_IOW('M',35,long)
++#define NSLU2LM_ALL_ON		_IO('M',36)
++#define NSLU2LM_ALL_OFF		_IO('M',37)
++
++#define PHYS_LEDS		4
++#define BLINK_DELAY		25
++
++//  OR Masks to turn these LEDs ON
++
++#define	RS_RED_ON	0x00000001	//0b0000 0000 0000 0010
++#define	RS_GRN_ON	0x00000002	//0b0000 0000 0000 0001
++#define RS_YEL_ON	0x00000003	//0b0000 0000 0000 0011
++
++// AND Masks to turn these LEDs OFF
++
++#define	RS_RED_OFF	0xfffffffe	//0b1111 1111 1111 1101
++#define	RS_GRN_OFF	0xfffffffd	//0b1111 1111 1111 1110
++#define RS_YEL_OFF	0xfffffffc	//0b1111 1111 1111 1100
++
++// AND Masks to turn these LEDs ON
++
++#define DISK1_ON	0xfffffff7	//0b1111 1111 1111 0111
++#define	DISK2_ON	0xfffffffb	//0b1111 1111 1111 1011
++
++// Or Masks to turn these LEDs OFF
++
++#define DISK1_OFF	0x00000008	//0b0000 0000 0000 1000
++#define	DISK2_OFF	0x00000004	//0b0000 0000 0000 0100	
++
++// EOR masks for toggling LEDs on/off
++
++#define RS_RG_ALT	0x00000003	//eor mask to toggle rs rg bits
++#define RS_GRN_TGL	0x00000002
++#define RS_RED_TGL	0x00000001
++#define DISK1_TGL	0x00000008
++#define DISK2_TGL	0x00000004
++
++// The LED names for switches
++
++#define LED_RS_RED	0
++#define LED_RS_GRN	1
++#define	LED_DISK1	2
++#define LED_DISK2	3
++#define LED_ALL		4
++
++static unsigned long ontime = 50;
++static unsigned long offtime = 450;
++static unsigned long bz_repeatcnt = 10;
++static unsigned long tone = 1000;
++
++static struct timer_list n2lm_rsg_timer;	//rs green 
++static struct timer_list n2lm_rsr_timer;	//rs red
++static struct timer_list n2lm_d1_timer;		//drive 1
++static struct timer_list n2lm_d2_timer;		//drive 2
++static struct timer_list n2bz_timer;		//beeper
++
++// sysfs class
++static struct class *n2lm_class;
++
++//==================================================================================================
++//
++// Blinking is handled entirely by the 4 timer handlers.  On timeout, the bit in the
++// GPIO output register is xor'd with a mask corresponding to the selected led which simply
++// flips that bit.  No record of what any of the other leds is doing is needed.
++//
++//==================================================================================================
++// this blinks rs green or green/yellow if rs red is on
++#ifndef CONFIG_LEDS
++static void n2lm_rsg_handler(unsigned long data)
++{
++	*IXP4XX_GPIO_GPOUTR ^= RS_GRN_TGL;			//flip the led
++	n2lm_rsg_timer.expires = jiffies + BLINK_DELAY;		//next timeout
++	add_timer(&n2lm_rsg_timer);				//reinit timer
++	return;
++}
++
++// this blinks or alternates rs red green... inited wit green on/red off
++static void n2lm_rsr_handler(unsigned long data)
++{
++	*IXP4XX_GPIO_GPOUTR ^= n2lm_rsr_timer.data;
++	n2lm_rsr_timer.expires = jiffies + BLINK_DELAY;
++	add_timer(&n2lm_rsr_timer);
++	return;	
++}
++// blinks disk 1
++static void n2lm_d1_handler(unsigned long data)
++{
++	*IXP4XX_GPIO_GPOUTR ^= DISK1_TGL;
++	n2lm_d1_timer.expires = jiffies + BLINK_DELAY;
++	add_timer(&n2lm_d1_timer);
++	return;
++}
++// blinks disk 2
++static void n2lm_d2_handler(unsigned long data)
++{
++	*IXP4XX_GPIO_GPOUTR ^= DISK2_TGL;
++	n2lm_d2_timer.expires = jiffies + BLINK_DELAY;
++	add_timer(&n2lm_d2_timer);
++	return;
++}
++
++//==================================================================================================
++
++static void n2lm_timer_start(unsigned long led)
++{
++
++	nslu2_io_debug((KERN_DEBUG "timer: %ld\n",led));
++
++	switch(led) {
++		case LED_RS_RED:
++			n2lm_rsr_timer.expires = jiffies + BLINK_DELAY;
++			add_timer(&n2lm_rsr_timer);
++			break;
++
++		case LED_RS_GRN:
++			n2lm_rsg_timer.expires = jiffies + BLINK_DELAY;
++			add_timer(&n2lm_rsg_timer);
++			break;
++
++		case LED_DISK1:
++			n2lm_d1_timer.expires = jiffies + BLINK_DELAY;
++			add_timer(&n2lm_d1_timer);
++ 			break;
++
++		case LED_DISK2:
++			n2lm_d2_timer.expires = jiffies + BLINK_DELAY; 
++			add_timer(&n2lm_d2_timer);
++			break;
++
++		default:
++			break;
++	}
++	return;
++}
++
++//==================================================================================================
++
++static void n2lm_timer_stop(unsigned long led)
++{
++	switch (led) {
++		case LED_RS_RED:
++			del_timer(&n2lm_rsr_timer);
++			break;
++		case LED_RS_GRN:
++			del_timer(&n2lm_rsg_timer);
++			break;
++		case LED_DISK1:
++			del_timer(&n2lm_d1_timer);
++ 			break;
++		case LED_DISK2: 
++			del_timer(&n2lm_d2_timer);
++			break;
++		default:
++			break;
++	}
++	return;
++}
++
++//--------------------------------------------------------------------------------------------------
++
++static void n2lm_timer_stop_all(void)
++{
++	del_timer(&n2lm_rsg_timer);
++	del_timer(&n2lm_rsr_timer);
++	del_timer(&n2lm_d1_timer); 
++	del_timer(&n2lm_d2_timer);
++	return;
++}
++//--------------------------------------------------------------------------------------------------
++
++static void n2lm_ledon(unsigned long led)
++{
++
++	nslu2_io_debug((KERN_DEBUG "ledon: %ld\n", led));
++
++	switch (led) {
++		case LED_RS_RED:	
++			*IXP4XX_GPIO_GPOUTR |= RS_RED_ON;	//1
++			return;
++		case LED_RS_GRN:
++			*IXP4XX_GPIO_GPOUTR |= RS_GRN_ON;	//2
++			return;
++		case LED_DISK1:
++			*IXP4XX_GPIO_GPOUTR &= DISK1_ON;	//0xfffffff7
++			return;
++		case LED_DISK2:	
++			*IXP4XX_GPIO_GPOUTR &= DISK2_ON;	//0xfffffffb
++			return;
++		case LED_ALL:					//all green
++			*IXP4XX_GPIO_GPOUTR |= RS_GRN_ON;
++			*IXP4XX_GPIO_GPOUTR &= (DISK1_ON & DISK2_ON);
++			return;	
++	}
++}
++
++//--------------------------------------------------------------------------------------------------
++
++static void n2lm_ledoff(unsigned long led)
++{
++
++	switch (led) {
++		case LED_RS_RED:	
++			*IXP4XX_GPIO_GPOUTR &= RS_RED_OFF;	//0xffffffffe
++			return;
++		case LED_RS_GRN:
++			*IXP4XX_GPIO_GPOUTR &= RS_GRN_OFF;	//0xfffffffd
++			return;
++		case LED_DISK1:
++			*IXP4XX_GPIO_GPOUTR |= DISK1_OFF;	//0x00000008
++			return;
++		case LED_DISK2:	
++			*IXP4XX_GPIO_GPOUTR |= DISK2_OFF;	//0x00000004
++			return;
++		case LED_ALL:
++			*IXP4XX_GPIO_GPOUTR &= (RS_GRN_OFF & RS_RED_OFF);
++			*IXP4XX_GPIO_GPOUTR |= (DISK1_OFF | DISK2_OFF);
++	}
++}
++
++//==================================================================================================
++
++static int n2lm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long led)
++{
++
++	nslu2_io_debug((KERN_DEBUG "cmd=%d, led=%ld\n", cmd, led));
++	
++	if (led < 0 || led >= PHYS_LEDS)
++		return -EINVAL;
++
++	switch (cmd ) {
++		case NSLU2LM_ON:
++			n2lm_timer_stop(led);
++			n2lm_ledon(led);
++			break;
++			
++		case NSLU2LM_OFF:
++			n2lm_timer_stop(led);
++			n2lm_ledoff(led);
++			break;
++			
++		case NSLU2LM_BLINK:
++			n2lm_ledon(led);
++			if (led == LED_RS_RED)
++				n2lm_rsr_timer.data = RS_RED_TGL;
++			n2lm_timer_start(led);
++			break;
++
++		case NSLU2LM_ALT:
++			if (led == LED_RS_RED)
++			{
++				n2lm_ledon(LED_RS_GRN);
++				n2lm_ledoff(LED_RS_RED);
++				n2lm_rsr_timer.data = RS_RG_ALT;
++				n2lm_timer_start(LED_RS_RED);
++				break;
++			} else
++				return -EINVAL;
++		
++		case NSLU2LM_ALL_ON:
++			n2lm_timer_stop_all();
++			n2lm_ledon(LED_ALL);
++			break;
++		
++		case NSLU2LM_ALL_OFF:
++			n2lm_timer_stop_all();
++			n2lm_ledoff(LED_ALL);
++			break;
++		
++		default:
++			return -EINVAL;
++	}
++
++	return 0;
++}
++
++static struct file_operations n2lm_fops = {
++	.owner		= THIS_MODULE,
++	.ioctl		= n2lm_ioctl,
++};
++#endif
++//==================================================================================================
++// We can't do anything fancy here since the system tick rate is far below that required to
++// generate a desirable tone.  Therefore we haven't much choice but to use a busy loop until
++// I get up to speed on the timers.  The saving grace is that for the normal uses, nothing 
++// important should be haprepening. 
++//==================================================================================================
++
++static void n2_buzz(int tone_delay, int duration)
++{
++	int i;
++
++	*IXP4XX_GPIO_GPOER &= ~NSLU2_BZ_BM;
++		
++	for (i = 1; i < duration; i++) {
++		*IXP4XX_GPIO_GPOUTR &= ~NSLU2_BZ_BM;
++		udelay(tone_delay);
++		*IXP4XX_GPIO_GPOUTR |= NSLU2_BZ_BM;
++		udelay(tone_delay);
++	}
++	*IXP4XX_GPIO_GPOER |= NSLU2_BZ_BM;
++
++	return;
++}
++//=================================================================================================
++
++// this handles the buzzer duty cycle
++static void n2bz_handler(unsigned long data)
++{
++	if (--bz_repeatcnt > 0) {			//if just one beep left to do
++		n2bz_timer.expires = jiffies + ontime + offtime;	//next timeout
++		add_timer(&n2bz_timer);					//reinit timer
++	}
++	n2_buzz(tone/2, ontime);
++	nslu2_io_debug((KERN_DEBUG "Count = %d\tOntime = %d\n", bz_repeatcnt, ontime));
++	return;
++}
++
++//==================================================================================================
++
++static int n2bz_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long param)
++{
++	switch (cmd) {
++		case NSLU2BZ_BEEP:
++			n2_buzz(tone/2, ontime);
++			break;
++	
++		case NSLU2BZ_BEEP_STOP:
++			del_timer(&n2bz_timer);
++			break;
++
++		case NSLU2BZ_BEEPS:
++			if (param == 0)
++				bz_repeatcnt = 0xffffffff;
++			else
++				bz_repeatcnt = param;
++			n2bz_handler(0);
++			break;
++	
++		case NSLU2BZ_TONESET:
++			if (param >= 250 && param <= 2000)
++				tone = param;
++			break;
++
++		case NSLU2BZ_ONTIME:
++			if (param > 4 && param < 201)
++				ontime = param;
++			break;
++
++		case NSLU2BZ_SILENTTIME:
++			if (param > ontime)			//enforce a reasonable duty cycle
++				offtime = param;
++			else
++				offtime = ontime;
++			break;
++
++		case NSLU2BZ_REPEATCNT:
++			if (param == 0)
++				bz_repeatcnt = 0xffffffff;
++			else
++				bz_repeatcnt = param;
++			break;
++
++		case NSLU2BZ_COMBINED:
++			bz_repeatcnt =  (param & 0xF0000000) >> 28;	//repeat 1 - 16
++			ontime =        (param & 0x0FF00000) >> 20; 	//ontime 1 - 256 jiffies
++			offtime =       (param & 0x000FFF00) >> 8;	//offtime 1 - 4095 jiffies
++			tone =          (param & 0x000000FF) << 4;	//tone (1 - 255) * 16
++			break;
++
++		default:
++			break;
++	}
++	return 0;
++}
++
++static struct file_operations n2bz_fops = {
++	.owner		= THIS_MODULE,
++	.ioctl		= n2bz_ioctl,
++};
++
++static void n2iom_initarch(void)
++{
++#ifndef CONFIG_LEDS
++	init_timer(&n2lm_rsg_timer);
++	init_timer(&n2lm_rsr_timer);
++	init_timer(&n2lm_d1_timer);
++	init_timer(&n2lm_d2_timer);
++
++	n2lm_rsr_timer.function = n2lm_rsr_handler;
++	n2lm_rsg_timer.function = n2lm_rsg_handler;
++	n2lm_d2_timer.function = n2lm_d2_handler;
++	n2lm_d1_timer.function = n2lm_d1_handler;
++#endif
++
++	init_timer(&n2bz_timer);
++	n2bz_timer.function = n2bz_handler;
++
++	n2lm_rsr_timer.data = n2lm_rsg_timer.data = n2lm_d1_timer.data = n2lm_d2_timer.data = n2bz_timer.data = 0;
++
++#ifndef CONFIG_LEDS
++	*IXP4XX_GPIO_GPOER &= 0xfffffff0;	//enable gpio 0-3
++	*IXP4XX_GPIO_GPOUTR |= 0x00000003;	//turn off the leds
++	*IXP4XX_GPIO_GPOUTR &= 0xfffffffc;
++	n2lm_ledon(LED_ALL);
++	n2_buzz(NSLU2_BEEP_PITCH_MED, NSLU2_BEEP_DUR_SHORT);
++	n2lm_ledoff(LED_ALL);
++
++	// Default the Ready/Status to Red during kernel boot, Turn Green at the end of sysvinit
++	n2lm_ledon(LED_RS_RED);
++#endif
++
++	return;
++}
++
++//==================================================================================================
++
++static int __init n2iom_init(void)
++{
++	printk(KERN_INFO "NSLU2: i/o, %s\n", VERSION);
++  	
++	n2iom_initarch();
++
++	n2lm_class = class_create(THIS_MODULE, "nslu2");
++
++#ifndef CONFIG_LEDS
++	if (register_chrdev(NSLU2LM_MAJOR, "n2_ledm", &n2lm_fops) < 0) {
++		printk(KERN_DEBUG "Led Manager Major %d not available\n", NSLU2LM_MAJOR);
++		return -EBUSY;
++	}
++	else {
++		class_device_create(n2lm_class, NULL, MKDEV(NSLU2LM_MAJOR, 0), NULL, "leds");
++	}
++#endif
++
++	if (register_chrdev(NSLU2BZ_MAJOR, "n2_bzm", &n2bz_fops) < 0) {
++		printk(KERN_DEBUG "Buzzer Major %d not available\n", NSLU2BZ_MAJOR);
++		return -EBUSY;
++	}
++	else {
++		class_device_create(n2lm_class, NULL, MKDEV(NSLU2BZ_MAJOR, 0), NULL, "buzzer");
++	}
++
++	return 0;
++}
++
++//==================================================================================================
++
++static void __exit n2iom_exit(void)
++{
++
++#ifndef CONFIG_LEDS
++	del_timer(&n2lm_rsg_timer);
++	del_timer(&n2lm_rsr_timer);
++	del_timer(&n2lm_d1_timer);
++	del_timer(&n2lm_d2_timer);	
++
++	unregister_chrdev(NSLU2LM_MAJOR, "n2lm" );
++	class_device_destroy(n2lm_class, MKDEV(NSLU2LM_MAJOR, 0));
++#endif
++
++	unregister_chrdev(NSLU2BZ_MAJOR, "n2bz");
++	class_device_destroy(n2lm_class, MKDEV(NSLU2BZ_MAJOR, 0));
++
++	class_destroy(n2lm_class);
++}
++
++module_init(n2iom_init);
++module_exit(n2iom_exit);
++
++MODULE_AUTHOR("Karen Spearel <kas11@tampabay.rr.com>");
++MODULE_DESCRIPTION("NSLU2 I/O driver");
++MODULE_LICENSE("GPL");
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/85-timer.patch b/packages/linux/ixp4xx-kernel/2.6.15/85-timer.patch
new file mode 100644
index 0000000000..3d4a03f616
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/85-timer.patch
@@ -0,0 +1,285 @@
+--- linux-2.6.15/arch/arm/mach-ixp4xx/common.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/common.c	1970-01-01 00:00:00.000000000 +0000
+@@ -239,36 +239,165 @@ void __init ixp4xx_init_irq(void)
+  * IXP4xx timer tick
+  * We use OS timer1 on the CPU for the timer tick and the timestamp 
+  * counter as a source of real clock ticks to account for missed jiffies.
++ *
++ * 'CLOCK_TICK_RATE' is the nominal number of internal ticks per second,
++ * this is significantly greater than the actual number on any ixp4xx
++ * board.  Neither this nor 'LATCH' are required by this code because
++ * the only requirement is to generate HZ timer_tick calls per second.
+  *************************************************************************/
++#if TICK_NSEC * HZ != 1000000000
++	/* This will cause the jiffies to drift unnecessarily. */
++#	error CLOCK_TICK_RATE should be a multiple of HZ for this code
++#endif
++
++/* These are the control registers for the interrupt handler, they must
++ * only be read and written by the interrupt handler and by the init
++ * method (which sets them to 0).
++ */
++static volatile u32 last_timer_time;
++static volatile int accumulated_error;
++
++/* Most ixp4xx boards have 66.6666MHz crystals, so default to this, reset
++ * this from the board level code if required.  The following variables
++ * must be *written* only by set_board_tick_rate
++ */
++static u32 board_tick_rate;
++static u32 board_tick_per_1000; /* board_tick_rate/1000 */
++static u32 timer_count;
++
++/* The following symbol may be written to change the current tick rate,
++ * it is read by the interrupt handler and used to reload the timer.
++ * The 'real' value (the one in use) is 'board_tick_rate' above.
++ * NOTE: this can be tweaked to match the actual crystal on a particular
++ * machine.
++ */
++volatile u32 ixp4xx_board_tick_rate = 66666600;
++EXPORT_SYMBOL(ixp4xx_board_tick_rate);
++
++/* The set API may run asynchronously in the presence of interrupts,
++ * everything it does it is both atomic and complete (notice that it
++ * doesn't change any of the 'volatile' values).  The mathematics in
++ * here require the following values.  Changing the board tick rate
++ * implies an unknown error in the current timestamp tick count.
++ */
++#if IXP4XX_OST_RELOAD_MASK != 3 || IXP4XX_OST_ENABLE != 1
++#	error unexpected value for timer reload mask
++#endif
++static void set_board_tick_rate(u32 rate) {
++	u32 reload;
++
++	/* Store the two effectively informational rate values, the
++	 * error calculation is (rate - count*HZ) (above), and rate
++	 * is changed first, this can cause a temporary error which
++	 * will be corrected on the next interrupt.
++	 */
++	board_tick_rate = rate;
++	board_tick_per_1000 = (rate+500)/1000;
++
++	/* Calculate the correct value to load into the timer countdown
++	 * register, the low two bits must be b01 (to enable the timer).
++	 * Select the top bits to be as close to the desired value as
++	 * possible.
++	 *
++	 * First find the best value, regardless of the low two bits -
++	 * this is the value used in the interrupt calculation even though
++	 * it cannot necessarily be set into the register.
++	 */
++	timer_count = (rate + (HZ/2))/HZ;
++
++	/* Now the timer_ticks are being generated at this rate, calculate
++	 * an appropriate value for the register.  This stores a 30 bit
++	 * value which gives a period of 4*x+1, we want:
++	 *
++	 *   4*x+1 = board_tick_rate/HZ
++	 *
++	 * This needs to be rounded to the closest 4*HZ value:
++	 * 
++	 *   x = ((board_tick_rate-HZ) + (4*HZ)/2) / 4*HZ
++	 *   x = (board_tick_rate+HZ) / (4*HZ);
++	 */
++	reload = (board_tick_rate + HZ) / HZ;
++	reload = (reload & ~IXP4XX_OST_RELOAD_MASK) | IXP4XX_OST_ENABLE;
++	*IXP4XX_OSRT1 = reload;
+ 
+-static unsigned volatile last_jiffy_time;
++	/* If the clock is drifing, look in syslog: */
++	printk(KERN_INFO "IXP4xx: FREQ=%d COUNT=%d\n", rate, reload);
++}
+ 
+-#define CLOCK_TICKS_PER_USEC	((CLOCK_TICK_RATE + USEC_PER_SEC/2) / USEC_PER_SEC)
++/* This returns the time in timer ticks since the 'last_timer_time'
++ * recorded above.  Use this to avoid arithmetic errors because of
++ * the overflow when the timer wraps.
++ */
++static inline u32 ixp4xx_timer_delta(void)
++{
++	return *IXP4XX_OSTS - last_timer_time;
++}
+ 
+ /* IRQs are disabled before entering here from do_gettimeofday() */
+ static unsigned long ixp4xx_gettimeoffset(void)
+ {
+-	u32 elapsed;
+-
+-	elapsed = *IXP4XX_OSTS - last_jiffy_time;
++	/* Return the offset of the current time from the last time
++	 * timer tick in microseconds.  This is only used for the
++	 * gettimeofday call.
++	 *
++	 * The result of this API is at most about 20000 (for a 50Hz
++	 * HZ - 20000 uS/tick), the input delta is at most about
++	 * 1.3M - 21 bits.
++	 */
++	u32 delta = ixp4xx_timer_delta(); /* About 21 bits max */
++	/* return delta * 1000000 / board_tick_rate; */
++	return (delta * 1000 + board_tick_per_1000/2) / board_tick_per_1000;
++}
+ 
+-	return elapsed / CLOCK_TICKS_PER_USEC;
++/* This is the correct adjustment to the counter to compensate for an
++ * error iff timer_count-1 <= exact_count <= timer_count+1
++ */
++static inline int adjustment(int error) {
++	if (error >= HZ)
++		return 1;
++	else if (error <= -HZ)
++		return -1;
++	return 0;
+ }
+ 
+ static irqreturn_t ixp4xx_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+ {
++	u32 rate;
++	u32 count;
++	int error;
++
+ 	write_seqlock(&xtime_lock);
+ 
+ 	/* Clear Pending Interrupt by writing '1' to it */
+ 	*IXP4XX_OSST = IXP4XX_OSST_TIMER_1_PEND;
+ 
++	/* If the board tick rate has been changed update the cached
++	 * value.
++	 */
++	if (ixp4xx_board_tick_rate != board_tick_rate) {
++		set_board_tick_rate(ixp4xx_board_tick_rate);
++		accumulated_error = 0;
++	}
++
+ 	/*
+ 	 * Catch up with the real idea of time
++	 *
++	 * board_tick_rate: actual ixp4xx ticks/second, read-only
++	 * accumulated_error: aggregate error/tick * HZ, read/write
++	 * timer_count: best ixp4xx ticks per timer_tick, read-only
+ 	 */
+-	while ((*IXP4XX_OSTS - last_jiffy_time) > LATCH) {
++	rate = board_tick_rate;
++	error = accumulated_error;
++	count = timer_count;
++	do {
++		u32 adjusted_count = count + adjustment(error);
++		if (ixp4xx_timer_delta() < adjusted_count)
++			break;
+ 		timer_tick(regs);
+-		last_jiffy_time += LATCH;
+-	}
++		last_timer_time += adjusted_count;
++		error += rate - adjusted_count*HZ;
++	} while (1);
++	accumulated_error = error;
+ 
+ 	write_sequnlock(&xtime_lock);
+ 
+@@ -281,17 +410,30 @@ static struct irqaction ixp4xx_timer_irq
+ 	.handler	= ixp4xx_timer_interrupt,
+ };
+ 
++u32 ixp4xx_get_board_tick_rate(void) {
++	return board_tick_rate;
++}
++
++EXPORT_SYMBOL(ixp4xx_get_board_tick_rate);
++
++void ixp4xx_set_board_tick_rate(u32 rate) {
++	ixp4xx_board_tick_rate = rate;
++}
++
++EXPORT_SYMBOL(ixp4xx_set_board_tick_rate);
++
+ static void __init ixp4xx_timer_init(void)
+ {
+ 	/* Clear Pending Interrupt by writing '1' to it */
+ 	*IXP4XX_OSST = IXP4XX_OSST_TIMER_1_PEND;
+ 
+ 	/* Setup the Timer counter value */
+-	*IXP4XX_OSRT1 = (LATCH & ~IXP4XX_OST_RELOAD_MASK) | IXP4XX_OST_ENABLE;
++	set_board_tick_rate(ixp4xx_board_tick_rate);
+ 
+ 	/* Reset time-stamp counter */
+ 	*IXP4XX_OSTS = 0;
+-	last_jiffy_time = 0;
++	last_timer_time = 0;
++	accumulated_error = 0;
+ 
+ 	/* Connect the interrupt handler and enable the interrupt */
+ 	setup_irq(IRQ_IXP4XX_TIMER1, &ixp4xx_timer_irq);
+@@ -337,4 +479,3 @@ void __init ixp4xx_sys_init(void)
+ 				ARRAY_SIZE(ixp46x_devices));
+ 	}
+ }
+-
+--- linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-setup.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-setup.c	1970-01-01 00:00:00.000000000 +0000
+@@ -119,6 +119,11 @@ static void nslu2_power_off(void)
+ 
+ static void __init nslu2_init(void)
+ {
++	/* The NSLU2 has a 33MHz crystal on board - 1.01% different
++	 * from the typical value.
++	 */
++	ixp4xx_set_board_tick_rate(66000000);
++
+ 	ixp4xx_sys_init();
+ 
+ 	pm_power_off = nslu2_power_off;
+--- linux-2.6.15/drivers/input/misc/nslu2spkr.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/input/misc/nslu2spkr.c	1970-01-01 00:00:00.000000000 +0000
+@@ -51,7 +51,7 @@ static int nslu2_spkr_event(struct input
+ 	}
+ 
+ 	if (value > 20 && value < 32767)
+-		count = (NSLU2_FREQ / (value*4)) - 1;
++		count = (ixp4xx_get_board_tick_rate() / (value*4)) - 1;
+ 
+ 	spin_lock_irqsave(&beep_lock, flags);
+ 
+--- linux-2.6.15/include/asm-arm/arch-ixp4xx/nslu2.h	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/include/asm-arm/arch-ixp4xx/nslu2.h	1970-01-01 00:00:00.000000000 +0000
+@@ -38,11 +38,6 @@
+ #define NSLU2_PCI_INTD_PIN	8
+ 
+ 
+-/* NSLU2 Timer */
+-#define NSLU2_FREQ 66000000
+-#define NSLU2_CLOCK_TICK_RATE (((NSLU2_FREQ / HZ & ~IXP4XX_OST_RELOAD_MASK) + 1) * HZ)
+-#define NSLU2_CLOCK_TICKS_PER_USEC ((NSLU2_CLOCK_TICK_RATE + USEC_PER_SEC/2) / USEC_PER_SEC)
+-
+ /* GPIO */
+ 
+ #define NSLU2_GPIO0		0
+--- linux-2.6.15/include/asm-arm/arch-ixp4xx/timex.h	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/include/asm-arm/arch-ixp4xx/timex.h	1970-01-01 00:00:00.000000000 +0000
+@@ -6,10 +6,23 @@
+ #include <asm/hardware.h>
+ 
+ /*
+- * We use IXP425 General purpose timer for our timer needs, it runs at 
+- * 66.66... MHz. We do a convulted calculation of CLOCK_TICK_RATE b/c the
+- * timer register ignores the bottom 2 bits of the LATCH value.
++ * In linux/timex.h 'LATCH' is defined as CLOCK_TICK_RATE/HZ and
++ * is the number of internal counts per timer interrupt.  Thus
++ * CLOCK_TICK_RATE is LATCH*HZ.
++ *
++ * The actual values of these numbers do not matter, because they
++ * are only used to calculate ACTHZ (rate/latch as a 24.8 fixed
++ * point number), so the value here gives a LATCH of 1 and pretty
++ * much guarantees to flush out any off-by-one errors.
++ *
++ * ACTHZ is equal to HZ, because CLOCK_TICK_RATE is a multiple of
++ * HZ, this is checked in the ixp4xx/common.c code.
+  */
+-#define FREQ 66666666
+-#define CLOCK_TICK_RATE (((FREQ / HZ & ~IXP4XX_OST_RELOAD_MASK) + 1) * HZ)
++#define CLOCK_TICK_RATE HZ
+ 
++/* The following allow the exact board tick rate to be set and
++ * discovered.  The value should be exactly twice the frequency
++ * (in Hz) of the onboard crystal.
++ */
++extern u32 ixp4xx_get_board_tick_rate(void);
++extern void ixp4xx_set_board_tick_rate(u32 new_rate);
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/91-maclist.patch b/packages/linux/ixp4xx-kernel/2.6.15/91-maclist.patch
new file mode 100644
index 0000000000..27af1ea639
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/91-maclist.patch
@@ -0,0 +1,377 @@
+--- linux-2.6.15/include/net/maclist.h	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/include/net/maclist.h	1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,23 @@
++#ifndef _MACLIST_H
++#define _MACLIST_H 1
++/*
++ * Interfaces to the MAC repository
++ */
++/*
++ * Add a single entry, returns 0 on success else an error
++ * code.  Must *not* be called from an interrupt handler.
++ */
++extern int maclist_add(const u8 id_to_add[6]);
++
++/*
++ * Return the current entry count (valid in any context).
++ */
++extern int maclist_count(void);
++
++/*
++ * Return the ID from the n'th entry (valid in any context),
++ * returns 0 on success, -EINVAL if 'n' is out of range.
++ */
++extern int maclist_read(u8 (*buffer_for_id)[6], int index_of_id_to_return);
++
++#endif /*_MACLIST_H*/
+--- linux-2.6.15/drivers/net/maclist.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/net/maclist.c	1970-01-01 00:00:00.000000000 +0000
+@@ -0,0 +1,314 @@
++/*
++ * drivers/net/maclist.c
++ *
++ * a simple driver to remember ethernet MAC values
++ *
++ * Some Ethernet hardware implementations have no built-in
++ * storage for allocated MAC values - an example is the Intel
++ * IXP420 chip which has support for Ethernet but no defined
++ * way of storing allocated MAC values.  With such hardware
++ * different board level implementations store the allocated
++ * MAC (or MACs) in different ways.  Rather than put board
++ * level code into a specific Ethernet driver this driver
++ * provides a generally accessible repository for the MACs
++ * which can be written by board level code and read by the
++ * driver.
++ *
++ * The implementation also allows user level programs to
++ * access the MAC information in /proc/net/maclist.  This is
++ * useful as it allows user space code to use the MAC if it
++ * is not used by a built-in driver.
++ *
++ * Copyright (C) 2005 John Bowler
++ * Author: John Bowler <jbowler@acm.org>
++ * Maintainers: http://www.nslu2-linux.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.
++ *
++ * External interfaces:
++ *  Interfaces to linux kernel (and modules)
++ *   maclist_add:   add a single MAC
++ *   maclist_count: total number of MACs stored
++ *   maclist_read:  read a MAC 0..(maclist_count-1)
++ */
++#include <linux/module.h>
++#include <linux/moduleparam.h>
++#include <linux/etherdevice.h>
++#include <linux/proc_fs.h>
++#include <linux/errno.h>
++
++#include <net/maclist.h>
++
++#define MACLIST_NAME "maclist"
++
++MODULE_AUTHOR("John Bowler <jbowler@acm.org>");
++MODULE_DESCRIPTION("MAC list repository");
++MODULE_LICENSE("GPL");
++
++typedef struct maclist_entry {
++	struct maclist_entry *next;  /* Linked list, first first */
++	u8                    id[6]; /* 6 byte Ethernet MAC */
++} maclist_entry_t;
++
++/* Access to this list is possible at any time - entries in
++ * the list are never destroyed.  Modification of the list is
++ * safe only from the init code (i.e. modification must be
++ * single threaded), but read from an interrupt at the same
++ * time is possible and safe.
++ */
++static maclist_entry_t *maclist_list = 0;
++
++/*
++ * External interfaces.
++ *
++ * Add a single entry, returns 0 on success else an error
++ * code.  Must be single threaded.
++ */
++int maclist_add(const u8 new_id[6]) {
++	maclist_entry_t *new_entry, **tail;
++
++	if (new_id == 0 || !is_valid_ether_addr(new_id)) {
++		printk(KERN_ERR MACLIST_NAME ": invalid ethernet address\n");
++		return -EINVAL;
++	}
++	new_entry = kmalloc(sizeof *new_entry, GFP_KERNEL);
++	if (new_entry == 0)
++		return -ENOMEM;
++	new_entry->next = 0;
++	memcpy(new_entry->id, new_id, sizeof new_entry->id);
++
++	tail = &maclist_list;
++	while (*tail != 0)
++		tail = &(*tail)->next;
++	*tail = new_entry;
++	return 0;
++}
++EXPORT_SYMBOL(maclist_add);
++
++/*
++ * Return the current entry count (valid in any context).
++ */
++int maclist_count(void) {
++	maclist_entry_t *tail = maclist_list;
++	int count = 0;
++
++	while (tail != 0) {
++		tail = tail->next;
++		++count;
++	}
++
++	return count;
++}
++EXPORT_SYMBOL(maclist_count);
++
++/*
++ * Return the ID from the n'th entry (valid in any context),
++ * returns 0 on success, -EINVAL if 'n' is out of range.
++ */
++int maclist_read(u8 (*id)[6], int n) {
++	maclist_entry_t *entry = maclist_list;
++
++	while (n > 0 && entry != 0) {
++		--n;
++		entry = entry->next;
++	}
++
++	if (n == 0 && entry != 0) {
++		memcpy(id, entry->id, sizeof *id);
++		return 0;
++	}
++
++	printk(KERN_ERR MACLIST_NAME ": id does not exist\n");
++	return -EINVAL;
++}
++EXPORT_SYMBOL(maclist_read);
++
++/*
++ * Parameter parsing.  The option string is a list of MAC
++ * addresses, comma separated.  (The parsing really should
++ * be somewhere central...)
++ */
++static int __init maclist_setup(char *param) {
++	int bytes = 0, seen_a_digit = 0;
++	u8 id[6];
++
++	memset(id, 0, sizeof id);
++
++	if (param) do {
++		int digit = -1;
++		switch (*param) {
++		case '0': digit = 0; break;
++		case '1': digit = 1; break;
++		case '2': digit = 2; break;
++		case '3': digit = 3; break;
++		case '4': digit = 4; break;
++		case '5': digit = 5; break;
++		case '6': digit = 6; break;
++		case '7': digit = 7; break;
++		case '8': digit = 8; break;
++		case '9': digit = 9; break;
++		case 'a': case 'A': digit = 10; break;
++		case 'b': case 'B': digit = 11; break;
++		case 'c': case 'C': digit = 12; break;
++		case 'd': case 'D': digit = 13; break;
++		case 'e': case 'E': digit = 14; break;
++		case 'f': case 'F': digit = 15; break;
++		case ':':
++			if (seen_a_digit)
++				bytes = (bytes+1) & ~1;
++			else
++				bytes += 2; /* i.e. ff::ff is ff:00:ff */
++			seen_a_digit = 0;
++			break;
++		case 0:
++			if (bytes == 0) /* nothing new seen so far */
++				return 0;
++			/*fall through*/
++		case ',': case ';':
++			if (bytes > 0)
++				bytes = 12; /* i.e. all trailing bytes 0 */
++			break;
++		default:
++			printk(KERN_ERR MACLIST_NAME ": invalid character <%c[%d]>\n",
++					*param, *param);
++			return -EINVAL;
++		}
++
++		if (digit >= 0) {
++			id[bytes>>1] = (id[bytes>>1] << 4) + digit; break;
++			++bytes;
++			seen_a_digit = 1;
++		}
++
++		if (bytes >= 12) {
++			int rc = maclist_add(id);
++			if (rc)
++				return rc;
++			bytes = 0;
++			seen_a_digit = 0;
++			memset(id, 0, sizeof id);
++			if (*param == 0)
++				return 0;
++		}
++		++param;
++	} while (1);
++
++	return 0;
++}
++
++/*
++ * procfs support, if compiled in.
++ */
++#ifdef CONFIG_PROC_FS
++/*
++ * Character device read
++ */
++static int maclist_getchar(off_t n) {
++	static char xdigit[16] = "0123456789abcdef";
++	maclist_entry_t *head = maclist_list;
++	int b;
++
++	do {
++		if (head == 0)
++			return -1;
++		if (n < 18)
++			break;
++		head = head->next;
++		n -= 18;
++	} while (1);
++
++	if (n == 17)
++		return '\n';
++
++	b = n/3;
++	switch (n - b*3) {
++	case 0: return xdigit[head->id[b] >> 4];
++	case 1: return xdigit[head->id[b] & 0xf];
++	default: return ':';
++	}
++}
++
++/*
++ * The extensively undocumented proc_read_t callback is implemented here.
++ * Go look in fs/proc/generic.c:
++ *
++ * Prototype:
++ *    int f(char *buffer, char **start, off_t offset,
++ *          int count, int *peof, void *dat)
++ *
++ * Assume that the buffer is "count" bytes in size.
++ *
++ * 2) Set *start = an address within the buffer.
++ *    Put the data of the requested offset at *start.
++ *    Return the number of bytes of data placed there.
++ *    If this number is greater than zero and you
++ *    didn't signal eof and the reader is prepared to
++ *    take more data you will be called again with the
++ *    requested offset advanced by the number of bytes
++ *    absorbed.
++ */
++static int maclist_proc_read(char *buffer, char **start, off_t offset,
++		int count, int *peof, void *dat) {
++	int total;
++
++	*start = buffer;
++	total = 0;
++
++	while (total < count) {
++		int ch = maclist_getchar(offset++);
++		if (ch == -1) {
++			*peof = 1;
++			break;
++		}
++		*buffer++ = ch;
++		++total;
++	}
++
++	return total;
++}
++#endif
++
++/*
++ * Finally, the init/exit functions.
++ */
++static void __exit maclist_exit(void)
++{
++	maclist_entry_t *list;
++
++	remove_proc_entry(MACLIST_NAME, proc_net);
++
++	list = maclist_list;
++	maclist_list = 0;
++
++	while (list != 0) {
++		maclist_entry_t *head = list;
++		list = head->next;
++		kfree(head);
++	}
++}
++
++#ifdef MODULE
++static char ids[256];
++module_param_string(ids, ids, sizeof ids, 0);
++MODULE_PARM_DESC(ids, "comma separated list of MAC ids\n");
++#else
++__setup("maclist_ids=", maclist_setup);
++#endif
++
++static int __init maclist_init(void)
++{
++#	ifdef MODULE
++		if (ids[0])
++			maclist_setup(ids);
++#	endif
++
++	/* Ignore failure, the module will still work. */
++	(void)create_proc_read_entry(MACLIST_NAME, S_IRUGO, proc_net, maclist_proc_read, NULL);
++
++	return 0;
++}
++
++module_init(maclist_init);
++module_exit(maclist_exit);
+--- linux-2.6.15/drivers/net/Makefile	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/net/Makefile	1970-01-01 00:00:00.000000000 +0000
+@@ -70,6 +70,7 @@ obj-$(CONFIG_RIONET) += rionet.o
+ # end link order section
+ #
+ 
++obj-$(CONFIG_MACLIST) += maclist.o
+ obj-$(CONFIG_MII) += mii.o
+ obj-$(CONFIG_PHYLIB) += phy/
+ 
+--- linux-2.6.15/drivers/net/Kconfig	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/drivers/net/Kconfig	1970-01-01 00:00:00.000000000 +0000
+@@ -166,6 +166,21 @@ config NET_ETHERNET
+ 	  kernel: saying N will just cause the configurator to skip all
+ 	  the questions about Ethernet network cards. If unsure, say N.
+ 
++config MACLIST
++	tristate "Ethernet MAC repository"
++	depends on NET_ETHERNET
++	help
++	  Some ethernet controllers have no built-in way of obtaining an
++	  appropriate Ethernet MAC address.  Such controllers have to be
++	  initialised in a board-specific way, depending on how the allocated
++	  MAC is stored.  The MAC repository provides a set of APIs and a
++	  proc entry (/proc/net/maclist) to store MAC values from the board
++	  so that such drivers can obtain a MAC address without board-specific
++	  code.  You do not need to enable this device - it will be selected
++	  automatically by any device which requires it.  It is only useful
++	  to enable it manually when building a device driver independently
++	  of the kernel build.
++
+ config MII
+ 	tristate "Generic Media Independent Interface device support"
+ 	depends on NET_ETHERNET
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/92-nas100d-maclist.patch b/packages/linux/ixp4xx-kernel/2.6.15/92-nas100d-maclist.patch
new file mode 100644
index 0000000000..3143850b22
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/92-nas100d-maclist.patch
@@ -0,0 +1,72 @@
+--- linux-2.6.15/arch/arm/mach-ixp4xx/Kconfig	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/Kconfig	1970-01-01 00:00:00.000000000 +0000
+@@ -74,6 +74,7 @@ comment "IXP4xx Platforms"
+ config MACH_NAS100D
+ 	bool
+ 	prompt "NAS100D"
++	select MACLIST
+ 	help
+ 	  Say 'Y' here if you want your kernel to support Iomega's
+ 	  NAS 100d device. For more information on this platform,
+--- linux-2.6.15/arch/arm/mach-ixp4xx/nas100d-setup.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/nas100d-setup.c	1970-01-01 00:00:00.000000000 +0000
+@@ -14,11 +14,14 @@
+ #include <linux/kernel.h>
+ #include <linux/serial.h>
+ #include <linux/serial_8250.h>
++#include <linux/mtd/mtd.h>
+ 
+ #include <asm/mach-types.h>
+ #include <asm/mach/arch.h>
+ #include <asm/mach/flash.h>
+ 
++#include <net/maclist.h>
++
+ static struct flash_platform_data nas100d_flash_data = {
+ 	.map_name		= "cfi_probe",
+ 	.width			= 2,
+@@ -110,8 +113,44 @@
+ 	gpio_line_set(NAS100D_PO_GPIO, IXP4XX_GPIO_HIGH);
+ }
+ 
++/*
++ * When the RedBoot config partition is added the MAC address is read from
++ * it.
++ */
++void flash_add(struct mtd_info *mtd) {
++	if (strcmp(mtd->name, "RedBoot config") == 0) {
++		size_t retlen;
++		u_char mac[6];
++
++		/* The MAC is at a known offset... */
++		if (mtd->read(mtd, 0x0FD8, 6, &retlen, mac) == 0 && retlen == 6) {
++			printk(KERN_INFO "NAS100D MAC: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
++				mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
++			maclist_add(mac);
++		} else {
++			printk(KERN_ERR "NAS100D MAC: read failed\n");
++		}
++	}
++}
++
++/*
++ * Nothing to do on remove at present.
++ */
++void flash_remove(struct mtd_info *mtd) {
++}
++
++struct mtd_notifier flash_notifier = {
++	.add = flash_add,
++	.remove = flash_remove,
++};
++
+ static void __init nas100d_init(void)
+ {
++	/* The flash has an ethernet MAC embedded in it which we need,
++	 * that is all this notifier does.
++	 */
++	register_mtd_user(&flash_notifier);
++
+ 	ixp4xx_sys_init();
+ 
+ 	pm_power_off = nas100d_power_off;
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/92-nslu2-maclist.patch b/packages/linux/ixp4xx-kernel/2.6.15/92-nslu2-maclist.patch
new file mode 100644
index 0000000000..c8b8a9bede
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/92-nslu2-maclist.patch
@@ -0,0 +1,80 @@
+--- linux-2.6.15/arch/arm/mach-ixp4xx/Kconfig	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/Kconfig	1970-01-01 00:00:00.000000000 +0000
+@@ -11,8 +11,8 @@ comment "IXP4xx Platforms"
+ # This entry is placed on top because otherwise it would have
+ # been shown as a submenu.
+ config MACH_NSLU2
+-	bool
+-	prompt "NSLU2" if !(MACH_IXDP465 || MACH_IXDPG425 || ARCH_IXDP425 || ARCH_ADI_COYOTE || ARCH_AVILA || ARCH_IXCDP1100 || ARCH_PRPMC1100 || MACH_GTWX5715)
++	bool "NSLU2"
++	select MACLIST
+ 	help
+ 	  Say 'Y' here if you want your kernel to support Linksys's
+ 	  NSLU2 NAS device. For more information on this platform,
+--- linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-setup.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.15/arch/arm/mach-ixp4xx/nslu2-setup.c	1970-01-01 00:00:00.000000000 +0000
+@@ -16,11 +16,14 @@
+ #include <linux/kernel.h>
+ #include <linux/serial.h>
+ #include <linux/serial_8250.h>
++#include <linux/mtd/mtd.h>
+ 
+ #include <asm/mach-types.h>
+ #include <asm/mach/arch.h>
+ #include <asm/mach/flash.h>
+ 
++#include <net/maclist.h>
++
+ static struct flash_platform_data nslu2_flash_data = {
+ 	.map_name		= "cfi_probe",
+ 	.width			= 2,
+@@ -112,6 +115,37 @@ static void nslu2_power_off(void)
+ 	gpio_line_set(NSLU2_PO_GPIO, IXP4XX_GPIO_HIGH);
+ }
+ 
++/*
++ * When the RedBoot partition is added the MAC address is read from
++ * it.
++ */
++void flash_add(struct mtd_info *mtd) {
++	if (strcmp(mtd->name, "RedBoot") == 0) {
++		size_t retlen;
++		u_char mac[6];
++
++		/* The MAC is at a known offset... */
++		if (mtd->read(mtd, 0x3FFB0, 6, &retlen, mac) == 0 && retlen == 6) {
++			printk(KERN_INFO "NSLU2 MAC: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
++				mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
++			maclist_add(mac);
++		} else {
++			printk(KERN_ERR "NSLU2 MAC: read failed\n");
++		}
++	}
++}
++
++/*
++ * Nothing to do on remove at present.
++ */
++void flash_remove(struct mtd_info *mtd) {
++}
++
++struct mtd_notifier flash_notifier = {
++	.add = flash_add,
++	.remove = flash_remove,
++};
++
+ static void __init nslu2_init(void)
+ {
+ 	/* The NSLU2 has a 33MHz crystal on board - 1.01% different
+@@ -119,6 +153,11 @@ static void __init nslu2_init(void)
+ 	 */
+ 	ixp4xx_set_board_tick_rate(66000000);
+ 
++	/* The flash has an ethernet MAC embedded in it which we need,
++	 * that is all this notifier does.
++	 */
++	register_mtd_user(&flash_notifier);
++
+ 	ixp4xx_sys_init();
+ 
+ 	pm_power_off = nslu2_power_off;
diff --git a/packages/linux/ixp4xx-kernel/2.6.15/defconfig b/packages/linux/ixp4xx-kernel/2.6.15/defconfig
new file mode 100644
index 0000000000..558a2a104a
--- /dev/null
+++ b/packages/linux/ixp4xx-kernel/2.6.15/defconfig
@@ -0,0 +1,1603 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.15
+# Mon Nov 14 10:44:43 2005
+#
+CONFIG_ARM=y
+CONFIG_MMU=y
+CONFIG_UID16=y
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_CLEAN_COMPILE=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+# CONFIG_POSIX_MQUEUE is not set
+# CONFIG_BSD_PROCESS_ACCT is not set
+CONFIG_SYSCTL=y
+# CONFIG_AUDIT is not set
+CONFIG_HOTPLUG=y
+CONFIG_KOBJECT_UEVENT=y
+# CONFIG_IKCONFIG is not set
+CONFIG_INITRAMFS_SOURCE=""
+CONFIG_EMBEDDED=y
+# CONFIG_KALLSYMS is not set
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+# CONFIG_BASE_FULL is not set
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_SHMEM=y
+CONFIG_CC_ALIGN_FUNCTIONS=0
+CONFIG_CC_ALIGN_LABELS=0
+CONFIG_CC_ALIGN_LOOPS=0
+CONFIG_CC_ALIGN_JUMPS=0
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=1
+
+#
+# Loadable module support
+#
+CONFIG_MODULES=y
+CONFIG_MODULE_UNLOAD=y
+# CONFIG_MODULE_FORCE_UNLOAD is not set
+CONFIG_OBSOLETE_MODPARM=y
+# CONFIG_MODVERSIONS is not set
+# CONFIG_MODULE_SRCVERSION_ALL is not set
+CONFIG_KMOD=y
+
+#
+# Block layer
+#
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+# CONFIG_IOSCHED_AS is not set
+CONFIG_IOSCHED_DEADLINE=y
+# CONFIG_IOSCHED_CFQ is not set
+# CONFIG_DEFAULT_AS is not set
+CONFIG_DEFAULT_DEADLINE=y
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="deadline"
+
+#
+# System Type
+#
+# CONFIG_ARCH_CLPS7500 is not set
+# CONFIG_ARCH_CLPS711X is not set
+# CONFIG_ARCH_CO285 is not set
+# CONFIG_ARCH_EBSA110 is not set
+# CONFIG_ARCH_CAMELOT is not set
+# CONFIG_ARCH_FOOTBRIDGE is not set
+# CONFIG_ARCH_INTEGRATOR is not set
+# CONFIG_ARCH_IOP3XX is not set
+CONFIG_ARCH_IXP4XX=y
+# CONFIG_ARCH_IXP2000 is not set
+# CONFIG_ARCH_L7200 is not set
+# CONFIG_ARCH_PXA is not set
+# CONFIG_ARCH_RPC is not set
+# CONFIG_ARCH_SA1100 is not set
+# CONFIG_ARCH_S3C2410 is not set
+# CONFIG_ARCH_SHARK is not set
+# CONFIG_ARCH_LH7A40X is not set
+# CONFIG_ARCH_OMAP is not set
+# CONFIG_ARCH_VERSATILE is not set
+# CONFIG_ARCH_REALVIEW is not set
+# CONFIG_ARCH_IMX is not set
+# CONFIG_ARCH_H720X is not set
+# CONFIG_ARCH_AAEC2000 is not set
+CONFIG_ARCH_SUPPORTS_BIG_ENDIAN=y
+
+#
+# Intel IXP4xx Implementation Options
+#
+
+#
+# IXP4xx Platforms
+#
+# CONFIG_ARCH_AVILA is not set
+CONFIG_ARCH_ADI_COYOTE=y
+CONFIG_MACH_NSLU2=y
+CONFIG_MACH_NAS100D=y
+CONFIG_ARCH_IXDP425=y
+# CONFIG_MACH_IXDPG425 is not set
+# CONFIG_MACH_IXDP465 is not set
+CONFIG_ARCH_IXCDP1100=y
+CONFIG_ARCH_PRPMC1100=y
+CONFIG_ARCH_IXDP4XX=y
+# CONFIG_MACH_GTWX5715 is not set
+
+#
+# IXP4xx Options
+#
+# CONFIG_IXP4XX_INDIRECT_PCI is not set
+
+#
+# Processor Type
+#
+CONFIG_CPU_32=y
+CONFIG_CPU_XSCALE=y
+CONFIG_CPU_32v5=y
+CONFIG_CPU_ABRT_EV5T=y
+CONFIG_CPU_CACHE_VIVT=y
+CONFIG_CPU_TLB_V4WBI=y
+
+#
+# Processor Features
+#
+CONFIG_ARM_THUMB=y
+CONFIG_CPU_BIG_ENDIAN=y
+CONFIG_XSCALE_PMU=y
+CONFIG_DMABOUNCE=y
+
+#
+# Bus support
+#
+CONFIG_ISA_DMA_API=y
+CONFIG_PCI=y
+# CONFIG_PCI_LEGACY_PROC is not set
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+# CONFIG_PCCARD is not set
+
+#
+# Kernel Features
+#
+# CONFIG_PREEMPT is not set
+# CONFIG_NO_IDLE_HZ is not set
+# CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPLIT_PTLOCK_CPUS=4096
+# CONFIG_LEDS is not set
+CONFIG_ALIGNMENT_TRAP=y
+
+#
+# Boot options
+#
+CONFIG_ZBOOT_ROM_TEXT=0x0
+CONFIG_ZBOOT_ROM_BSS=0x0
+CONFIG_CMDLINE="root=/dev/mtdblock4 rw rootfstype=jffs2 mem=32M@0x00000000 init=/linuxrc x1205.hctosys=1 x1205.probe=0,0x6f noirqdebug console=ttyS0,115200n8"
+# CONFIG_XIP_KERNEL is not set
+
+#
+# Floating point emulation
+#
+
+#
+# At least one emulation must be selected
+#
+CONFIG_FPE_NWFPE=y
+# CONFIG_FPE_NWFPE_XP is not set
+# CONFIG_FPE_FASTFPE is not set
+
+#
+# Userspace binary formats
+#
+CONFIG_BINFMT_ELF=y
+# CONFIG_BINFMT_AOUT is not set
+# CONFIG_BINFMT_MISC is not set
+# CONFIG_ARTHUR is not set
+
+#
+# Power management options
+#
+# CONFIG_PM is not set
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=m
+CONFIG_PACKET_MMAP=y
+CONFIG_UNIX=y
+CONFIG_XFRM=y
+# CONFIG_XFRM_USER is not set
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+# CONFIG_IP_PNP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+CONFIG_INET_AH=m
+CONFIG_INET_ESP=m
+CONFIG_INET_IPCOMP=m
+CONFIG_INET_TUNNEL=m
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+
+#
+# IP: Virtual Server Configuration
+#
+# CONFIG_IP_VS is not set
+CONFIG_IPV6=m
+# CONFIG_IPV6_PRIVACY is not set
+CONFIG_INET6_AH=m
+CONFIG_INET6_ESP=m
+CONFIG_INET6_IPCOMP=m
+CONFIG_INET6_TUNNEL=m
+CONFIG_IPV6_TUNNEL=m
+CONFIG_NETFILTER=y
+# CONFIG_NETFILTER_DEBUG is not set
+CONFIG_BRIDGE_NETFILTER=y
+
+#
+# Core Netfilter Configuration
+#
+# CONFIG_NETFILTER_NETLINK is not set
+
+#
+# IP: Netfilter Configuration
+#
+CONFIG_IP_NF_CONNTRACK=m
+# CONFIG_IP_NF_CT_ACCT is not set
+# CONFIG_IP_NF_CONNTRACK_MARK is not set
+# CONFIG_IP_NF_CONNTRACK_EVENTS is not set
+CONFIG_IP_NF_CT_PROTO_SCTP=m
+CONFIG_IP_NF_FTP=m
+CONFIG_IP_NF_IRC=m
+# CONFIG_IP_NF_NETBIOS_NS is not set
+CONFIG_IP_NF_TFTP=m
+CONFIG_IP_NF_AMANDA=m
+# CONFIG_IP_NF_PPTP is not set
+CONFIG_IP_NF_QUEUE=m
+CONFIG_IP_NF_IPTABLES=m
+CONFIG_IP_NF_MATCH_LIMIT=m
+CONFIG_IP_NF_MATCH_IPRANGE=m
+CONFIG_IP_NF_MATCH_MAC=m
+CONFIG_IP_NF_MATCH_PKTTYPE=m
+CONFIG_IP_NF_MATCH_MARK=m
+CONFIG_IP_NF_MATCH_MULTIPORT=m
+CONFIG_IP_NF_MATCH_TOS=m
+CONFIG_IP_NF_MATCH_RECENT=m
+CONFIG_IP_NF_MATCH_ECN=m
+CONFIG_IP_NF_MATCH_DSCP=m
+CONFIG_IP_NF_MATCH_AH_ESP=m
+CONFIG_IP_NF_MATCH_LENGTH=m
+CONFIG_IP_NF_MATCH_TTL=m
+CONFIG_IP_NF_MATCH_TCPMSS=m
+CONFIG_IP_NF_MATCH_HELPER=m
+CONFIG_IP_NF_MATCH_STATE=m
+CONFIG_IP_NF_MATCH_CONNTRACK=m
+CONFIG_IP_NF_MATCH_OWNER=m
+CONFIG_IP_NF_MATCH_PHYSDEV=m
+CONFIG_IP_NF_MATCH_ADDRTYPE=m
+CONFIG_IP_NF_MATCH_REALM=m
+# CONFIG_IP_NF_MATCH_SCTP is not set
+# CONFIG_IP_NF_MATCH_DCCP is not set
+CONFIG_IP_NF_MATCH_COMMENT=m
+CONFIG_IP_NF_MATCH_HASHLIMIT=m
+# CONFIG_IP_NF_MATCH_STRING is not set
+CONFIG_IP_NF_FILTER=m
+# CONFIG_IP_NF_TARGET_REJECT is not set
+CONFIG_IP_NF_TARGET_LOG=m
+CONFIG_IP_NF_TARGET_ULOG=m
+CONFIG_IP_NF_TARGET_TCPMSS=m
+# CONFIG_IP_NF_TARGET_NFQUEUE is not set
+CONFIG_IP_NF_NAT=m
+CONFIG_IP_NF_NAT_NEEDED=y
+CONFIG_IP_NF_TARGET_MASQUERADE=m
+CONFIG_IP_NF_TARGET_REDIRECT=m
+CONFIG_IP_NF_TARGET_NETMAP=m
+CONFIG_IP_NF_TARGET_SAME=m
+CONFIG_IP_NF_NAT_SNMP_BASIC=m
+CONFIG_IP_NF_NAT_IRC=m
+CONFIG_IP_NF_NAT_FTP=m
+CONFIG_IP_NF_NAT_TFTP=m
+CONFIG_IP_NF_NAT_AMANDA=m
+CONFIG_IP_NF_MANGLE=m
+CONFIG_IP_NF_TARGET_TOS=m
+CONFIG_IP_NF_TARGET_ECN=m
+CONFIG_IP_NF_TARGET_DSCP=m
+CONFIG_IP_NF_TARGET_MARK=m
+CONFIG_IP_NF_TARGET_CLASSIFY=m
+# CONFIG_IP_NF_TARGET_TTL is not set
+# CONFIG_IP_NF_RAW is not set
+# CONFIG_IP_NF_ARPTABLES is not set
+
+#
+# IPv6: Netfilter Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP6_NF_QUEUE is not set
+# CONFIG_IP6_NF_IPTABLES is not set
+# CONFIG_IP6_NF_TARGET_NFQUEUE is not set
+
+#
+# Bridge: Netfilter Configuration
+#
+# CONFIG_BRIDGE_NF_EBTABLES is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+CONFIG_BRIDGE=m
+CONFIG_VLAN_8021Q=m
+# CONFIG_DECNET is not set
+CONFIG_LLC=m
+# CONFIG_LLC2 is not set
+CONFIG_IPX=m
+# CONFIG_IPX_INTERN is not set
+CONFIG_ATALK=m
+CONFIG_DEV_APPLETALK=y
+CONFIG_IPDDP=m
+CONFIG_IPDDP_ENCAP=y
+CONFIG_IPDDP_DECAP=y
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+
+#
+# QoS and/or fair queueing
+#
+# CONFIG_NET_SCHED is not set
+CONFIG_NET_CLS_ROUTE=y
+
+#
+# Network testing
+#
+CONFIG_NET_PKTGEN=m
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+CONFIG_BT=m
+CONFIG_BT_L2CAP=m
+CONFIG_BT_SCO=m
+CONFIG_BT_RFCOMM=m
+CONFIG_BT_RFCOMM_TTY=y
+CONFIG_BT_BNEP=m
+CONFIG_BT_BNEP_MC_FILTER=y
+CONFIG_BT_BNEP_PROTO_FILTER=y
+# CONFIG_BT_HIDP is not set
+
+#
+# Bluetooth device drivers
+#
+CONFIG_BT_HCIUSB=m
+CONFIG_BT_HCIUSB_SCO=y
+# CONFIG_BT_HCIUART is not set
+CONFIG_BT_HCIBCM203X=m
+# CONFIG_BT_HCIBPA10X is not set
+# CONFIG_BT_HCIBFUSB is not set
+# CONFIG_BT_HCIVHCI is not set
+# CONFIG_IEEE80211 is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+CONFIG_FW_LOADER=m
+
+#
+# Memory Technology Devices (MTD)
+#
+CONFIG_MTD=y
+# CONFIG_MTD_DEBUG is not set
+CONFIG_MTD_CONCAT=y
+CONFIG_MTD_PARTITIONS=y
+CONFIG_MTD_REDBOOT_PARTS=y
+CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1
+# CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED is not set
+# CONFIG_MTD_REDBOOT_PARTS_READONLY is not set
+# CONFIG_MTD_CMDLINE_PARTS is not set
+# CONFIG_MTD_AFS_PARTS is not set
+
+#
+# User Modules And Translation Layers
+#
+CONFIG_MTD_CHAR=y
+CONFIG_MTD_BLOCK=y
+# CONFIG_FTL is not set
+# CONFIG_NFTL is not set
+# CONFIG_INFTL is not set
+# CONFIG_RFD_FTL is not set
+
+#
+# RAM/ROM/Flash chip drivers
+#
+CONFIG_MTD_CFI=y
+# CONFIG_MTD_JEDECPROBE is not set
+CONFIG_MTD_GEN_PROBE=y
+CONFIG_MTD_CFI_ADV_OPTIONS=y
+# CONFIG_MTD_CFI_NOSWAP is not set
+CONFIG_MTD_CFI_BE_BYTE_SWAP=y
+# CONFIG_MTD_CFI_LE_BYTE_SWAP is not set
+CONFIG_MTD_CFI_GEOMETRY=y
+# CONFIG_MTD_MAP_BANK_WIDTH_1 is not set
+CONFIG_MTD_MAP_BANK_WIDTH_2=y
+# CONFIG_MTD_MAP_BANK_WIDTH_4 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
+CONFIG_MTD_CFI_I1=y
+CONFIG_MTD_CFI_I2=y
+# CONFIG_MTD_CFI_I4 is not set
+# CONFIG_MTD_CFI_I8 is not set
+# CONFIG_MTD_OTP is not set
+CONFIG_MTD_CFI_INTELEXT=y
+# CONFIG_MTD_CFI_AMDSTD is not set
+# CONFIG_MTD_CFI_STAA is not set
+CONFIG_MTD_CFI_UTIL=y
+# CONFIG_MTD_RAM is not set
+# CONFIG_MTD_ROM is not set
+# CONFIG_MTD_ABSENT is not set
+# CONFIG_MTD_XIP is not set
+
+#
+# Mapping drivers for chip access
+#
+CONFIG_MTD_COMPLEX_MAPPINGS=y
+# CONFIG_MTD_PHYSMAP is not set
+# CONFIG_MTD_ARM_INTEGRATOR is not set
+CONFIG_MTD_IXP4XX=y
+# CONFIG_MTD_PCI is not set
+# CONFIG_MTD_PLATRAM is not set
+
+#
+# Self-contained MTD device drivers
+#
+# CONFIG_MTD_PMC551 is not set
+# CONFIG_MTD_SLRAM is not set
+# CONFIG_MTD_PHRAM is not set
+# CONFIG_MTD_MTDRAM is not set
+# CONFIG_MTD_BLKMTD is not set
+# CONFIG_MTD_BLOCK2MTD is not set
+
+#
+# Disk-On-Chip Device Drivers
+#
+# CONFIG_MTD_DOC2000 is not set
+# CONFIG_MTD_DOC2001 is not set
+# CONFIG_MTD_DOC2001PLUS is not set
+
+#
+# NAND Flash Device Drivers
+#
+# CONFIG_MTD_NAND is not set
+
+#
+# OneNAND Flash Device Drivers
+#
+# CONFIG_MTD_ONENAND is not set
+
+#
+# Parallel port support
+#
+# CONFIG_PARPORT is not set
+
+#
+# Plug and Play support
+#
+
+#
+# Block devices
+#
+# CONFIG_BLK_CPQ_DA is not set
+# CONFIG_BLK_CPQ_CISS_DA is not set
+# CONFIG_BLK_DEV_DAC960 is not set
+# CONFIG_BLK_DEV_UMEM is not set
+# CONFIG_BLK_DEV_COW_COMMON is not set
+CONFIG_BLK_DEV_LOOP=m
+# CONFIG_BLK_DEV_CRYPTOLOOP is not set
+# CONFIG_BLK_DEV_NBD is not set
+# CONFIG_BLK_DEV_SX8 is not set
+# CONFIG_BLK_DEV_UB is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=4
+CONFIG_BLK_DEV_RAM_SIZE=10240
+CONFIG_BLK_DEV_INITRD=y
+CONFIG_CDROM_PKTCDVD=m
+CONFIG_CDROM_PKTCDVD_BUFFERS=8
+# CONFIG_CDROM_PKTCDVD_WCACHE is not set
+# CONFIG_ATA_OVER_ETH is not set
+
+#
+# ATA/ATAPI/MFM/RLL support
+#
+# CONFIG_IDE is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+CONFIG_SCSI=y
+CONFIG_SCSI_PROC_FS=y
+
+#
+# SCSI support type (disk, tape, CD-ROM)
+#
+CONFIG_BLK_DEV_SD=y
+# CONFIG_CHR_DEV_ST is not set
+# CONFIG_CHR_DEV_OSST is not set
+CONFIG_BLK_DEV_SR=m
+# CONFIG_BLK_DEV_SR_VENDOR is not set
+CONFIG_CHR_DEV_SG=m
+# CONFIG_CHR_DEV_SCH is not set
+
+#
+# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+#
+CONFIG_SCSI_MULTI_LUN=y
+# CONFIG_SCSI_CONSTANTS is not set
+# CONFIG_SCSI_LOGGING is not set
+
+#
+# SCSI Transport Attributes
+#
+# CONFIG_SCSI_SPI_ATTRS is not set
+# CONFIG_SCSI_FC_ATTRS is not set
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
+
+#
+# SCSI low-level drivers
+#
+# CONFIG_ISCSI_TCP is not set
+# CONFIG_BLK_DEV_3W_XXXX_RAID is not set
+# CONFIG_SCSI_3W_9XXX is not set
+# CONFIG_SCSI_ACARD is not set
+# CONFIG_SCSI_AACRAID is not set
+# CONFIG_SCSI_AIC7XXX is not set
+# CONFIG_SCSI_AIC7XXX_OLD is not set
+# CONFIG_SCSI_AIC79XX is not set
+# CONFIG_SCSI_DPT_I2O is not set
+# CONFIG_MEGARAID_NEWGEN is not set
+# CONFIG_MEGARAID_LEGACY is not set
+# CONFIG_MEGARAID_SAS is not set
+# CONFIG_SCSI_SATA is not set
+# CONFIG_SCSI_BUSLOGIC is not set
+# CONFIG_SCSI_DMX3191D is not set
+# CONFIG_SCSI_EATA is not set
+# CONFIG_SCSI_FUTURE_DOMAIN is not set
+# CONFIG_SCSI_GDTH is not set
+# CONFIG_SCSI_IPS is not set
+# CONFIG_SCSI_INITIO is not set
+# CONFIG_SCSI_INIA100 is not set
+# CONFIG_SCSI_SYM53C8XX_2 is not set
+# CONFIG_SCSI_IPR is not set
+# CONFIG_SCSI_QLOGIC_FC is not set
+# CONFIG_SCSI_QLOGIC_1280 is not set
+CONFIG_SCSI_QLA2XXX=y
+# CONFIG_SCSI_QLA21XX is not set
+# CONFIG_SCSI_QLA22XX is not set
+# CONFIG_SCSI_QLA2300 is not set
+# CONFIG_SCSI_QLA2322 is not set
+# CONFIG_SCSI_QLA6312 is not set
+# CONFIG_SCSI_QLA24XX is not set
+# CONFIG_SCSI_LPFC is not set
+# CONFIG_SCSI_DC395x is not set
+# CONFIG_SCSI_DC390T is not set
+# CONFIG_SCSI_NSP32 is not set
+# CONFIG_SCSI_DEBUG is not set
+
+#
+# Multi-device support (RAID and LVM)
+#
+CONFIG_MD=y
+CONFIG_BLK_DEV_MD=m
+CONFIG_MD_LINEAR=m
+CONFIG_MD_RAID0=m
+CONFIG_MD_RAID1=m
+CONFIG_MD_RAID10=m
+CONFIG_MD_RAID5=m
+CONFIG_MD_RAID6=m
+CONFIG_MD_MULTIPATH=m
+CONFIG_MD_FAULTY=m
+CONFIG_BLK_DEV_DM=m
+# CONFIG_DM_CRYPT is not set
+# CONFIG_DM_SNAPSHOT is not set
+# CONFIG_DM_MIRROR is not set
+# CONFIG_DM_ZERO is not set
+# CONFIG_DM_MULTIPATH is not set
+
+#
+# Fusion MPT device support
+#
+# CONFIG_FUSION is not set
+# CONFIG_FUSION_SPI is not set
+# CONFIG_FUSION_FC is not set
+# CONFIG_FUSION_SAS is not set
+
+#
+# IEEE 1394 (FireWire) support
+#
+# CONFIG_IEEE1394 is not set
+
+#
+# I2O device support
+#
+# CONFIG_I2O is not set
+
+#
+# Network device support
+#
+CONFIG_NETDEVICES=y
+# CONFIG_DUMMY is not set
+# CONFIG_BONDING is not set
+# CONFIG_EQUALIZER is not set
+CONFIG_TUN=m
+
+#
+# ARCnet devices
+#
+# CONFIG_ARCNET is not set
+
+#
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+CONFIG_NET_ETHERNET=y
+CONFIG_MACLIST=y
+CONFIG_MII=y
+# CONFIG_HAPPYMEAL is not set
+# CONFIG_SUNGEM is not set
+# CONFIG_CASSINI is not set
+# CONFIG_NET_VENDOR_3COM is not set
+# CONFIG_SMC91X is not set
+# CONFIG_DM9000 is not set
+
+#
+# Tulip family network device support
+#
+# CONFIG_NET_TULIP is not set
+# CONFIG_HP100 is not set
+CONFIG_NET_PCI=y
+# CONFIG_PCNET32 is not set
+# CONFIG_AMD8111_ETH is not set
+# CONFIG_ADAPTEC_STARFIRE is not set
+# CONFIG_B44 is not set
+# CONFIG_FORCEDETH is not set
+# CONFIG_DGRS is not set
+# CONFIG_EEPRO100 is not set
+# CONFIG_E100 is not set
+# CONFIG_FEALNX is not set
+# CONFIG_NATSEMI is not set
+# CONFIG_NE2K_PCI is not set
+# CONFIG_8139CP is not set
+# CONFIG_8139TOO is not set
+# CONFIG_SIS900 is not set
+# CONFIG_EPIC100 is not set
+# CONFIG_SUNDANCE is not set
+# CONFIG_TLAN is not set
+# CONFIG_VIA_RHINE is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+# CONFIG_ACENIC is not set
+# CONFIG_DL2K is not set
+# CONFIG_E1000 is not set
+# CONFIG_NS83820 is not set
+# CONFIG_HAMACHI is not set
+# CONFIG_YELLOWFIN is not set
+# CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
+# CONFIG_SKGE is not set
+# CONFIG_SK98LIN is not set
+# CONFIG_VIA_VELOCITY is not set
+# CONFIG_TIGON3 is not set
+# CONFIG_BNX2 is not set
+
+#
+# Ethernet (10000 Mbit)
+#
+# CONFIG_CHELSIO_T1 is not set
+# CONFIG_IXGB is not set
+# CONFIG_S2IO is not set
+
+#
+# Token Ring devices
+#
+# CONFIG_TR is not set
+
+#
+# Wireless LAN (non-hamradio)
+#
+CONFIG_NET_RADIO=y
+
+#
+# Obsolete Wireless cards support (pre-802.11)
+#
+# CONFIG_STRIP is not set
+
+#
+# Wireless 802.11b ISA/PCI cards support
+#
+# CONFIG_AIRO is not set
+# CONFIG_HERMES is not set
+# CONFIG_ATMEL is not set
+
+#
+# Prism GT/Duette 802.11(a/b/g) PCI/Cardbus support
+#
+# CONFIG_PRISM54 is not set
+# CONFIG_HOSTAP is not set
+CONFIG_NET_WIRELESS=y
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN is not set
+# CONFIG_FDDI is not set
+# CONFIG_HIPPI is not set
+CONFIG_PPP=m
+# CONFIG_PPP_MULTILINK is not set
+CONFIG_PPP_FILTER=y
+CONFIG_PPP_ASYNC=m
+# CONFIG_PPP_SYNC_TTY is not set
+CONFIG_PPP_DEFLATE=m
+CONFIG_PPP_BSDCOMP=m
+# CONFIG_PPP_MPPE is not set
+# CONFIG_PPPOE is not set
+# CONFIG_SLIP is not set
+# CONFIG_NET_FC is not set
+# CONFIG_SHAPER is not set
+CONFIG_NETCONSOLE=m
+CONFIG_NETPOLL=y
+# CONFIG_NETPOLL_RX is not set
+# CONFIG_NETPOLL_TRAP is not set
+CONFIG_NET_POLL_CONTROLLER=y
+
+#
+# ISDN subsystem
+#
+# CONFIG_ISDN is not set
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+
+#
+# Userland interfaces
+#
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_JOYDEV is not set
+# CONFIG_INPUT_TSDEV is not set
+CONFIG_INPUT_EVDEV=m
+# CONFIG_INPUT_EVBUG is not set
+
+#
+# Input Device Drivers
+#
+# CONFIG_INPUT_KEYBOARD is not set
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TOUCHSCREEN is not set
+CONFIG_INPUT_MISC=y
+CONFIG_INPUT_NSLU2_BEEPER=m
+# CONFIG_INPUT_UINPUT is not set
+
+#
+# Hardware I/O ports
+#
+# CONFIG_SERIO is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+# CONFIG_VT is not set
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_NR_UARTS=2
+# CONFIG_SERIAL_8250_EXTENDED is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_SERIAL_JSM is not set
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=16
+
+#
+# IPMI
+#
+# CONFIG_IPMI_HANDLER is not set
+
+#
+# Watchdog Cards
+#
+CONFIG_WATCHDOG=y
+# CONFIG_WATCHDOG_NOWAYOUT is not set
+
+#
+# Watchdog Device Drivers
+#
+# CONFIG_SOFT_WATCHDOG is not set
+CONFIG_IXP4XX_WATCHDOG=y
+
+#
+# PCI-based Watchdog Cards
+#
+# CONFIG_PCIPCWATCHDOG is not set
+# CONFIG_WDTPCI is not set
+
+#
+# USB-based Watchdog Cards
+#
+# CONFIG_USBPCWATCHDOG is not set
+# CONFIG_NVRAM is not set
+# CONFIG_RTC is not set
+CONFIG_RTC_X1205=n
+# CONFIG_DTLK is not set
+# CONFIG_R3964 is not set
+# CONFIG_APPLICOM is not set
+
+#
+# Ftape, the floppy tape device driver
+#
+# CONFIG_DRM is not set
+# CONFIG_RAW_DRIVER is not set
+
+#
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
+# CONFIG_TELCLOCK is not set
+
+#
+# I2C support
+#
+CONFIG_I2C=y
+CONFIG_I2C_CHARDEV=y
+
+#
+# I2C Algorithms
+#
+CONFIG_I2C_ALGOBIT=y
+# CONFIG_I2C_ALGOPCF is not set
+# CONFIG_I2C_ALGOPCA is not set
+
+#
+# I2C Hardware Bus support
+#
+# CONFIG_I2C_ALI1535 is not set
+# CONFIG_I2C_ALI1563 is not set
+# CONFIG_I2C_ALI15X3 is not set
+# CONFIG_I2C_AMD756 is not set
+# CONFIG_I2C_AMD8111 is not set
+# CONFIG_I2C_I801 is not set
+# CONFIG_I2C_I810 is not set
+# CONFIG_I2C_PIIX4 is not set
+# CONFIG_I2C_IOP3XX is not set
+CONFIG_I2C_IXP4XX=y
+# CONFIG_I2C_NFORCE2 is not set
+# CONFIG_I2C_PARPORT_LIGHT is not set
+# CONFIG_I2C_PROSAVAGE is not set
+# CONFIG_I2C_SAVAGE4 is not set
+# CONFIG_SCx200_ACB is not set
+# CONFIG_I2C_SIS5595 is not set
+# CONFIG_I2C_SIS630 is not set
+# CONFIG_I2C_SIS96X is not set
+# CONFIG_I2C_STUB is not set
+# CONFIG_I2C_VIA is not set
+# CONFIG_I2C_VIAPRO is not set
+# CONFIG_I2C_VOODOO3 is not set
+# CONFIG_I2C_PCA_ISA is not set
+
+#
+# Miscellaneous I2C Chip support
+#
+# CONFIG_SENSORS_DS1337 is not set
+# CONFIG_SENSORS_DS1374 is not set
+CONFIG_SENSORS_EEPROM=y
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_RTC8564 is not set
+# CONFIG_SENSORS_MAX6875 is not set
+CONFIG_RTC_X1205_I2C=y
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+CONFIG_RTC_PCF8563_I2C=y
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_SENSORS_ADM1021 is not set
+# CONFIG_SENSORS_ADM1025 is not set
+# CONFIG_SENSORS_ADM1026 is not set
+# CONFIG_SENSORS_ADM1031 is not set
+# CONFIG_SENSORS_ADM9240 is not set
+# CONFIG_SENSORS_ASB100 is not set
+# CONFIG_SENSORS_ATXP1 is not set
+# CONFIG_SENSORS_DS1621 is not set
+# CONFIG_SENSORS_FSCHER is not set
+# CONFIG_SENSORS_FSCPOS is not set
+# CONFIG_SENSORS_GL518SM is not set
+# CONFIG_SENSORS_GL520SM is not set
+# CONFIG_SENSORS_IT87 is not set
+# CONFIG_SENSORS_LM63 is not set
+# CONFIG_SENSORS_LM75 is not set
+# CONFIG_SENSORS_LM77 is not set
+# CONFIG_SENSORS_LM78 is not set
+# CONFIG_SENSORS_LM80 is not set
+# CONFIG_SENSORS_LM83 is not set
+# CONFIG_SENSORS_LM85 is not set
+# CONFIG_SENSORS_LM87 is not set
+# CONFIG_SENSORS_LM90 is not set
+# CONFIG_SENSORS_LM92 is not set
+# CONFIG_SENSORS_MAX1619 is not set
+# CONFIG_SENSORS_PC87360 is not set
+# CONFIG_SENSORS_SIS5595 is not set
+# CONFIG_SENSORS_SMSC47M1 is not set
+# CONFIG_SENSORS_SMSC47B397 is not set
+# CONFIG_SENSORS_VIA686A is not set
+# CONFIG_SENSORS_W83781D is not set
+# CONFIG_SENSORS_W83792D is not set
+# CONFIG_SENSORS_W83L785TS is not set
+# CONFIG_SENSORS_W83627HF is not set
+# CONFIG_SENSORS_W83627EHF is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# Multimedia Capabilities Port drivers
+#
+
+#
+# Multimedia devices
+#
+CONFIG_VIDEO_DEV=m
+
+#
+# Video For Linux
+#
+
+#
+# Video Adapters
+#
+CONFIG_VIDEO_BT848=m
+# CONFIG_VIDEO_SAA6588 is not set
+CONFIG_VIDEO_CPIA=m
+CONFIG_VIDEO_CPIA_USB=m
+CONFIG_VIDEO_SAA5246A=m
+CONFIG_VIDEO_SAA5249=m
+CONFIG_TUNER_3036=m
+CONFIG_VIDEO_STRADIS=m
+CONFIG_VIDEO_ZORAN=m
+CONFIG_VIDEO_ZORAN_BUZ=m
+CONFIG_VIDEO_ZORAN_DC10=m
+CONFIG_VIDEO_ZORAN_DC30=m
+CONFIG_VIDEO_ZORAN_LML33=m
+CONFIG_VIDEO_ZORAN_LML33R10=m
+CONFIG_VIDEO_SAA7134=m
+CONFIG_VIDEO_MXB=m
+CONFIG_VIDEO_DPC=m
+CONFIG_VIDEO_HEXIUM_ORION=m
+CONFIG_VIDEO_HEXIUM_GEMINI=m
+CONFIG_VIDEO_CX88=m
+# CONFIG_VIDEO_EM28XX is not set
+CONFIG_VIDEO_OVCAMCHIP=m
+
+#
+# Radio Adapters
+#
+# CONFIG_RADIO_GEMTEK_PCI is not set
+# CONFIG_RADIO_MAXIRADIO is not set
+# CONFIG_RADIO_MAESTRO is not set
+
+#
+# Digital Video Broadcasting Devices
+#
+# CONFIG_DVB is not set
+CONFIG_VIDEO_SAA7146=m
+CONFIG_VIDEO_SAA7146_VV=m
+CONFIG_VIDEO_VIDEOBUF=m
+CONFIG_VIDEO_TUNER=m
+CONFIG_VIDEO_BUF=m
+CONFIG_VIDEO_BTCX=m
+CONFIG_VIDEO_IR=m
+CONFIG_VIDEO_TVEEPROM=m
+
+#
+# Graphics support
+#
+# CONFIG_FB is not set
+
+#
+# Sound
+#
+CONFIG_SOUND=m
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=m
+CONFIG_SND_TIMER=m
+CONFIG_SND_PCM=m
+CONFIG_SND_HWDEP=m
+CONFIG_SND_RAWMIDI=m
+# CONFIG_SND_SEQUENCER is not set
+CONFIG_SND_OSSEMUL=y
+CONFIG_SND_MIXER_OSS=m
+CONFIG_SND_PCM_OSS=m
+# CONFIG_SND_VERBOSE_PRINTK is not set
+# CONFIG_SND_DEBUG is not set
+
+#
+# Generic devices
+#
+# CONFIG_SND_DUMMY is not set
+# CONFIG_SND_MTPAV is not set
+# CONFIG_SND_SERIAL_U16550 is not set
+# CONFIG_SND_MPU401 is not set
+
+#
+# PCI devices
+#
+# CONFIG_SND_ALI5451 is not set
+# CONFIG_SND_ATIIXP is not set
+# CONFIG_SND_ATIIXP_MODEM is not set
+# CONFIG_SND_AU8810 is not set
+# CONFIG_SND_AU8820 is not set
+# CONFIG_SND_AU8830 is not set
+# CONFIG_SND_AZT3328 is not set
+# CONFIG_SND_BT87X is not set
+# CONFIG_SND_CS46XX is not set
+# CONFIG_SND_CS4281 is not set
+# CONFIG_SND_EMU10K1 is not set
+# CONFIG_SND_EMU10K1X is not set
+# CONFIG_SND_CA0106 is not set
+# CONFIG_SND_KORG1212 is not set
+# CONFIG_SND_MIXART is not set
+# CONFIG_SND_NM256 is not set
+# CONFIG_SND_RME32 is not set
+# CONFIG_SND_RME96 is not set
+# CONFIG_SND_RME9652 is not set
+# CONFIG_SND_HDSP is not set
+# CONFIG_SND_HDSPM is not set
+# CONFIG_SND_TRIDENT is not set
+# CONFIG_SND_YMFPCI is not set
+# CONFIG_SND_AD1889 is not set
+# CONFIG_SND_ALS4000 is not set
+# CONFIG_SND_CMIPCI is not set
+# CONFIG_SND_ENS1370 is not set
+# CONFIG_SND_ENS1371 is not set
+# CONFIG_SND_ES1938 is not set
+# CONFIG_SND_ES1968 is not set
+# CONFIG_SND_MAESTRO3 is not set
+# CONFIG_SND_FM801 is not set
+# CONFIG_SND_ICE1712 is not set
+# CONFIG_SND_ICE1724 is not set
+# CONFIG_SND_INTEL8X0 is not set
+# CONFIG_SND_INTEL8X0M is not set
+# CONFIG_SND_SONICVIBES is not set
+# CONFIG_SND_VIA82XX is not set
+# CONFIG_SND_VIA82XX_MODEM is not set
+# CONFIG_SND_VX222 is not set
+# CONFIG_SND_HDA_INTEL is not set
+
+#
+# ALSA ARM devices
+#
+
+#
+# USB devices
+#
+CONFIG_SND_USB_AUDIO=m
+
+#
+# Open Sound System
+#
+# CONFIG_SOUND_PRIME is not set
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB=y
+# CONFIG_USB_DEBUG is not set
+
+#
+# Miscellaneous USB options
+#
+CONFIG_USB_DEVICEFS=y
+# CONFIG_USB_BANDWIDTH is not set
+# CONFIG_USB_DYNAMIC_MINORS is not set
+# CONFIG_USB_OTG is not set
+
+#
+# USB Host Controller Drivers
+#
+CONFIG_USB_EHCI_HCD=y
+CONFIG_USB_EHCI_SPLIT_ISO=y
+# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
+# CONFIG_USB_ISP116X_HCD is not set
+CONFIG_USB_OHCI_HCD=y
+# CONFIG_USB_OHCI_BIG_ENDIAN is not set
+CONFIG_USB_OHCI_LITTLE_ENDIAN=y
+# CONFIG_USB_UHCI_HCD is not set
+# CONFIG_USB_SL811_HCD is not set
+
+#
+# USB Device Class drivers
+#
+# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
+CONFIG_USB_ACM=m
+CONFIG_USB_PRINTER=m
+
+#
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+#
+
+#
+# may also be needed; see USB_STORAGE Help for more information
+#
+CONFIG_USB_STORAGE=y
+# CONFIG_USB_STORAGE_DEBUG is not set
+# CONFIG_USB_STORAGE_DATAFAB is not set
+# CONFIG_USB_STORAGE_FREECOM is not set
+# CONFIG_USB_STORAGE_DPCM is not set
+# CONFIG_USB_STORAGE_USBAT is not set
+# CONFIG_USB_STORAGE_SDDR09 is not set
+# CONFIG_USB_STORAGE_SDDR55 is not set
+# CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ONETOUCH is not set
+
+#
+# USB Input Devices
+#
+CONFIG_USB_HID=m
+CONFIG_USB_HIDINPUT=y
+# CONFIG_HID_FF is not set
+CONFIG_USB_HIDDEV=y
+
+#
+# USB HID Boot Protocol drivers
+#
+CONFIG_USB_KBD=m
+# CONFIG_USB_MOUSE is not set
+# CONFIG_USB_AIPTEK is not set
+# CONFIG_USB_WACOM is not set
+# CONFIG_USB_ACECAD is not set
+# CONFIG_USB_KBTAB is not set
+# CONFIG_USB_POWERMATE is not set
+# CONFIG_USB_MTOUCH is not set
+# CONFIG_USB_ITMTOUCH is not set
+# CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
+# CONFIG_USB_XPAD is not set
+# CONFIG_USB_ATI_REMOTE is not set
+# CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
+
+#
+# USB Imaging devices
+#
+# CONFIG_USB_MDC800 is not set
+# CONFIG_USB_MICROTEK is not set
+
+#
+# USB Multimedia devices
+#
+# CONFIG_USB_DABUSB is not set
+# CONFIG_USB_VICAM is not set
+# CONFIG_USB_DSBR is not set
+# CONFIG_USB_IBMCAM is not set
+# CONFIG_USB_KONICAWC is not set
+# CONFIG_USB_OV511 is not set
+# CONFIG_USB_SE401 is not set
+# CONFIG_USB_SN9C102 is not set
+# CONFIG_USB_STV680 is not set
+# CONFIG_USB_W9968CF is not set
+CONFIG_USB_PWC=m
+
+#
+# USB Network Adapters
+#
+CONFIG_USB_CATC=m
+CONFIG_USB_KAWETH=m
+CONFIG_USB_PEGASUS=m
+CONFIG_USB_RTL8150=m
+CONFIG_USB_USBNET=m
+CONFIG_USB_NET_AX8817X=m
+CONFIG_USB_NET_CDCETHER=m
+# CONFIG_USB_NET_GL620A is not set
+CONFIG_USB_NET_NET1080=m
+# CONFIG_USB_NET_PLUSB is not set
+# CONFIG_USB_NET_RNDIS_HOST is not set
+# CONFIG_USB_NET_CDC_SUBSET is not set
+CONFIG_USB_NET_ZAURUS=m
+# CONFIG_USB_ZD1201 is not set
+# CONFIG_USB_MON is not set
+
+#
+# USB port drivers
+#
+
+#
+# USB Serial Converter support
+#
+CONFIG_USB_SERIAL=m
+CONFIG_USB_SERIAL_GENERIC=y
+# CONFIG_USB_SERIAL_AIRPRIME is not set
+CONFIG_USB_SERIAL_BELKIN=m
+CONFIG_USB_SERIAL_WHITEHEAT=m
+CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m
+# CONFIG_USB_SERIAL_CP2101 is not set
+CONFIG_USB_SERIAL_CYPRESS_M8=m
+CONFIG_USB_SERIAL_EMPEG=m
+CONFIG_USB_SERIAL_FTDI_SIO=m
+CONFIG_USB_SERIAL_VISOR=m
+CONFIG_USB_SERIAL_IPAQ=m
+CONFIG_USB_SERIAL_IR=m
+CONFIG_USB_SERIAL_EDGEPORT=m
+CONFIG_USB_SERIAL_EDGEPORT_TI=m
+CONFIG_USB_SERIAL_GARMIN=m
+CONFIG_USB_SERIAL_IPW=m
+CONFIG_USB_SERIAL_KEYSPAN_PDA=m
+# CONFIG_USB_SERIAL_KEYSPAN is not set
+CONFIG_USB_SERIAL_KLSI=m
+CONFIG_USB_SERIAL_KOBIL_SCT=m
+CONFIG_USB_SERIAL_MCT_U232=m
+# CONFIG_USB_SERIAL_NOKIA_DKU2 is not set
+CONFIG_USB_SERIAL_PL2303=m
+# CONFIG_USB_SERIAL_HP4X is not set
+CONFIG_USB_SERIAL_SAFE=m
+# CONFIG_USB_SERIAL_SAFE_PADDED is not set
+CONFIG_USB_SERIAL_TI=m
+CONFIG_USB_SERIAL_CYBERJACK=m
+CONFIG_USB_SERIAL_XIRCOM=m
+CONFIG_USB_SERIAL_OMNINET=m
+CONFIG_USB_EZUSB=y
+
+#
+# USB Miscellaneous drivers
+#
+# CONFIG_USB_EMI62 is not set
+# CONFIG_USB_EMI26 is not set
+# CONFIG_USB_AUERSWALD is not set
+# CONFIG_USB_RIO500 is not set
+# CONFIG_USB_LEGOTOWER is not set
+# CONFIG_USB_LCD is not set
+# CONFIG_USB_LED is not set
+# CONFIG_USB_CYTHERM is not set
+# CONFIG_USB_PHIDGETKIT is not set
+# CONFIG_USB_PHIDGETSERVO is not set
+# CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_SISUSBVGA is not set
+# CONFIG_USB_LD is not set
+# CONFIG_USB_TEST is not set
+
+#
+# USB DSL modem support
+#
+
+#
+# USB Gadget Support
+#
+# CONFIG_USB_GADGET is not set
+
+#
+# MMC/SD Card support
+#
+# CONFIG_MMC is not set
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=m
+CONFIG_EXT2_FS_XATTR=y
+CONFIG_EXT2_FS_POSIX_ACL=y
+CONFIG_EXT2_FS_SECURITY=y
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=m
+CONFIG_EXT3_FS_XATTR=y
+CONFIG_EXT3_FS_POSIX_ACL=y
+CONFIG_EXT3_FS_SECURITY=y
+CONFIG_JBD=m
+# CONFIG_JBD_DEBUG is not set
+CONFIG_FS_MBCACHE=m
+CONFIG_REISERFS_FS=m
+# CONFIG_REISERFS_CHECK is not set
+# CONFIG_REISERFS_PROC_INFO is not set
+CONFIG_REISERFS_FS_XATTR=y
+CONFIG_REISERFS_FS_POSIX_ACL=y
+CONFIG_REISERFS_FS_SECURITY=y
+# CONFIG_JFS_FS is not set
+CONFIG_FS_POSIX_ACL=y
+# CONFIG_XFS_FS is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
+# CONFIG_QUOTA is not set
+CONFIG_DNOTIFY=y
+# CONFIG_AUTOFS_FS is not set
+CONFIG_AUTOFS4_FS=m
+# CONFIG_FUSE_FS is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+CONFIG_ISO9660_FS=m
+CONFIG_JOLIET=y
+CONFIG_ZISOFS=y
+CONFIG_ZISOFS_FS=m
+CONFIG_UDF_FS=m
+CONFIG_UDF_NLS=y
+
+#
+# DOS/FAT/NT Filesystems
+#
+CONFIG_FAT_FS=m
+CONFIG_MSDOS_FS=m
+CONFIG_VFAT_FS=m
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+CONFIG_FAT_DEFAULT_IOCHARSET="utf8"
+CONFIG_NTFS_FS=m
+# CONFIG_NTFS_DEBUG is not set
+CONFIG_NTFS_RW=y
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+# CONFIG_HUGETLB_PAGE is not set
+CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
+
+#
+# Miscellaneous filesystems
+#
+# CONFIG_ADFS_FS is not set
+# CONFIG_AFFS_FS is not set
+# CONFIG_HFS_FS is not set
+# CONFIG_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_JFFS_FS is not set
+CONFIG_JFFS2_FS=y
+CONFIG_JFFS2_FS_DEBUG=0
+CONFIG_JFFS2_FS_WRITEBUFFER=y
+# CONFIG_JFFS2_SUMMARY is not set
+# CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
+CONFIG_JFFS2_ZLIB=y
+CONFIG_JFFS2_RTIME=y
+# CONFIG_JFFS2_RUBIN is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+
+#
+# Network File Systems
+#
+CONFIG_NFS_FS=m
+CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
+CONFIG_NFS_V4=y
+CONFIG_NFS_DIRECTIO=y
+CONFIG_NFSD=m
+CONFIG_NFSD_V3=y
+# CONFIG_NFSD_V3_ACL is not set
+CONFIG_NFSD_V4=y
+CONFIG_NFSD_TCP=y
+CONFIG_LOCKD=m
+CONFIG_LOCKD_V4=y
+CONFIG_EXPORTFS=m
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=m
+CONFIG_SUNRPC_GSS=m
+CONFIG_RPCSEC_GSS_KRB5=m
+# CONFIG_RPCSEC_GSS_SPKM3 is not set
+CONFIG_SMB_FS=m
+# CONFIG_SMB_NLS_DEFAULT is not set
+CONFIG_CIFS=m
+# CONFIG_CIFS_STATS is not set
+CONFIG_CIFS_XATTR=y
+CONFIG_CIFS_POSIX=y
+# CONFIG_CIFS_EXPERIMENTAL is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_CODA_FS is not set
+# CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
+
+#
+# Partition Types
+#
+CONFIG_PARTITION_ADVANCED=y
+# CONFIG_ACORN_PARTITION is not set
+# CONFIG_OSF_PARTITION is not set
+# CONFIG_AMIGA_PARTITION is not set
+# CONFIG_ATARI_PARTITION is not set
+# CONFIG_MAC_PARTITION is not set
+CONFIG_MSDOS_PARTITION=y
+# CONFIG_BSD_DISKLABEL is not set
+# CONFIG_MINIX_SUBPARTITION is not set
+# CONFIG_SOLARIS_X86_PARTITION is not set
+# CONFIG_UNIXWARE_DISKLABEL is not set
+# CONFIG_LDM_PARTITION is not set
+# CONFIG_SGI_PARTITION is not set
+# CONFIG_ULTRIX_PARTITION is not set
+# CONFIG_SUN_PARTITION is not set
+# CONFIG_EFI_PARTITION is not set
+
+#
+# Native Language Support
+#
+CONFIG_NLS=m
+CONFIG_NLS_DEFAULT="utf8"
+CONFIG_NLS_CODEPAGE_437=m
+CONFIG_NLS_CODEPAGE_737=m
+CONFIG_NLS_CODEPAGE_775=m
+CONFIG_NLS_CODEPAGE_850=m
+CONFIG_NLS_CODEPAGE_852=m
+CONFIG_NLS_CODEPAGE_855=m
+CONFIG_NLS_CODEPAGE_857=m
+CONFIG_NLS_CODEPAGE_860=m
+CONFIG_NLS_CODEPAGE_861=m
+CONFIG_NLS_CODEPAGE_862=m
+CONFIG_NLS_CODEPAGE_863=m
+CONFIG_NLS_CODEPAGE_864=m
+CONFIG_NLS_CODEPAGE_865=m
+CONFIG_NLS_CODEPAGE_866=m
+CONFIG_NLS_CODEPAGE_869=m
+CONFIG_NLS_CODEPAGE_936=m
+CONFIG_NLS_CODEPAGE_950=m
+CONFIG_NLS_CODEPAGE_932=m
+CONFIG_NLS_CODEPAGE_949=m
+CONFIG_NLS_CODEPAGE_874=m
+CONFIG_NLS_ISO8859_8=m
+CONFIG_NLS_CODEPAGE_1250=m
+CONFIG_NLS_CODEPAGE_1251=m
+CONFIG_NLS_ASCII=m
+CONFIG_NLS_ISO8859_1=m
+CONFIG_NLS_ISO8859_2=m
+CONFIG_NLS_ISO8859_3=m
+CONFIG_NLS_ISO8859_4=m
+CONFIG_NLS_ISO8859_5=m
+CONFIG_NLS_ISO8859_6=m
+CONFIG_NLS_ISO8859_7=m
+CONFIG_NLS_ISO8859_9=m
+CONFIG_NLS_ISO8859_13=m
+CONFIG_NLS_ISO8859_14=m
+CONFIG_NLS_ISO8859_15=m
+CONFIG_NLS_KOI8_R=m
+CONFIG_NLS_KOI8_U=m
+CONFIG_NLS_UTF8=m
+
+#
+# Profiling support
+#
+# CONFIG_PROFILING is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_DEBUG_KERNEL is not set
+CONFIG_LOG_BUF_SHIFT=14
+# CONFIG_DEBUG_BUGVERBOSE is not set
+CONFIG_FRAME_POINTER=y
+# CONFIG_DEBUG_USER is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+
+#
+# Cryptographic options
+#
+CONFIG_CRYPTO=y
+CONFIG_CRYPTO_HMAC=y
+# CONFIG_CRYPTO_NULL is not set
+CONFIG_CRYPTO_MD4=m
+CONFIG_CRYPTO_MD5=y
+CONFIG_CRYPTO_SHA1=m
+CONFIG_CRYPTO_SHA256=m
+CONFIG_CRYPTO_SHA512=m
+CONFIG_CRYPTO_WP512=m
+CONFIG_CRYPTO_TGR192=m
+CONFIG_CRYPTO_DES=m
+CONFIG_CRYPTO_BLOWFISH=m
+CONFIG_CRYPTO_TWOFISH=m
+CONFIG_CRYPTO_SERPENT=m
+CONFIG_CRYPTO_AES=m
+CONFIG_CRYPTO_CAST5=m
+CONFIG_CRYPTO_CAST6=m
+CONFIG_CRYPTO_TEA=m
+CONFIG_CRYPTO_ARC4=m
+CONFIG_CRYPTO_KHAZAD=m
+CONFIG_CRYPTO_ANUBIS=m
+CONFIG_CRYPTO_DEFLATE=m
+CONFIG_CRYPTO_MICHAEL_MIC=m
+CONFIG_CRYPTO_CRC32C=m
+CONFIG_CRYPTO_TEST=m
+
+#
+# Hardware crypto devices
+#
+
+#
+# Library routines
+#
+CONFIG_CRC_CCITT=m
+# CONFIG_CRC16 is not set
+CONFIG_CRC32=y
+CONFIG_LIBCRC32C=m
+CONFIG_ZLIB_INFLATE=y
+CONFIG_ZLIB_DEFLATE=y
+
+CONFIG_RTC_CLASS=y
+# RTC interfaces
+CONFIG_RTC_INTF_SYSFS=y
+CONFIG_RTC_INTF_PROC=y
+CONFIG_RTC_INTF_DEV=y
+# RTC drivers
+CONFIG_RTC_DRV_X1205=y
+CONFIG_RTC_DRV_DS1672=n
+CONFIG_RTC_DRV_TEST=n