Add realtek target files

Signed-off-by: Roman Yeryomin <roman@advem.lv>

1 files changed, 800 insertions, 0 deletions

diff --git a/target/linux/realtek/files/drivers/net/rtl819x/l3Driver/rtl865x_multipleWan.c b/target/linux/realtek/files/drivers/net/rtl819x/l3Driver/rtl865x_multipleWan.c
new file mode 100644
index 000000000..d10e3d845
--- /dev/null
+++ b/target/linux/realtek/files/drivers/net/rtl819x/l3Driver/rtl865x_multipleWan.c
@@ -0,0 +1,800 @@
+/*
+* Copyright c                  Realtek Semiconductor Corporation, 2010  
+* All rights reserved.
+* 
+* Program : multiple wan
+* Abstract : 
+* Author : hyking (hyking_liu@realsil.com.cn)  
+*/
+
+/*      @doc RTL_LAYEREDDRV_API
+
+        @module rtl865x_multipleWan.c - RTL865x Home gateway controller Layered driver API documentation       |
+        This document explains the API interface of the table driver module. Functions with rtl865x prefix
+        are external functions.
+        @normal Hyking Liu (Hyking_liu@realsil.com.cn) <date>
+
+        Copyright <cp>2010 Realtek<tm> Semiconductor Cooperation, All Rights Reserved.
+
+        @head3 List of Symbols |
+        Here is a list of all functions and variables in this module.
+        
+        @index | RTL_LAYEREDDRV_API
+*/
+#include <linux/proc_fs.h>
+//#include <linux/seq_file.h>
+
+
+#include <net/rtl/rtl_types.h>
+#include <net/rtl/rtl_glue.h>
+#include "common/rtl_errno.h"
+#include <net/rtl/rtl865x_netif.h>
+#include "common/rtl865x_netif_local.h"
+#include "rtl865x_ppp_local.h"
+#include "rtl865x_route.h"
+#include "rtl865x_nexthop.h"
+#include <net/rtl/rtl865x_arp_api.h>
+#include "rtl865x_arp.h"
+
+#include <net/rtl/rtl865x_multipleWan_api.h>
+#include "rtl865x_multipleWan.h"
+
+#include "AsicDriver/rtl865x_asicCom.h"
+#include "AsicDriver/asicRegs.h"
+#include "AsicDriver/rtl865x_asicBasic.h"
+
+
+
+static rtl_advRoute_entry_t rtl_advRt_table[RTL_ADVRT_MAX_NUM];
+static enum ENUM_NETDEC_POLICY oldNetDecision;
+static struct proc_dir_entry *adv_rt_entry;
+extern int32 rtl865x_getAsicFun(uint32 *enable);
+
+static void rtl_show_advRoute(rtl_advRoute_entry_t *rule)
+{
+	switch(rule->ruleType_)	
+	{
+			case RTL_ADVRT_MAC:
+				printk("rule type: %s\n", "MAC based");
+				printk("\tether type: %x   ether type mask: %x\n", rule->advrt_typeLen_, rule->advrt_typeLenMask_);
+				printk("\tDMAC: %x:%x:%x:%x:%x:%x  DMACM: %x:%x:%x:%x:%x:%x\n",
+						rule->advrt_dstMac_.octet[0], rule->advrt_dstMac_.octet[1], rule->advrt_dstMac_.octet[2],
+						rule->advrt_dstMac_.octet[3], rule->advrt_dstMac_.octet[4], rule->advrt_dstMac_.octet[5],
+						rule->advrt_dstMacMask_.octet[0], rule->advrt_dstMacMask_.octet[1], rule->advrt_dstMacMask_.octet[2],
+						rule->advrt_dstMacMask_.octet[3], rule->advrt_dstMacMask_.octet[4], rule->advrt_dstMacMask_.octet[5]
+						);
+				
+				printk( "\tSMAC: %x:%x:%x:%x:%x:%x  SMACM: %x:%x:%x:%x:%x:%x\n",
+						rule->advrt_srcMac_.octet[0], rule->advrt_srcMac_.octet[1], rule->advrt_srcMac_.octet[2],
+						rule->advrt_srcMac_.octet[3], rule->advrt_srcMac_.octet[4], rule->advrt_srcMac_.octet[5],
+						rule->advrt_srcMacMask_.octet[0], rule->advrt_srcMacMask_.octet[1], rule->advrt_srcMacMask_.octet[2],
+						rule->advrt_srcMacMask_.octet[3], rule->advrt_srcMacMask_.octet[4], rule->advrt_srcMacMask_.octet[5]
+					);
+				break;
+
+			case RTL_ADVRT_IP:
+				printk("rule type: %s\n", "IP");
+				printk( "\tdip: %d.%d.%d.%d dipM: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsip: %d.%d.%d.%d sipM: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos: %x   TosM: %x   ipProto: %x   ipProtoM: %x   ipFlag: %x   ipFlagM: %x\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_ipProto_, rule->advrt_ipProtoMask_, rule->advrt_ipFlag_, rule->advrt_ipFlagMask_
+					);
+				
+				printk("\t<FOP:%x> <FOM:%x> <http:%x> <httpM:%x> <IdentSdip:%x> <IdentSdipM:%x> \n",
+						rule->advrt_ipFOP_, rule->advrt_ipFOM_, rule->advrt_ipHttpFilter_, rule->advrt_ipHttpFilterM_, rule->advrt_ipIdentSrcDstIp_,
+						rule->advrt_ipIdentSrcDstIpM_
+						);
+				printk( "\t<DF:%x> <MF:%x>\n", rule->advrt_ipDF_, rule->advrt_ipMF_); 
+					break;
+					
+			case RTL_ADVRT_IP_RANGE:
+				printk("rule type: %s \n", "IP Range");
+				printk("\tdipU: %d.%d.%d.%d dipL: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsipU: %d.%d.%d.%d sipL: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos: %x   TosM: %x   ipProto: %x   ipProtoM: %x   ipFlag: %x   ipFlagM: %x\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_ipProto_, rule->advrt_ipProtoMask_, rule->advrt_ipFlag_, rule->advrt_ipFlagMask_
+						);
+				printk("\t<FOP:%x> <FOM:%x> <http:%x> <httpM:%x> <IdentSdip:%x> <IdentSdipM:%x> \n",
+						rule->advrt_ipFOP_, rule->advrt_ipFOM_, rule->advrt_ipHttpFilter_, rule->advrt_ipHttpFilterM_, rule->advrt_ipIdentSrcDstIp_,
+						rule->advrt_ipIdentSrcDstIpM_
+						);
+					printk("\t<DF:%x> <MF:%x>\n", rule->advrt_ipDF_, rule->advrt_ipMF_); 
+					break;			
+			case RTL_ADVRT_ICMP:
+				printk("rule type: %s\n", "ICMP");
+				printk("\tdip: %d.%d.%d.%d dipM: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsip: %d.%d.%d.%d sipM: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos: %x   TosM: %x   type: %x   typeM: %x   code: %x   codeM: %x\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_icmpType_, rule->advrt_icmpTypeMask_, 
+						rule->advrt_icmpCode_, rule->advrt_icmpCodeMask_);
+				break;
+			case RTL_ADVRT_ICMP_IPRANGE:
+				printk("rule type: %s\n","ICMP IP RANGE");
+				printk("\tdipU: %d.%d.%d.%d dipL: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsipU: %d.%d.%d.%d sipL: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos: %x   TosM: %x   type: %x   typeM: %x   code: %x   codeM: %x\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_icmpType_, rule->advrt_icmpTypeMask_, 
+						rule->advrt_icmpCode_, rule->advrt_icmpCodeMask_);
+				break;
+			case RTL_ADVRT_IGMP:
+				printk("rule type: %s\n", "IGMP");
+				printk("\tdip: %d.%d.%d.%d dipM: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsip: %d.%d.%d.%d sipM: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos: %x   TosM: %x   type: %x   typeM: %x\n", rule->advrt_tos_, rule->advrt_tosMask_,
+						rule->advrt_igmpType_, rule->advrt_igmpTypeMask_
+						);
+				break;
+
+
+			case RTL_ADVRT_IGMP_IPRANGE:
+				printk(" rule type: %s\n",  "IGMP IP RANGE");
+				printk("\tdipU: %d.%d.%d.%d dipL: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsipU: %d.%d.%d.%d sipL: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos: %x   TosM: %x   type: %x   typeM: %x\n", rule->advrt_tos_, rule->advrt_tosMask_,
+						rule->advrt_igmpType_, rule->advrt_igmpTypeMask_
+						);
+				break;
+
+			case RTL_ADVRT_TCP:
+				printk("rule type: %s\n","TCP");
+				printk("\tdip: %d.%d.%d.%d dipM: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsip: %d.%d.%d.%d sipM: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);				
+				printk("\tTos:%x  TosM:%x  sportL:%d  sportU:%d  dportL:%d  dportU:%d\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_tcpSrcPortLB_, rule->advrt_tcpSrcPortUB_,
+						rule->advrt_tcpDstPortLB_, rule->advrt_tcpDstPortUB_
+						);
+				printk("\tflag: %x  flagM: %x  <URG:%x> <ACK:%x> <PSH:%x> <RST:%x> <SYN:%x> <FIN:%x>\n",
+						rule->advrt_tcpFlag_, rule->advrt_tcpFlagMask_, rule->advrt_tcpURG_, rule->advrt_tcpACK_,
+						rule->advrt_tcpPSH_, rule->advrt_tcpRST_, rule->advrt_tcpSYN_, rule->advrt_tcpFIN_
+						);
+				break;
+			case RTL_ADVRT_TCP_IPRANGE:
+					printk("rule type: %s\n","TCP IP RANGE");
+					printk("\tdipU: %d.%d.%d.%d dipL: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+					printk("\tsipU: %d.%d.%d.%d sipL: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+					printk("\tTos:%x  TosM:%x  sportL:%d  sportU:%d  dportL:%d  dportU:%d\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_tcpSrcPortLB_, rule->advrt_tcpSrcPortUB_,
+						rule->advrt_tcpDstPortLB_, rule->advrt_tcpDstPortUB_
+						);
+					printk("\tflag: %x  flagM: %x  <URG:%x> <ACK:%x> <PSH:%x> <RST:%x> <SYN:%x> <FIN:%x>\n",
+						rule->advrt_tcpFlag_, rule->advrt_tcpFlagMask_, rule->advrt_tcpURG_, rule->advrt_tcpACK_,
+						rule->advrt_tcpPSH_, rule->advrt_tcpRST_, rule->advrt_tcpSYN_, rule->advrt_tcpFIN_
+					);
+				break;
+
+			case RTL_ADVRT_UDP:
+				printk("rule type: %s\n","UDP");
+				printk("\tdip: %d.%d.%d.%d dipM: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsip: %d.%d.%d.%d sipM: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos:%x  TosM:%x  sportL:%d  sportU:%d  dportL:%d  dportU:%d\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_udpSrcPortLB_, rule->advrt_udpSrcPortUB_,
+						rule->advrt_udpDstPortLB_, rule->advrt_udpDstPortUB_
+						);
+				break;				
+			case RTL_ADVRT_UDP_IPRANGE:
+				printk("rule type: %s\n","UDP IP RANGE");
+				printk("\tdipU: %d.%d.%d.%d dipL: %d.%d.%d.%d\n", (rule->advrt_dstIpAddr_>>24),
+						((rule->advrt_dstIpAddr_&0x00ff0000)>>16), ((rule->advrt_dstIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_dstIpAddr_&0xff), (rule->advrt_dstIpAddrMask_>>24), ((rule->advrt_dstIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_dstIpAddrMask_&0x0000ff00)>>8), (rule->advrt_dstIpAddrMask_&0xff)
+						);
+				printk("\tsipU: %d.%d.%d.%d sipL: %d.%d.%d.%d\n", (rule->advrt_srcIpAddr_>>24),
+						((rule->advrt_srcIpAddr_&0x00ff0000)>>16), ((rule->advrt_srcIpAddr_&0x0000ff00)>>8),
+						(rule->advrt_srcIpAddr_&0xff), (rule->advrt_srcIpAddrMask_>>24), ((rule->advrt_srcIpAddrMask_&0x00ff0000)>>16),
+						((rule->advrt_srcIpAddrMask_&0x0000ff00)>>8), (rule->advrt_srcIpAddrMask_&0xff)
+						);
+				printk("\tTos:%x  TosM:%x  sportL:%d  sportU:%d  dportL:%d  dportU:%d\n",
+						rule->advrt_tos_, rule->advrt_tosMask_, rule->advrt_udpSrcPortLB_, rule->advrt_udpSrcPortUB_,
+						rule->advrt_udpDstPortLB_, rule->advrt_udpDstPortUB_
+					);
+				break;
+
+				default:
+					printk("rule->ruleType_(0x%x)\n", rule->ruleType_);
+
+		}
+
+		printk("\tNexthop(%u.%u.%u.%u),extip(%u.%u.%u.%u),outif(%s),Op(%d)\n", NIPQUAD(rule->nexthop),NIPQUAD(rule->extIp),rule->outIfName,rule->pktOpApp_);
+	
+}
+void rtl_show_advRt_table(void)
+{
+	rtl_advRoute_entry_t *tmp_entry;
+	int i;
+	
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{
+		tmp_entry = &rtl_advRt_table[i];
+		if(tmp_entry->valid_)
+		{
+			printk("idx(%d):\n",i);
+			rtl_show_advRoute(tmp_entry);
+		}
+		
+	}
+}
+
+static int8 _rtl_same_AdvRt_rule(rtl_advRoute_entry_t *rule1, rtl_advRoute_entry_t *rule2)
+{
+
+	if (rule1->ruleType_ != rule2->ruleType_)
+		return FALSE;
+
+	switch(rule1->ruleType_) 
+	{
+	case RTL_ADVRT_MAC:
+		 if (rule1->advrt_typeLen_ != rule2->advrt_typeLen_ || rule1->advrt_typeLenMask_ != rule2->advrt_typeLenMask_)
+		 	return FALSE;
+		 if (memcmp(&rule1->advrt_dstMac_, &rule2->advrt_dstMac_, sizeof(ether_addr_t)) || 
+		 	 memcmp(&rule1->advrt_dstMacMask_, &rule2->advrt_dstMacMask_, sizeof(ether_addr_t)) ||
+			 memcmp(&rule1->advrt_srcMac_, &rule2->advrt_srcMac_, sizeof(ether_addr_t)) ||
+			 memcmp(&rule1->advrt_srcMacMask_, &rule2->advrt_srcMacMask_, sizeof(ether_addr_t)) )
+			 return FALSE;
+		 return TRUE;
+	case RTL_ADVRT_IP:
+	case RTL_ADVRT_IP_RANGE:
+		 if (rule1->advrt_ipProto_ != rule2->advrt_ipProto_ || rule1->advrt_ipProtoMask_ != rule2->advrt_ipProtoMask_ ||
+			rule1->advrt_ipFlag_ != rule2->advrt_ipFlag_ || rule1->advrt_ipFlagMask_ != rule2->advrt_ipFlagMask_)
+			return FALSE; 
+		break;
+			
+	case RTL_ADVRT_ICMP:
+	case RTL_ADVRT_ICMP_IPRANGE:
+		 if (rule1->advrt_icmpType_ != rule2->advrt_icmpType_ || rule1->advrt_icmpTypeMask_ != rule2->advrt_icmpTypeMask_ ||
+			rule1->advrt_icmpCode_ != rule2->advrt_icmpCode_ || rule1->advrt_icmpCodeMask_ != rule2->advrt_icmpCodeMask_)
+			return FALSE; 
+		 break;
+
+	case RTL_ADVRT_IGMP:
+	case RTL_ADVRT_IGMP_IPRANGE:
+		 if(rule1->advrt_igmpType_ != rule2->advrt_igmpType_ || rule1->advrt_igmpTypeMask_ != rule2->advrt_igmpTypeMask_)
+		 	return FALSE; 
+		 break;
+	case RTL_ADVRT_TCP:
+	case RTL_ADVRT_TCP_IPRANGE:
+		 if(rule1->advrt_tcpFlag_ != rule2->advrt_tcpFlag_ || rule1->advrt_tcpFlagMask_ != rule2->advrt_tcpFlagMask_ ||
+			rule1->advrt_tcpSrcPortUB_ != rule2->advrt_tcpSrcPortUB_ || rule1->advrt_tcpSrcPortLB_ != rule2->advrt_tcpSrcPortLB_ ||
+			rule1->advrt_tcpDstPortUB_ != rule2->advrt_tcpDstPortUB_ || rule1->advrt_tcpDstPortLB_ != rule2->advrt_tcpDstPortLB_)
+		 	return FALSE; 
+		 break;
+	case RTL_ADVRT_UDP:
+	case RTL_ADVRT_UDP_IPRANGE:
+		 if(rule1->advrt_udpSrcPortUB_ != rule2->advrt_udpSrcPortUB_ || rule1->advrt_udpSrcPortLB_ != rule2->advrt_udpSrcPortLB_ ||
+			rule1->advrt_udpDstPortUB_ != rule2->advrt_udpDstPortUB_ || rule1->advrt_udpDstPortLB_ != rule2->advrt_udpDstPortLB_)
+			return FALSE;
+		 break;
+
+	case RTL_ADVRT_SRCFILTER:
+	case RTL_ADVRT_SRCFILTER_IPRANGE:
+		if((rule1->advrt_srcFilterPort_ != rule2->advrt_srcFilterPort_)||
+			memcmp(&rule1->advrt_srcFilterMac_, &rule2->advrt_srcFilterMac_, sizeof(ether_addr_t)) != 0||
+			memcmp(&rule1->advrt_srcFilterMacMask_, &rule2->advrt_srcFilterMacMask_,sizeof(ether_addr_t)) != 0||
+			(rule1->advrt_srcFilterVlanIdx_ != rule2->advrt_srcFilterVlanIdx_)||
+			(rule1->advrt_srcFilterVlanIdxMask_ != rule2->advrt_srcFilterVlanIdxMask_)||
+			(rule1->advrt_srcFilterIgnoreL3L4_ != rule2->advrt_srcFilterIgnoreL3L4_)||
+			(rule1->advrt_srcFilterIgnoreL4_ != rule2->advrt_srcFilterIgnoreL4_))
+		{
+			return FALSE;
+		}
+
+		if(rule1->advrt_srcFilterIgnoreL4_==0 && rule1->advrt_srcFilterIgnoreL3L4_==0)
+		{
+			if((rule1->advrt_srcFilterPortUpperBound_ != rule2->advrt_srcFilterPortUpperBound_)||
+			   (rule1->advrt_srcFilterPortLowerBound_ != rule2->advrt_srcFilterPortLowerBound_))
+				return FALSE;
+		}
+
+		if(rule1->advrt_srcFilterIgnoreL3L4_==0)
+		{
+			if((rule1->advrt_srcFilterIpAddr_ != rule2->advrt_srcFilterIpAddr_)||
+				(rule2->advrt_srcFilterIpAddrMask_ != rule2->advrt_srcFilterIpAddrMask_))
+				return FALSE;
+		}
+		
+		break;
+		
+	case RTL_ADVRT_DSTFILTER:
+	case RTL_ADVRT_DSTFILTER_IPRANGE:
+		if(	memcmp(&rule1->advrt_dstFilterMac_, &rule2->advrt_dstFilterMac_, sizeof(ether_addr_t)) != 0||
+			memcmp(&rule1->advrt_dstFilterMacMask_, &rule2->advrt_dstFilterMacMask_,sizeof(ether_addr_t)) != 0||
+			(rule1->advrt_dstFilterVlanIdx_ != rule2->advrt_dstFilterVlanIdx_)||
+			(rule1->advrt_dstFilterVlanIdxMask_ != rule2->advrt_dstFilterVlanIdxMask_)||
+			(rule1->advrt_dstFilterIgnoreL3L4_ != rule2->advrt_dstFilterIgnoreL3L4_)||
+			(rule1->advrt_dstFilterIgnoreL4_ != rule2->advrt_dstFilterIgnoreL4_))
+		{
+			return FALSE;
+		}
+
+		if(rule1->advrt_dstFilterIgnoreL4_==0 && rule1->advrt_dstFilterIgnoreL4_==0)
+		{
+			if((rule1->advrt_dstFilterPortUpperBound_ != rule2->advrt_dstFilterPortUpperBound_)||
+			   (rule1->advrt_dstFilterPortLowerBound_ != rule2->advrt_dstFilterPortLowerBound_))
+				return FALSE;
+		}
+
+		if(rule1->advrt_dstFilterIgnoreL3L4_==0)
+		{
+			if((rule1->advrt_dstFilterIpAddr_ != rule2->advrt_dstFilterIpAddr_)||
+				(rule2->advrt_dstFilterIpAddrMask_ != rule2->advrt_dstFilterIpAddrMask_))
+				return FALSE;
+		}
+		
+		break;
+	default: return FALSE; /* Unknown rule type */
+	
+	}
+	/* Compare common part */
+	if (rule1->advrt_srcIpAddr_ != rule2->advrt_srcIpAddr_ || rule1->advrt_srcIpAddrMask_ != rule2->advrt_srcIpAddrMask_ ||
+		rule1->advrt_dstIpAddr_ != rule2->advrt_dstIpAddr_ || rule1->advrt_dstIpAddrMask_ != rule2->advrt_dstIpAddrMask_ ||
+		rule1->advrt_tos_ != rule2->advrt_tos_ || rule1->advrt_tosMask_ != rule2->advrt_tosMask_ )
+		return FALSE;
+	return TRUE;				
+}
+
+static int _rtl_advRt_to_acl(rtl_advRoute_entry_t *advRt, rtl865x_AclRule_t *acl)
+{
+	if(NULL == advRt || NULL == acl)
+		return RTL_EINVALIDINPUT;
+	
+	switch(advRt->ruleType_)
+	{		
+		case RTL_ADVRT_IP:
+		case RTL_ADVRT_IP_RANGE:
+			memcpy(&acl->un_ty,&advRt->un_ty,sizeof(advRt->un_ty));
+			acl->pktOpApp_ = advRt->pktOpApp_;
+			
+			if(advRt->ruleType_ == RTL_ADVRT_IP)
+				acl->ruleType_ = RTL865X_ACL_IP;
+			else
+				acl->ruleType_ = RTL865X_ACL_IP_RANGE;
+			
+		break;
+		default:
+			printk("ruletype(0x%x) is NOT support now!\n",advRt->ruleType_);
+	}
+	
+	return SUCCESS;
+}
+
+static int _rtl_advRt_fullMatch_with_route(rtl_advRoute_entry_t *entry)
+{
+	int retval = FAILED;
+	rtl865x_netif_local_t *dstNetif;
+	rtl865x_route_t rt;
+
+	memset(&rt,0,sizeof(rtl865x_route_t));
+	
+	retval = rtl865x_getRouteEntry(entry->nexthop,&rt);
+	if(SUCCESS == retval)
+	{
+		dstNetif = _rtl865x_getNetifByName(entry->outIfName);
+		if(rt.dstNetif == dstNetif)
+			return SUCCESS;
+	}
+	
+	return FAILED;
+}
+
+static int _rtl_flush_multiWan_redirectACL(void)
+{
+	rtl_advRoute_entry_t *entry;
+	rtl865x_netif_local_t *netif;
+	int nexthopIdx;
+	int i;
+
+	/*delete nexthop entry which used for redirectacl*/
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{
+		entry = &rtl_advRt_table[i];
+		if(entry->valid_)
+		{	
+			if(SUCCESS == _rtl_advRt_fullMatch_with_route(entry))
+				continue;
+			
+			netif = _rtl865x_getSWNetifByName(entry->outIfName);
+			if(NULL == netif)
+			{
+				printk("====%s(%d),netif(%s) is NULL\n",__FUNCTION__,__LINE__,entry->outIfName);
+				continue;
+			}
+
+			nexthopIdx = rtl865x_getNxtHopIdx(NEXTHOP_DEFREDIRECT_ACL,netif,entry->nexthop);
+			if(nexthopIdx == -1)
+			{
+				 printk("====%s(%d),get nxthop error, nxthop(%u.%u.%u.%u)!!\n",__FUNCTION__,__LINE__,NIPQUAD(entry->nexthop));
+				 continue;
+			}
+
+			rtl865x_delNxtHop(NEXTHOP_DEFREDIRECT_ACL,nexthopIdx);
+		}
+	}
+
+	/*delete all acl rule*/
+	rtl865x_flush_allAcl_fromChain(RTL_DRV_LAN_NETIF_NAME,RTL865X_ACL_MULTIWAN_USED,RTL865X_ACL_INGRESS);
+
+	return SUCCESS;
+}
+
+static int _rtl_rearrange_multiWan_redirectACL(void)
+{
+	rtl865x_AclRule_t acl_entry;
+	rtl_advRoute_entry_t *entry;
+	rtl865x_netif_local_t *netif;
+	int nexthopIdx;
+	int i,ret;
+	rtl865x_arpMapping_entry_t arp;
+	
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{
+		entry = &rtl_advRt_table[i];
+		if(entry->valid_)
+		{
+			if(SUCCESS == _rtl_advRt_fullMatch_with_route(entry))
+				continue;
+
+			netif = _rtl865x_getSWNetifByName(entry->outIfName);
+			if(NULL == netif)
+			{
+				printk("====%s(%d),netif(%s) is NULL\n",__FUNCTION__,__LINE__,entry->outIfName);
+				continue;
+			}
+
+			/*add nexthop entry*/
+			rtl865x_addNxtHop(NEXTHOP_DEFREDIRECT_ACL,NULL,netif,entry->nexthop,entry->extIp);
+			nexthopIdx = rtl865x_getNxtHopIdx(NEXTHOP_DEFREDIRECT_ACL,netif,entry->nexthop);
+			if(nexthopIdx == -1)
+			{
+				 printk("====%s(%d),get nxthop error, nxthop(%u.%u.%u.%u)!!\n",__FUNCTION__,__LINE__,NIPQUAD(entry->nexthop));
+				 continue;
+			}
+			
+			//add acl
+			memset(&acl_entry,0,sizeof(rtl865x_AclRule_t));
+			_rtl_advRt_to_acl(entry,&acl_entry);
+
+			acl_entry.actionType_ = RTL865X_ACL_DEFAULT_REDIRECT;
+			acl_entry.nexthopIdx_ = nexthopIdx;
+
+			ret = rtl865x_add_acl(&acl_entry,RTL_DRV_LAN_NETIF_NAME,RTL865X_ACL_MULTIWAN_USED);
+			if(SUCCESS != ret)
+			{
+				rtl865x_delNxtHop(NEXTHOP_DEFREDIRECT_ACL,nexthopIdx);
+				continue;
+			}
+
+			/*callback function for sync arp/l2*/
+			memset(&arp,0,sizeof(rtl865x_arpMapping_entry_t));
+			ret = rtl865x_get_ps_arpMapping(entry->nexthop,&arp);
+			if(SUCCESS == ret)
+			{
+				rtl865x_eventHandle_addArp_for_multiWan(&arp);
+			}
+			
+			
+		}
+	}
+	
+	return SUCCESS;
+}
+
+#if 0
+static int _rtl_get_advRt_num(void)
+{
+	int cnt = 0;
+	int i = 0;
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{	
+		if(rtl_advRt_table[i].valid_)
+		{
+			cnt++;
+		}
+	}
+
+	return cnt;
+}
+#endif
+
+static int32 adv_rt_read( char *page, char **start, off_t off, int count, int *eof, void *data )
+{
+	int len = 0;
+	rtl_show_advRt_table();
+	return len;
+}
+
+static int32 adv_rt_write( struct file *filp, const char *buff,unsigned long len, void *data )	
+{
+	char 		tmpbuf[128];
+	char cmd[8];
+	char outif_name[16];
+	char netif_name[MAX_IFNAMESIZE];
+	int srcip_start[4];
+	int srcip_end[4];
+	int dst_start[4];
+	int dst_end[4];
+	int ext_ip[4];
+	int nexthop_ip[4];
+	int num = 0;
+	int retval = 0;
+	rtl_advRoute_entry_t rule;
+	
+	if (buff && !copy_from_user(tmpbuf, buff, len))
+	{
+		tmpbuf[len -1] = '\0';		
+		num= sscanf(tmpbuf, "%s %d.%d.%d.%d %d.%d.%d.%d %d.%d.%d.%d %d.%d.%d.%d %d.%d.%d.%d %d.%d.%d.%d %s", cmd, 
+			&srcip_start[0], &srcip_start[1], &srcip_start[2], &srcip_start[3],
+			&srcip_end[0], &srcip_end[1], &srcip_end[2], &srcip_end[3],
+			&dst_start[0], &dst_start[1], &dst_start[2], &dst_start[3],
+			&dst_end[0], &dst_end[1], &dst_end[2], &dst_end[3],
+			&ext_ip[0], &ext_ip[1], &ext_ip[2], &ext_ip[3], 
+			&nexthop_ip[0], &nexthop_ip[1], &nexthop_ip[2], &nexthop_ip[3], 
+			outif_name);
+		
+		if (num !=  26) 
+			return -EFAULT;		
+
+		if(strlen(outif_name) >= 15)
+			return -EFAULT;
+
+		
+		retval = rtl865x_get_drvNetifName_by_psName(outif_name,netif_name);
+		if(retval != SUCCESS)
+			return -EFAULT;
+		
+		memset(&rule,0,sizeof(rtl_advRoute_entry_t));
+		rule.extIp = (ext_ip[0]<<24)|(ext_ip[1]<<16)|(ext_ip[2]<<8)|(ext_ip[3]<<0);
+		rule.nexthop = (nexthop_ip[0]<<24)|(nexthop_ip[1]<<16)|(nexthop_ip[2]<<8)|(nexthop_ip[3]<<0);
+		rule.pktOpApp_ = 6;
+		memcpy(rule.outIfName,netif_name,strlen(netif_name));		
+		rule.outIfName[strlen(netif_name)+1] ='\0';
+		
+		rule.ruleType_ = RTL_ADVRT_IP_RANGE;
+		rule.valid_ = 1;
+
+		rule.advrt_srcIpAddrStart_ = (srcip_start[0]<<24)|(srcip_start[1]<<16)|(srcip_start[2]<<8)|(srcip_start[3]<<0);
+		rule.advrt_srcIpAddrEnd_ = (srcip_end[0]<<24)|(srcip_end[1]<<16)|(srcip_end[2]<<8)|(srcip_end[3]<<0);
+		rule.advrt_dstIpAddrStart_ = (dst_start[0]<<24)|(dst_start[1]<<16)|(dst_start[2]<<8)|(dst_start[3]<<0);
+		rule.advrt_dstIpAddrEnd_ = (dst_end[0]<<24)|(dst_end[1]<<16)|(dst_end[2]<<8)|(dst_end[3]<<0);
+
+		
+		if((strcmp(cmd, "add")==0) || (strcmp(cmd, "ADD")==0))
+		{
+			rtl_add_advRt_entry(&rule);
+		}
+		else if((strcmp(cmd, "del")==0) || (strcmp(cmd, "DEL")==0))
+		{
+			rtl_del_advRt_entry(&rule);
+		}
+		
+	}
+	return len;
+}
+
+int rtl_exit_advRt(void)
+{
+	_rtl_flush_multiWan_redirectACL();
+	/*unregist the acl chain*/
+	rtl865x_unRegist_aclChain(RTL_DRV_LAN_NETIF_NAME,RTL865X_ACL_MULTIWAN_USED,RTL865X_ACL_INGRESS);
+	memset(rtl_advRt_table,0,RTL_ADVRT_MAX_NUM*sizeof(rtl_advRoute_entry_t));
+	/*switch back old netdecision policy*/
+	rtl865xC_setNetDecisionPolicy(oldNetDecision);	
+	if(adv_rt_entry)
+	{
+		remove_proc_entry("adv_rt",NULL);
+		adv_rt_entry = NULL;
+	}
+	return SUCCESS;
+}
+
+int rtl_init_advRt(void)
+{	
+#if 1
+	uint32 enable;
+	rtl865x_getAsicFun(&enable);
+
+	if(!(enable & ALL_NAT))
+		return FAILED;
+#endif
+
+	adv_rt_entry = create_proc_entry("adv_rt", 0, NULL);
+	if(adv_rt_entry)
+	{
+		adv_rt_entry->read_proc = adv_rt_read;
+		adv_rt_entry->write_proc = adv_rt_write;
+		
+	}
+	memset(rtl_advRt_table,0,RTL_ADVRT_MAX_NUM*sizeof(rtl_advRoute_entry_t));
+	rtl865x_regist_aclChain(RTL_DRV_LAN_NETIF_NAME,RTL865X_ACL_MULTIWAN_USED,RTL865X_ACL_INGRESS);
+	//switch to mac based
+	rtl865xC_getNetDecisionPolicy(&oldNetDecision);
+	rtl865xC_setNetDecisionPolicy(NETIF_MAC_BASED );
+	rtl865x_setDefACLForNetDecisionMiss(RTL865X_ACLTBL_PERMIT_ALL,RTL865X_ACLTBL_PERMIT_ALL,RTL865X_ACLTBL_PERMIT_ALL,RTL865X_ACLTBL_PERMIT_ALL);
+	return SUCCESS;
+}
+
+rtl_advRoute_entry_t* rtl_get_advRt_entry_by_nexthop(ipaddr_t nexthop)
+{
+	int i;
+	rtl_advRoute_entry_t *tmp_entry;
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{
+		tmp_entry = &rtl_advRt_table[i];
+		if(tmp_entry->valid_)
+		{
+			if(tmp_entry->nexthop == nexthop)
+				return tmp_entry;
+		}
+	}
+	return NULL;	
+}
+
+int rtl_add_advRt_entry(rtl_advRoute_entry_t *entry)
+{	
+	int i;
+	rtl_advRoute_entry_t *tmp_entry,*ready_entry;	
+	if(NULL == entry)
+		return RTL_EINVALIDINPUT;
+
+	ready_entry = NULL;
+	
+	/*duplicate check & try to find a usable entry*/
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{
+		tmp_entry = &rtl_advRt_table[i];
+		if(tmp_entry->valid_)
+		{
+			if(_rtl_same_AdvRt_rule(entry,tmp_entry))
+				return RTL_EENTRYALREADYEXIST;
+		}
+		else
+		{
+			if(NULL==ready_entry)
+				ready_entry = &rtl_advRt_table[i];
+		}
+	}
+
+	if(NULL == ready_entry)
+		return RTL_ENOFREEBUFFER;
+
+	/*flush acl firstly*/
+	_rtl_flush_multiWan_redirectACL();
+	
+	/*add entry*/
+	memcpy(ready_entry,entry,sizeof(rtl_advRoute_entry_t));
+	ready_entry->valid_ = 1;
+
+	_rtl_rearrange_multiWan_redirectACL();
+	
+	return SUCCESS;
+}
+
+int rtl_del_advRt_entry(rtl_advRoute_entry_t *entry)
+{
+	int i;
+	rtl_advRoute_entry_t *tmp_entry;	
+	if(NULL == entry)
+		return RTL_EINVALIDINPUT;
+
+	for(i = 0; i < RTL_ADVRT_MAX_NUM; i++)
+	{
+		tmp_entry = &rtl_advRt_table[i];
+		if(tmp_entry->valid_)
+		{
+			if(_rtl_same_AdvRt_rule(entry,tmp_entry))
+				break;
+		}
+	}
+
+	if(RTL_ADVRT_MAX_NUM == i)
+		return RTL_EENTRYNOTFOUND;
+
+	/*flush acl firstly*/
+	_rtl_flush_multiWan_redirectACL();
+	
+	/*delete entry*/
+	memset(tmp_entry,0,sizeof(rtl_advRoute_entry_t));
+
+	/*rearrange for redirect acl*/
+	_rtl_rearrange_multiWan_redirectACL();
+	return SUCCESS;
+}
+
+int rtl_enable_advRt_by_netifName(const char *name)
+{
+	int i;
+	_rtl_flush_multiWan_redirectACL();
+	for(i = 0;i < RTL_ADVRT_MAX_NUM;i++)
+	{
+		if(strcmp(rtl_advRt_table[i].outIfName,name) == 0)
+			rtl_advRt_table[i].valid_ = 1;
+	}
+	_rtl_rearrange_multiWan_redirectACL();
+
+	return SUCCESS;
+}
+int rtl_disable_advRt_by_netifName(const char *name)
+{
+	int i;
+	_rtl_flush_multiWan_redirectACL();
+	for(i = 0;i < RTL_ADVRT_MAX_NUM;i++)
+	{
+		if(strcmp(rtl_advRt_table[i].outIfName,name) == 0)
+			rtl_advRt_table[i].valid_ = 0;
+	}
+	_rtl_rearrange_multiWan_redirectACL();
+
+	return SUCCESS;
+}
+
+