Remove the EOLN_NATIVE flag from a ton of files (patches & the like for which line ending conversions can break things).

BKrev: 41a5b1c6eA2OPeQrDQEgEwAmKXvQJg

6 files changed, 1581 insertions, 0 deletions

diff --git a/linux/openslug-kernel-2.6.9/nslu2-io.c b/linux/openslug-kernel-2.6.9/nslu2-io.c
index e69de29bb2..ad5bdc221d 100644
--- a/linux/openslug-kernel-2.6.9/nslu2-io.c
+++ b/linux/openslug-kernel-2.6.9/nslu2-io.c
@@ -0,0 +1,651 @@
+//=============================================================================
+//
+// nslu2-io.c version 0.1.0
+// Author: Karen Spearel <kas11 at tampabay.rr.com>
+// please report problems/bugs directly to the address above
+//
+// NOTE: THIS IS INCOMPLETE.  INCLUDED ONLY TO KEEP FROM BREAKING THE BUILD,
+// IT BEEPS AND SENDS A MESSAGE TO /proc/poweroff.  EVENTUALLY IT
+// WILL TALK TO THE n2_pbuttond DAEMON.  EVENTUALLY THE LED DRIVER
+// WILL TALK TO SOME USERLAND APP BUT ***NOT*** THE NASTY SETLEDS.
+// 
+//=============================================================================
+//	GPIO		Function	State
+//	0		Red LED		Status		
+//	1		Green LED	Ready = 1
+//	2		Disk 2 LED	On = 0
+//	3		Disk 1 LED	On = 0
+//	4		Buzzer
+//	5		Power Button	Pressed = 1
+//	8		Power Down	Output = 1 powers down N2
+//	12		Reset		Pressed = 0
+//=============================================================================
+// this driver is N2 specific and is purposely designed to do the minimum 
+// necessary to provide the necessary services given the limited memory resources
+// of the N2.  As OpenSlug develops, addition features will be added as
+// suggested by community leadership.
+//
+// The Userland apps such as SetLeds are just to crufty to bother with.
+// This driver makes no attempt to do so...one day a Userland app will appear
+// ...until then, this does very little.
+//=============================================================================
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/utsname.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/string.h>
+#include <linux/proc_fs.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/moduleparam.h>
+#include <linux/timer.h>
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+#include <asm/hardware.h>
+#include <asm-arm/irq.h>
+#include <asm-arm/delay.h>
+
+// Print kernel error 
+#define P_ERROR(args...) \
+	printk(KERN_ERR DRV_NAME ": " args)
+// Print kernel warning 
+#define P_WARN(args...) \
+	printk(KERN_WARNING DRV_NAME ": " args)
+// Print kernel notice 
+#define P_NOTICE(args...) \
+	printk(KERN_NOTICE DRV_NAME ": " args)
+// Print kernel info 
+#define P_INFO(args...) \
+	printk(KERN_INFO DRV_NAME ": " args)
+// Print verbose message. Enabled/disabled by 'log_level' param 
+#define P_VERBOSE(args...) \
+	if (log_level >= 1) printk(DRV_NAME ": " args)
+// Print debug message. Enabled/disabled by 'log_level' param  
+#define P_DEBUG(args...) \
+	if (log_level >= 2) { \
+		printk("%s: %s()\n", DRV_NAME, __FUNCTION__); \
+		printk(args); }
+
+#ifdef DEBUG
+// Print trace message 
+#define TRACE \
+	if (log_level >= 2) printk("%s: %s(): line %d\n", \
+			DRV_NAME, __FUNCTION__, __LINE__)
+#else
+// no trace 
+#define TRACE 
+#endif
+
+#define VERSION			"0.1.1"
+
+#define N2RB_MAJOR		60
+#define N2PB_MAJOR		61
+#define	N2BZ_MAJOR		62
+#define N2LM_MAJOR		126
+
+#define N2PB_IRQ		22		//gpio5
+#define	N2RB_IRQ		29		//gpio12
+
+#define N2_BEEP_DUR_LONG	2000
+#define N2_BEEP_DUR_MED		400
+#define N2_BEEP_DUR_SHORT	100
+#define N2_BEEP_PITCH_HIGH	250
+#define N2_BEEP_PITCH_MED	500
+#define N2_BEEP_PITCH_LOW	1000
+#define N2_LONG_DELAY		30000
+
+#define N2_BZ_GPIO		4
+#define N2_PB_GPIO		5
+#define N2_PO_GPIO		8		//power off
+#define N2_RB_GPIO		12
+
+#define GPIO_BZ_BM		0x0010	//b0000 0000 0001 0000
+#define GPIO_PB_BM		0x0020	//b0000 0000 0010 0000
+#define GPIO_PO_BM		0x0100  //b0000 0001 0000 0000
+#define GPIO_RB_BM		0x1000	//b0001 0000 0000 0000
+
+#define NOERR			0
+
+#define RB_DELAY		50
+#define PB_DELAY		20
+
+#define PWR_OFF_STR		"poweroff"
+
+
+// ioctls -- THESE NEED TO BE PROPERLY DEFINED
+
+#define N2LM_ON			0
+#define N2LM_OFF		1
+#define N2LM_BLINK		2
+#define N2LM_ALT		3
+#define N2LM_ALL_ON		4
+#define N2LM_ALL_OFF		5
+
+#define PHYS_LEDS		4
+#define BLINK_DELAY		25
+
+static int  n2lm_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg);
+
+
+ 
+//  OR Masks to turn these LEDs ON
+
+#define	RS_RED_ON	0x00000001	//0b0000 0000 0000 0010
+#define	RS_GRN_ON	0x00000002	//0b0000 0000 0000 0001
+#define RS_YEL_ON	0x00000003	//0b0000 0000 0000 0011
+
+// AND Masks to turn these LEDs OFF
+
+#define	RS_RED_OFF	0xfffffffe	//0b1111 1111 1111 1101
+#define	RS_GRN_OFF	0xfffffffd	//0b1111 1111 1111 1110
+#define RS_YEL_OFF	0xfffffffc	//0b1111 1111 1111 1100
+
+// AND Masks to turn these LEDs ON
+
+#define DISK1_ON	0xfffffff7	//0b1111 1111 1111 0111
+#define	DISK2_ON	0xfffffffb	//0b1111 1111 1111 1011
+
+// Or Masks to turn these LEDs OFF
+
+#define DISK1_OFF	0x00000008	//0b0000 0000 0000 1000
+#define	DISK2_OFF	0x00000004	//0b0000 0000 0000 0100	
+
+// EOR masks for toggling LEDs on/off
+
+#define RS_RG_ALT	0x00000003	//eor mask to toggle rs rg bits
+#define RS_GRN_TGL	0x00000002
+#define RS_RED_TGL	0x00000001
+#define DISK1_TGL	0x00000008
+#define DISK2_TGL	0x00000004
+
+// The LED names for switches
+
+#define LED_RS_RED	0
+#define LED_RS_GRN	1
+#define	LED_DISK1	2
+#define LED_DISK2	3
+#define LED_ALL		4
+
+static long init_jiffy = 0;			//jiffies at init time
+static int rb_presses = 0;			//number of reset button presses
+
+DECLARE_WAIT_QUEUE_HEAD(n2rb_waitq);
+DECLARE_WAIT_QUEUE_HEAD(n2pb_waitq);
+
+static struct timer_list n2lm_rsg_timer;	//rs green 
+static struct timer_list n2lm_rsr_timer;	//rs red
+static struct timer_list n2lm_d1_timer;		//drive 1
+static struct timer_list n2lm_d2_timer;		//drive 2
+static struct timer_list n2rb_timer;
+static struct timer_list n2pb_timer;
+
+
+//==================================================================================================
+//
+// Blinking is handled entirely by the 4 timer handlers.  On timeout, the bit in the
+// GPIO output register is xor'd with a mask corresponding to the selected led which simply
+// flips that bit.  No record of what any of the other leds is doing is needed.
+//
+//==================================================================================================
+// this blinks rs green or green/yellow if rs red is on
+static void n2lm_rsg_handler(unsigned long data)
+{
+	*IXP4XX_GPIO_GPOUTR ^= RS_GRN_TGL;			//flip the led
+	n2lm_rsg_timer.expires = jiffies + BLINK_DELAY;		//next timeout
+	add_timer(&n2lm_rsg_timer);				//reinit timer
+	return;
+}
+
+// this blinks or alternates rs red green... inited wit green on/red off
+static void n2lm_rsr_handler(unsigned long data)
+{
+	*IXP4XX_GPIO_GPOUTR ^= n2lm_rsr_timer.data;
+	n2lm_rsr_timer.expires = jiffies + BLINK_DELAY;
+	add_timer(&n2lm_rsr_timer);
+	return;	
+}
+// blinks disk 1
+static void n2lm_d1_handler(unsigned long data)
+{
+	*IXP4XX_GPIO_GPOUTR ^= DISK1_TGL;
+	n2lm_d1_timer.expires = jiffies + BLINK_DELAY;
+	add_timer(&n2lm_d1_timer);
+	return;
+}
+// blinks disk 2
+static void n2lm_d2_handler(unsigned long data)
+{
+	*IXP4XX_GPIO_GPOUTR ^= DISK2_TGL;
+	n2lm_d2_timer.expires = jiffies + BLINK_DELAY;
+	add_timer(&n2lm_d2_timer);
+	return;
+}
+
+//==================================================================================================
+
+static void n2lm_timer_start(unsigned long led)
+{
+
+	printk(KERN_DEBUG "timer: %ld\n",led);
+
+	switch(led) {
+		case LED_RS_RED:
+			n2lm_rsr_timer.expires = jiffies + BLINK_DELAY;
+			n2lm_rsr_timer.function = n2lm_rsr_handler;
+			add_timer(&n2lm_rsr_timer);
+			break;
+
+		case LED_RS_GRN:
+			n2lm_rsg_timer.expires = jiffies + BLINK_DELAY;
+			n2lm_rsg_timer.function = n2lm_rsg_handler;
+			add_timer(&n2lm_rsg_timer);
+			break;
+
+		case LED_DISK1:
+			n2lm_d1_timer.expires = jiffies + BLINK_DELAY;
+			n2lm_d1_timer.function = n2lm_d1_handler;
+			add_timer(&n2lm_d1_timer);
+ 			break;
+
+		case LED_DISK2:
+			n2lm_d2_timer.expires = jiffies + BLINK_DELAY;
+			n2lm_d2_timer.function = n2lm_d2_handler; 
+			add_timer(&n2lm_d2_timer);
+			break;
+
+		default:
+			break;
+	}
+	return;
+}
+
+//==================================================================================================
+
+static void n2lm_timer_stop(unsigned long led)
+{
+	switch (led) {
+		case LED_RS_RED:
+			del_timer(&n2lm_rsr_timer);
+			break;
+		case LED_RS_GRN:
+			del_timer(&n2lm_rsg_timer);
+			break;
+		case LED_DISK1:
+			del_timer(&n2lm_d1_timer);
+ 			break;
+		case LED_DISK2: 
+			del_timer(&n2lm_d2_timer);
+			break;
+		default:
+			break;
+	}
+	return;
+}
+
+//--------------------------------------------------------------------------------------------------
+
+static void n2lm_timer_stop_all(void)
+{
+	del_timer(&n2lm_rsg_timer);
+	del_timer(&n2lm_rsr_timer);
+	del_timer(&n2lm_d1_timer); 
+	del_timer(&n2lm_d2_timer);
+	return;
+}
+//--------------------------------------------------------------------------------------------------
+
+static void n2lm_ledon(unsigned long led)
+{
+
+	printk("ledon: %ld\n", led);
+
+	switch (led) {
+		case LED_RS_RED:	
+			*IXP4XX_GPIO_GPOUTR |= RS_RED_ON;	//1
+			return;
+		case LED_RS_GRN:
+			*IXP4XX_GPIO_GPOUTR |= RS_GRN_ON;	//2
+			return;
+		case LED_DISK1:
+			*IXP4XX_GPIO_GPOUTR &= DISK1_ON;	//0xfffffffb
+			return;
+		case LED_DISK2:	
+			*IXP4XX_GPIO_GPOUTR &= DISK2_ON;	//0xfffffff7
+			return;
+		case LED_ALL:					//all green
+			*IXP4XX_GPIO_GPOUTR |= RS_GRN_ON;
+			*IXP4XX_GPIO_GPOUTR &= (DISK1_ON & DISK2_ON);
+			return;	
+	}
+}
+
+//--------------------------------------------------------------------------------------------------
+
+static void n2lm_ledoff(unsigned long led)
+{
+
+	switch (led) {
+		case LED_RS_RED:	
+			*IXP4XX_GPIO_GPOUTR &= RS_RED_OFF;	//0xffffffffe
+			return;
+		case LED_RS_GRN:
+			*IXP4XX_GPIO_GPOUTR &= RS_GRN_OFF;	//0xfffffffd
+			return;
+		case LED_DISK1:
+			*IXP4XX_GPIO_GPOUTR |= DISK1_OFF;	//0x00000004
+			return;
+		case LED_DISK2:	
+			*IXP4XX_GPIO_GPOUTR |= DISK2_OFF;	//0x00000008
+			return;
+		case LED_ALL:
+			*IXP4XX_GPIO_GPOUTR &= (RS_GRN_OFF & RS_RED_OFF);
+			*IXP4XX_GPIO_GPOUTR |= (DISK1_OFF | DISK2_OFF);
+	}
+}
+
+//==================================================================================================
+
+static int n2lm_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long led)
+{
+
+	printk(KERN_DEBUG "cmd=%d, led=%ld\n", cmd, led);
+	
+	if (led < 0 || led >= PHYS_LEDS)
+		return -EINVAL;
+
+	switch (cmd ) {
+		case N2LM_ON:
+			n2lm_timer_stop(led);
+			n2lm_ledon(led);
+			break;
+			
+		case N2LM_OFF:
+			n2lm_timer_stop(led);
+			n2lm_ledoff(led);
+			break;
+			
+		case N2LM_BLINK:
+			n2lm_ledon(led);
+			if (led == LED_RS_RED)
+				n2lm_rsr_timer.data = RS_RED_TGL;
+			if (led == LED_RS_GRN)
+				n2lm_rsr_timer.data = RS_GRN_TGL;
+			n2lm_timer_start(led);
+			break;
+
+		case N2LM_ALT:
+			if (led == LED_RS_RED)
+			{
+				n2lm_ledon(LED_RS_GRN);
+				n2lm_ledoff(LED_RS_RED);
+				n2lm_rsr_timer.data = RS_RG_ALT;
+				n2lm_timer_start(LED_RS_RED);
+				break;
+			} else
+				return -EINVAL;
+		
+		case N2LM_ALL_ON:
+			n2lm_timer_stop_all();
+			n2lm_ledon(LED_ALL);
+			break;
+		
+		case N2LM_ALL_OFF:
+			n2lm_timer_stop_all();
+			n2lm_ledoff(LED_ALL);
+			break;
+		
+		default:
+			return -EINVAL;
+	}
+
+	return NOERR;
+}
+
+static struct file_operations n2lm_fops = {
+	.owner		= THIS_MODULE,
+	.ioctl		= n2lm_ioctl,
+};
+//==================================================================================================
+// We can't do anything fancy here since the system tick rate is far below that required to
+// generate a desirable tone.  Therefore we haven't much choice but to use a busy loop until
+// I get up to speed on the timers.  The saving grace is that for the normal uses, nothing 
+// important should be haprepening. 
+//==================================================================================================
+
+static void n2_beep(int tone_delay, int duration)
+{
+	int i;
+
+	*IXP4XX_GPIO_GPOER &= ~GPIO_BZ_BM;
+		
+	for (i = 1; i < duration; i++) {
+		*IXP4XX_GPIO_GPOUTR &= ~GPIO_BZ_BM;
+		udelay(tone_delay);
+		*IXP4XX_GPIO_GPOUTR |= GPIO_BZ_BM;
+		udelay(tone_delay);
+	}
+	*IXP4XX_GPIO_GPOER |= GPIO_BZ_BM;
+
+	return;
+}
+
+//==================================================================================================
+		
+static irqreturn_t n2pb_handler (int irq, void *dev_id, struct pt_regs *regs)
+{
+	void *ret;
+	
+	wake_up(&n2pb_waitq);	
+	remove_proc_entry(PWR_OFF_STR, NULL);		//no parent	
+	n2_beep(N2_BEEP_PITCH_MED, N2_BEEP_DUR_MED);
+	ret = create_proc_entry(PWR_OFF_STR, 0, NULL);
+
+// WARNING: This is RUDE...it unconditionally pulls the power plug
+// your data will be at risk...since this is just a test system
+// I am leaving it enabled...eventually userland needs to get the
+// message, do an orderly shutdown and use an ioctl or something in
+// /proc/powerdowm to actually have us pull the plug.
+
+	*IXP4XX_GPIO_GPOER &= ~GPIO_PO_BM;	// enable the pwr cntl gpio
+	*IXP4XX_GPIO_GPOUTR |= GPIO_PO_BM;	// do the deed
+
+	printk(KERN_DEBUG "cpe ret = %p\n", ret);
+	return IRQ_HANDLED;
+}
+
+//==================================================================================================
+//
+//static void do_rb_timeout(unsigned long data)
+//{
+//	int i;
+//
+//	for (i = 0; i < rb_presses; i++)
+//		n2_beep(N2_BEEP_PITCH_MED,N2_BEEP_DUR_SHORT);
+//	return;
+//}
+//
+//==================================================================================================
+// does nothing -- waiting for userland to define
+// This thing is sorta braindead...edge triggered IRQs aren't available in the drivers yet...so
+// we hang in a loop until the button is no longer pressed
+static irqreturn_t n2rb_handler (int irq, void *dev_id, struct pt_regs *regs)
+{
+
+	unsigned long test[] = { 5,0, 0,0, 1,0, 0,1, 1,1, 0,2, 1,2, 0,3, 1,3, 2,0, 1,0, 2,1, 1,1, 2,2, 1,2, 2,3, 1,3, 5,0, 3,1, 5,0, 4,0  };
+
+	printk(KERN_DEBUG "Reset Entry IRQ=%d Presses= %d Jiffies= %08lx\n", irq, rb_presses, jiffies);
+
+	wake_up(&n2rb_waitq);	
+  	while ((*IXP4XX_GPIO_GPINR & GPIO_RB_BM) == 0)
+		;					//wait for button release
+
+	if (rb_presses == 21) {
+		rb_presses = 0;
+	}
+	n2lm_ioctl(NULL,NULL,test[rb_presses*2], test[rb_presses*2+1]);
+	rb_presses++;
+
+//	if (rb_presses == 0) {
+//		init_jiffy = jiffies;
+//		init_timer (&n2rb_timer);
+//		n2rb_timer.function = do_rb_timeout;
+//	};
+//
+//	if (rb_presses == 8)
+//		rb_presses = 0;
+//	if (rb_presses & 1)
+//		n2lm_ledon(test[rb_presses]);
+//	else
+//		n2lm_ledoff(test[rb_presses]);
+//	
+//	n2rb_timer.expires = (jiffies + RB_DELAY);
+//	add_timer (&n2rb_timer);
+//	if (rb_presses < 5) {
+//		if (rb_presses > 0)
+//			n2lm_ledoff(rb_presses);
+//		n2lm_ledon(++rb_presses);
+//		n2lm_timer_start(rb_presses);
+//	};
+
+	printk(KERN_DEBUG "Reset Exit IRQ=%d Presses= %d Jiffies= %08lx\n", irq, rb_presses, jiffies);
+	return IRQ_HANDLED;
+}
+
+//==================================================================================================
+//  What to do here is majorly undetermined...
+
+static int n2rb_read (struct file *filp, char __user *buffer, size_t count, loff_t *ppos)
+{
+	printk(KERN_DEBUG "Reset Button Wait\n");
+	interruptible_sleep_on(&n2rb_waitq);
+	return copy_to_user(buffer, "reset", 5) ? -EFAULT : 5;
+
+}
+
+//==================================================================================================
+//  What to do here is majorly undetermined...
+
+static int n2pb_read (struct file *filp, char __user *buffer, size_t count, loff_t *ppos)
+{
+	printk(KERN_DEBUG "Power Button Wait\n");
+	interruptible_sleep_on(&n2pb_waitq);
+	return copy_to_user(buffer, "poweroff", 8) ? -EFAULT : 8;
+
+}
+
+//--------------------------------------------------------------------------------------------------
+
+static struct file_operations n2rb_fops = {
+	.owner		= THIS_MODULE,
+	.read		= n2rb_read,
+};
+
+//--------------------------------------------------------------------------------------------------
+
+static struct file_operations n2pb_fops = {
+	.owner		= THIS_MODULE,
+	.read		= n2pb_read,
+};
+
+//==================================================================================================
+
+static void n2iom_initarch(void)
+{
+	printk(KERN_DEBUG "setup_interrupts - jiffies=%ld init_jiffy=%ld\n", jiffies, init_jiffy);
+
+	*IXP4XX_GPIO_GPISR = 0x20400000;	// read the 2 irqs to clr
+	gpio_line_config(N2_RB_GPIO, IXP4XX_GPIO_IN | IXP4XX_GPIO_ACTIVE_LOW);
+	gpio_line_isr_clear(N2_RB_GPIO);
+	gpio_line_config(N2_PB_GPIO, IXP4XX_GPIO_IN | IXP4XX_GPIO_ACTIVE_HIGH);
+	gpio_line_isr_clear(N2_PB_GPIO);
+
+	init_timer(&n2lm_rsg_timer);
+	init_timer(&n2lm_rsr_timer);
+	init_timer(&n2lm_d1_timer);
+	init_timer(&n2lm_d2_timer);
+	init_timer(&n2rb_timer);
+	init_timer(&n2pb_timer);
+
+	*IXP4XX_GPIO_GPOER &= 0xfffffff0;	//enable gpio 0-3
+	*IXP4XX_GPIO_GPOUTR |= 0x00000003;	//turn off the leds
+	*IXP4XX_GPIO_GPOUTR &= 0xfffffffc;
+	n2lm_ledon(LED_ALL);
+	n2_beep(N2_BEEP_PITCH_MED, N2_BEEP_DUR_SHORT);
+	n2lm_ledoff(LED_ALL);
+
+	return;
+}
+
+//==================================================================================================
+
+static int __init n2iom_init(void)
+{
+	printk(KERN_INFO "NSLU2 Misc I/O Driver Version %s (C) Karen Spearel\n", VERSION);
+  	
+	init_jiffy = jiffies;
+	printk(KERN_DEBUG "init_jiffy=%ld\n",init_jiffy);
+	n2iom_initarch();
+
+	if (register_chrdev(N2RB_MAJOR, "n2_rb", &n2pb_fops) < NOERR) {
+		printk(KERN_DEBUG "Reset Button Major %d not available\n", N2RB_MAJOR);
+		return -EBUSY;
+	}
+	if (register_chrdev(N2PB_MAJOR, "n2_pb", &n2rb_fops) < NOERR) {
+		printk(KERN_DEBUG "Power Button Major %d not available\n", N2PB_MAJOR);
+		return -EBUSY;
+	}
+	if (register_chrdev(N2LM_MAJOR, "n2_leds", &n2lm_fops) < NOERR) {
+		printk(KERN_DEBUG "Led Manager Major %d not available\n", N2LM_MAJOR);
+		return -EBUSY;
+	}
+	if (request_irq(N2RB_IRQ, &n2rb_handler, SA_INTERRUPT, "n2_rb", NULL) < NOERR) {
+		printk(KERN_DEBUG "Reset Button IRQ %d not available\n", N2RB_IRQ);
+		return -EIO;
+	}
+	if (request_irq(N2PB_IRQ, &n2pb_handler, SA_INTERRUPT, "n2_pb", NULL) < NOERR) {
+		printk(KERN_DEBUG "Power Button IRQ %d not available\n", N2PB_IRQ);
+		return -EIO;	
+	}
+	
+	enable_irq(N2PB_IRQ);
+	enable_irq(N2RB_IRQ);
+	return (NOERR);
+}
+
+//==================================================================================================
+
+static void __exit n2iom_exit(void)
+{
+	remove_proc_entry(PWR_OFF_STR, NULL);
+	del_timer(&n2rb_timer);
+	free_irq(N2RB_IRQ,NULL);
+	unregister_chrdev(N2PB_MAJOR, "n2pb");
+	del_timer(&n2pb_timer);	
+	free_irq(N2PB_IRQ, NULL);
+	unregister_chrdev(N2RB_MAJOR, "n2rb" );
+	del_timer(&n2lm_rsg_timer);
+	del_timer(&n2lm_rsr_timer);
+	del_timer(&n2lm_d1_timer);
+	del_timer(&n2lm_d2_timer);	
+	unregister_chrdev(N2LM_MAJOR, "n2lm" );
+}
+
+module_init (n2iom_init);
+module_exit (n2iom_exit);
+
+MODULE_AUTHOR("Karen Spearel <kas11@tampabay.rr.com>");
+MODULE_DESCRIPTION("NSLU2 Buttons/LEDs IO Driver");
+MODULE_LICENSE("GPL");
+static int debug = 7;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Debugging enabled = 1");
+
diff --git a/linux/openslug-kernel-2.6.9/nslu2-part.c b/linux/openslug-kernel-2.6.9/nslu2-part.c
index e69de29bb2..6fbf952e2a 100644
--- a/linux/openslug-kernel-2.6.9/nslu2-part.c
+++ b/linux/openslug-kernel-2.6.9/nslu2-part.c
@@ -0,0 +1,120 @@
+/*
+ * nslu2-part.c
+ *
+ * Maintainers: http://www.nslu2-linux.org/
+ * Initial port: Mark Rakes <mrakes AT mac.com>
+ *
+ * "Parse" the fixed partition table of the Linksys NSLU2 and
+ * produce a Linux partition array to match.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/vmalloc.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+
+/* info we know about the NSLU2's flash setup:
+ *
+ * Num	Partition		offset		size
+ * ---	---------		----------	-----------
+ * 0	RedBoot			0x00000000	0x00040000
+ * 1	System Configuration	0x00040000	0x00020000
+ * 2	Kernel			0x00060000	0x00100000
+ * 3	Ramdisk			0x00160000	0x006a0000
+ */
+ #define NSLU2_NUM_FLASH_PARTITIONS	4
+ #define NSLU2_FLASH_PART0_NAME		"RedBoot"
+ #define NSLU2_FLASH_PART0_OFFSET	0x00000000
+ #define NSLU2_FLASH_PART0_SIZE		0x00040000
+ #define NSLU2_FLASH_PART1_NAME		"System Configuration"
+ #define NSLU2_FLASH_PART1_OFFSET	(NSLU2_FLASH_PART0_OFFSET + NSLU2_FLASH_PART0_SIZE)
+ #define NSLU2_FLASH_PART1_SIZE		0x00020000
+ #define NSLU2_FLASH_PART2_NAME		"Kernel"
+ #define NSLU2_FLASH_PART2_OFFSET	(NSLU2_FLASH_PART1_OFFSET + NSLU2_FLASH_PART1_SIZE)
+ #define NSLU2_FLASH_PART2_SIZE		0x00100000
+ #define NSLU2_FLASH_PART3_NAME		"Ramdisk"
+ #define NSLU2_FLASH_PART3_OFFSET	(NSLU2_FLASH_PART2_OFFSET + NSLU2_FLASH_PART2_SIZE)
+ #define NSLU2_FLASH_PART3_SIZE		0x006a0000
+
+static int parse_nslu2_partitions(struct mtd_info *master,
+                             struct mtd_partition **pparts,
+                             unsigned long flash_start)
+{
+	struct mtd_partition *parts;
+	int ret = 0, namelen = 0;
+	char *names;
+
+	namelen = strlen(NSLU2_FLASH_PART0_NAME) +
+		  strlen(NSLU2_FLASH_PART1_NAME) +
+		  strlen(NSLU2_FLASH_PART2_NAME) +
+		  strlen(NSLU2_FLASH_PART3_NAME) +
+		  NSLU2_NUM_FLASH_PARTITIONS; /*4 strings + each terminator */
+
+	parts = kmalloc(sizeof(*parts)*NSLU2_NUM_FLASH_PARTITIONS + namelen, GFP_KERNEL);
+	if (!parts) {
+		ret = -ENOMEM;
+		goto out;
+	}
+
+	memset(parts, 0, sizeof(*parts)*NSLU2_NUM_FLASH_PARTITIONS + namelen);
+	names = (char *)&parts[NSLU2_NUM_FLASH_PARTITIONS];
+
+	/* RedBoot partition */
+	parts[0].size	= NSLU2_FLASH_PART0_SIZE;
+	parts[0].offset	= NSLU2_FLASH_PART0_OFFSET;
+	parts[0].name	= NSLU2_FLASH_PART0_NAME;
+	parts[0].mask_flags = MTD_WRITEABLE; /* readonly */
+	strcpy(names, NSLU2_FLASH_PART0_NAME);
+	names += strlen(names)+1;
+	/* System Configuration */
+	parts[1].size	= NSLU2_FLASH_PART1_SIZE;
+	parts[1].offset	= NSLU2_FLASH_PART1_OFFSET;
+	parts[1].name	= NSLU2_FLASH_PART1_NAME;
+	parts[1].mask_flags = MTD_WRITEABLE; /* readonly */
+	strcpy(names, NSLU2_FLASH_PART1_NAME);
+	names += strlen(names)+1;
+	/* Kernel */
+	parts[2].size	= NSLU2_FLASH_PART2_SIZE;
+	parts[2].offset	= NSLU2_FLASH_PART2_OFFSET;
+	parts[2].name	= NSLU2_FLASH_PART2_NAME;
+	parts[2].mask_flags = MTD_WRITEABLE; /* readonly */
+	strcpy(names, NSLU2_FLASH_PART2_NAME);
+	names += strlen(names)+1;
+	/* Ramdisk */
+	parts[3].size	= NSLU2_FLASH_PART3_SIZE;
+	parts[3].offset	= NSLU2_FLASH_PART3_OFFSET;
+	parts[3].name	= NSLU2_FLASH_PART3_NAME;
+	parts[3].mask_flags = MTD_WRITEABLE; /* readonly */
+	strcpy(names, NSLU2_FLASH_PART3_NAME);
+	names += strlen(names)+1;
+
+	ret = NSLU2_NUM_FLASH_PARTITIONS;
+	*pparts = parts;
+ out:
+	return ret;
+}
+
+static struct mtd_part_parser nslu2_parser = {
+	.owner = THIS_MODULE,
+	.parse_fn = parse_nslu2_partitions,
+	.name = "NSLU2",
+};
+
+static int __init nslu2_parser_init(void)
+{
+	return register_mtd_parser(&nslu2_parser);
+}
+
+static void __exit nslu2_parser_exit(void)
+{
+	deregister_mtd_parser(&nslu2_parser);
+}
+
+module_init(nslu2_parser_init);
+module_exit(nslu2_parser_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mark Rakes");
+MODULE_DESCRIPTION("Parsing code for NSLU2 flash tables");
diff --git a/linux/openslug-kernel-2.6.9/nslu2-pci.c b/linux/openslug-kernel-2.6.9/nslu2-pci.c
index e69de29bb2..7327c65a4f 100644
--- a/linux/openslug-kernel-2.6.9/nslu2-pci.c
+++ b/linux/openslug-kernel-2.6.9/nslu2-pci.c
@@ -0,0 +1,87 @@
+/*
+ * arch/arm/mach-ixp4xx/nslu2-pci.c
+ *
+ * NSLU2 board-level PCI initialization
+ *
+ * based on ixdp425-pci.c:
+ *	Copyright (C) 2002 Intel Corporation.
+ *	Copyright (C) 2003-2004 MontaVista Software, Inc.
+ *
+ * Maintainer: http://www.nslu2-linux.org/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+// GPIO 8 is used as the power input so is not free for use as a PCI IRQ
+// However, all the common PCI setup code presumes the standard 4 PCI
+// interrupts are available.  So we compromise...we don't enable the
+// IRQ on Pin 8 but we let
+
+#include <linux/config.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+
+#include <asm/mach/pci.h>
+#include <asm/irq.h>
+#include <asm/hardware.h>
+#include <asm/mach-types.h>
+
+void __init nslu2_pci_preinit(void)
+{
+	gpio_line_config(NSLU2_PCI_INTA_PIN,
+				IXP4XX_GPIO_IN | IXP4XX_GPIO_ACTIVE_LOW);
+	gpio_line_config(NSLU2_PCI_INTB_PIN,
+				IXP4XX_GPIO_IN | IXP4XX_GPIO_ACTIVE_LOW);
+	gpio_line_config(NSLU2_PCI_INTC_PIN,
+				IXP4XX_GPIO_IN | IXP4XX_GPIO_ACTIVE_LOW);
+//	gpio_line_config(NSLU2_PCI_INTD_PIN,
+//				IXP4XX_GPIO_IN | IXP4XX_GPIO_ACTIVE_LOW);
+
+	gpio_line_isr_clear(NSLU2_PCI_INTA_PIN);
+	gpio_line_isr_clear(NSLU2_PCI_INTB_PIN);
+	gpio_line_isr_clear(NSLU2_PCI_INTC_PIN);
+//	gpio_line_isr_clear(NSLU2_PCI_INTD_PIN);
+
+	ixp4xx_pci_preinit();
+}
+
+static int __init nslu2_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
+{
+	static int pci_irq_table[NSLU2_PCI_IRQ_LINES] = {
+		IRQ_NSLU2_PCI_INTA,
+		IRQ_NSLU2_PCI_INTB,
+		IRQ_NSLU2_PCI_INTC,
+//		IRQ_NSLU2_PCI_INTD
+	};
+
+	int irq = -1;
+
+	if (slot >= 1 && slot <= NSLU2_PCI_MAX_DEV &&
+		pin >= 1 && pin <= NSLU2_PCI_IRQ_LINES) {
+		irq = pci_irq_table[(slot + pin - 2) % 3]; // ! % 4 kas11
+	}
+
+	return irq;
+}
+
+struct hw_pci __initdata nslu2_pci = {
+	.nr_controllers = 1,
+	.preinit	= nslu2_pci_preinit,
+	.swizzle	= pci_std_swizzle,
+	.setup		= ixp4xx_setup,
+	.scan		= ixp4xx_scan_bus,
+	.map_irq	= nslu2_map_irq,
+};
+
+int __init nslu2_pci_init(void)		//monkey see, monkey do
+{
+	if (machine_is_nslu2())
+		pci_common_init(&nslu2_pci);
+	return 0;
+}
+
+subsys_initcall(nslu2_pci_init);
+
diff --git a/linux/openslug-kernel-2.6.9/nslu2-setup.c b/linux/openslug-kernel-2.6.9/nslu2-setup.c
index e69de29bb2..5698ea9813 100644
--- a/linux/openslug-kernel-2.6.9/nslu2-setup.c
+++ b/linux/openslug-kernel-2.6.9/nslu2-setup.c
@@ -0,0 +1,132 @@
+/*
+ * arch/arm/mach-ixp4xx/nslu2-setup.c
+ *
+ * NSLU2 board-setup
+ *
+ * based ixdp425-setup.c:
+ *	Copyright (C) 2003-2004 MontaVista Software, Inc.
+ *
+ * Author: Mark Rakes <mrakes at mac.com>
+ * Maintainers: http://www.nslu2-linux.org/
+ *
+ * Fixed missing init_time in MACHINE_START kas11 10/22/04
+ * Changed to conform to new style __init ixdp425 kas11 10/22/04 
+ */
+
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/serial.h>
+#include <linux/tty.h>
+#include <linux/serial_core.h>
+
+#include <asm/types.h>
+#include <asm/setup.h>
+#include <asm/memory.h>
+#include <asm/hardware.h>
+#include <asm/mach-types.h>
+#include <asm/irq.h>
+#include <asm/mach/arch.h>
+#include <asm/mach/flash.h>
+
+#ifdef	__ARMEB__
+#define	REG_OFFSET	3
+#else
+#define	REG_OFFSET	0
+#endif
+
+/*
+ * NSLU2 uses only one serial port
+ */
+static struct uart_port nslu2_serial_ports[] = {
+	{
+		.membase	= (char*)(IXP4XX_UART1_BASE_VIRT + REG_OFFSET),
+		.mapbase	= (IXP4XX_UART1_BASE_PHYS),
+		.irq		= IRQ_IXP4XX_UART1,
+		.flags		= UPF_SKIP_TEST,
+		.iotype		= UPIO_MEM,
+		.regshift	= 2,
+		.uartclk	= IXP4XX_UART_XTAL,
+		.line		= 0,
+		.type		= PORT_XSCALE,
+		.fifosize	= 32
+	}
+#if 0
+	, {
+		.membase	= (char*)(IXP4XX_UART2_BASE_VIRT + REG_OFFSET),
+		.mapbase	= (IXP4XX_UART2_BASE_PHYS),
+		.irq		= IRQ_IXP4XX_UART2,
+		.flags		= UPF_SKIP_TEST,
+		.iotype		= UPIO_MEM,
+		.regshift	= 2,
+		.uartclk	= IXP4XX_UART_XTAL,
+		.line		= 1,
+		.type		= PORT_XSCALE,
+		.fifosize	= 32
+	}
+#endif
+};
+
+void __init nslu2_map_io(void)
+{
+	early_serial_setup(&nslu2_serial_ports[0]);
+#if 0
+	early_serial_setup(&nslu2_serial_ports[1]);
+#endif
+	ixp4xx_map_io();
+}
+
+static struct flash_platform_data nslu2_flash_data = {
+	.map_name	= "cfi_probe",
+	.width		= 2,
+};
+
+static struct resource nslu2_flash_resource = {
+	.start		= NSLU2_FLASH_BASE,
+	.end		= NSLU2_FLASH_BASE + NSLU2_FLASH_SIZE,
+	.flags		= IORESOURCE_MEM,
+};
+
+static struct platform_device nslu2_flash = {
+	.name		= "IXP4XX-Flash",
+	.id		= 0,
+	.dev		= {
+		.platform_data = &nslu2_flash_data,
+	},
+	.num_resources	= 1,
+	.resource	= &nslu2_flash_resource,
+};
+
+static struct ixp4xx_i2c_pins nslu2_i2c_gpio_pins = {
+	.sda_pin	= NSLU2_SDA_PIN,
+	.scl_pin	= NSLU2_SCL_PIN,
+};
+
+static struct platform_device nslu2_i2c_controller = {
+	.name		= "IXP4XX-I2C",
+	.id		= 0,
+	.dev		= {
+		.platform_data = &nslu2_i2c_gpio_pins,
+	},
+	.num_resources	= 0
+};
+
+static struct platform_device *nslu2_devices[] __initdata = {
+	&nslu2_i2c_controller,
+	&nslu2_flash
+};
+
+static void __init nslu2_init(void)
+{
+	platform_add_devices(&nslu2_devices, ARRAY_SIZE(nslu2_devices));
+}
+
+MACHINE_START(NSLU2, "Linksys NSLU2")
+	MAINTAINER("www.nslu2-linux.org")
+	BOOT_MEM(PHYS_OFFSET, IXP4XX_PERIPHERAL_BASE_PHYS,
+		IXP4XX_PERIPHERAL_BASE_VIRT)
+	MAPIO(nslu2_map_io)
+	INITIRQ(ixp4xx_init_irq)	//FIXME: all irq are off here
+	INITTIME(ixp4xx_init_time)	//this was missing in 2.6.7 code ...soft reboot needed?
+	BOOT_PARAMS(0x0100)
+	INIT_MACHINE(nslu2_init)
+MACHINE_END
diff --git a/linux/openslug-kernel-2.6.9/nslu2.h b/linux/openslug-kernel-2.6.9/nslu2.h
index e69de29bb2..bb79aaa007 100644
--- a/linux/openslug-kernel-2.6.9/nslu2.h
+++ b/linux/openslug-kernel-2.6.9/nslu2.h
@@ -0,0 +1,43 @@
+/*
+ * include/asm-arm/arch-ixp4xx/nslu2.h
+ *
+ * NSLU2 platform specific definitions
+ *
+ * Author: Mark Rakes <mrakes AT mac.com>
+ * Maintainers: http://www.nslu2-linux.org
+ *
+ * based on ixdp425.h:
+ *	Copyright 2004 (c) MontaVista, Software, Inc.
+ *
+ * This file is licensed under  the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+// GPIO 8 is used as the power input so is not free for use as a PCI IRQ
+// kas11 11-2-04
+
+#ifndef __ASM_ARCH_HARDWARE_H__
+#error "Do not include this directly, instead #include <asm/hardware.h>"
+#endif
+
+#define	NSLU2_FLASH_BASE	IXP4XX_EXP_BUS_CS0_BASE_PHYS
+#define	NSLU2_FLASH_SIZE	IXP4XX_EXP_BUS_CSX_REGION_SIZE
+
+#define	NSLU2_SDA_PIN		7
+#define	NSLU2_SCL_PIN		6
+
+/*
+ * NSLU2 PCI IRQs
+ */
+#define NSLU2_PCI_MAX_DEV	3
+#define NSLU2_PCI_IRQ_LINES	3
+
+
+/* PCI controller GPIO to IRQ pin mappings */
+#define NSLU2_PCI_INTA_PIN	11
+#define NSLU2_PCI_INTB_PIN	10
+#define	NSLU2_PCI_INTC_PIN	9
+//#define	NSLU2_PCI_INTD_PIN	8
+
+
diff --git a/linux/openslug-kernel-2.6.9/x1205-rtc.c b/linux/openslug-kernel-2.6.9/x1205-rtc.c
index e69de29bb2..c194608ad6 100644
--- a/linux/openslug-kernel-2.6.9/x1205-rtc.c
+++ b/linux/openslug-kernel-2.6.9/x1205-rtc.c
@@ -0,0 +1,548 @@
+/*
+    x1205 - an 12c driver for the Xicor X1205 RTC
+    Copyright 2004 Karen Spearel
+
+    please send all reports to:
+	kas11 at tampabay dot rr dot com
+      
+    based on linux/drivers/acron/char/pcf8583.h
+    Copyright (C) 2000 Russell King
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+/*
+
+ * i2c_adapter is the structure used to identify a physical i2c bus along
+ * with the access algorithms necessary to access it.
+
+struct i2c_adapter {
+	struct module *owner;
+	unsigned int id;  == is algo->id | hwdep.struct->id, for registered values see below
+	unsigned int class;
+	struct i2c_algorithm *algo; the algorithm to access the bus
+	void *algo_data;
+
+	--- administration stuff.
+	int (*client_register)(struct i2c_client *);
+	int (*client_unregister)(struct i2c_client *);
+
+	 data fields that are valid for all devices
+	struct semaphore bus_lock;
+	struct semaphore clist_lock;
+
+	int timeout;
+	int retries;
+	struct device dev;		the adapter device 
+	struct class_device class_dev;	the class device
+
+#ifdef CONFIG_PROC_FS 
+	No need to set this when you initialize the adapter
+	int inode;
+#endif def CONFIG_PROC_FS
+
+	int nr;
+	struct list_head clients;
+	struct list_head list;
+	char name[I2C_NAME_SIZE];
+	struct completion dev_released;
+	struct completion class_dev_released;
+};
+*/
+
+
+/*========== Driver for the X1205 on the Linksys NSLU2 ==================*/
+
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/bcd.h>
+#include <linux/rtc.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <linux/miscdevice.h>
+#include <linux/device.h>
+#include <asm/uaccess.h>
+#include <asm/system.h>
+#include <linux/moduleparam.h>
+
+#define		RTC_GETDATETIME		0
+#define		RTC_SETTIME		1
+#define		RTC_SETDATETIME		2
+
+#define		I2C_M_WR		0	// just for consistancy
+
+//  offsets into read buf - add 2 for write buf
+#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_I2C_BUS_ADDR	0x6f	// hardwired into x1205
+#define		X1205_ALM0_BASE		0x00	// Base address of the ALM0
+#define		X1205_CCR_BASE		0x30	// Base address of the CCR
+#define		X1205_SR_ADDR		0x3f	// Status Register
+#define		X1205_SR_WEL		0x02	// Write Enable Latch bit
+#define		X1205_SR_RWEL		0x04	// Register Write Enable Bit
+#define		X1205_MILBIT		0x80	// this bit set in ccr.hour for 24 hr mode
+#define		NOERR			0
+#define		RTC_NODATE		0
+#define		RTC_DATETOO		1
+
+// comment out next line is your x1205 can't do page writes
+//#define 	X1205PAGEWRITE		1
+#ifdef X1205PAGEWRITE
+#define		DRIVERNAME		"Xicor x1205 RTC Driver v0.9.3.3"
+#else
+#define		DRIVERNAME		"Xicor x1205 RTC Dvr v0.9.3.3NPW"
+#endif
+
+#define		DEBUG			KERN_DEBUG
+
+
+static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm, u8 reg_base);
+static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm, int datetoo, u8 reg_base);
+static int x1205_attach(struct i2c_adapter *adapter);
+static int x1205_detach(struct i2c_client *client);
+static int x1205_validate_tm(struct rtc_time *tm);
+static int x1205_command(struct i2c_client *client, unsigned int cmd, void *arg);
+static int x1205_sync_rtc(void);
+static int x1205_read(struct file *file, char *buf, size_t count, loff_t *ptr);
+static int x1205_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
+static int x1205_read_proc(char *buf, char **start, off_t off, int len, int *eof, void *data);
+
+static struct i2c_driver x1205_driver = {
+	.owner		= THIS_MODULE,
+	.name		= DRIVERNAME,
+	.id		= I2C_DRIVERID_X1205,
+	.flags		= I2C_DF_NOTIFY,
+	.attach_adapter = &x1205_attach,		//we don't need to probe...x1205 is hardwired @ 0x6f
+	.detach_client	= &x1205_detach,
+	.command	= &x1205_command,		//this prolly never gets called...used internally tho
+};
+
+static struct i2c_client x1205_i2c_client = {
+	.id		=	I2C_DRIVERID_X1205,
+	.flags		=	0,
+	.addr		=	X1205_I2C_BUS_ADDR,	// chip address - NOTE: 7bit
+	.adapter	=	NULL,			// the adapter we sit on assigned in attach
+	.driver		=	&x1205_driver,		// and our access routines
+	.usage_count	=	0,			// How many accesses currently to this client
+	.dev		=	{},			// the device structure
+	.list		=	{},
+	.name		=	DRIVERNAME,
+	.released	=	{},
+};
+
+static struct file_operations rtc_fops = {
+	owner:		THIS_MODULE,
+	ioctl:		x1205_ioctl,
+	read:		x1205_read,
+};
+
+static struct miscdevice x1205_miscdev = {
+	.minor		= RTC_MINOR,
+	.name		= "rtc",
+	.fops		= &rtc_fops,
+};
+extern int (*set_rtc)(void);
+static unsigned epoch = 1900;		//coresponds to year 0
+static unsigned  rtc_epoch = 2000;
+static const unsigned char days_in_mo[] = 
+{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+//===================================CODE======================================
+// 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 inited as 2000. Time is set to UT
+//=============================================================================   
+static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm, u8 reg_base)
+{
+	static unsigned char addr[2] = { 0,} ;
+	unsigned char buf[8];	
+	struct i2c_msg msgs[2] = {
+		{ client->addr, I2C_M_WR, 2, addr },	//msg 1 = send base address
+		{ client->addr, I2C_M_RD, 8, buf },	//msg 2 = read sequential data
+	};
+	addr[1] = reg_base;
+	if ((i2c_transfer(client->adapter, msgs, 2)) == 2) {	//did we read 2 messages?
+		printk(KERN_DEBUG "raw x1205 read data  - sec-%02x min-%02x hr-%02x mday-%02x mon-%02x year-%02x wday-%02x y2k-%02x\n", 
+			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]);
+		buf[CCR_HOUR] &= ~X1205_MILBIT;
+		tm->tm_hour = BCD2BIN(buf[CCR_HOUR]);		//hr is 0-23
+		tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
+		tm->tm_mon  = BCD2BIN(buf[CCR_MONTH]);
+		rtc_epoch   = BCD2BIN(buf[CCR_Y2K]) * 100;
+		tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + rtc_epoch - epoch;
+		tm->tm_wday = buf[CCR_WDAY];
+		printk(KERN_DEBUG "rtc_time output data - sec-%02d min-%02d hr-%02d mday-%02d mon-%02d year-%02d wday-%02d epoch-%d rtc_epoch-%d\n",
+			tm->tm_sec,tm->tm_min,tm->tm_hour,tm->tm_mday,tm->tm_mon,tm->tm_year,tm->tm_wday,epoch, rtc_epoch);
+	} else {
+		printk(KERN_DEBUG "i2c_transfer Read Error\n");
+		return -EIO;
+	}		
+	
+	return NOERR;
+}
+// x1205pagewrite allows writing a block of registers in msg3 even though the x1205 says
+// nothing about this in its spec. 
+// it needs more testing as it is possible some x1205s are actually not-completely-
+// functional x1226s and there is a reason for the multiple write to not be in the spec.
+// anyhow, it is enabled for the time being...and we even push out luck by sending 10 bytes
+
+static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm, int datetoo, u8 reg_base)
+{
+	static unsigned char wel[3]   = { 0, X1205_SR_ADDR, X1205_SR_WEL };
+	static unsigned char rwel[3]  = { 0, X1205_SR_ADDR, X1205_SR_WEL | X1205_SR_RWEL };
+	static unsigned char diswe[3] = { 0, X1205_SR_ADDR, 0 };
+
+#ifdef X1205PAGEWRITE
+
+	static unsigned char buf[10]   = { 0, X1205_CCR_BASE, };		
+	struct i2c_msg msgs[4] = {
+		{ client->addr, I2C_M_WR, 3, wel   },	//msg 1 = write WEL to to ccr sr
+		{ client->addr, I2C_M_WR, 3, rwel  },	//msg 2 = write RWEL to ccr sr
+		{ client->addr, I2C_M_WR, 10, buf   },	//msg 3 = write ccr base addr +seq data
+		{ client->addr, I2C_M_WR, 3, diswe },	//msg 4 = 0 to ccr sr to disable writes
+	};
+
+	msgs[2].len = 5;					// 5 bytes + addr to set time only
+	buf [1] = reg_base;
+	buf[CCR_SEC+2]  = BIN2BCD(tm->tm_sec);
+	buf[CCR_MIN+2]  = BIN2BCD(tm->tm_min);
+	buf[CCR_HOUR+2] = BIN2BCD(tm->tm_hour) | X1205_MILBIT; // set 24 hour format
+	if (datetoo == 1) {
+		buf[CCR_MDAY+2]  = BIN2BCD(tm->tm_mday);
+		buf[CCR_MONTH+2] = BIN2BCD(tm->tm_mon);		// input is 0-11	
+		buf[CCR_YEAR+2]  = BIN2BCD((tm->tm_year + epoch - rtc_epoch));	// input is yrs since 1900
+		buf[CCR_WDAY+2]  = tm->tm_wday & 7;
+		buf[CCR_Y2K+2]   = BIN2BCD((rtc_epoch/100));
+		msgs[2].len += 5;				//5 more bytes to set date
+	}
+	printk(KERN_DEBUG "rtc_time input - sec-%02d min-%02d hour-%02d mday-%02d mon-%02d year-%02d wday-%02d epoch-%d rtc_epoch-%d\n",
+		tm->tm_sec,tm->tm_min,tm->tm_hour,tm->tm_mday,tm->tm_mon,tm->tm_year,tm->tm_wday, epoch, rtc_epoch);
+	printk(KERN_DEBUG "BCD write data - sec-%02x min-%02x hour-%02x mday-%02x mon-%02x year-%02x wday-%02x y2k-%02x\n",
+		buf[2],buf[3],buf[4],buf[5],buf[6], buf[7], buf[8], buf[9]);
+
+	if ((i2c_transfer(client->adapter, msgs, 4)) != 4)
+		return -EIO;
+	return NOERR;
+	
+#else		//do this if page writes aren't working
+
+	int i,xfer;
+	static unsigned char data[3]  = { 0,};
+	static unsigned char buf[8];
+
+	buf[CCR_SEC]  = BIN2BCD(tm->tm_sec);
+	buf[CCR_MIN]  = BIN2BCD(tm->tm_min);
+	buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_MILBIT; // set 24 hour format
+	if (datetoo == 1) {
+		buf[CCR_MDAY]  = BIN2BCD(tm->tm_mday);
+		buf[CCR_MONTH] = BIN2BCD(tm->tm_mon);		// input is 0-11	
+		buf[CCR_YEAR]  = BIN2BCD((tm->tm_year + epoch - rtc_epoch));	// input is yrs since 1900
+		buf[CCR_WDAY]  = tm->tm_wday & 7;
+		buf[CCR_Y2K]   = BIN2BCD((rtc_epoch/100));
+	}
+	printk(KERN_DEBUG "rtc_time input - sec-%02d min-%02d hour-%02d mday-%02d mon-%02d year-%02d wday-%02d epoch-%d rtc_epoch-%d\n",
+		tm->tm_sec,tm->tm_min,tm->tm_hour,tm->tm_mday,tm->tm_mon,tm->tm_year,tm->tm_wday, epoch, rtc_epoch);
+
+	xfer = i2c_master_send(client, wel, 3);
+	printk(KERN_DEBUG "wen - %x\n", xfer);
+	if (xfer != 3)
+		return -EIO;
+
+	xfer = i2c_master_send(client, rwel, 3);
+	printk(KERN_DEBUG "wenb - %x\n", xfer);
+	if (xfer != 3)
+		return -EIO;
+
+	for (i = 0; i < 8; i++) {
+		data[1] = i + reg_base;
+		data[2] =  buf[i];
+		xfer = i2c_master_send(client, data, 3);
+		printk(KERN_DEBUG "xfer - %d addr - %02x  data - %02x\n", xfer, data[1], data[2]);
+		if (xfer != 3)
+			return -EIO;
+	};
+
+	xfer = i2c_master_send(client, diswe, 3);
+	printk(KERN_DEBUG "wdis - %x\n", xfer);
+	if (xfer != 3)
+		return -EIO;		
+	return NOERR;
+#endif
+}
+//=============================================================================
+
+static int x1205_attach(struct i2c_adapter *adapter)
+{
+	struct rtc_time tm;
+	struct timespec tv;
+	int errno;
+		
+	x1205_i2c_client.adapter = adapter;
+	x1205_i2c_client.id++;
+
+	if ((x1205_get_datetime(&x1205_i2c_client, &tm, X1205_CCR_BASE)) != NOERR)	//test for functional driver 
+		return -EIO;
+	
+	if ((errno = i2c_attach_client(&x1205_i2c_client)) != NOERR)
+		return errno;
+
+	tv.tv_nsec = tm.tm_sec * 10000000;
+	tv.tv_sec  = mktime(tm.tm_year+epoch, tm.tm_mon+1, tm.tm_mday, tm.tm_hour,
+						tm.tm_min, tm.tm_sec);
+	do_settimeofday(&tv);
+	set_rtc = x1205_sync_rtc;
+	
+	printk(KERN_DEBUG "%s attached on adapter %s\n",x1205_i2c_client.name,
+		x1205_i2c_client.adapter->name); //why is this name a null string?
+
+	return NOERR;
+}
+
+static int x1205_detach(struct i2c_client *client)
+{
+	int errno;
+	
+	if ((errno = i2c_detach_client(client)) != 0) {
+		printk(KERN_DEBUG "i2c_detach failed - errno = %d\n", errno);
+		return errno;
+	}
+
+	return NOERR;
+}
+
+// make sure the rtc_time values are in bounds
+static int x1205_validate_tm(struct rtc_time *tm)
+{
+	tm->tm_year += 1900;
+
+	if (tm->tm_year < 1970)
+		return -EINVAL;
+
+	if ((tm->tm_mon > 11) || (tm->tm_mday == 0))
+		return -EINVAL;
+
+	if (tm->tm_mday > (days_in_mo[tm->tm_mon] + ( (tm->tm_mon == 1) && 
+		((!(tm->tm_year % 4) && (tm->tm_year % 100) ) || !(tm->tm_year % 400)))))
+		return -EINVAL;
+
+	if ((tm->tm_year -= epoch) > 255)
+		return -EINVAL;
+			
+	if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60))
+		return -EINVAL;
+	return NOERR;
+}
+
+static int x1205_command(struct i2c_client *client, unsigned int cmd, void *tm)
+{
+	int errno, dodate = RTC_DATETOO;
+
+	if (client == NULL || tm == NULL)
+		return -EINVAL;
+	if (!capable(CAP_SYS_TIME))
+		return -EACCES;
+
+	printk(KERN_DEBUG "x1205_command %d\n", cmd);
+
+	switch (cmd) {
+	case RTC_GETDATETIME:
+		return x1205_get_datetime(client, tm, X1205_CCR_BASE);
+
+	case RTC_SETTIME:		// note fall thru
+		dodate = RTC_NODATE;
+	case RTC_SETDATETIME:
+		if ((errno = x1205_validate_tm(tm)) < NOERR)
+			return errno;
+		return x1205_set_datetime(client, tm, dodate, X1205_CCR_BASE);
+
+	default:
+		return -EINVAL;
+	}
+}
+
+static int x1205_sync_rtc(void)
+{
+	struct rtc_time new_tm, old_tm;
+	unsigned long cur_secs = xtime.tv_sec;
+
+	printk(KERN_DEBUG "x1205_sync_rtc entry\n");
+
+	if (x1205_command(&x1205_i2c_client, RTC_GETDATETIME, &old_tm))
+		return 0;
+
+//	xtime.tv_nsec = old_tm.tm_sec * 10000000;   //FIXME:
+	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;
+	printk(KERN_DEBUG "x1205_sync_rtc exit\n");
+
+	return x1205_command(&x1205_i2c_client, RTC_SETTIME, &new_tm);
+}
+
+static int x1205_read(struct file *file, char *buf, size_t count, loff_t *ptr)
+{
+	struct rtc_time tm;
+
+	if ((x1205_get_datetime(&x1205_i2c_client, &tm, X1205_CCR_BASE)) < NOERR)
+		return -EIO;
+	return copy_to_user(buf, &tm, sizeof(tm)) ? -EFAULT : NOERR;
+}
+
+//==============================================================================
+
+static int x1205_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+		     unsigned long arg)
+{
+	struct rtc_time tm;
+	int errno;
+
+	printk(KERN_DEBUG "ioctl = %x\n", cmd);
+	
+	switch (cmd) {
+	case RTC_RD_TIME:
+		if ((x1205_get_datetime(&x1205_i2c_client, &tm, X1205_CCR_BASE)) < NOERR)
+			return -EIO;
+		break;
+		
+	case RTC_SET_TIME:
+		if (!capable(CAP_SYS_TIME))
+			return -EACCES;
+
+		if (copy_from_user(&tm, (struct rtc_time *) arg, sizeof(struct rtc_time))) 
+			return -EFAULT;
+		if ((errno = x1205_validate_tm(&tm)) < NOERR)
+			return errno;
+		return x1205_set_datetime(&x1205_i2c_client, &tm, RTC_DATETOO, X1205_CCR_BASE);
+
+	case RTC_ALM_SET:						//FIXME: set Control Regs
+		if (copy_from_user(&tm, (struct rtc_time *) arg, sizeof(struct rtc_time))) 
+			return -EFAULT;
+		return x1205_set_datetime(&x1205_i2c_client, &tm, RTC_DATETOO, X1205_ALM0_BASE);
+
+	case RTC_ALM_READ:
+		if ((x1205_get_datetime(&x1205_i2c_client, &tm, X1205_ALM0_BASE)) < NOERR)
+			return -EIO;
+		break;
+
+	case RTC_EPOCH_READ:
+
+		return put_user (epoch, (unsigned long __user *)arg);
+
+	case RTC_EPOCH_SET:
+		if (arg < 1900)
+			return -EINVAL;
+
+		if (!capable(CAP_SYS_TIME))
+			return -EACCES;
+
+		epoch = arg;
+		return 0;
+
+	default:
+		return -ENOTTY;
+	}
+	return copy_to_user((void __user *)arg, &tm, sizeof tm) ? -EFAULT : 0;
+
+}
+
+static int x1205_read_proc(char *buf, char **start, off_t off, int len, int *eof, void *data)
+{
+	struct rtc_time tm;
+	int slen, errno;
+
+	if ((errno = x1205_get_datetime(&x1205_i2c_client, &tm, X1205_CCR_BASE)) < NOERR)
+		return errno;
+
+//	here we return the real year and the month as 1-12 since it is human-readable
+	slen = sprintf(buf, "rtc_time\t: %02d:%02d:%02d\nrtc_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);
+ 	printk(KERN_DEBUG "raw rtc_time\t: %02d:%02d:%02d\nraw rtc_date\t: %04d-%02d-%02d\n",
+		tm.tm_hour, tm.tm_min, tm.tm_sec, tm.tm_year, tm.tm_mon, tm.tm_mday);
+
+	if (slen <= off + len)
+		*eof = 1;
+	*start = buf + off;
+	slen -= off;
+	if (slen > len)
+		slen = len;
+	if ( slen < 0 )
+		slen = 0;
+
+	return slen;
+}
+
+static int __init x1205_init(void)
+{
+	struct	rtc_time tm;
+	int errno;
+	printk(KERN_INFO "LOADED %s\n", DRIVERNAME);
+
+	if ((errno = i2c_add_driver(&x1205_driver)) != NOERR) {
+		dev_dbg(x1205_i2c_client.dev, "x1205_init failed - errno = %d\n", errno);
+		return (errno);
+	}
+	if ((errno = misc_register(&x1205_miscdev)) != NOERR) {
+		dev_dbg(x1205_i2c_client.dev, "Register Misc Driver failed - errno = %d\n", errno);
+		i2c_del_driver(&x1205_driver);
+		return errno; 
+	}
+	if (create_proc_read_entry("driver/rtc", 0, NULL, x1205_read_proc, NULL) < NOERR)
+		return -ENOMEM;
+	if ((x1205_get_datetime(&x1205_i2c_client, &tm, X1205_CCR_BASE)) != NOERR)	//test for functionality
+		return -EIO;
+
+	return NOERR;	
+}
+
+static void __exit x1205_exit(void)
+{
+	remove_proc_entry("driver/rtc", NULL);
+	misc_deregister(&x1205_miscdev);
+	i2c_del_driver(&x1205_driver);
+	set_rtc = NULL;
+}
+
+MODULE_AUTHOR("Karen Spearel <kas11@tampabay.rr.com>");
+MODULE_DESCRIPTION("Xicor X1205-RTC Driver");
+MODULE_LICENSE("GPL");
+static int debug = 7;
+module_param(debug, bool, 0644);
+MODULE_PARM_DESC(debug, "Debugging enabled = 1");
+
+module_init(x1205_init);
+module_exit(x1205_exit);