openwrt-xburst/target/linux/linux-2.4/patches/ar7/002-led_driver.patch

diff -urN linux.old/drivers/char/avalanche_led/gpio.c linux.dev/drivers/char/avalanche_led/gpio.c
--- linux.old/drivers/char/avalanche_led/gpio.c	1970-01-01 01:00:00.000000000 +0100
+++ linux.dev/drivers/char/avalanche_led/gpio.c	2005-07-22 06:52:42.973338640 +0200
@@ -0,0 +1,382 @@
+#include <linux/kernel.h>
+#include <asm/uaccess.h>
+#include <linux/spinlock.h>
+#include <linux/proc_fs.h>
+#include <linux/fs.h>
+#include <linux/timer.h>
+#include <linux/module.h>
+
+#include <asm/ar7/tnetd73xx_err.h>
+#include <asm/ar7/tnetd73xx_misc.h>
+#include <asm/ar7/ledapp.h>
+
+#define TRUE 1
+#define FALSE 0
+
+#if defined CONFIG_AR7WRD || defined CONFIG_AR7RD
+
+#define AR7_RESET_FILE "led_mod/ar7reset"
+#define AR7_VERSION_FILE "led_mod/hardware_version"
+#define AR7_RESET_GPIO 11
+#define RESET_POLL_TIME 1
+#define RESET_HOLD_TIME 4
+#define NO_OF_LEDS	
+
+static struct proc_dir_entry *reset_file;
+static int res_state = 0;
+static int count;
+static struct timer_list *pTimer = NULL;
+static ssize_t proc_read_reset_fops(struct file *filp,
+                                    char *buf,size_t count , loff_t *offp);
+
+static ssize_t proc_read_hwversion_fops(struct file *filp,
+                                    char *buf,size_t count , loff_t *offp);
+
+struct file_operations reset_fops = {
+                                     read: proc_read_reset_fops
+                                   };
+struct file_operations hardware_version_fops = {
+                                     read: proc_read_hwversion_fops
+                                   };
+#endif
+
+static spinlock_t	device_lock;
+led_reg_t temp[15];
+
+static void gpio_led_on( unsigned long param )
+{
+	unsigned int flags;
+
+	spin_lock_irqsave(&device_lock, flags);
+
+	tnetd73xx_gpio_out(param,FALSE);
+	spin_unlock_irqrestore(&device_lock, flags);
+}
+
+static void gpio_led_off ( unsigned long param )
+{
+	unsigned int flags = 0x00;
+
+ 	spin_lock_irqsave(&device_lock, flags);
+
+	tnetd73xx_gpio_out(param,TRUE);
+	spin_unlock_irqrestore(&device_lock, flags);
+}
+
+static void gpio_led_init( unsigned long param)
+{
+	tnetd73xx_gpio_ctrl(param,GPIO_PIN,GPIO_OUTPUT_PIN);
+}
+
+static void board_gpio_reset(void)
+{
+	/* Initialize the link mask */
+	device_lock = SPIN_LOCK_UNLOCKED;
+	return;
+}
+
+#if defined CONFIG_AR7WRD || defined CONFIG_AR7RD
+
+static ssize_t proc_read_hwversion_fops(struct file *filp, char *buf, 
+					size_t count, loff_t *offp)
+{
+	char line[8];
+  	int len = 0;
+  	if( *offp != 0 )
+  		return 0;
+
+	len = sprintf(line,  "%d%d.%d%d%d%d\n", tnetd73xx_gpio_in(20),
+			tnetd73xx_gpio_in(21), tnetd73xx_gpio_in(22),
+			tnetd73xx_gpio_in(23), tnetd73xx_gpio_in(24),
+		        tnetd73xx_gpio_in(25));
+  	
+	copy_to_user(buf, line, len);
+	*offp = len;
+	return len;
+}	
+
+static ssize_t proc_read_reset_fops(struct file *filp,
+                                 char *buf,size_t count , loff_t *offp)
+{
+  char * pdata = NULL;
+  char line[3];
+  int len = 0;
+  if( *offp != 0 )
+  	return 0;
+
+  pdata = buf;
+	len = sprintf(line,"%d\n", res_state );
+//wwzh
+//  res_state = 0;
+  copy_to_user(buf,line,len );
+	*offp = len;
+	return len;
+}
+
+static void reset_timer_func(unsigned long data)
+{
+//wwzh
+#if 0
+  	count = (tnetd73xx_gpio_in(AR7_RESET_GPIO) == 0) ? count + 1: 0;
+        if( count >= RESET_HOLD_TIME/RESET_POLL_TIME )
+#endif
+	if (tnetd73xx_gpio_in(AR7_RESET_GPIO) == 0)
+    		res_state = 1;
+	else
+		res_state = 0;
+	pTimer->expires = jiffies + HZ*RESET_POLL_TIME;
+	add_timer (pTimer);
+  return;
+}
+
+static void hardware_version_init(void)
+{
+   	static struct proc_dir_entry *hardware_version_file;
+  	hardware_version_file = create_proc_entry(AR7_VERSION_FILE, 0777, NULL);
+  	if(hardware_version_file == NULL)
+   		 return;
+  	
+	hardware_version_file->owner = THIS_MODULE;
+  	hardware_version_file->proc_fops = &hardware_version_fops;
+
+  	tnetd73xx_gpio_ctrl(20,GPIO_PIN,GPIO_INPUT_PIN);
+  	tnetd73xx_gpio_ctrl(21,GPIO_PIN,GPIO_INPUT_PIN);
+  	tnetd73xx_gpio_ctrl(22,GPIO_PIN,GPIO_INPUT_PIN);
+  	tnetd73xx_gpio_ctrl(23,GPIO_PIN,GPIO_INPUT_PIN);
+  	tnetd73xx_gpio_ctrl(24,GPIO_PIN,GPIO_INPUT_PIN);
+  	tnetd73xx_gpio_ctrl(25,GPIO_PIN,GPIO_INPUT_PIN);
+	
+	return;
+}
+
+static void reset_init(void)
+{
+  /* Create board reset proc file */
+  reset_file = create_proc_entry( AR7_RESET_FILE, 0777, NULL);
+  if( reset_file == NULL)
+    goto reset_file;
+  reset_file->owner = THIS_MODULE;
+  reset_file->proc_fops = &reset_fops;
+
+  /* Initialise GPIO 11 for input */
+  tnetd73xx_gpio_ctrl(AR7_RESET_GPIO,GPIO_PIN,GPIO_INPUT_PIN);
+
+  /* Create a timer which fires every seconds */
+  pTimer = kmalloc(sizeof(struct timer_list),GFP_KERNEL);
+	init_timer( pTimer );
+	pTimer->function = reset_timer_func;
+	pTimer->data = 0;
+  /* Start the timer */
+  reset_timer_func(0);
+  return ;
+
+  reset_file:
+    remove_proc_entry("AR7_RESET_FILE",NULL);
+	return;
+}
+#endif
+/*************wwzh****************/
+#if 1
+extern unsigned int sys_mod_state;
+extern unsigned int  wan_mod_state;
+extern unsigned int wlan_mod_state;
+void sys_led_init(void)
+{
+	tnetd73xx_gpio_ctrl(4, GPIO_PIN, GPIO_OUTPUT_PIN);
+	tnetd73xx_gpio_ctrl(5, GPIO_PIN, GPIO_OUTPUT_PIN);
+	tnetd73xx_gpio_ctrl(8, GPIO_PIN, GPIO_OUTPUT_PIN);
+
+	tnetd73xx_gpio_out(4, FALSE);
+	tnetd73xx_gpio_out(5, TRUE);
+	tnetd73xx_gpio_out(8, TRUE);
+	
+
+	sys_mod_state = 2;
+
+}
+void wan_led_init(void)
+{
+	
+	tnetd73xx_gpio_ctrl(2, GPIO_PIN, GPIO_OUTPUT_PIN);
+	tnetd73xx_gpio_ctrl(3, GPIO_PIN, GPIO_OUTPUT_PIN);
+	
+	tnetd73xx_gpio_out(2, FALSE);
+	tnetd73xx_gpio_out(3, FALSE);
+
+	wan_mod_state = 1;
+}
+//wwzh wireless
+#if 0
+void wlan_led_init(void)
+{
+	//unsigned long i = 0;	
+	tnetd73xx_gpio_ctrl(12, GPIO_PIN, GPIO_OUTPUT_PIN);
+	tnetd73xx_gpio_ctrl(13, GPIO_PIN, GPIO_OUTPUT_PIN);
+	
+	tnetd73xx_gpio_out(12, FALSE);
+	tnetd73xx_gpio_out(13, TRUE);
+	//for (i = 0; i < 0x20000000; i++);
+	wlan_mod_state = 1;
+}
+#endif
+
+#endif
+/*************end ****************/
+
+void board_gpio_init(void)
+{
+
+	board_gpio_reset();
+/**************wwzh*************/
+	sys_led_init();
+	wan_led_init();
+
+	//junzhao 2004.3.15
+	hardware_version_init();
+	
+	//wlan_led_init();
+
+  	/* Register Device MAX_LED_ID + 1 for reset to factory default */
+	 temp[0].param = 0;
+ 	 temp[0].init = reset_init;
+  	 temp[0].onfunc = 0;
+ 	 temp[0].offfunc = 0;
+	 register_led_drv( MAX_LED_ID + 1 , &temp[0]);
+//wwzh for wireless led  
+#if 1
+  /* Register led 12 WiFi 6 */
+  temp[1].param = 6;
+  temp[1].init = gpio_led_init;
+  temp[1].onfunc = gpio_led_on;
+  temp[1].offfunc = gpio_led_off;
+  register_led_drv( 12 , &temp[1]);
+
+#endif
+
+#if 0
+/**************end ************/
+#if defined(CONFIG_AR5D01)
+  /* Register led 1 GPIO0 */
+  temp[0].param = GPIO_0;
+  temp[0].init = gpio_led_init;
+  temp[0].onfunc = gpio_led_on;
+  temp[0].offfunc = gpio_led_off;
+	register_led_drv( 1 , &temp[0]);
+
+  /* Register led 2 EINT1 */
+  temp[1].param = EINT_1;
+  temp[1].init = gpio_led_init;
+  temp[1].onfunc = gpio_led_on;
+  temp[1].offfunc = gpio_led_off;
+	register_led_drv( 2 , &temp[1]);
+
+  /* Register led 5 EINT1 */
+  temp[2].param = GPIO_1;
+  temp[2].init = gpio_led_init;
+  temp[2].onfunc = gpio_led_on;
+  temp[2].offfunc = gpio_led_off;
+	register_led_drv( 5 , &temp[2]);
+#endif
+
+#if defined(CONFIG_AR5W01)
+  /* Register led 5 GPIO_1 */
+  temp[0].param = GPIO_1;
+  temp[0].init = gpio_led_init;
+  temp[0].onfunc = gpio_led_on;
+  temp[0].offfunc = gpio_led_off;
+	register_led_drv( 5 , &temp[0]);
+
+  /* Register led 7 GPIO_0 */
+  temp[1].param = GPIO_0;
+  temp[1].init = gpio_led_init;
+  temp[1].onfunc = gpio_led_on;
+  temp[1].offfunc = gpio_led_off;
+	register_led_drv( 7 , &temp[1]);
+#endif
+
+//wwzh #if defined(CONFIG_AR7RD)
+#if defined CONFIG_AR7WRD || defined CONFIG_AR7RD
+  /* Register led 5 Green PPPOE GPIO 13 */
+  temp[0].param = 13;
+  temp[0].init = gpio_led_init;
+  temp[0].onfunc = gpio_led_on;
+  temp[0].offfunc = gpio_led_off;
+	register_led_drv( 5 , &temp[0]);
+
+  /* Register led 7 Green USB GPIO 12 */
+  temp[1].param = 12;
+  temp[1].init = gpio_led_init;
+  temp[1].onfunc = gpio_led_on;
+  temp[1].offfunc = gpio_led_off;
+	register_led_drv( 7 , &temp[1]);
+
+  /* Register Device MAX_LED_ID + 1 for reset to factory default */
+  temp[2].param = 0;
+  temp[2].init = reset_init;
+  temp[2].onfunc = 0;
+  temp[2].offfunc = 0;
+	register_led_drv( MAX_LED_ID + 1 , &temp[2]);
+
+  /* Register led 8 RED DSL GPIO 10 */
+  temp[3].param = 10;
+  temp[3].init = gpio_led_init;
+  temp[3].onfunc = gpio_led_on;
+  temp[3].offfunc = gpio_led_off;
+	register_led_drv( 8 , &temp[3]);
+
+  /* Register led 9 RED PPPoE down GPIO 9 */
+  temp[4].param = 9;
+  temp[4].init = gpio_led_init;
+  temp[4].onfunc = gpio_led_on;
+  temp[4].offfunc = gpio_led_off;
+	register_led_drv( 9 , &temp[4]);
+
+  /* Register led 10 DSL down GPIO 8 */
+  temp[5].param = 8;
+  temp[5].init = gpio_led_init;
+  temp[5].onfunc = gpio_led_on;
+  temp[5].offfunc = gpio_led_off;
+	register_led_drv( 10 , &temp[5]);
+
+  /* Register led 11 Power GPIO 7 */
+  temp[6].param = 7;
+  temp[6].init = gpio_led_init;
+  temp[6].onfunc = gpio_led_on;
+  temp[6].offfunc = gpio_led_off;
+	register_led_drv( 11 , &temp[6]);
+
+  /* Register led 12 WiFi 6 */
+  temp[7].param = 6;
+  temp[7].init = gpio_led_init;
+  temp[7].onfunc = gpio_led_on;
+  temp[7].offfunc = gpio_led_off;
+	register_led_drv( 12 , &temp[7]);
+
+  /* Register led 13 ELINK(AA1313) GPIO 15 */
+  temp[8].param = 15;
+  temp[8].init = gpio_led_init;
+  temp[8].onfunc = gpio_led_on;
+  temp[8].offfunc = gpio_led_off;
+	register_led_drv( 13 , &temp[8]);
+
+  /* Register led 14 EACT(Y13) GPIO 16 */
+  temp[9].param = 16;
+  temp[9].init = gpio_led_init;
+  temp[9].onfunc = gpio_led_on;
+  temp[9].offfunc = gpio_led_off;
+	register_led_drv( 14 , &temp[9]);
+
+#endif
+/**************wwzh**************/
+#endif
+/**************end **************/
+  return;
+}
+
+
+
+
+
+
+
+
diff -urN linux.old/drivers/char/avalanche_led/ledmod.c linux.dev/drivers/char/avalanche_led/ledmod.c
--- linux.old/drivers/char/avalanche_led/ledmod.c	1970-01-01 01:00:00.000000000 +0100
+++ linux.dev/drivers/char/avalanche_led/ledmod.c	2005-07-22 06:52:42.975338336 +0200
@@ -0,0 +1,1116 @@
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/proc_fs.h>
+#include <asm/uaccess.h>
+#include <linux/fs.h>
+#include <linux/timer.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+#include <asm/ar7/avalanche_regs.h>
+#include <asm/ar7/ledapp.h>
+#include <linux/module.h>
+
+#define LED_ON  		1
+#define LED_OFF 		2
+#define LED_BLINK   3
+#define LED_FLASH		4
+
+#define LED_BLINK_UP   		5
+#define LED_BLINK_DOWN   	6
+
+extern void avalanche_leds_init(void);
+
+/***********wwzh**************/
+unsigned int sys_mod_state;
+unsigned int wan_mod_state;
+unsigned int wlan_mod_state;
+
+struct timer_list *pWanTimer = NULL;
+struct timer_list *pWlanTimer = NULL;
+/***********end **************/
+
+typedef struct state_entry{
+  unsigned char mode;
+  unsigned char led;
+	void (*handler)(struct state_entry *pState);
+  unsigned long param;
+}state_entry_t;
+
+typedef struct mod_entry{
+  state_entry_t *states[MAX_STATE_ID];
+}mod_entry_t;
+
+static mod_entry_t *modArr[MAX_MOD_ID];
+static struct proc_dir_entry *led_proc_dir,*led_file;
+
+/* index of the array is the led number HARDWARE SPECIFIC*/
+typedef struct led_data{
+	led_reg_t *led;
+  int				state;
+	struct timer_list *pTimer;
+	unsigned char timer_running;
+  unsigned long param;
+}led_data_t;
+
+led_data_t led_arr[MAX_LED_ID + 1];
+/*!!! The last device is actually being used for ar7 reset to factory default */
+
+
+static spinlock_t	config_lock;
+
+static void board_led_link_up( state_entry_t *pState );
+static void board_led_link_down( state_entry_t *pState );
+static void board_led_activity_on( state_entry_t *pState );
+static void board_led_activity_off( state_entry_t *pState );
+static void led_timer_func(unsigned long data);
+
+extern void board_gpio_init(void);
+extern void uart_led_init(void);
+
+static ssize_t proc_read_led_fops(struct file *filp,
+                                 char *buf,size_t count , loff_t *offp);
+static ssize_t proc_write_led_fops(struct file *filp,const char *buffer,
+                                                      size_t count , loff_t *offp);
+static int config_led( unsigned long y);
+
+struct file_operations led_fops = {
+                                     read: proc_read_led_fops,
+                                     write: proc_write_led_fops,
+                                   };
+
+static int led_atoi( char *name)
+{
+	int val = 0;
+  for(;;name++)
+	{
+		switch(*name)
+		{
+			case '0'...'9':
+				val = val*10+(*name - '0');
+				break;
+			default:
+				return val;
+		}
+	}
+}
+
+static int free_memory(void)
+{
+  int i, j;
+
+  for( i = 0; i < MAX_MOD_ID ; i++)
+	{
+		if( modArr[i] != NULL )
+		{
+			for( j = 0; j < MAX_STATE_ID ; j++ )
+			{
+				if( modArr[i]->states[j] != NULL )
+					kfree( modArr[i]->states[j]);
+			}
+			kfree(modArr[i]);
+      modArr[i] = NULL;
+		}
+	}
+  return 0;
+}
+
+static int led_on( state_entry_t *pState )
+{
+	if( led_arr[pState->led].led == NULL)
+		return -1;
+  led_arr[pState->led].led->onfunc( led_arr[pState->led].led->param);
+  return 0;
+}
+
+static int led_off( state_entry_t *pState )
+{
+	if( led_arr[pState->led].led == NULL)
+		return -1;
+  led_arr[pState->led].led->offfunc( led_arr[pState->led].led->param);
+  return 0;
+}
+
+static void board_led_link_up( state_entry_t *pState )
+{
+  led_arr[pState->led].state = LED_ON;
+  if( led_arr[pState->led].timer_running == 0 )
+  	led_on(pState);
+  return;
+}
+
+static void board_led_link_down( state_entry_t *pState )
+{
+	led_arr[pState->led].state = LED_OFF;
+  if( led_arr[pState->led].timer_running == 0 )
+  	led_off(pState);
+  return;
+}
+
+static void add_led_timer(state_entry_t *pState)
+{
+	led_arr[pState->led].pTimer->expires = jiffies + HZ*(pState->param)/1000;
+  led_arr[pState->led].param = pState->param;
+  led_arr[pState->led].pTimer->data = pState;
+	add_timer (led_arr[pState->led].pTimer);
+}
+
+static void board_led_activity_on(state_entry_t *pState)
+{
+  if(led_arr[pState->led].timer_running == 0)
+	{
+		led_on(pState);
+		add_led_timer(pState);
+	  led_arr[pState->led].timer_running = 1;
+	  led_arr[pState->led].state = LED_BLINK_UP;
+	}
+	else if( led_arr[pState->led].timer_running > 0xF0)
+	{
+	  led_arr[pState->led].state = LED_BLINK_UP;
+		led_arr[pState->led].pTimer->expires = jiffies + HZ*(pState->param)/1000;
+  	led_arr[pState->led].param = pState->param;
+  	led_arr[pState->led].pTimer->data = pState;
+	}
+	return;
+}
+
+static void board_led_activity_off(state_entry_t *pState)
+{
+  if(led_arr[pState->led].timer_running == 0)
+	{
+		led_off(pState);
+		add_led_timer(pState);
+	  led_arr[pState->led].timer_running = 1;
+	  led_arr[pState->led].state = LED_BLINK_UP;
+	}
+	else if( led_arr[pState->led].timer_running > 0xF0)
+	{
+	  led_arr[pState->led].state = LED_BLINK_UP;
+		led_arr[pState->led].pTimer->expires = jiffies + HZ*(pState->param)/1000;
+  	led_arr[pState->led].param = pState->param;
+  	led_arr[pState->led].pTimer->data = pState;
+	}
+	return;
+}
+
+static void board_led_link_flash(state_entry_t *pState)
+{
+  if(led_on(pState))
+		return;
+  if(led_arr[pState->led].timer_running == 0)
+		add_led_timer(pState);
+	else
+    led_arr[pState->led].param = pState->param;
+  led_arr[pState->led].timer_running = 0xFF;
+	led_arr[pState->led].state = LED_FLASH;
+	return;
+}
+
+static void led_timer_func(unsigned long data)
+{
+	state_entry_t *pState = NULL;
+  mod_entry_t *pMod = NULL;
+	unsigned int flags;
+
+	spin_lock_irqsave(&config_lock, flags);
+
+  pState = (state_entry_t *)data;
+
+  if( led_arr[pState->led].state == LED_BLINK_DOWN )
+	{
+		led_arr[pState->led].timer_running = 0;
+		if( pState->mode == 2 )
+			led_arr[pState->led].state = LED_OFF;
+		else
+			led_arr[pState->led].state = LED_ON;
+	}
+  else if( led_arr[pState->led].state == LED_BLINK_UP )
+	{
+    led_arr[pState->led].pTimer->expires = jiffies + HZ*(led_arr[pState->led].param)/1000;
+  	led_arr[pState->led].pTimer->data = pState;
+		add_timer (led_arr[pState->led].pTimer);
+		if( pState->mode == 2 )
+		{
+  		led_off(pState);
+			led_arr[pState->led].state = LED_BLINK_DOWN;
+		}
+		else
+		{
+  		led_on(pState);
+			led_arr[pState->led].state = LED_BLINK_DOWN;
+		}
+		led_arr[pState->led].timer_running = 1;
+	}
+  else if( led_arr[pState->led].state == LED_FLASH )
+	{
+    led_arr[pState->led].pTimer->expires = jiffies + HZ*(led_arr[pState->led].param)/1000;
+  	led_arr[pState->led].pTimer->data = pState;
+		add_timer (led_arr[pState->led].pTimer);
+
+		if( led_arr[pState->led].timer_running == 0xFF )
+		{
+  		led_off(pState);
+			led_arr[pState->led].timer_running--;
+		}
+		else
+		{
+  		led_on(pState);
+			led_arr[pState->led].timer_running++;
+		}
+		spin_unlock_irqrestore(&config_lock, flags);
+    return;
+	}
+  else if(led_arr[pState->led].state == LED_OFF)
+	{
+  	led_off(pState);
+    led_arr[pState->led].timer_running = 0;
+	}
+	else if( led_arr[pState->led].state == LED_ON )
+	{
+  	led_on(pState);
+    led_arr[pState->led].timer_running = 0;
+	}
+	spin_unlock_irqrestore(&config_lock, flags);
+  return;
+}
+/************wwzh*****************/
+#if 0
+/************end *****************/
+static ssize_t proc_read_led_fops(struct file *filp,
+                                 char *buf,size_t count , loff_t *offp)
+{
+  char * pdata = NULL;
+  int i = 0, j = 0, len = 0, totallen = 0;
+  char line[255];
+
+  if( *offp != 0 )
+  	return 0;
+
+  pdata = buf;
+  len += sprintf(line,"LEDS Registered for use are:");
+  for( i = 0; i< MAX_LED_ID; i++)
+		if( led_arr[i].led != NULL )
+			len += sprintf(&line[len]," %d ", i );
+  line[len++] = '\n';
+
+  copy_to_user(pdata, line,len );
+  pdata += len;
+  totallen += len;
+  len = 0;
+  len = sprintf(line,"USER MODULE INFORMATION:\n");
+  copy_to_user(pdata, line,len );
+  pdata += len;
+  totallen += len;
+  len = 0;
+  for( i = 0; i< MAX_MOD_ID; i++)
+	{
+		if( modArr[i] != NULL )
+		{
+			len = sprintf(line,"  Module ID = %d \n" , i);
+  		copy_to_user(pdata, line,len );
+      pdata += len;
+  		totallen += len;
+  		len = 0;
+ 			for( j = 0; j < MAX_STATE_ID; j++)
+			{
+				if( modArr[i]->states[j] != NULL)
+				{
+					len = sprintf(line ,
+                		"    State = %d , Led = %d," , j , modArr[i]->states[j]->led);
+  				copy_to_user(pdata, line,len );
+          pdata += len;
+  				totallen += len;
+
+  				len = 0;
+          switch( modArr[i]->states[j]->mode )
+					{
+						case 1:
+									len = sprintf(line ," Mode = OFF\n");
+									break;
+						case 2:
+									len = sprintf(line ," Mode = BLINK_ON , On Time(ms) = %d\n" ,
+                                       (unsigned int)modArr[i]->states[j]->param);
+									break;
+						case 3:
+									len = sprintf(line ," Mode = BLINK_OFF , Off Time(ms) = %d\n" ,
+                                       (unsigned int)modArr[i]->states[j]->param);
+									break;
+						case 4:
+									len = sprintf(line ," Mode = ON \n");
+									break;
+						case 5:
+									len = sprintf(line ," Mode = FLASH , Time Period(ms) = %d\n" ,
+                                       (unsigned int)modArr[i]->states[j]->param);
+									break;
+						default:
+							break;
+
+					}
+  				copy_to_user(pdata, line,len );
+          pdata += len;
+  				totallen += len;
+
+  				len = 0;
+				}
+			}
+		}
+	}
+  /* Return with configuration information for LEDs */
+	*offp = totallen;
+	return totallen;
+}
+static ssize_t proc_write_led_fops(struct file *filp,const char *buffer,
+                                                      size_t count , loff_t *offp)
+{
+  char *pdata = NULL, *ptemp = NULL;
+  char line[10],temp[10];
+  int i = 0;
+  int mod = 0xFFFF , state = 0xFFFF;
+  int flag = 0;
+
+  /* Check if this write is for configuring stuff */
+  if( *(int *)(buffer) == 0xFFEEDDCC )
+	{
+    printk("<1>proc write:Calling Configuration\n");
+		config_led((unsigned long)(buffer + sizeof(int)) );
+		return count;
+	}
+
+  if( count >= 10)
+	{
+    printk("<1>proc write:Input too long,max length = %d\n",10);
+    return count;
+	}
+  memset( temp, 0x00 , 10);
+  memset( line, 0x00 , 10);
+  copy_from_user(line,buffer,count);
+  line[count] = 0x00;
+  pdata = line;
+  ptemp = temp;
+  while( flag == 0)
+  {
+		if( i > 10 )
+			break;
+		if( ((*pdata) >= '0' ) && ((*pdata) <= '9') )
+		{	
+			*ptemp = *pdata ;
+			ptemp++;
+		}	
+		else if( (*pdata) == ',' )
+		{
+      *ptemp = 0x00;
+			flag = 1;
+		}	
+		pdata++;
+		i++;
+  };
+	if( flag == 1)
+  	mod = led_atoi( temp);
+	else
+		return count;
+		
+  ptemp = temp;
+  *ptemp = 0x00;
+  flag = 0;
+  while( flag == 0)
+  {
+		if( i > 10 )
+			break;
+		if( ((*pdata) >= '0' ) && ((*pdata) <= '9') )
+		{	
+			*ptemp = *pdata ;
+			ptemp++;
+		}	
+		else if( (*pdata) == 0x00 )
+		{
+      *ptemp = 0x00;
+			flag = 1;
+		}	
+		pdata++;
+    i++;
+  };
+	if( flag == 1)
+  	state = led_atoi( temp);
+	else
+		return count;
+  if( (mod == 0xFFFF) || (state == 0xFFFF))
+		return count;
+  else
+    led_operation( mod , state );
+  return count;
+}
+
+/************wwzh*******************/
+#else
+
+#define TRUE 1
+#define FALSE 0
+#define FLICK_TIME (HZ*100/1000)
+static unsigned int wan_txrx_state = 0;
+static unsigned int wlan_txrx_state = 0;
+
+void led_operation( int mod , int state)
+{
+
+	unsigned int flags;
+
+	spin_lock_irqsave(&config_lock, flags);
+
+	if( (mod >= MAX_MOD_ID) || ( state >= MAX_STATE_ID) )
+	{
+	  spin_unlock_irqrestore(&config_lock, flags);
+		return;
+	}
+ 	if ( modArr[mod] == NULL )
+	{
+	  spin_unlock_irqrestore(&config_lock, flags);
+		return;
+	}
+	if( modArr[mod]->states[state] == NULL )
+	{
+	  spin_unlock_irqrestore(&config_lock, flags);
+		return;
+	}
+  /* Call the function handler  */
+  modArr[mod]->states[state]->handler(modArr[mod]->states[state]);
+
+	spin_unlock_irqrestore(&config_lock, flags);
+}
+
+static void wan_led_func(unsigned long data)
+{
+	if (wan_txrx_state == 0)
+	{
+		tnetd73xx_gpio_out(2, TRUE);
+		tnetd73xx_gpio_out(3, FALSE);
+		wan_txrx_state = 1;
+	}
+	else
+	{
+		tnetd73xx_gpio_out(2, FALSE);
+		tnetd73xx_gpio_out(3, FALSE);
+		wan_txrx_state = 0;
+	}
+	pWanTimer->expires = jiffies + FLICK_TIME;
+	add_timer(pWanTimer);
+}
+//wwzh for wireless
+#if 0
+static void wlan_led_func(unsigned long data)
+{
+	if (wlan_txrx_state == 0)
+	{
+		tnetd73xx_gpio_out(12, TRUE);
+		tnetd73xx_gpio_out(13, FALSE);
+		wlan_txrx_state = 1;
+	}
+	else
+	{
+		tnetd73xx_gpio_out(12, FALSE);
+		tnetd73xx_gpio_out(13, FALSE);
+		wlan_txrx_state = 0;
+		
+	}
+	pWlanTimer->expires = jiffies + FLICK_TIME;
+	add_timer(pWlanTimer);
+}
+#endif
+
+void led_active(int mod, int state)
+{
+	unsigned int flags = 0;
+
+//printk("mod = %d state = %d\n", mod, state);
+	spin_lock_irqsave(&config_lock, flags);
+	if ((mod >= 5) || (state >= 5))
+	{
+		spin_unlock_irqrestore(&config_lock, flags);
+		return;
+	}
+	
+	switch (mod)
+	{
+		case 2: /*system led */
+			sys_mod_state = state;
+			switch (state)
+			{
+				case 1:	
+					break;
+				case 2:  /*sys led flashing green */
+					tnetd73xx_gpio_out(4, FALSE);
+					tnetd73xx_gpio_out(5, TRUE);
+					tnetd73xx_gpio_out(8, TRUE);
+					break;
+				case 3: /*sys led solid green */
+					tnetd73xx_gpio_out(4, TRUE);
+					tnetd73xx_gpio_out(5, TRUE);
+					tnetd73xx_gpio_out(8, TRUE);
+					
+					break;
+				case 4: /*sys fail red */
+					tnetd73xx_gpio_out(4, TRUE);
+					tnetd73xx_gpio_out(5, FALSE);
+					tnetd73xx_gpio_out(8, FALSE);
+					break;
+				default:
+					break;
+			}
+			break;
+		case 3: /*wan led */
+			wan_mod_state = state;
+			switch (state)
+			{
+				case 1: /*no wan interface*/
+					if (pWanTimer)
+					{
+						del_timer(pWanTimer);
+						kfree(pWanTimer);
+						pWanTimer = NULL;
+					}
+					tnetd73xx_gpio_out(2, FALSE);
+					tnetd73xx_gpio_out(3, FALSE);
+					break;
+				case 2: /*wan connected */
+					if (pWanTimer)
+					{
+						del_timer(pWanTimer);
+						kfree(pWanTimer);
+						pWanTimer = NULL;
+					}
+					tnetd73xx_gpio_out(2, TRUE);
+					tnetd73xx_gpio_out(3, FALSE);
+					break;
+				case 3: /*rx/tx activity */
+					if (pWanTimer != NULL)
+						break;	
+				
+					pWanTimer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
+					init_timer(pWanTimer);
+					
+					pWanTimer->function = wan_led_func;
+					pWanTimer->data = 0;
+					pWanTimer->expires = jiffies + FLICK_TIME;
+					tnetd73xx_gpio_out(2, FALSE);
+					tnetd73xx_gpio_out(3, FALSE);
+					wan_txrx_state = 0;
+					add_timer(pWanTimer);
+
+					break;
+				case 4: /*no ipaddress */
+					if (pWanTimer)
+					{
+						del_timer(pWanTimer);
+						kfree(pWanTimer);
+						pWanTimer = NULL;
+					}
+					tnetd73xx_gpio_out(2, FALSE);
+					tnetd73xx_gpio_out(3, TRUE);
+					break;
+				default:
+					if (pWanTimer)
+					{	
+						del_timer(pWanTimer);
+						kfree(pWanTimer);
+						pWanTimer = NULL;
+					}
+					break;
+			}
+			break;
+	//wwzh for wireless 
+	#if 0
+		case 4: /*wlan led */
+			wlan_mod_state = state;
+			switch (state)
+			{
+				case 1: /* wlan off */
+					if (pWlanTimer)
+					{
+						del_timer(pWlanTimer);
+						kfree(pWlanTimer);
+						pWlanTimer = NULL;
+					}
+					tnetd73xx_gpio_out(12, FALSE);
+					tnetd73xx_gpio_out(13, FALSE);
+					break;
+				case 2: /* wlan ready */
+					if (pWlanTimer)
+					{
+						del_timer(pWlanTimer);
+						kfree(pWlanTimer);
+						pWlanTimer = NULL;
+					}
+					tnetd73xx_gpio_out(12, TRUE);
+					tnetd73xx_gpio_out(13, FALSE);
+					break;
+				case 3: /* wlan rx/tx activity */
+					if (pWlanTimer != NULL)
+						break;
+					
+					pWlanTimer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
+					init_timer(pWlanTimer);
+					
+					pWlanTimer->function = wlan_led_func;
+					pWlanTimer->data = 0;
+					pWlanTimer->expires = jiffies + FLICK_TIME;
+					tnetd73xx_gpio_out(12, FALSE);
+					tnetd73xx_gpio_out(13, FALSE);
+					wlan_txrx_state = 0;
+					add_timer(pWlanTimer);
+					
+					break;
+				default:
+					if (pWlanTimer)
+					{
+						del_timer(pWlanTimer);
+						kfree(pWlanTimer);
+						pWlanTimer = NULL;
+					}
+					
+					break;
+			}
+			break;
+	#endif //for wireless
+		default:
+			break;
+	}
+	spin_unlock_irqrestore(&config_lock, flags);
+}
+static ssize_t proc_read_led_fops(struct file *filp,
+                                 char *buf,size_t count , loff_t *offp)
+{
+	char *pdata = NULL;
+	int i = 0, j = 0, len = 0, totallen = 0;
+	char line[255];
+	
+	if (*offp != 0)
+		return 0;
+	pdata = buf;
+	len = sprintf(line, "USER MODULE INFORMATION:\n");
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+	
+	//*******add Module 1 , this Module is ADSL ********/
+	for (i = 0; i < MAX_MOD_ID; i++)
+	{
+		if (modArr[i] != NULL)
+		{
+			len = sprintf(line, " Module ID = %d\n", i);
+			copy_to_user(pdata, line, len);
+			pdata += len;
+			totallen += len;
+			len = 0;
+			for(j = 0; j < MAX_STATE_ID; j++)
+			{
+				if (modArr[i]->states[j] != NULL)
+				{
+					len = sprintf(line, "State =%d, Led = %d,", j, modArr[i]->states[j]->led);
+					copy_to_user(pdata, line, len);
+					pdata += len;
+					totallen += len;
+					len = 0;
+					switch(modArr[i]->states[j]->mode)
+					{
+					  case 1:
+				            len = sprintf(line, "Mode = OFF\n");
+					    break;
+					  case 2:
+					    len = sprintf(line, "Mode = BLINK_ON, On Time(ms) = %d\n", (unsigned int)modArr[i]->states[j]->param);	
+					    break;
+					  case 3:
+					    len = sprintf(line, "Mode = BLINK_OFF, Off Time(ms) = %d\n", (unsigned int)modArr[i]->states[j]->param);
+					    break;
+					  case 4:
+					    len = sprintf(line, "Mode = On\n");
+					    break;
+					  case 5:
+					    len = sprintf(line, "Mode = FLASH, Time Period(ms) = %d\n", (unsigned int)modArr[i]->states[j]->param);
+					    break;
+					  default:
+					    break;		
+					}
+					copy_to_user(pdata, line, len);
+					pdata += len;
+					totallen += len;
+					len = 0;
+				}
+			} 
+		}
+
+	}
+
+	len = sprintf(line, "Module ID = 2(system led)\n");
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+	switch(sys_mod_state)
+	{
+		case 1:
+			len = sprintf(line, "State = OFF\n");
+			break;
+		case 2:	
+			len = sprintf(line, "State = Booting\n");
+			break;
+		case 3:
+			len = sprintf(line, "State = System Ready\n");
+			break;
+		case 4:
+			len = sprintf(line, "State = System Failure\n");
+			break;
+		default:
+			break;
+	}
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+	
+	len = sprintf(line, "Module ID = 3(WAN led)\n");
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+	switch(wan_mod_state)
+	{
+		case 1:
+			len = sprintf(line, "State = OFF\n");
+			break;
+		case 2:
+			len = sprintf(line, "State = Wan Connected\n");
+			break;
+		case 3:
+			len = sprintf(line, "State = Wan Tx/Rx Activity\n");
+			break;
+		case 4:
+			len = sprintf(line, "State = Wan Connect Failure\n");
+			break;
+		default:
+			break;
+	}
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+
+//wwzh for wireless
+#if 0
+	len = sprintf(line, "Module ID = 4(WLAN led)\n");
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+	switch(wlan_mod_state)
+	{
+		case 1:
+			len = sprintf(line, "State = OFF\n");
+			break;
+		case 2:
+			len = sprintf(line, "State = wlan Ready\n");
+			break;
+		case 3:
+			len = sprintf(line, "State = wlan rx/tx activity\n");
+			break;
+		default:
+			break; 
+	}
+	copy_to_user(pdata, line, len);
+	pdata += len;
+	totallen += len;
+	len = 0;
+#endif //for wireless
+	
+	*offp = totallen;
+	return totallen;
+}
+static ssize_t proc_write_led_fops(struct file *filp,const char *buffer,
+                                               size_t count , loff_t *offp)
+{
+	char *pdata = NULL, *ptemp = NULL;
+	char line[10], temp[10];
+	int i = 0;
+	int mod = 0xffff, state = 0xffff;
+	int flag = 0;
+
+ 	 /* Check if this write is for configuring ADSL */
+  	if( *(int *)(buffer) == 0xFFEEDDCC )
+	{
+   		 printk("<1>proc write:Calling Configuration\n");
+		 config_led((unsigned long)(buffer + sizeof(int)) );
+		 return count;
+	}
+
+	if (count > 10)
+	{
+		printk("<1> proc write: Input too long, max length = 10\n");
+		return count;
+	}
+	memset(temp, 0x00, 10);
+	memset(line, 0x00, 10);
+	copy_from_user(line, buffer, count);
+	line[count] = 0x00;
+	pdata = line;
+	ptemp = temp;	
+	
+	while (flag == 0)
+	{
+		if (i > 10)
+			break;
+		if (((*pdata) >= '0') && ((*pdata) <= '9'))
+		{
+			*ptemp = *pdata;
+			ptemp++;
+		}
+		else if ((*pdata) == ',')
+		{
+			*ptemp = 0x00;
+			flag = 1;
+		}
+		pdata++;
+		i++;
+	}
+	if (flag == 1)
+		mod = led_atoi(temp);
+	else
+		return count;
+	
+	ptemp = temp;
+	*ptemp = 0x00;
+	flag = 0;
+	
+	while(flag == 0)
+	{
+		if (i > 10)
+			break;
+		if (((*pdata) >= '0') && ((*pdata) <= '9'))
+		{
+			*ptemp = *pdata;
+			ptemp++;
+		}
+		else if ((*pdata) == 0x00)
+		{
+			*ptemp = 0x00;
+			flag = 1;
+		}
+		pdata++;
+		i++;
+	}
+	if (flag == 1)
+		state = led_atoi(temp);
+	else
+		return count;
+	if ((mod == 0xFFFF) || (state == 0xFFFF))
+		return count;
+	else
+	{
+		if (mod != 4)
+			led_active(mod, state);	
+		else 
+			led_operation(mod, state);
+	} 
+	return 1;
+}
+#endif
+/************end *******************/
+static int config_led(unsigned long y)
+{
+  config_elem_t *pcfg = NULL;
+  char *pdata = NULL;
+  int i;
+  int length = 0 , number = 0;
+	unsigned int flags;
+
+	spin_lock_irqsave(&config_lock, flags);
+
+    /* ioctl to configure */
+    length =  *((int*)y);
+    pdata = (char *)y + sizeof(int);
+    number =  (length - sizeof(int))/sizeof(config_elem_t);
+    pcfg = (config_elem_t *)(pdata);
+
+    /* Check if an earlier configuration exists IF yes free it up */
+    free_memory();
+
+    for ( i = 0 ; i < number ; i++ )
+    {
+			/* If no structure has been allocated for the module do so */
+      if ( modArr[pcfg->name] == NULL )
+			{
+					printk("<1>module =  %d\n",pcfg->name);
+        if( pcfg->name >= MAX_MOD_ID)
+				{
+					printk("<1>Exiting Configuration: Module ID too large %d\n",pcfg->name);
+					free_memory();
+					spin_unlock_irqrestore(&config_lock, flags);
+					return -1;
+				}
+        modArr[pcfg->name] = kmalloc(sizeof(mod_entry_t),GFP_KERNEL);
+        if(modArr[pcfg->name] == NULL)
+				{
+					printk("<1>Exiting Configuration: Error in allocating memory\n");
+					free_memory();
+					spin_unlock_irqrestore(&config_lock, flags);
+					return -1;
+				}
+				memset( modArr[pcfg->name], 0x00, sizeof(mod_entry_t));
+			}
+
+      /* if no structure is allocated previously for this state
+         allocate a structure, if it's already there fill it up */
+			if( modArr[pcfg->name]->states[pcfg->state] == NULL)
+			{
+					printk("<1>STATE =  %d\n",pcfg->state);
+				if( pcfg->state >= MAX_STATE_ID)
+				{
+					printk("<1>Exiting Configuration: State ID too large\n");
+					free_memory();
+					spin_unlock_irqrestore(&config_lock, flags);
+					return -1;
+				}
+				modArr[pcfg->name]->states[pcfg->state] =
+                        kmalloc(sizeof(state_entry_t),GFP_KERNEL);
+				if( modArr[pcfg->name]->states[pcfg->state] == NULL)
+				{
+					free_memory();
+					spin_unlock_irqrestore(&config_lock, flags);
+					return -1;
+				}
+				memset( modArr[pcfg->name]->states[pcfg->state], 0x00, sizeof(state_entry_t));
+			}
+			/* Fill up the fields of the state */
+      if( pcfg->led >= MAX_LED_ID)
+			{
+				printk("<1>led =  %d\n",pcfg->led);
+				free_memory();
+				spin_unlock_irqrestore(&config_lock, flags);
+				return -1;
+			}
+      modArr[pcfg->name]->states[pcfg->state]->led = pcfg->led;
+      modArr[pcfg->name]->states[pcfg->state]->mode = pcfg->mode;
+      modArr[pcfg->name]->states[pcfg->state]->param = pcfg->param;
+			switch(pcfg->mode)
+			{
+				case 1:
+      		modArr[pcfg->name]->states[pcfg->state]->handler = board_led_link_down;
+					break;
+				case 2:
+				case 3:
+				case 5:
+					if( pcfg->mode == 2 )
+						modArr[pcfg->name]->states[pcfg->state]->handler = board_led_activity_on;
+					else if( pcfg->mode == 3)
+      			modArr[pcfg->name]->states[pcfg->state]->handler = board_led_activity_off;
+					else
+		        modArr[pcfg->name]->states[pcfg->state]->handler = board_led_link_flash;
+					break;
+				case 4:
+      		modArr[pcfg->name]->states[pcfg->state]->handler = board_led_link_up;
+					break;
+				default:
+				  printk("<1>Exiting Configuration: Unknown LED Mode\n");
+					free_memory();
+					spin_unlock_irqrestore(&config_lock, flags);
+					return -1;
+			}
+			pcfg++;			
+    }
+	spin_unlock_irqrestore(&config_lock, flags);
+  return 0;
+}
+
+
+int __init led_init(void)
+{
+
+  /* Clear our memory */
+  memset(modArr,0x00,sizeof(mod_entry_t *)*MAX_MOD_ID);
+  memset(led_arr,0x00,sizeof(led_data_t *)*MAX_LED_ID);
+
+	/* Create spin lock for config data structure */
+	config_lock=SPIN_LOCK_UNLOCKED;
+
+  /* Create directory */
+  led_proc_dir = proc_mkdir("led", NULL);
+  if( led_proc_dir == NULL )
+    goto out;
+
+  /* Create adsl file */
+  led_file = create_proc_entry("led", 0777, led_proc_dir);
+  if( led_file == NULL)
+    goto led_file;
+  led_file->owner = THIS_MODULE;
+  led_file->proc_fops = &led_fops;
+
+  memset( modArr , 0x00 , sizeof(mod_entry_t *) * MAX_MOD_ID);
+	/* Reset the GPIO pins  */
+  board_gpio_init();
+
+	/* Register the UART controlled LEDS  */
+  uart_led_init();
+  /* Create the usb proc file */
+	avalanche_leds_init();
+  return 0;
+
+  led_file:
+    remove_proc_entry("led",led_proc_dir);
+  out:
+    return 0;
+
+}
+
+void led_exit()
+{
+	remove_proc_entry("led", led_proc_dir);
+}
+
+module_init(led_init);
+module_exit(led_exit);
+
+void register_led_drv( int device , led_reg_t *pInfo)
+{
+	unsigned int flags;
+	struct timer_list *pTimer = NULL;
+
+	spin_lock_irqsave(&config_lock, flags);
+
+	led_arr[device].led = pInfo;
+	if( led_arr[device].led->init != 0x00)
+      led_arr[device].led->init(led_arr[device].led->param);
+	if( led_arr[device].led->offfunc != 0x00)
+      led_arr[device].led->offfunc(led_arr[device].led->param);
+
+	/* Create a timer for blinking   */
+  pTimer = kmalloc(sizeof(struct timer_list),GFP_KERNEL);
+	init_timer( pTimer );
+	pTimer->function = led_timer_func;
+	pTimer->data = 0;
+  led_arr[device].pTimer = pTimer;
+  led_arr[device].timer_running = 0;
+
+	spin_unlock_irqrestore(&config_lock, flags);
+
+  return;
+}
+
+void deregister_led_drv( int device)
+{
+	unsigned int flags;
+
+	spin_lock_irqsave(&config_lock, flags);
+	led_arr[device].led = NULL;
+
+	if( led_arr[device].pTimer != NULL)
+	{
+		del_timer(led_arr[device].pTimer);
+		kfree(led_arr[device].pTimer);
+	}
+	spin_unlock_irqrestore(&config_lock, flags);
+
+  return;
+}
+
+EXPORT_SYMBOL_NOVERS(led_operation);
+EXPORT_SYMBOL_NOVERS(register_led_drv);
+EXPORT_SYMBOL_NOVERS(deregister_led_drv);
+
diff -urN linux.old/drivers/char/avalanche_led/leds.c linux.dev/drivers/char/avalanche_led/leds.c
--- linux.old/drivers/char/avalanche_led/leds.c	1970-01-01 01:00:00.000000000 +0100
+++ linux.dev/drivers/char/avalanche_led/leds.c	2005-07-22 06:52:42.976338184 +0200
@@ -0,0 +1,133 @@
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <asm/ar7/avalanche_regs.h>
+#include <linux/spinlock.h>
+#include <linux/timer.h>
+#include <linux/sched.h>
+#include <linux/module.h>
+#include <linux/proc_fs.h>
+#include <asm/uaccess.h>
+#include <linux/fs.h>
+
+#include <asm/ar7/ledapp.h>
+
+#if defined(CONFIG_AR5D01) || defined(CONFIG_AR5W01) || defined(CONFIG_AR7)
+
+#define ETH_MASK 0x01
+#define USB_MASK 0x02
+
+static struct proc_dir_entry *usb_file;
+static ssize_t proc_read_usb_fops(struct file *filp,
+                                 char *buf,size_t count , loff_t *offp);
+struct file_operations usb_fops = {read: proc_read_usb_fops};
+
+typedef struct mod_states{
+  int module;
+  int activity;
+  int linkup;
+  int idle;
+}mod_states_t;
+
+mod_states_t state_arr[] = {
+                          	{ MOD_ETH,DEF_ETH_ACTIVITY,DEF_ETH_LINK_UP,DEF_ETH_IDLE },
+                          	{ MOD_USB,DEF_USB_ACTIVITY,DEF_USB_LINK_UP,DEF_USB_IDLE },
+                          	{ MOD_LAN,DEF_LAN_ACTIVITY,DEF_LAN_LINK_UP,DEF_LAN_IDLE }
+                        	};
+
+unsigned char	device_links = 0;	/* Bitmask with the devices that are up */
+
+
+void avalanche_led_activity_pulse(unsigned long device)
+{
+	/* If device link is not up return */
+  if( !(device_links & (unsigned char)(1 << device)))
+		return;
+#ifdef MULTIPLEX_LED
+	led_operation( state_arr[2].module, state_arr[2].activity);
+#else
+	led_operation( state_arr[device].module, state_arr[device].activity);
+#endif
+}
+
+void avalanche_led_link_up( unsigned long device )
+{
+	
+  /* If already UP ignore */
+  if( device_links & (unsigned char)(1 << device))
+		return;
+  /* Turn on the bit for the device */
+	device_links |= (unsigned char)(1 << device);
+#ifdef MULTIPLEX_LED
+	led_operation( state_arr[2].module, state_arr[2].linkup);
+#else
+	led_operation( state_arr[device].module, state_arr[device].linkup);
+#endif
+}
+
+void avalanche_led_link_down ( unsigned long device )
+{
+
+  /* If already DOWN ignore */
+  if( !(device_links & (unsigned char)(1 << device)))
+		return;
+
+	/* Turn off the bit for the device */
+	device_links &= ~(unsigned char)(1 << device);
+#ifdef MULTIPLEX_LED
+	/* If no links, then shut the LED off  */
+	if(!device_links)
+		led_operation( state_arr[2].module, state_arr[2].idle);
+#else
+	led_operation( state_arr[device].module, state_arr[device].idle);
+#endif
+}
+
+static ssize_t proc_read_usb_fops(struct file *filp,
+                                 char *buf,size_t count , loff_t *offp)
+{
+  char * pdata = NULL;
+  char line[3];
+  if( *offp != 0 )
+  	return 0;
+  pdata = buf;
+  if( device_links & USB_MASK)
+  	sprintf(line,"%s\n","1");
+  else
+  	sprintf(line,"%s\n","0");
+  copy_to_user(pdata,line,2);
+	*offp = 2;
+	return 2;
+}
+
+
+void avalanche_leds_init(void)
+{
+  /* Create usb link proc file */
+  usb_file = create_proc_entry("avalanche/usb_link", 0444, NULL);
+  if( usb_file == NULL)
+    return;
+  usb_file->owner = THIS_MODULE;
+  usb_file->proc_fops = &usb_fops;
+	return;
+}
+
+EXPORT_SYMBOL(avalanche_led_activity_pulse);
+EXPORT_SYMBOL(avalanche_led_link_up);
+EXPORT_SYMBOL(avalanche_led_link_down);
+
+#else
+/* We make a dummy init routine for the platforms that do not support this led
+   API
+*/
+
+void avalanche_leds_init(void)
+{
+}
+
+#endif
+
+
+
+
+
diff -urN linux.old/drivers/char/avalanche_led/Makefile linux.dev/drivers/char/avalanche_led/Makefile
--- linux.old/drivers/char/avalanche_led/Makefile	1970-01-01 01:00:00.000000000 +0100
+++ linux.dev/drivers/char/avalanche_led/Makefile	2005-07-22 06:52:42.977338032 +0200
@@ -0,0 +1,23 @@
+# File: drivers/char/avalanche_led/Makefile
+#
+# Makefile for the Linux LED device driver.
+#
+
+
+O_TARGET := avalanche_led.o
+obj-m := avalanche_led.o
+list-multi      := avalanche_led.o
+
+EXTRA_CFLAGS := -I$(TOPDIR)/include/asm/ar7
+
+export-objs := ledmod.o leds.o
+
+avalanche_led-objs := ledmod.o gpio.o uartled.o leds.o
+
+include $(TOPDIR)/Rules.make
+
+avalanche_led.o:      $(avalanche_led-objs)
+	$(LD) -r -o $@ $(avalanche_led-objs)
+
+clean:
+	rm -f core *.o *.a *.s
diff -urN linux.old/drivers/char/avalanche_led/uartled.c linux.dev/drivers/char/avalanche_led/uartled.c
--- linux.old/drivers/char/avalanche_led/uartled.c	1970-01-01 01:00:00.000000000 +0100
+++ linux.dev/drivers/char/avalanche_led/uartled.c	2005-07-22 06:52:42.977338032 +0200
@@ -0,0 +1,55 @@
+#include <linux/kernel.h>
+#include <asm/uaccess.h>
+#include <linux/spinlock.h>
+#include <asm/ar7/avalanche_regs.h>
+#include <asm/ar7/ledapp.h>
+
+#define UART_LED_REG  (*(volatile unsigned int *)(UARTA_BASE + 0x10))
+
+static spinlock_t	device_lock;
+led_reg_t temp1[2];
+
+static void uart_led_on(unsigned long param)
+{
+  unsigned long flags;
+
+  spin_lock_irqsave(&device_lock,flags);
+  UART_LED_REG &= 0xFFFD;
+  spin_unlock_irqrestore(&device_lock, flags);
+}
+
+static void uart_led_off ( unsigned long param )
+{
+   unsigned int flags = 0x00;
+   spin_lock_irqsave(&device_lock, flags);
+   UART_LED_REG |= 0x02;
+	spin_unlock_irqrestore(&device_lock, flags);
+}
+
+void uart_led_init(void)
+{
+
+#if defined(CONFIG_AR5D01)
+  /* Register led 6 UART Pin 1 */
+  temp1[0].param = 0;
+  temp1[0].init = NULL;
+  temp1[0].onfunc = uart_led_on;
+  temp1[0].offfunc = uart_led_off;
+	register_led_drv( 6 , &temp1[0]);
+#endif
+
+#if defined(CONFIG_AR5W01)
+  /* Register led 8 UART Pin 1 */
+  temp1[0].param = 0;
+  temp1[0].init = NULL;
+  temp1[0].onfunc = uart_led_on;
+  temp1[0].offfunc = uart_led_off;
+	register_led_drv( 8 , &temp1[0]);
+#endif
+
+	/* Initialize the link mask */
+	device_lock = SPIN_LOCK_UNLOCKED;
+
+  return;
+}
+
diff -urN linux.old/drivers/char/Config.in linux.dev/drivers/char/Config.in
--- linux.old/drivers/char/Config.in	2005-07-10 20:53:55.650624000 +0200
+++ linux.dev/drivers/char/Config.in	2005-07-22 06:52:58.716945248 +0200
@@ -133,6 +133,10 @@
       fi
    fi
 fi
+if [ "$CONFIG_AR7" = "y" ]; then
+   bool  'Enable LED support' CONFIG_AR7_LED
+fi
+
 if [ "$CONFIG_EXPERIMENTAL" = "y" -a "$CONFIG_ZORRO" = "y" ]; then
    tristate 'Commodore A2232 serial support (EXPERIMENTAL)' CONFIG_A2232
 fi
diff -urN linux.old/drivers/char/Makefile linux.dev/drivers/char/Makefile
--- linux.old/drivers/char/Makefile	2005-07-10 20:53:55.651623000 +0200
+++ linux.dev/drivers/char/Makefile	2005-07-22 06:53:35.321380528 +0200
@@ -190,6 +190,12 @@
   obj-$(CONFIG_PCI) += keyboard.o $(KEYMAP)
 endif
 
+#
+# Texas Intruments LED driver
+# 
+obj-$(CONFIG_AR7_LED) += avalanche_led/avalanche_led.o
+subdir-$(CONFIG_AR7_LED) += avalanche_led
+
 obj-$(CONFIG_HIL) += hp_keyb.o
 obj-$(CONFIG_MAGIC_SYSRQ) += sysrq.o
 obj-$(CONFIG_ATARI_DSP56K) += dsp56k.o
diff -urN linux.old/include/asm-mips/ar7/ledapp.h linux.dev/include/asm-mips/ar7/ledapp.h
--- linux.old/include/asm-mips/ar7/ledapp.h	1970-01-01 01:00:00.000000000 +0100
+++ linux.dev/include/asm-mips/ar7/ledapp.h	2005-07-22 06:52:42.982337272 +0200
@@ -0,0 +1,59 @@
+#ifndef __LED_APP__
+#define __LED_APP__
+
+#define CONF_FILE		"/etc/led.conf"
+#define LED_PROC_FILE		"/proc/led_mod/led"
+
+#define CONFIG_LED_MODULE
+
+#define MAX_MOD_ID        25
+#define MAX_STATE_ID   	  25
+#define MAX_LED_ID 	  25
+
+#define MOD_ADSL 1
+#define DEF_ADSL_IDLE     1
+#define DEF_ADSL_TRAINING 2
+#define DEF_ADSL_SYNC     3
+#define DEF_ADSL_ACTIVITY 4
+
+#define MOD_WAN  2
+#define DEF_WAN_IDLE      1
+#define DEF_WAN_NEGOTIATE 2
+#define DEF_WAN_SESSION   3
+
+#define MOD_LAN  3
+#define DEF_LAN_IDLE		  1
+#define DEF_LAN_LINK_UP   2
+#define DEF_LAN_ACTIVITY  3
+
+#define MOD_WLAN 4
+#define DEF_WLAN_IDLE     1
+#define DEF_WLAN_LINK_UP  2
+#define DEF_WLAN_ACTIVITY 3
+
+#define MOD_USB  5
+#define DEF_USB_IDLE		  1
+#define DEF_USB_LINK_UP   2
+#define DEF_USB_ACTIVITY  3
+
+#define MOD_ETH  6
+#define DEF_ETH_IDLE		  1
+#define DEF_ETH_LINK_UP   2
+#define DEF_ETH_ACTIVITY  3
+
+typedef struct config_elem{
+  unsigned char name;
+  unsigned char state;
+  unsigned char mode;
+  unsigned char led;
+            int param;
+}config_elem_t;
+
+typedef struct led_reg{
+	unsigned int param;
+  void (*init)(unsigned long param);
+  void (*onfunc)(unsigned long param);
+  void (*offfunc)(unsigned long param);
+}led_reg_t;
+
+#endif