nslu2-kernel: Added the scsi-idle patch, Enabled CONFIG_INPUT=y, cause Debian tools (especially yaird) assume that /proc/bus/input exists, Updated patchsets to match 2.6.15, removed some patches, and combined some others, Updated to class-based RTC driver from azummo, changed defconfig to remove the pwc module, memory-h-page-shift page revised due to feedback from RMK, Removed old kernel versions, Updated to 2.6.15 final.

11 files changed, 3341 insertions, 271 deletions

diff --git a/packages/linux/nslu2-kernel/2.6.15/00-memory-h-page-shift.patch b/packages/linux/nslu2-kernel/2.6.15/00-memory-h-page-shift.patch
index 29b048e27a..4ec8f0475f 100644
--- a/packages/linux/nslu2-kernel/2.6.15/00-memory-h-page-shift.patch
+++ b/packages/linux/nslu2-kernel/2.6.15/00-memory-h-page-shift.patch
@@ -1,10 +1,68 @@
---- linux-2.6.15/include/asm-arm/arch-ixp4xx/memory.h	1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/include/asm-arm/arch-ixp4xx/memory.h	1970-01-01 00:00:00.000000000 +0000
-@@ -8,6 +8,7 @@
- #define __ASM_ARCH_MEMORY_H
+--- 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 @@
  
- #include <asm/sizes.h>
-+#include <asm/page.h>
+ #ifndef __ASSEMBLY__
  
- /*
-  * Physical DRAM offset.
+-/*
+- * 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/nslu2-kernel/2.6.15/01-i2c-ixp4xx.patch b/packages/linux/nslu2-kernel/2.6.15/01-i2c-ixp4xx.patch
deleted file mode 100644
index 16426bdee6..0000000000
--- a/packages/linux/nslu2-kernel/2.6.15/01-i2c-ixp4xx.patch
+++ /dev/null
@@ -1,29 +0,0 @@
---- linux-2.6.15/drivers/i2c/busses/i2c-ixp4xx.c	1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/i2c/busses/i2c-ixp4xx.c	1970-01-01 00:00:00.000000000 +0000
-@@ -35,7 +35,7 @@
- 
- #include <asm/hardware.h>	/* Pick up IXP4xx-specific bits */
- 
--static struct device_driver ixp4xx_i2c_driver;
-+static struct platform_driver ixp4xx_i2c_driver;
- 
- static inline int ixp4xx_scl_pin(void *data)
- {
-@@ -128,7 +128,7 @@ static int ixp4xx_i2c_probe(struct platf
- 	drv_data->algo_data.timeout = 100;
- 
- 	drv_data->adapter.id = I2C_HW_B_IXP4XX;
--	strlcpy(drv_data->adapter.name, ixp4xx_i2c_driver.name,
-+	strlcpy(drv_data->adapter.name, ixp4xx_i2c_driver.driver.name,
- 		I2C_NAME_SIZE);
- 	drv_data->adapter.algo_data = &drv_data->algo_data;
- 
-@@ -140,7 +140,7 @@ static int ixp4xx_i2c_probe(struct platf
- 	gpio_line_set(gpio->sda_pin, 0);
- 
- 	if ((err = i2c_bit_add_bus(&drv_data->adapter) != 0)) {
--		printk(KERN_ERR "ERROR: Could not install %s\n", dev->bus_id);
-+		printk(KERN_ERR "ERROR: Could not install %s\n", ixp4xx_i2c_driver.driver.name);
- 
- 		kfree(drv_data);
- 		return err;
diff --git a/packages/linux/nslu2-kernel/2.6.15/35-x1205-fix-osc.patch b/packages/linux/nslu2-kernel/2.6.15/35-x1205-fix-osc.patch
new file mode 100644
index 0000000000..44f2636c5c
--- /dev/null
+++ b/packages/linux/nslu2-kernel/2.6.15/35-x1205-fix-osc.patch
@@ -0,0 +1,204 @@
+ drivers/i2c/chips/x1205.c |  116 ++++++++++++++++++++++++++++++----------------
+ 1 file changed, 76 insertions(+), 40 deletions(-)
+
+--- linux-nslu2.orig/drivers/i2c/chips/x1205.c	2005-12-12 18:59:07.000000000 +0100
++++ linux-nslu2/drivers/i2c/chips/x1205.c	2005-12-13 21:31:32.000000000 +0100
+@@ -22,9 +22,9 @@
+ #include <linux/string.h>
+ #include <linux/bcd.h>
+ #include <linux/rtc.h>
++#include <linux/delay.h>
+ 
+-
+-#define DRV_VERSION "1.0.0"
++#define DRV_VERSION "1.0.1"
+ 
+ /* Addresses to scan: none. This chip is located at
+  * 0x6f and uses a two bytes register addressing.
+@@ -141,35 +141,19 @@ static int x1205_validate_tm(struct rtc_
+  * Epoch is initialized as 2000. Time is set to UTC.
+  */
+ static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
+-				u8 reg_base)
++				unsigned char reg_base)
+ {
+ 	unsigned char dt_addr[2] = { 0, reg_base };
+-	static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
+ 
+-	unsigned char buf[8], sr;
++	unsigned char buf[8];
+ 
+ 	struct i2c_msg msgs[] = {
+-		{ client->addr, 0, 2, sr_addr },	/* setup read ptr */
+-		{ client->addr, I2C_M_RD, 1, &sr }, 	/* read status */
+ 		{ client->addr, 0, 2, dt_addr },	/* setup read ptr */
+ 		{ client->addr, I2C_M_RD, 8, buf },	/* read date */
+ 	};
+ 
+-	/* read status register */
+-	if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+-		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+-		return -EIO;
+-	}
+-
+-	/* check for battery failure */
+-	if (sr & X1205_SR_RTCF) {
+-		dev_warn(&client->dev,
+-			"Clock had a power failure, you must set the date.\n");
+-		return -EINVAL;
+-	}
+-
+ 	/* read date registers */
+-	if ((i2c_transfer(client->adapter, &msgs[2], 2)) != 2) {
++	if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
+ 		dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
+ 		return -EIO;
+ 	}
+@@ -199,11 +183,28 @@ static int x1205_get_datetime(struct i2c
+ 	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, err, xfer;
+-
++	int i, xfer;
+ 	unsigned char buf[8];
+ 
+ 	static const unsigned char wel[3] = { 0, X1205_REG_SR,
+@@ -214,15 +215,10 @@ static int x1205_set_datetime(struct i2c
+ 
+ 	static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
+ 
+-	/* check if all values in the tm struct are correct */
+-	if ((err = x1205_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",
++	dev_dbg(&client->dev,
++		"%s: secs=%d, mins=%d, hours=%d\n",
+ 		__FUNCTION__,
+-		tm->tm_sec, tm->tm_min, tm->tm_hour,
+-		tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
++		tm->tm_sec, tm->tm_min, tm->tm_hour);
+ 
+ 	buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
+ 	buf[CCR_MIN] = BIN2BCD(tm->tm_min);
+@@ -232,6 +228,11 @@ static int x1205_set_datetime(struct i2c
+ 
+ 	/* 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, 0 - 11 */
+@@ -280,6 +281,22 @@ static int x1205_set_datetime(struct i2c
+ 	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;
+@@ -352,14 +369,17 @@ static int x1205_hctosys(struct i2c_clie
+ 
+ 	struct rtc_time tm;
+ 	struct timespec tv;
++	unsigned char sr;
+ 
++	if ((err = x1205_get_status(client, &sr)) < 0)
++		return err;
+ 
+-	err = x1205_get_datetime(client, &tm, X1205_CCR_BASE);
+-	if (err) {
+-		dev_err(&client->dev,
+-			"Unable to set the system clock\n");
++	/* 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
+@@ -506,9 +526,9 @@ static int x1205_attach(struct i2c_adapt
+ 
+ static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
+ {
+-	struct i2c_client *client;
+-
+ 	int err = 0;
++	unsigned char sr;
++	struct i2c_client *client;
+ 
+ 	dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
+ 
+@@ -543,9 +563,25 @@ static int x1205_probe(struct i2c_adapte
+ 
+ 	dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
+ 
++	/* 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)
+-		x1205_hctosys(client);
++	if (hctosys) {
++		if ((err = x1205_hctosys(client)) < 0)
++			dev_err(&client->dev,
++				"unable to set the system clock\n");
++	}
+ 
+ 	return 0;
+ 
diff --git a/packages/linux/nslu2-kernel/2.6.15/40-rtc-class.patch b/packages/linux/nslu2-kernel/2.6.15/40-rtc-class.patch
new file mode 100644
index 0000000000..feea3f2f8b
--- /dev/null
+++ b/packages/linux/nslu2-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/nslu2-kernel/2.6.15/55-rtc-x1205.patch b/packages/linux/nslu2-kernel/2.6.15/55-rtc-x1205.patch
deleted file mode 100644
index 70befe5fe4..0000000000
--- a/packages/linux/nslu2-kernel/2.6.15/55-rtc-x1205.patch
+++ /dev/null
@@ -1,193 +0,0 @@
- drivers/char/Kconfig     |    4 +
- drivers/char/Makefile    |    1 
- drivers/char/x1205-rtc.c |  162 +++++++++++++++++++++++++++++++++++++++++++++++
- 3 files changed, 167 insertions(+)
-
---- linux-2.6.15/drivers/char/Kconfig	1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/char/Kconfig	1970-01-01 00:00:00.000000000 +0000
-@@ -783,6 +783,10 @@ config RTC_VR41XX
- 	tristate "NEC VR4100 series Real Time Clock Support"
- 	depends on CPU_VR41XX
- 
-+config RTC_X1205
-+        tristate "X1205 I2C RTC Support"
-+        depends on I2C && RTC_X1205_I2C
-+
- config COBALT_LCD
- 	bool "Support for Cobalt LCD"
- 	depends on MIPS_COBALT
---- linux-2.6.15/drivers/char/Makefile	1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/char/Makefile	1970-01-01 00:00:00.000000000 +0000
-@@ -65,6 +65,7 @@ obj-$(CONFIG_SGI_IP27_RTC) += ip27-rtc.o
- obj-$(CONFIG_DS1302) += ds1302.o
- obj-$(CONFIG_S3C2410_RTC) += s3c2410-rtc.o
- obj-$(CONFIG_RTC_VR41XX) += vr41xx_rtc.o
-+obj-$(CONFIG_RTC_X1205) += x1205-rtc.o
- ifeq ($(CONFIG_GENERIC_NVRAM),y)
-   obj-$(CONFIG_NVRAM) += generic_nvram.o
- else
---- linux-2.6.15/drivers/char/x1205-rtc.c	1970-01-01 00:00:00.000000000 +0000
-+++ linux-2.6.15/drivers/char/x1205-rtc.c	1970-01-01 00:00:00.000000000 +0000
-@@ -0,0 +1,162 @@
-+/*
-+ * drivers/char/x1205-rtc.c
-+ *
-+ * NSLU2 RTC driver
-+ *
-+ * Copyright (C) 2005 Tower Technologies
-+ *
-+ * based on the original X1205 NSLU2 driver
-+ *  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/device.h>
-+#include <linux/time.h>
-+#include <linux/rtc.h>
-+#include <linux/init.h>
-+#include <linux/platform_device.h>
-+
-+#include <linux/i2c.h>
-+#include <linux/x1205.h>
-+
-+#include <asm/rtc.h>
-+
-+#define DRV_VERSION "0.9"
-+
-+extern int (*set_rtc)(void);
-+
-+static int x1205_set_rtc(void)
-+{
-+	int err;
-+
-+	struct rtc_time new_tm, old_tm;
-+	unsigned long cur_secs = xtime.tv_sec;
-+
-+	if ((err = x1205_do_command(X1205_CMD_GETDATETIME, &old_tm) == 0))
-+		return err;
-+
-+	/* FIXME      xtime.tv_nsec = old_tm.tm_sec * 10000000; */
-+	new_tm.tm_sec  = cur_secs % 60;
-+	cur_secs /= 60;
-+	new_tm.tm_min  = cur_secs % 60;
-+	cur_secs /= 60;
-+	new_tm.tm_hour = cur_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_do_command(X1205_CMD_SETTIME, &new_tm);
-+}
-+
-+static int x1205_rtc_read_alarm(struct rtc_wkalrm *alrm)
-+{
-+	return x1205_do_command(X1205_CMD_GETALARM, &alrm->time);
-+}
-+
-+static int x1205_rtc_set_alarm(struct rtc_wkalrm *alrm)
-+{
-+	return x1205_do_command(X1205_CMD_SETALARM, &alrm->time);
-+}
-+
-+static int x1205_rtc_read_time(struct rtc_time *tm)
-+{
-+	return x1205_do_command(X1205_CMD_GETDATETIME, tm);
-+}
-+
-+static int x1205_rtc_set_time(struct rtc_time *tm)
-+{
-+	return x1205_do_command(X1205_CMD_SETDATETIME, tm);
-+}
-+
-+static int x1205_rtc_proc(char *buf)
-+{
-+	int err, dtrim, atrim;
-+	char *p = buf;
-+
-+	p += sprintf(p, "24hr\t\t: yes\n");
-+
-+	err = x1205_do_command(X1205_CMD_GETDTRIM, &dtrim);
-+	if (err == 0)
-+		p += sprintf(p, "digital_trim\t: %d ppm\n", dtrim);
-+
-+	err = x1205_do_command(X1205_CMD_GETATRIM, &atrim);
-+	if (err == 0)
-+		p += sprintf(p, "analog_trim\t: %d.%02d pF\n",
-+			atrim / 1000, atrim % 1000);
-+
-+	return p - buf;
-+}
-+
-+static struct rtc_ops x1205_rtc_ops = {
-+	.owner		= THIS_MODULE,
-+	.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,
-+};
-+
-+static int x1205_rtc_probe(struct device *dev)
-+{
-+	int ret;
-+
-+	if ((ret = register_rtc(&x1205_rtc_ops)) != 0)
-+		return ret;
-+
-+	set_rtc = x1205_set_rtc;
-+
-+	printk(KERN_INFO "x1205-rtc: real time clock\n");
-+
-+	return 0;
-+}
-+
-+static int x1205_rtc_remove(struct device *dev)
-+{
-+	set_rtc = NULL;
-+
-+	unregister_rtc(&x1205_rtc_ops);
-+
-+	return 0;
-+}
-+
-+static struct device_driver x1205_rtc_driver = {
-+	.name		= "x1205-rtc",
-+        .bus            = &platform_bus_type,
-+	.probe		= x1205_rtc_probe,
-+	.remove		= x1205_rtc_remove,
-+};
-+
-+static int __init x1205_rtc_init(void)
-+{
-+        return driver_register(&x1205_rtc_driver);
-+}
-+
-+static void __exit x1205_rtc_exit(void)
-+{
-+        driver_unregister(&x1205_rtc_driver);
-+}
-+
-+module_init(x1205_rtc_init);
-+module_exit(x1205_rtc_exit);
-+
-+MODULE_AUTHOR(
-+        "Karen Spearel <kas11@tampabay.rr.com>, "
-+        "Alessandro Zummo <a.zummo@towertech.it>");
-+MODULE_DESCRIPTION("Xicor X1205 RTC platform driver");
-+MODULE_LICENSE("GPL");
-+MODULE_VERSION(DRV_VERSION);
diff --git a/packages/linux/nslu2-kernel/2.6.15/80-nslu2-io.patch b/packages/linux/nslu2-kernel/2.6.15/80-nslu2-io.patch
index 0b90c486e3..26031f6f00 100644
--- a/packages/linux/nslu2-kernel/2.6.15/80-nslu2-io.patch
+++ b/packages/linux/nslu2-kernel/2.6.15/80-nslu2-io.patch
@@ -516,7 +516,7 @@
 +		return -EBUSY;
 +	}
 +	else {
-+		class_device_create(n2lm_class, MKDEV(NSLU2LM_MAJOR, 0), NULL, "leds");
++		class_device_create(n2lm_class, NULL, MKDEV(NSLU2LM_MAJOR, 0), NULL, "leds");
 +	}
 +#endif
 +
@@ -525,7 +525,7 @@
 +		return -EBUSY;
 +	}
 +	else {
-+		class_device_create(n2lm_class, MKDEV(NSLU2BZ_MAJOR, 0), NULL, "buzzer");
++		class_device_create(n2lm_class, NULL, MKDEV(NSLU2BZ_MAJOR, 0), NULL, "buzzer");
 +	}
 +
 +	return 0;
diff --git a/packages/linux/nslu2-kernel/2.6.15/81-nslu2-class-device-create.patch b/packages/linux/nslu2-kernel/2.6.15/81-nslu2-class-device-create.patch
deleted file mode 100644
index cc33222d91..0000000000
--- a/packages/linux/nslu2-kernel/2.6.15/81-nslu2-class-device-create.patch
+++ /dev/null
@@ -1,20 +0,0 @@
---- 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
-@@ -504,7 +504,7 @@ static int __init n2iom_init(void)
- 		return -EBUSY;
- 	}
- 	else {
--		class_device_create(n2lm_class, MKDEV(NSLU2LM_MAJOR, 0), NULL, "leds");
-+		class_device_create(n2lm_class, NULL, MKDEV(NSLU2LM_MAJOR, 0), NULL, "leds");
- 	}
- #endif
- 
-@@ -513,7 +513,7 @@ static int __init n2iom_init(void)
- 		return -EBUSY;
- 	}
- 	else {
--		class_device_create(n2lm_class, MKDEV(NSLU2BZ_MAJOR, 0), NULL, "buzzer");
-+		class_device_create(n2lm_class, NULL, MKDEV(NSLU2BZ_MAJOR, 0), NULL, "buzzer");
- 	}
- 
- 	return 0;
diff --git a/packages/linux/nslu2-kernel/2.6.15/85-timer.patch b/packages/linux/nslu2-kernel/2.6.15/85-timer.patch
new file mode 100644
index 0000000000..3d4a03f616
--- /dev/null
+++ b/packages/linux/nslu2-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/nslu2-kernel/2.6.15/defconfig b/packages/linux/nslu2-kernel/2.6.15/defconfig
index 7074421cd7..883230ce19 100644
--- a/packages/linux/nslu2-kernel/2.6.15/defconfig
+++ b/packages/linux/nslu2-kernel/2.6.15/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
 # Linux kernel version: 2.6.15
-# Mon Nov 28 13:10:38 2005
+# Mon Nov 14 10:44:43 2005
 #
 CONFIG_ARM=y
 CONFIG_MMU=y
@@ -177,7 +177,7 @@ CONFIG_ALIGNMENT_TRAP=y
 #
 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 noirqdebug console=ttyS0,115200n8"
+CONFIG_CMDLINE="root=/dev/mtdblock4 rw rootfstype=jffs2 mem=32M@0x00000000 init=/linuxrc rtc-x1205.hctosys=1 rtc-x1205.probe=0,0x6f noirqdebug console=ttyS0,115200n8"
 # CONFIG_XIP_KERNEL is not set
 
 #
@@ -411,11 +411,6 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 CONFIG_FW_LOADER=m
 
 #
-# Connector - unified userspace <-> kernelspace linker
-#
-# CONFIG_CONNECTOR is not set
-
-#
 # Memory Technology Devices (MTD)
 #
 CONFIG_MTD=y
@@ -797,7 +792,7 @@ CONFIG_NET_POLL_CONTROLLER=y
 #
 # Input device support
 #
-CONFIG_INPUT=m
+CONFIG_INPUT=y
 
 #
 # Userland interfaces
@@ -878,7 +873,7 @@ CONFIG_IXP4XX_WATCHDOG=y
 # CONFIG_USBPCWATCHDOG is not set
 # CONFIG_NVRAM is not set
 # CONFIG_RTC is not set
-CONFIG_RTC_X1205=y
+CONFIG_RTC_X1205=n
 # CONFIG_DTLK is not set
 # CONFIG_R3964 is not set
 # CONFIG_APPLICOM is not set
@@ -946,7 +941,7 @@ CONFIG_SENSORS_EEPROM=y
 # CONFIG_SENSORS_PCF8591 is not set
 # CONFIG_SENSORS_RTC8564 is not set
 # CONFIG_SENSORS_MAX6875 is not set
-CONFIG_RTC_X1205_I2C=y
+# CONFIG_RTC_X1205_I2C is not set
 # CONFIG_I2C_DEBUG_CORE is not set
 # CONFIG_I2C_DEBUG_ALGO is not set
 # CONFIG_I2C_DEBUG_BUS is not set
@@ -1035,8 +1030,6 @@ CONFIG_VIDEO_HEXIUM_GEMINI=m
 CONFIG_VIDEO_CX88=m
 # CONFIG_VIDEO_EM28XX is not set
 CONFIG_VIDEO_OVCAMCHIP=m
-# CONFIG_VIDEO_AUDIO_DECODER is not set
-# CONFIG_VIDEO_DECODER is not set
 
 #
 # Radio Adapters
@@ -1281,7 +1274,6 @@ CONFIG_USB_NET_ZAURUS=m
 CONFIG_USB_SERIAL=m
 CONFIG_USB_SERIAL_GENERIC=y
 # CONFIG_USB_SERIAL_AIRPRIME is not set
-# CONFIG_USB_SERIAL_ANYDATA is not set
 CONFIG_USB_SERIAL_BELKIN=m
 CONFIG_USB_SERIAL_WHITEHEAT=m
 CONFIG_USB_SERIAL_DIGI_ACCELEPORT=m
@@ -1301,6 +1293,7 @@ CONFIG_USB_SERIAL_KEYSPAN_PDA=m
 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
@@ -1594,3 +1587,13 @@ 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
diff --git a/packages/linux/nslu2-kernel/2.6/40-scsi-idle.patch b/packages/linux/nslu2-kernel/2.6/40-scsi-idle.patch
new file mode 100644
index 0000000000..e04996e2a8
--- /dev/null
+++ b/packages/linux/nslu2-kernel/2.6/40-scsi-idle.patch
@@ -0,0 +1,44 @@
+diff -ur linux-2.6.12.2/drivers/scsi/sd.c linux-2.6.12.2_scsi-idle/drivers/scsi/sd.c
+--- linux-2.6.12.2/drivers/scsi/sd.c	2005-08-27 06:12:31.000000000 +0200
++++ linux-2.6.12.2_scsi-idle/drivers/scsi/sd.c	2005-08-27 06:26:50.000000000 +0200
+@@ -266,6 +266,9 @@
+ 			    "count=%d\n", disk->disk_name,
+ 			 (unsigned long long)block, this_count));
+ 
++	/* Update idle-since time */
++	sdp->idle = jiffies;
++
+ 	if (!sdp || !scsi_device_online(sdp) ||
+  	    block + rq->nr_sectors > get_capacity(disk)) {
+ 		SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n", 
+@@ -600,6 +603,8 @@
+ 		case SCSI_IOCTL_GET_IDLUN:
+ 		case SCSI_IOCTL_GET_BUS_NUMBER:
+ 			return scsi_ioctl(sdp, cmd, p);
++		case SCSI_IOCTL_IDLE:
++			return (jiffies - sdp->idle) / HZ + 1;
+ 		default:
+ 			error = scsi_cmd_ioctl(filp, disk, cmd, p);
+ 			if (error != -ENOTTY)
+diff -ur linux-2.6.12.2/include/scsi/scsi_device.h linux-2.6.12.2_scsi-idle/include/scsi/scsi_device.h
+--- linux-2.6.12.2/include/scsi/scsi_device.h	2005-08-27 06:12:44.000000000 +0200
++++ linux-2.6.12.2_scsi-idle/include/scsi/scsi_device.h	2005-08-27 06:27:09.000000000 +0200
+@@ -125,6 +125,7 @@
+ 	atomic_t ioerr_cnt;
+ 
+ 	int timeout;
++	unsigned long		idle;	/* scsi idle time in jiffers */
+ 
+ 	struct device		sdev_gendev;
+ 	struct class_device	sdev_classdev;
+diff -ur linux-2.6.12.2/include/scsi/scsi_ioctl.h linux-2.6.12.2_scsi-idle/include/scsi/scsi_ioctl.h
+--- linux-2.6.12.2/include/scsi/scsi_ioctl.h	2005-08-27 06:12:44.000000000 +0200
++++ linux-2.6.12.2_scsi-idle/include/scsi/scsi_ioctl.h	2005-08-28 17:32:17.000000000 +0200
+@@ -7,6 +7,7 @@
+ #define SCSI_IOCTL_SYNC 4			/* Request synchronous parameters */
+ #define SCSI_IOCTL_START_UNIT 5
+ #define SCSI_IOCTL_STOP_UNIT 6
++#define SCSI_IOCTL_IDLE 4746			/* get idle time in jiffies */
+ /* The door lock/unlock constants are compatible with Sun constants for
+    the cdrom */
+ #define SCSI_IOCTL_DOORLOCK 0x5380		/* lock the eject mechanism */
diff --git a/packages/linux/nslu2-kernel_2.6.15-rc5.bb b/packages/linux/nslu2-kernel_2.6.15.bb
index 659ddd0eae..90e52821dd 100644
--- a/packages/linux/nslu2-kernel_2.6.15-rc5.bb
+++ b/packages/linux/nslu2-kernel_2.6.15.bb
@@ -8,7 +8,7 @@ PR_CONFIG = "0"
 # Increment the number below (i.e. the digits after PR) when
 # making changes within this file or for changes to the patches
 # applied to the kernel.
-PR = "r0.${PR_CONFIG}"
+PR = "r2.${PR_CONFIG}"
 
 include nslu2-kernel.inc
 
@@ -17,13 +17,12 @@ N2K_PATCHES = "\
 	file://00-memory-h-page-shift.patch;patch=1 \
 	file://10-mtdpart-redboot-fis-byteswap.patch;patch=1 \
 	file://19-jffs2-force-be.patch;patch=1 \
-	file://55-rtc-x1205.patch;patch=1 \
+	file://40-rtc-class.patch;patch=1 \
+	file://40-scsi-idle.patch;patch=1 \
 	file://60-nslu2-beeper.patch;patch=1 \
-	file://60-nslu2-rtc.patch;patch=1 \
 	file://75-nslu2-leds.patch;patch=1 \
 	file://80-nslu2-io.patch;patch=1 \
-	file://81-nslu2-class-device-create.patch;patch=1 \
-	file://20-timer.patch;patch=1 \
+	file://85-timer.patch;patch=1 \
 	file://91-maclist.patch;patch=1 \
 	file://92-nslu2-maclist.patch;patch=1 \
 	file://anonymiser.patch;patch=1 \
@@ -33,4 +32,4 @@ N2K_PATCHES = "\
 # specific to the bootstrap of *this* kernel in here - DISTRO specfic
 # config must be in CMDLINE_ROOT (see the full definition of CMDLINE
 # in nslu2-kernel.inc)
-CMDLINE_KERNEL_OPTIONS = "x1205.hctosys=1"
+CMDLINE_KERNEL_OPTIONS = "rtc-x1205.hctosys=1 rtc-x1205.probe=0,0x6f"