#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <asm/io.h>

#include "ip1811.h"
#include "ip1811reg.h"
#include "ip1811ds.h"
#include "ip1811op.h"
#include "ip1811fdat.h"
#include "ip218.h"

#define MII_OP_READ 0
#define MII_OP_WRITE 1

//#define TEST_REG
//#define IP1811DEBUG
//#define IP1811DRV_REG_DEBUG
#ifdef	IP1811DRV_REG_DEBUG
#define	ip1811drv_dbg(fmt, ...)	printk(KERN_DEBUG "<%s:%d>" fmt, __func__, __LINE__, ##__VA_ARGS__)
#else
#define	ip1811drv_dbg(...)
#endif//IP1811DRV_REG_DEBUG

#define IP1811DRV_REG_ERROR
#ifdef	IP1811DRV_REG_ERROR
#define	ip1811drv_err(fmt, ...)	printk(KERN_ERR "<%s:%d>" fmt, __func__, __LINE__, ##__VA_ARGS__)
#else
#define	ip1811drv_err(...)
#endif//IP1811DRV_REG_ERROR

#define FUNC_MSG_IN		ip1811drv_dbg("IN \n")
#define FUNC_MSG_OUT	ip1811drv_dbg("OUT\n")

extern u8 CPU_IF_SPEED_NORMAL;

#ifdef TEST_REG
u16 RegList[16][256];
u8 pg;
#endif//TEST_REG

#define ip1811delay()		(udelay(100))

/*=============   misc. driver functions   ===================*/

//#define ACCESS_REG_BY_MDIO
#ifdef ACCESS_REG_BY_MDIO
//--------------  p1811 project GPIO MDIO Function ---------------------
#define MDIO_DELAY	0
#define MDIO_RD		0
#define MDIO_WR		1
#define GPIO_MDIO_OFFSET 10
#define GPIO_MDC_OFFSET 11
#include <asm/io.h>
static DEFINE_MUTEX(ip1811_gpio_lock);
#define IP1811_GPIO_BASE      0xBD700000
#define IP1811_GPIO_OUTPUT_VALUE_2_OFFSET	0x003C
#define IP1811_GPIO_OUTPUT_ENABLE_2_OFFSET	0x0040
#define IP1811_GPIO_INPUT_VALUE_2_OFFSET	0x0038
#define IP1811_GPIO_SET_VALUE_1 0x1
#define IP1811_GPIO_SET_VALUE_0 0x0
static int ip1811_gpio_get(unsigned offset)
{
	void __iomem				*base;
	u32					val;

	mutex_lock(&ip1811_gpio_lock);


	base = IP1811_GPIO_BASE + IP1811_GPIO_INPUT_VALUE_2_OFFSET;
	val = readl(base);
	val = ((val & BIT(offset))>>offset);

	mutex_unlock(&ip1811_gpio_lock);

	return val;
}
static void ip1811_gpio_set(unsigned offset,int value)
{
	void __iomem				*base;
	u32					val;

	mutex_lock(&ip1811_gpio_lock);

	base = IP1811_GPIO_BASE + IP1811_GPIO_OUTPUT_VALUE_2_OFFSET;
	val = readl(base);
	val = (value == IP1811_GPIO_SET_VALUE_1) ? (val | BIT(offset)) : (val & ~((BIT(offset))));
	writel(val, base);

	mutex_unlock(&ip1811_gpio_lock);

	return;
}
static int ip1811_gpio_direction_out(unsigned offset,int value)
{
	void __iomem				*base;
	u32					val;

	mutex_lock(&ip1811_gpio_lock);

	base = IP1811_GPIO_BASE + IP1811_GPIO_OUTPUT_ENABLE_2_OFFSET;
	val = readl(base);
	val |= BIT(offset);
	writel(val, base);

	mutex_unlock(&ip1811_gpio_lock);

	return 0;
}
static int ip1811_gpio_direction_in( unsigned offset)
{
	void __iomem				*base;
	u32					val;

	mutex_lock(&ip1811_gpio_lock);

	base = IP1811_GPIO_BASE + IP1811_GPIO_OUTPUT_ENABLE_2_OFFSET;
	val = readl(base);
	val &= ~(BIT(offset));
	writel(val, base);

	mutex_unlock(&ip1811_gpio_lock);

	return val;
}
void mdio_1(void){

	int i;
	//set MDIO to 1
	//set MDC to 0
	ip1811_gpio_set(GPIO_MDIO_OFFSET,1);
	ip1811_gpio_set(GPIO_MDC_OFFSET,0);

	for(i=0;i<MDIO_DELAY;i++);

	//set MDIO to 1
	//set MDC to 1
	ip1811_gpio_set(GPIO_MDIO_OFFSET,1);
	ip1811_gpio_set(GPIO_MDC_OFFSET,1);

	for(i=0;i<MDIO_DELAY;i++);
}

void mdio_0(void){

	int i;
	//set MDIO to 0
	//set MDC to 0
	ip1811_gpio_set(GPIO_MDIO_OFFSET,0);
	ip1811_gpio_set(GPIO_MDC_OFFSET,0);

	for(i=0;i<MDIO_DELAY;i++);

	//set MDIO to 0
	//set MDC to 1
	ip1811_gpio_set(GPIO_MDIO_OFFSET,0);
	ip1811_gpio_set(GPIO_MDC_OFFSET,1);

	for(i=0;i<MDIO_DELAY;i++);
}

void mdio_z(void){

	int i;
	//set MDC to 0
	ip1811_gpio_set(GPIO_MDC_OFFSET,0);

	for(i=0;i<MDIO_DELAY;i++);
	//set MDC to 1
	ip1811_gpio_set(GPIO_MDC_OFFSET,1);

	for(i=0;i<MDIO_DELAY;i++);
}

void mdio_start(void){
	mdio_0();
	mdio_1();
}

void mdio_rw(int rw){
	if(rw==MDIO_RD){
		mdio_1();
		mdio_0();
	}else{
		mdio_0();
		mdio_1();
	}
}
void mdio_set_MDC_MDIO_direction(unsigned char mdc, unsigned char mdio)//0:input, 1:output for mdc/mdio values
{
	if(mdc) ;
	if(mdio)
		ip1811_gpio_direction_out(GPIO_MDIO_OFFSET,0);
	else
		ip1811_gpio_direction_in(GPIO_MDIO_OFFSET);
}
void ic_mdio_wr(unsigned short pa, unsigned short ra, unsigned short va){
	int i=0;
	unsigned short data=0;

	//set MDC/MDIO pins to GPIO mode
	ip1811_gpio_direction_out(GPIO_MDC_OFFSET,0);
	ip1811_gpio_direction_out(GPIO_MDIO_OFFSET,0);

	//set MDC direction to output
	//set MDIO direction to output
	mdio_set_MDC_MDIO_direction(1,1);

	for(i=0;i<32;i++)
		mdio_1();
	mdio_start();
	mdio_rw(MDIO_WR);
	for(i=0;i<5;i++){
		if((pa>>(5-1-i))%2)
			mdio_1();
		else
			mdio_0();
	}
	for(i=0;i<5;i++){
		if((ra>>(5-1-i))%2)
			mdio_1();
		else
			mdio_0();
	}
	mdio_1();
	mdio_0();
	for(i=0;i<16;i++){
		data=va<<i;
		data=data>>15;
		if(data==1)
			mdio_1();
		else
			mdio_0();
	}
}
unsigned short ic_mdio_rd(unsigned short pa, unsigned short ra){
	int i=0,j=0;
	unsigned short data=0;
	int regBit;
	unsigned char debug[16];

	//set MDC/MDIO pins to GPIO mode
	ip1811_gpio_direction_out(GPIO_MDC_OFFSET,0);
	ip1811_gpio_direction_out(GPIO_MDIO_OFFSET,0);

	//set MDC/MDIO PIN direction
	//mdio_set_MDC_MDIO_dir();
	//MDC direction set to output
	//MDIO direction set to output
	mdio_set_MDC_MDIO_direction(1,1);

	for(i=0;i<32;i++)
		mdio_1();
	mdio_start();
	mdio_rw(MDIO_RD);
	for(i=0;i<5;i++){
		if((pa>>(5-1-i))%2)
			mdio_1();
		else
			mdio_0();
	}
	for(i=0;i<5;i++){
		if((ra>>(5-1-i))%2)
			mdio_1();
		else
			mdio_0();
	}
	mdio_z();
	//MDIO DIR set to input
	mdio_set_MDC_MDIO_direction(1,0);
	mdio_0();


	for(j=0;j<16;j++){
		//MDC set to 0
		ip1811_gpio_set(GPIO_MDC_OFFSET,0);

		for(i=0;i<MDIO_DELAY;i++);
		//get MDIO value
		regBit=ip1811_gpio_get(GPIO_MDIO_OFFSET);
		if(regBit==0)
		{
			data|=0;
			debug[15-j]=0;
		}
		else
		{
			data|=1;
			debug[15-j]=1;
		}
		if(j<15)
			data=data<<1;
		//MDC set to 1
		ip1811_gpio_set(GPIO_MDC_OFFSET,1);

		for(i=0;i<MDIO_DELAY;i++);
	}
	//MDC set to 0
	ip1811_gpio_set(GPIO_MDC_OFFSET,0);

	for(i=0;i<MDIO_DELAY;i++);
	//MDC set to 1
	ip1811_gpio_set(GPIO_MDC_OFFSET,1);

	for(i=0;i<MDIO_DELAY;i++);

	return data;
}
#else//#ifndef ACCESS_REG_BY_MDIO
void ic_mdio_wr(unsigned short pa, unsigned short ra, unsigned short va){
	void __iomem *base;
	unsigned long val;
	struct ip218_smictrl0 *smic0;

	FUNC_MSG_IN;

	val = 0;
	smic0 = (struct ip218_smictrl0 *)&val;
	smic0 -> phy = pa;
	smic0 -> reg = ra;
	smic0 -> wr_data = va;
	smic0 -> rdwr = 1;//1: write cycle
	smic0 -> en = 1;

	base = (void __iomem *)(IP218_MAC_BASE + IP218_MAC_SMICTRL0);
	ip1811drv_dbg("write [%p]=%08lX\n", base, val);
	writel(val, base);

	// wait for writing process done
	do{
		val = readl(base);
	}while(smic0 -> en);

	FUNC_MSG_OUT;
}
unsigned short ic_mdio_rd(unsigned short pa, unsigned short ra){
	void __iomem	*base;
	unsigned long val;
	unsigned short ret;
	struct ip218_smictrl0 *smic0;
	struct ip218_smictrl1 *smic1;

	FUNC_MSG_IN;

	val = 0;
	smic0 = (struct ip218_smictrl0 *)&val;
	smic0 -> phy = pa;
	smic0 -> reg = ra;
	smic0 -> rdwr = 0;//0: read cycle
	smic0 -> en = 1;

	base = (void __iomem *)(IP218_MAC_BASE + IP218_MAC_SMICTRL0);
	ip1811drv_dbg("write [%p]=%08lX\n", base, val);
	writel(val, base);

	// wait for writing process done
	do{
		val = readl(base);
	}while(smic0 -> en);

	// read data from register
	base = (void __iomem *)(IP218_MAC_BASE + IP218_MAC_SMICTRL1);
	val = readl(base);
	smic1 = (struct ip218_smictrl1 *)&val;
	ret = smic1 -> rd_data;
	ip1811drv_dbg("read [%p]=%08lX\n", base, val);

	FUNC_MSG_OUT;

	return ret;
}
#endif//ACCESS_REG_BY_MDIO

void Write_Reg(u8 regaddr, u16 value)
{
	u16 tmp = CPU_IF_SPEED_NORMAL ? regaddr : (u16)regaddr << 2;
#ifdef TEST_REG
	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, regaddr, RegList[pg][regaddr]);
	RegList[pg][regaddr]=value;
#else
	ic_mdio_wr(((tmp)>>5)&0x1f,(tmp)&0x1f,value);
#endif//TEST_REG

#ifdef TEST_REG
	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, regaddr, RegList[pg][regaddr]);
#endif//TEST_REG

	ip1811drv_dbg("write [%02X]=%04x\n", regaddr, value);
}
u16 Read_Reg(u8 regaddr)
{
	u16 u16d;
	u16 tmp = CPU_IF_SPEED_NORMAL ? regaddr : (u16)regaddr << 2;
#ifdef TEST_REG
	u16d = RegList[pg][regaddr];
#else
	u16d=ic_mdio_rd(((tmp)>>5)&0x1f,(tmp)&0x1f);
#endif//TEST_REG
#ifdef TEST_REG
	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, regaddr, RegList[pg][regaddr]);
#endif//TEST_REG
	ip1811drv_dbg("read [%02X]=%04x\n", regaddr, u16d);
	return u16d;
}

void _Write_Reg(u8 regaddr, u16 value)
{
	u16 tmp = CPU_IF_SPEED_NORMAL ? regaddr : (u16)regaddr << 2;
	ic_mdio_wr(((tmp)>>5)&0x1f,(tmp)&0x1f,value);

	ip1811drv_dbg("write [%02X]=%04x\n", regaddr, value);
}
u16 _Read_Reg(u8 regaddr)
{
	u16 u16d;
	u16 tmp = CPU_IF_SPEED_NORMAL ? regaddr : (u16)regaddr << 2;
	u16d=ic_mdio_rd(((tmp)>>5)&0x1f,(tmp)&0x1f);
	ip1811drv_dbg("read [%02X]=%04x\n", regaddr, u16d);
	return u16d;
}
u16 Read_Reg_0_With_1s(void)
{
	u16 u16d;
	u16 tmp = CPU_IF_SPEED_NORMAL ? 0x300 : 0x3;
	u16d = ic_mdio_rd(((tmp)>>5)&0x1f,(tmp)&0x1f);
	ip1811drv_dbg("read [%04X]=%04x\n", tmp, u16d);
	return u16d;
}
void IP2Page(u8 page)		// Change page to pagenum
{
	u16 tmp = CPU_IF_SPEED_NORMAL ? REG_Page : (u16)REG_Page << 2;
#ifdef TEST_REG
	pg = page;
#else
	ic_mdio_wr(((tmp)>>5)&0x1f,(tmp)&0x1f,page);
#endif//TEST_REG
	ip1811drv_dbg("set to  page[%02u]\n", page);
}
void _IP2Page(u8 page)		// Change page to pagenum
{
	u16 tmp = CPU_IF_SPEED_NORMAL ? REG_Page : (u16)REG_Page << 2;
	ic_mdio_wr(((tmp)>>5)&0x1f,(tmp)&0x1f,page);
	ip1811drv_dbg("set to  page[%02u]\n", page);
}
/*=============   sub. driver functions   ==================*/
static void _WriteRegBits(u8 page, u16 reg, u8 offset, u8 len, u16 val)
{
	u16 mask = 0;
	u16 u16dat;

	FUNC_MSG_IN;

	IP2Page(page);
	mask = (0x1 << len) - 1;
	u16dat = Read_Reg(reg);
	u16dat &= ~(mask<<offset);
	u16dat |= (val&mask)<<offset;
	Write_Reg(reg, u16dat);

	FUNC_MSG_OUT;
}

static u16 _ReadRegBits(u8 page, u16 reg, u8 offset, u8 len)
{
	u16 mask = 0;
	u16 u16dat;
	u16 val;

	FUNC_MSG_IN;

	IP2Page(page);
	mask = (0x1 << len) - 1;
	u16dat = Read_Reg(reg);
	val = (u16dat>>offset)&mask;

	FUNC_MSG_OUT;
	return val;
}
#if 0
u16 _read_mii_register(u8 phy, u8 page, u8 reg)
{
	u8 option = MII_OP_READ;
	u16 u16dat = 0;
	IP2Page(3);

	// change phy page
	Write_Reg(P3REG_PHYACCESS_DATA, page);
	
	u16dat = (phy & 0x1f); //PHY
	u16dat |= (0x14 & 0x1f ) << 5; //MII Reg
	u16dat |= (MII_OP_WRITE & 0x1 )<< 14;//Read or Write
	u16dat |= 0x1 << 15;//Trigger & Write
	
	Write_Reg(P3REG_PHYACCESS_CMD, u16dat);
	while(_ReadRegBits(3, P3REG_PHYACCESS_CMD, 15, 1));
	udelay(5000);
	
	// phy read command
	u16dat = 0;

	u16dat = (phy & 0x1f);	//PHY
	u16dat |= (reg & 0x1f ) << 5;//MII Reg
	u16dat |= (option & 0x1 )<< 14;//Read or Write
	u16dat |= 0x1 << 15;//Trigger & Write
	
	Write_Reg(P3REG_PHYACCESS_CMD, u16dat);
	while(_ReadRegBits(3, P3REG_PHYACCESS_CMD, 15, 1));
	udelay(5000);
	
	return Read_Reg(P3REG_PHYACCESS_DATA);

}

u16 _write_mii_register(u8 phy, u8 page, u8 reg, u16 val, u8 all)
{
	u8 option = MII_OP_WRITE;
	u16 u16dat = 0;
	u8 count = 0;
	IP2Page(3);

	// change phy page
	do
	{
		Write_Reg(P3REG_PHYACCESS_DATA, page);
	
		u16dat = ((phy+(count*8)) & 0x1f); //PHY
		u16dat |= (0x14 & 0x1f ) << 5; //MII Reg
		u16dat |= (MII_OP_WRITE & 0x1 )<< 14;//Read or Write
		u16dat |= 0x1 << 15;//Trigger & Write
	
		Write_Reg(P3REG_PHYACCESS_CMD, u16dat);
		while(_ReadRegBits(3, P3REG_PHYACCESS_CMD, 15, 1));
		udelay(5000);
		count = count + 1;
	}while(all&&(count<3));
	
	// phy write command
	Write_Reg(P3REG_PHYACCESS_DATA, val);
	u16dat = 0;
	
	u16dat = (phy & 0x1f); //PHY
	u16dat |= (reg & 0x1f ) << 5; //MII Reg
	u16dat |= (all & 0x1) << 10; // write to all 24 phy
	u16dat |= (option & 0x1 )<< 14;//Read or Write
	u16dat |= 0x1 << 15;//Trigger & Write
	
	Write_Reg(P3REG_PHYACCESS_CMD, u16dat);
	while(_ReadRegBits(3, P3REG_PHYACCESS_CMD, 15, 1));
	if(all)
		udelay(30000);
	else
		udelay(5000);
	
	return 0;
}

int get_mii_reg(void *cdata, int len)
{
	u8 phy, page, reg;
	u16 u16dat;

	if (sizeof(struct PhySetting) != len)
		return -EINVAL;

	phy = ((struct PhySetting *)cdata) ->phy;
	page = ((struct PhySetting *)cdata) ->page;
	reg = ((struct PhySetting *)cdata) ->reg;

	if (phy >= 0x20)
		return -EINVAL;	

	if (page >= 0x20)
		return -EINVAL;
	
	if (reg >= 0x20)
		return -EINVAL;
	
	u16dat = _read_mii_register(phy, page, reg);
	((struct PhySetting *)cdata) ->val = (unsigned short)u16dat;
	
	return 0;
}

int set_mii_reg(void *cdata, int len)
{
	u8 phy, page, reg, all;
	u16 val;
	u16 u16dat;

	if (sizeof(struct PhySetting) != len)
		return -EINVAL;

	phy = ((struct PhySetting *)cdata) ->phy;
	page = ((struct PhySetting *)cdata) ->page;
	reg = ((struct PhySetting *)cdata) ->reg;
	val = ((struct PhySetting *)cdata) ->val;
	all = ((struct PhySetting *)cdata) ->all;  // if the command is set 24 phy,bit=1

	if (phy >= 0x20)
		return -EINVAL;
	
	if (page >= 0x20)
		return -EINVAL;
	
	if (reg >= 0x20)
		return -EINVAL;
	
	if (all >= 2)
		return -EINVAL;

	u16dat = _write_mii_register(phy, page, reg, val, all);
	
	return 0;
}

#endif
static int _setGeneralEnable(void *cdata, int len, u8 page, u16 reg, u8 offset)
{
	int gdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	gdata = ((struct GeneralSetting *)cdata) ->gdata;
	if( gdata != OP_FUNC_ENABLE && gdata != OP_FUNC_DISABLE ){
		ip1811drv_err("Error: gdata=%X\n", gdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->gdata=%d\n", gdata);

	_WriteRegBits(page, reg, offset, 1, gdata);

	FUNC_MSG_OUT;
	return 0;
}

static int _getGeneralEnable(void *cdata, int len, u8 page, u16 reg, u8 offset)
{
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	((struct GeneralSetting *)cdata) ->gdata = _ReadRegBits(page, reg, offset, 1);

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	FUNC_MSG_OUT;
	return 0;
}

static int _setPortmapMask(void *cdata, int len, u8 page, u8 reg)
{
	unsigned long pm;
	int pd;
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	pm = ((struct PortmapSetting *)cdata) ->portmap;
	pd = ((struct PortmapSetting *)cdata) ->pmdata;
	if (pm & ~0x1FFFFFFF){
		ip1811drv_err("Error: portmap=%08lX\n", pm);
		return -EINVAL;
	}
	if (pd & ~0x1FFFFFFF){
		ip1811drv_err("Error: pmdata=%X\n", pd);
		return -EINVAL;
	}

	ip1811drv_dbg("portmap=0x%08lX\n", pm);
	ip1811drv_dbg("portdata=0x%08X\n", pd);

	IP2Page(page);
	u32dat = (u32)Read_Reg(reg+1)<<16 | (u32)Read_Reg(reg);

	u32dat &= ~pm;
	u32dat |= pm & pd;

	Write_Reg(reg, (u16)(u32dat & 0xFFFF));
	Write_Reg(reg+1, (u16)(u32dat >> 16));

	FUNC_MSG_OUT;
	return 0;
}

static int _getPortmapMask(void *cdata, int len, u8 page, u8 reg)
{
	unsigned long pm;
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	pm = ((struct PortmapSetting *)cdata) ->portmap;
	if (pm & ~0x1FFFFFFF){
		ip1811drv_err("Error: portmap=%08lX\n", pm);
		return -EINVAL;
	}

	IP2Page(page);
	u32dat = (u32)Read_Reg(reg+1)<<16 | (u32)Read_Reg(reg);
	((struct PortmapSetting *)cdata) ->pmdata = u32dat & pm;

	ip1811drv_dbg("cdata ->portmap=0x%08lX\n", ((struct PortmapSetting *)cdata) ->portmap);
	ip1811drv_dbg("cdata ->pmdata=0x%08X\n", ((struct PortmapSetting *)cdata) ->pmdata);
	FUNC_MSG_OUT;
	return 0;
}


static int _setPortmap(void *cdata, int len, u8 page, u8 reg)
{
	unsigned long pm;
	int pd;
	u16 u16dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	pm = ((struct PortmapSetting *)cdata) ->portmap;
	pd = ((struct PortmapSetting *)cdata) ->pmdata;

	if (pm & ~0xFFF) {
		ip1811drv_err("Error: portmap=%08lX\n", pm);
		return -EINVAL;
	}
	if ((pd != OP_FUNC_ENABLE) && (pd != OP_FUNC_DISABLE)) {
		ip1811drv_err("Error: pd=%X\n", pd);
		return -EINVAL;
	}

	ip1811drv_dbg("portmap=0x%08lX\n", pm);
	ip1811drv_dbg("portdata=0x%X\n", pd);

	IP2Page(page);
	u16dat = Read_Reg(reg);
	
#ifdef COMBINED_PORT
	if ((pm >> 9) & 0x1)
		pm |= (u16)(1 << 10);
#endif

	if (pd == OP_FUNC_ENABLE)
		u16dat |= (u16)pm;
	else//OP_FUNC_DISABLE
		u16dat &= ~(u16)pm;

	Write_Reg(reg, (u16dat & 0xFFF));

	FUNC_MSG_OUT;
	return 0;
}

static int _getPortmap(void *cdata, int len, u8 page, u8 reg)
{
	unsigned long pm;
	u16 u16dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	pm = ((struct PortmapSetting *)cdata) ->portmap;

	if (pm & ~0xFFF){
		ip1811drv_err("Error: portmap=%08lX\n", pm);
		return -EINVAL;
	}
	IP2Page(page);
	u16dat = Read_Reg(reg);
	u16dat &= (u16)pm;
	((struct PortmapSetting *)cdata) ->pmdata = u16dat;

	ip1811drv_dbg("cdata ->pmdata=0x%08X\n", ((struct PortmapSetting *)cdata) ->pmdata);
	FUNC_MSG_OUT;
	return 0;
}


//------------------------------------------------
//common_smi
int switchdSetPortAN(int port, int an)
{
	u16 u16dat;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(an==OP_FUNC_DISABLE || an==OP_FUNC_ENABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("an=%d\n", an);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_AN);
	if (an == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (an == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_AN, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortAN);
int setPortAN(void *cdata, int len)
{
	int port, an;

	ip1811drv_dbg("ip1811: +setPortAN...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	an = ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortAN(port, an) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortAN...\n");
	return 0;
}

int switchdGetPortAN(int port, int *ptrInt)
{
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = _ReadRegBits(3, P3REG_PORTSTS0 + port/2,6+(port&0x1)*8 , 1);
	ip1811drv_dbg("an=0x%x\n", *ptrInt);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetPortAN);
int getPortAN(void *cdata, int len)
{
	int port, an;

	ip1811drv_dbg("ip1811: +getPortAN...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortAN(port, &an) != 0)
		return -EINVAL;

	((struct ByPortSetting *)cdata) ->pdata = an;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortAN...\n");
	return 0;
}

int switchdSetPortSpeed(int port, int speed)
{
	u16 u16dat;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(speed==OP_SMI_SPEED_10 || speed==OP_SMI_SPEED_100 ||
				(speed==OP_SMI_SPEED_1000 && port>=8)) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("speed=%d\n", speed);

	IP2Page(3);
	if (speed == OP_SMI_SPEED_1000)
	{
		u16dat = Read_Reg(P3REG_SPG);
		u16dat |= (u16)(1 << (port-8));
#ifdef COMBINED_PORT
		if (port==9)
			u16dat |= (u16)(1 << (port+1-8));
#endif
		Write_Reg(P3REG_SPG, u16dat);
	}
	else
	{
		if (port >= 8)
		{
			u16dat = Read_Reg(P3REG_SPG);
			u16dat &= (u16)~(1 << (port-8));
#ifdef COMBINED_PORT
		if (port==9)
			u16dat &= (u16)~(1 << (port+1-8));
#endif
			Write_Reg(P3REG_SPG, u16dat);
		}

		u16dat = (u16)( Read_Reg(P3REG_SP) );
		if (speed == OP_SMI_SPEED_100)
			u16dat |= (u16)(1 << port);
		else
			u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
		if (port==9){
			if (speed == OP_SMI_SPEED_100)
				u16dat |= (u16)(1 << port+1);
			else
				u16dat &= (u16)~(1 << port+1);
		}
#endif
		Write_Reg(P3REG_SP, u16dat & 0xFFFF);
	}
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortSpeed);
int setPortSpeed(void *cdata, int len)
{
	int port, speed;

	ip1811drv_dbg("ip1811: +setPortSpeed...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;
	speed= ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortSpeed(port, speed) != 0)
		return -EINVAL;
	ip1811drv_dbg("ip1811: -setPortSpeed...\n");
	return 0;
}

int switchdGetPortSpeed(int port, int *ptrInt)
{
	int speed;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	speed = (int) _ReadRegBits(3, P3REG_PORTSTS0 + port/2,1+(port&0x1)*8 , 2);
	ip1811drv_dbg("speed=0x%x\n", speed);
	if (speed & 0x2)
		*ptrInt = OP_SMI_SPEED_1000;
	else{
		if (speed & 0x1)
			*ptrInt = OP_SMI_SPEED_100;
		else
			*ptrInt = OP_SMI_SPEED_10;
	}
	
	return 0;
}
EXPORT_SYMBOL(switchdGetPortSpeed);
int getPortSpeed(void *cdata, int len)
{
	int port, speed;

	ip1811drv_dbg("ip1811: +getPortSpeed...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortSpeed(port, &speed) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = speed;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortSpeed...\n");
	return 0;
}

int switchdSetPortDuplex(int port, int dup)
{
	u16 u16dat;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(dup==OP_SMI_DUPLEX_HALF || dup==OP_SMI_DUPLEX_FULL) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("dup=%d\n", dup);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_DUPLEX);
	if (dup == OP_SMI_DUPLEX_FULL)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (dup == OP_SMI_DUPLEX_FULL)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_DUPLEX, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortDuplex);
int setPortDuplex(void *cdata, int len)
{
	int port, dup;

	ip1811drv_dbg("ip1811: +setPortDuplex...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	dup =((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortDuplex(port, dup) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortDuplex...\n");
	return 0;
}

int switchdGetPortDuplex(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int) _ReadRegBits(3, P3REG_PORTSTS0 + port/2,(3+(port&0x1)*8), 1);
	ip1811drv_dbg("dup=0x%x\n", *ptrInt);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetPortDuplex);
int getPortDuplex(void *cdata, int len)
{
	int port, dup;

	ip1811drv_dbg("ip1811: +getPortDuplex...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortDuplex(port, &dup) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = dup;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortDuplex...\n");
	return 0;
}

int switchdSetPortPause(int port, int ps)
{
	u16 u16dat;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(ps==OP_FUNC_ENABLE || ps==OP_FUNC_DISABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("ps=%d\n", ps);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_PAUSE);
	if (ps == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (ps == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_PAUSE, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortPause);
int setPortPause(void *cdata, int len)
{
	int port, ps;

	ip1811drv_dbg("ip1811: +setPortPause...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	ps = ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortPause(port, ps) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortPause...\n");
	return 0;
}

int switchdGetPortPause(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int) _ReadRegBits(3, P3REG_PORTSTS0 + port/2,4+(port&0x1)*8 , 1);
	ip1811drv_dbg("ps=0x%x\n", *ptrInt);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetPortPause);
int getPortPause(void *cdata, int len)
{
	int port, ps;

	ip1811drv_dbg("ip1811: +getPortPause...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortPause(port, &ps) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = ps;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortPause...\n");
	return 0;
}

int switchdSetPortAsymPause(int port, int aps)
{
	u16 u16dat;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(aps==OP_FUNC_ENABLE || aps==OP_FUNC_DISABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("aps=%d\n", aps);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_ASPAUSE);
	if (aps == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (aps == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_ASPAUSE, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortAsymPause);
int setPortAsymPause(void *cdata, int len)
{
	int port, aps;

	ip1811drv_dbg("ip1811: +setPortAsymPause...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	aps =((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortAsymPause(port, aps) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortAsymPause...\n");
	return 0;
}

int switchdGetPortAsymPause(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int) _ReadRegBits(3, P3REG_PORTSTS0 + port/2,5+(port&0x1)*8 , 1);
	ip1811drv_dbg("aps=0x%x\n", *ptrInt);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetPortAsymPause);
int getPortAsymPause(void *cdata, int len)
{
	int port, aps;

	ip1811drv_dbg("ip1811: +getPortAsymPause...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortAsymPause(port, &aps) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = aps;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortAsymPause...\n");
	return 0;
}

int switchdSetPortLinkStatus(struct LinkStatusSetting *avg)
{
	int port, sp, dup, ps, asym, an;
	u16 u16dat;
	
	port= avg->port;
	sp = avg->speed;
	dup = avg->duplex;
	ps = avg->pause;
	asym= avg->asym;
	an = avg->an;
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(sp==OP_SMI_SPEED_10 || sp==OP_SMI_SPEED_100 || (sp==OP_SMI_SPEED_1000 && port>8)) )
		return -EINVAL;
	if ( !(dup==OP_SMI_DUPLEX_HALF || dup==OP_SMI_DUPLEX_FULL) )
		return -EINVAL;
	if ( !(ps==OP_FUNC_DISABLE || ps==OP_FUNC_ENABLE) )
		return -EINVAL;
	if ( !(asym==OP_FUNC_DISABLE || asym==OP_FUNC_ENABLE) )
		return -EINVAL;
	if ( !(an==OP_FUNC_DISABLE || an==OP_FUNC_ENABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("sp=%d  dup=%d  ps=%d  asym=%d  an=%d\n",
			sp, dup, ps, asym, an);

	IP2Page(3);
	if (sp == OP_SMI_SPEED_1000)
	{
		u16dat = Read_Reg(P3REG_SPG);
		u16dat |= (u16)(1 << (port-8));
#ifdef COMBINED_PORT
		if (port==9){
			u16dat |= (u16)(1 << (port+1-8));
		}
#endif
		Write_Reg(P3REG_SPG, u16dat);
	}
	else
	{
		if (port >= 8)
		{
			u16dat = Read_Reg(P3REG_SPG);
			u16dat &= (u16)~(1 << (port-8));
#ifdef COMBINED_PORT
			if (port==9){
				u16dat &= (u16)~(1 << (port+1-8));
			}
#endif
			Write_Reg(P3REG_SPG, u16dat);
		}

		u16dat = Read_Reg(P3REG_SP);
		if (sp == OP_SMI_SPEED_100)
			u16dat |= (u16)(1 << port);
		else
			u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
		if (port==9){
			if (sp == OP_SMI_SPEED_100)
				u16dat |= (u16)(1 << port+1);
			else
				u16dat &= (u16)~(1 << port+1);
		}
#endif
		Write_Reg(P3REG_SP, u16dat & 0xFFFF);
	}

	u16dat = Read_Reg(P3REG_DUPLEX);
	if (dup == OP_SMI_DUPLEX_FULL)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (dup == OP_SMI_DUPLEX_FULL)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_DUPLEX, u16dat & 0xFFFF);

	u16dat = Read_Reg(P3REG_PAUSE);
	if (ps == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (ps == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_PAUSE, u16dat & 0xFFFF);

	u16dat = Read_Reg(P3REG_ASPAUSE);
	if (asym == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (asym == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_ASPAUSE, u16dat & 0xFFFF);

	u16dat = Read_Reg(P3REG_AN);
	if (an == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (an == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_AN, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortLinkStatus);
int setPortLinkStatus(void *cdata, int len)
{
	int port, sp, dup, ps, asym, an;
	u16 u16dat;
	struct LinkStatusSetting *avg = (struct LinkStatusSetting *)cdata;

	ip1811drv_dbg("ip1811: +setPortLinkStatus...\n");
	if (sizeof(struct LinkStatusSetting) != len)
		return -EINVAL;

	if(switchdSetPortLinkStatus(avg) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortLinkStatus...\n");
	return 0;
}

int switchdGetPortLinkStatus(struct LinkStatusSetting *cdata)
{
	int port, link, sp, dup, ps, asym, an, fiber;
	u8  u8dat;
	u16 u16dat;
	
	port = ((struct LinkStatusSetting *)cdata) ->port;
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	IP2Page(3);
	u8dat = P3REG_PORTSTS0 + port/2;
	u16dat = Read_Reg(u8dat);
	ip1811drv_dbg("u16dat=0x%04x\n", u16dat);
	link=(int)( ( u16dat >> (0+(port&0x1)*8) ) & 0x1 );
	sp = (int)( ( u16dat >> (1+(port&0x1)*8) ) & 0x3 );
	if (sp & 0x2)	sp = OP_SMI_SPEED_1000;
	else
	{
		if (sp & 0x1)	sp = OP_SMI_SPEED_100;
		else			sp = OP_SMI_SPEED_10;
	}
	dup =(int)( ( u16dat >> (3+(port&0x1)*8) ) & 0x1 );
	ps = (int)( ( u16dat >> (4+(port&0x1)*8) ) & 0x1 );
	asym=(int)( ( u16dat >> (5+(port&0x1)*8) ) & 0x1 );
	an = (int)( ( u16dat >> (6+(port&0x1)*8) ) & 0x1 );
	fiber = (int)( ( u16dat >> (7+(port&0x1)*8) ) & 0x1 );
	ip1811drv_dbg("link=0x%x  sp=%d  dup=0x%x  ps=0x%x  asym=0x%x  an=0x%x  fiber=0x%x\n",
			link, sp, dup, ps, asym, an, fiber);
	((struct LinkStatusSetting *)cdata) ->link = link;
	((struct LinkStatusSetting *)cdata) ->speed = sp;
	((struct LinkStatusSetting *)cdata) ->duplex = dup;
	((struct LinkStatusSetting *)cdata) ->pause = ps;
	((struct LinkStatusSetting *)cdata) ->asym = asym;
	((struct LinkStatusSetting *)cdata) ->an = an;
	((struct LinkStatusSetting *)cdata) ->fiber = fiber;
	ip1811drv_dbg("cdata ->link=%d\n", ((struct LinkStatusSetting *)cdata) ->link);
	ip1811drv_dbg("cdata ->speed=%d\n", ((struct LinkStatusSetting *)cdata) ->speed);
	ip1811drv_dbg("cdata ->duplex=%d\n", ((struct LinkStatusSetting *)cdata) ->duplex);
	ip1811drv_dbg("cdata ->pause=%d\n", ((struct LinkStatusSetting *)cdata) ->pause);
	ip1811drv_dbg("cdata ->asym=%d\n", ((struct LinkStatusSetting *)cdata) ->asym);
	ip1811drv_dbg("cdata ->an=%d\n", ((struct LinkStatusSetting *)cdata) ->an);
	ip1811drv_dbg("cdata ->fiber=%d\n", ((struct LinkStatusSetting *)cdata) ->fiber);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetPortLinkStatus);
int getPortLinkStatus(void *cdata, int len)
{
	struct LinkStatusSetting *avg = (struct LinkStatusSetting *)cdata;

	ip1811drv_dbg("ip1811: +getPortLinkStatus...\n");
	if (sizeof(struct LinkStatusSetting) != len)
		return -EINVAL;

	if(switchdGetPortLinkStatus(avg) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -getPortLinkStatus...\n");
	return 0;
}

int switchdSetPortBackpressure(int port, int bp)
{
	u16 u16dat;

	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(bp==OP_FUNC_ENABLE || bp==OP_FUNC_DISABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("bp=%d\n", bp);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_BPRESS);
	if (bp == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (bp == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_BPRESS, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortBackpressure);
int setPortBackpressure(void *cdata, int len)
{
	int port, bp;

	ip1811drv_dbg("ip1811: +setPortBackpressure...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	bp = ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortBackpressure(port, bp) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortBackpressure...\n");
	return 0;
}

int switchdGetPortBackpressure(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int)_ReadRegBits(3, P3REG_BPRESS + port/16, port%16, 1);
	ip1811drv_dbg("bp=0x%x\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetPortBackpressure);
int getPortBackpressure(void *cdata, int len)
{
	int port, bp;

	ip1811drv_dbg("ip1811: +getPortBackpressure...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortBackpressure(port, &bp) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = bp;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortBackpressure...\n");
	return 0;
}

int switchdSetPortPowerDown(int port, int pd)
{
	u16 u16dat;

	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(pd==OP_FUNC_ENABLE || pd==OP_FUNC_DISABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("pd=%d\n", pd);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_POWERDOWN);
	if (pd == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
	Write_Reg(P3REG_POWERDOWN, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortPowerDown);
int setPortPowerDown(void *cdata, int len)
{
	int port, pd;

	ip1811drv_dbg("ip1811: +setPortPowerDown...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	pd = ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortPowerDown(port, pd) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortPowerDown...\n");
	return 0;
}

int switchdGetPortPowerDown(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

	*ptrInt = (int)_ReadRegBits(3, P3REG_POWERDOWN + port/16, port%16, 1);
	ip1811drv_dbg("pd=0x%x\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetPortPowerDown);
int getPortPowerDown(void *cdata, int len)
{
	int port, pd;

	ip1811drv_dbg("ip1811: +getPortPowerDown...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortPowerDown(port, &pd) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = pd;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortPowerDown...\n");
	return 0;
}

int switchdSetPortForceLink(int port, int fl)
{
	u16 u16dat;

	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(fl==OP_FUNC_ENABLE || fl==OP_FUNC_DISABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("fl=%d\n", fl);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_FORCELINK);
	if (fl == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (fl == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_FORCELINK, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortForceLink);
int setPortForceLink(void *cdata, int len)
{
	int port, fl;

	ip1811drv_dbg("ip1811: +setPortForceLink...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	fl = ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortForceLink(port, fl) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortForceLink...\n");
	return 0;
}

int switchdGetPortForceLink(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int)_ReadRegBits(3, P3REG_FORCELINK + port/16, port%16, 1);
	ip1811drv_dbg("fl=0x%x\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetPortForceLink);
int getPortForceLink(void *cdata, int len)
{
	int port, fl;

	ip1811drv_dbg("ip1811: +getPortForceLink...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortForceLink(port, &fl) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = fl;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortForceLink...\n");
	return 0;
}

int switchdSetPortUniDirection(int port, int uni)
{
	u16 u16dat;

	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(uni==OP_FUNC_ENABLE || uni==OP_FUNC_DISABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("uni=%d\n", uni);

	IP2Page(3);
	u16dat = Read_Reg(P3REG_UNIDIRECT);
	if (uni == OP_FUNC_ENABLE)
		u16dat |= (u16)(1 << port);
	else
		u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (uni == OP_FUNC_ENABLE)
			u16dat |= (u16)(1 << port+1);
		else
			u16dat &= (u16)~(1 << port+1);
	}
#endif
	Write_Reg(P3REG_UNIDIRECT, u16dat & 0xFFFF);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetPortUniDirection);
int setPortUniDirection(void *cdata, int len)
{
	int port, uni;

	ip1811drv_dbg("ip1811: +setPortUniDirection...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	uni =((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetPortUniDirection(port, uni) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setPortUniDirection...\n");
	return 0;
}

int switchdGetPortUniDirection(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int)_ReadRegBits(3, P3REG_UNIDIRECT + port/16, (port-1)%16, 1);
	ip1811drv_dbg("uni=0x%x\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetPortUniDirection);
int getPortUniDirection(void *cdata, int len)
{
	int port, uni;

	ip1811drv_dbg("ip1811: +getPortUniDirection...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetPortUniDirection(port, &uni) != 0)
		return -EINVAL;
	((struct ByPortSetting *)cdata) ->pdata = uni;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getPortUniDirection...\n");
	return 0;
}

//------------------------------------------------
//common_cap
int switchdSetL2CapAct(int ptcl, int act)
{
	u32 u32dat, mask;

	if (ptcl < OP_CAP_PTCL_BPDU || ptcl > OP_CAP_PTCL_GRP3)
		return -EINVAL;
	if (act!=OP_CAP_ACT_FORWARD && act!=OP_CAP_ACT_TO_CPU && act!=OP_CAP_ACT_DROP)
		return -EINVAL;
	ip1811drv_dbg("ptcl=%d\n", ptcl);
	ip1811drv_dbg("act=%d\n", act);

	IP2Page(0);
	u32dat = ( Read_Reg(P0REG_L2FRAMEGETCTRL1) << 16 | Read_Reg(P0REG_L2FRAMEGETCTRL) );
	mask = (u32)~(0x3 << (ptcl*2));
	u32dat &= mask;
	u32dat |= (u32)(act << (ptcl*2));
	Write_Reg(P0REG_L2FRAMEGETCTRL, (u16)(u32dat & 0xFFFF));
	Write_Reg(P0REG_L2FRAMEGETCTRL1, (u16)(u32dat >> 16));

	return 0;
}
EXPORT_SYMBOL(switchdSetL2CapAct);
int setL2CapAct(void *cdata, int len)
{
	int ptcl, act;

	ip1811drv_dbg("ip1811: +setL2CapAct...\n");
	if (sizeof(struct CapActSetting) != len)
		return -EINVAL;

	ptcl= ((struct CapActSetting *)cdata) ->protocol;
	act = ((struct CapActSetting *)cdata) ->act;

	if(switchdSetL2CapAct(ptcl, act) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setL2CapAct...\n");
	return 0;
}

int switchdSetCapInBand(int gdata)
{
	if( gdata != OP_CAP_ACT_TO_CPU && gdata != OP_CAP_ACT_DROP ){
		ip1811drv_err("Error: gdata=%X\n", gdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->gdata=%d\n", gdata);

	_WriteRegBits(0, P0REG_MACBEHAVIOR, 6, 1, (gdata==OP_CAP_ACT_TO_CPU?0x1:0x0));

	return 0;
}
EXPORT_SYMBOL(switchdSetCapInBand);
int setCapInBand(void *cdata, int len)
{
	int gdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	gdata = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetCapInBand(gdata) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

void switchdSetCapSwitchMac(unsigned char * mac)
{
	int i;
	u16 u16dat;

	for(i=0; i<6; i++)
		ip1811drv_dbg("cdata ->mac[%d]=%X\n", i, mac[i]);
	IP2Page(0);
	for(i=0; i<3; i++){
		u16dat = ((((u16)mac[i*2])&0xFF)<<8) | (((u16)mac[i*2+1])&0xFF);
		Write_Reg(P0REG_MACADDRESS+(2-i), u16dat);
	}
}
EXPORT_SYMBOL(switchdSetCapSwitchMac);
int setCapSwitchMac(void *cdata, int len)
{
	char mac[6];

	FUNC_MSG_IN;
	if (sizeof(struct MACSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	memcpy(mac, ((struct MACSetting *)cdata) ->mac, 6);

	switchdSetCapSwitchMac(mac);

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetCapIpv6TcpUdpEnable(int enable)
{
	if(enable!=OP_FUNC_ENABLE && enable!=OP_FUNC_DISABLE) {
		ip1811drv_err("Error: enable=%X\n", enable);
		return -EINVAL;
	}
	
	ip1811drv_dbg("enable=%d\n", enable);

	_WriteRegBits(0, P0REG_IPV6RLTCFG, 0, 1, enable);
	return 0;
}
EXPORT_SYMBOL(switchdSetCapIpv6TcpUdpEnable);
int setCapIpv6TcpUdpEnable(void *cdata, int len)
{
	int ret, en;
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	en = ((struct GeneralSetting *)cdata) ->gdata;

	ret = switchdSetCapIpv6TcpUdpEnable(en);
	FUNC_MSG_OUT;
	return ret;
}

//------------------------------------------------
//common_lut
int switchdSetSMACLearning(int port, int en)
{
	u32 u32dat;

	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if ( !(en==OP_FUNC_DISABLE || en==OP_FUNC_ENABLE) )
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("en=%d\n", en);

	IP2Page(1);
	u32dat = (u32)Read_Reg(P1REG_SRCLEARN_ENABLE);
	if (en == OP_FUNC_ENABLE)
		u32dat |= (u32)(1 << port);
	else
		u32dat &= (u32)~(1 << port);
#ifdef COMBINED_PORT
	if (port==9){
		if (en == OP_FUNC_ENABLE)
			u32dat |= (u32)(1 << port+1);
		else
			u32dat &= (u32)~(1 << port+1);
	}
#endif
	Write_Reg(P1REG_SRCLEARN_ENABLE, (u32dat & 0xFFF));

	return 0;
}
EXPORT_SYMBOL(switchdSetSMACLearning);
int setSMACLearning(void *cdata, int len)
{
	int port, en;

	ip1811drv_dbg("ip1811: +setSMACLearning...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port=((struct ByPortSetting *)cdata) ->port;
	en = ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetSMACLearning(port, en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setSMACLearning...\n");
	return 0;
}

int switchdGetSMACLearning(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int)_ReadRegBits(1, P1REG_SRCLEARN_ENABLE, port, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetSMACLearning);
int getSMACLearning(void *cdata, int len)
{
	int port, en;

	ip1811drv_dbg("ip1811: +getSMACLearning...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetSMACLearning(port, &en) != 0)
		return -EINVAL;

	((struct ByPortSetting *)cdata) ->pdata = en;

	ip1811drv_dbg("ip1811: -getSMACLearning...\n");
	return 0;
}

int switchdSetLutPortFlush(unsigned long pm, int en)
{
	u16 u16dat;
	
	if (pm & 0xF000)
		return -EINVAL;
	if (	en != OP_LUT_FLUSH_DYNAMIC_ONLY &&
			en != OP_LUT_FLUSH_STATIC_ONLY &&
			en != OP_LUT_FLUSH_ALL )
		return -EINVAL;
	ip1811drv_dbg("pm=0x%04x\n", (u16)pm);
	ip1811drv_dbg("en=%d\n", en);

    /* start to flush LUT */
	IP2Page(1);
	u16dat = 0x80;
	if (en == OP_LUT_FLUSH_ALL)
		u16dat |= (u16)0x40;	// flush static entries
	Write_Reg(P1REG_PORTFLUSH, (u16)(pm & 0x0FFF));
	Write_Reg(P1REG_LUTFLUSH_CFG, u16dat);
	udelay(10000);//flush LUT needs waiting at least 4 ms
				
	return 0;
}
EXPORT_SYMBOL(switchdSetLutPortFlush);
int setLutPortFlush(void *cdata, int len)
{
	unsigned long pm;
	int en;

	ip1811drv_dbg("ip1811: +setLutPortFlush...\n");
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;

	pm = ((struct PortmapSetting *)cdata) ->portmap;
	en = ((struct PortmapSetting *)cdata) ->pmdata;

	if(switchdSetLutPortFlush(pm, en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setLutPortFlush...\n");
	return 0;
}

int switchdSetLutAgingTime(int time)
{
	if (time > 18000)
		return -EINVAL;
	ip1811drv_dbg("time=%d\n", time);

	_WriteRegBits(1, P1REG_LUTAGINGTIME, 0, 15, (u16)(time*1000/AGING_TIME_UNIT));

	return 0;
}
EXPORT_SYMBOL(switchdSetLutAgingTime);
int setLutAgingTime(void *cdata, int len)
{
	int time;

	ip1811drv_dbg("ip1811: +setLutAgingTime...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	time = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetLutAgingTime(time) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setLutAgingTime...\n");
	return 0;
}

void switchdGetLutAgingTime(int *ptrInt)
{
	*ptrInt = ((int)_ReadRegBits(1, P1REG_LUTAGINGTIME, 0, 15))*AGING_TIME_UNIT/1000;
}
EXPORT_SYMBOL(switchdGetLutAgingTime);
int getLutAgingTime(void *cdata, int len)
{
	int time;

	ip1811drv_dbg("ip1811: +getLutAgingTime...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	switchdGetLutAgingTime(&time);

	((struct GeneralSetting *)cdata) ->gdata = time;

    ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getLutAgingTime...\n");
	return 0;
}

int switchdSetLutAgingTimeEnable(int en)
{
	if ( !(en==OP_FUNC_DISABLE || en==OP_FUNC_ENABLE) )
		return -EINVAL;

	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(1, P1REG_LUTAGINGTIME, 15, 1, (en==OP_FUNC_ENABLE)?0:1);

	return 0;
}
EXPORT_SYMBOL(switchdSetLutAgingTimeEnable);
int setLutAgingTimeEnable(void *cdata, int len)
{
	int en;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetLutAgingTimeEnable(en) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetLutLearningNullSA(int en)
{
	if ( !(en==OP_FUNC_DISABLE || en==OP_FUNC_ENABLE) )
		return -EINVAL;

	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(1, P1REG_SRCLEARNCFG, 1, 1, en);

	return 0;
}
EXPORT_SYMBOL(switchdSetLutLearningNullSA);
int setLutLearningNullSA(void *cdata, int len)
{
	int en;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetLutLearningNullSA(en) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetLutHashingAlgorithm(int hash)
{
	if ( !(hash==OP_HASH_DIRECT || hash==OP_HASH_CRC) )
		return -EINVAL;
		
	ip1811drv_dbg("hash=%d\n", hash);

	_WriteRegBits(1, P1REG_SRCLEARNCFG, 2, 1, (hash==OP_HASH_CRC)?0:1);

	return 0;
}
EXPORT_SYMBOL(switchdSetLutHashingAlgorithm);
int setLutHashingAlgorithm(void *cdata, int len)
{
	int hash;

	ip1811drv_dbg("ip1811: +setLutHashingAlgorithm...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	hash = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetLutHashingAlgorithm(hash) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setLutHashingAlgorithm...\n");
	return 0;
}

int switchdSetLutBindingEnable(int en)
{
	if ( !(en==OP_FUNC_DISABLE || en==OP_FUNC_ENABLE) )
		return -EINVAL;

	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(1, P1REG_SRCLEARNCFG, 5, 1, (en==OP_FUNC_ENABLE)?1:0);

	return 0;
}
EXPORT_SYMBOL(switchdSetLutBindingEnable);
int setLutBindingEnable(void *cdata, int len)
{
	int en;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetLutBindingEnable(en) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

void switchdGetLutBindingEnable(int *ptrInt)
{
	*ptrInt = (int)(_ReadRegBits(1, P1REG_SRCLEARNCFG, 5, 1)?OP_FUNC_ENABLE:OP_FUNC_DISABLE);
}
EXPORT_SYMBOL(switchdGetLutBindingEnable);
int getLutBindingEnable(void *cdata, int len)
{
	int en;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	switchdGetLutBindingEnable(&en);

	((struct GeneralSetting *)cdata) ->gdata = en;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	FUNC_MSG_OUT;
	return 0;
}

//------------------------------------------------
//common_sniffer
int switchdSetSnifferSrc(unsigned long pm)
{
	if (pm & 0xFFFFF000)
		return -EINVAL;
	ip1811drv_dbg("pm=0x%08x\n",(unsigned long)pm);

	IP2Page(1);
	Write_Reg(P1REG_SNIFSRC, (u16)(pm & 0xFFF));

	return 0;
}
EXPORT_SYMBOL(switchdSetSnifferSrc);
int setSnifferSrc(void *cdata, int len)
{
	unsigned long pm;

	ip1811drv_dbg("ip1811: +setSnifferSrc...\n");
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	pm = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetSnifferSrc(pm) != 0)
		return -EINVAL;
	ip1811drv_dbg("ip1811: -setSnifferSrc...\n");
	return 0;
}

int switchdGetSnifferSrc(u16 *u16dat)
{
	IP2Page(1);
	*u16dat = (u16)Read_Reg(P1REG_SNIFSRC);
	
	ip1811drv_dbg("cdata ->pdata=%d\n", *u16dat);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetSnifferSrc);
int getSnifferSrc(void *cdata, int len)
{
	u16 u16dat;

	ip1811drv_dbg("ip1811: +getSnifferSrc...\n");
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	if(switchdGetSnifferSrc(&u16dat) != 0)
		return -EINVAL;
		
	((struct PortMemberSetting *)cdata) ->member = (u16dat & 0xFFF);
	ip1811drv_dbg("cdata ->gdata=0x%08x\n",(unsigned int)((struct PortMemberSetting *)cdata) ->member);
	ip1811drv_dbg("ip1811: -getSnifferSrc...\n");
	return 0;
}

int switchdSetSnifferDestGrp1(unsigned long pm)
{
	u32 u32dat;
	
	if (pm & 0xFFFFF000)
		return -EINVAL;
	ip1811drv_dbg("pm=0x%08x\n", (unsigned int)pm);

	IP2Page(1);
	u32dat = (u32)Read_Reg(P1REG_SNIFDEST);
	u32dat = ((u32dat & 0xFFFFF000) | pm);
	Write_Reg(P1REG_SNIFDEST, (u16)(u32dat & 0xFFF));

	return 0;
}
EXPORT_SYMBOL(switchdSetSnifferDestGrp1);
int setSnifferDestGrp1(void *cdata, int len)
{
	unsigned long pm;

	ip1811drv_dbg("ip1811: +setSnifferDestGrp1...\n");
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	pm = ((struct PortMemberSetting *)cdata) ->member;

	if(switchdSetSnifferDestGrp1(pm) != 0)
		return -EINVAL;
	ip1811drv_dbg("ip1811: -setSnifferDestGrp1...\n");
	return 0;
}

int switchdGetSnifferDestGrp1(u16 *u16dat)
{
	IP2Page(1);
	*u16dat = (u16)Read_Reg(P1REG_SNIFDEST);
	ip1811drv_dbg("cdata ->pdata=%d\n", *u16dat);

	return 0;
}
EXPORT_SYMBOL(switchdGetSnifferDestGrp1);
int getSnifferDestGrp1(void *cdata, int len)
{
	u16 u16dat;

	ip1811drv_dbg("ip1811: +getSnifferDestGrp1...\n");
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	if(switchdGetSnifferDestGrp1(&u16dat) != 0)
		return -EINVAL;
		
	((struct PortMemberSetting *)cdata) ->member = (u16dat & 0xFFF);
	ip1811drv_dbg("cdata ->gdata=0x%08x\n", (unsigned int)((struct PortMemberSetting *)cdata) ->member);
	ip1811drv_dbg("ip1811: -getSnifferDestGrp1...\n");
	return 0;
}

int switchdSetS1Method(int method)
{
	if (method<OP_SNIFFER1_METHOD_DISABLE || method>OP_SNIFFER1_METHOD_BOTHDIR)
		return -EINVAL;
	ip1811drv_dbg("method=%d\n", method);

	_WriteRegBits(1, P1REG_SNIFCFG, 0, 2, method);

	return 0;
}
EXPORT_SYMBOL(switchdSetS1Method);
int setS1Method(void *cdata, int len)
{
	int method;

	ip1811drv_dbg("ip1811: +setS1Method...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	method = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetS1Method(method) != 0)
		return -EINVAL;
	ip1811drv_dbg("ip1811: -setS1Method...\n");
	return 0;
}

int switchdGetS1Method(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_SNIFCFG, 0, 2);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetS1Method);
int getS1Method(void *cdata, int len)
{
	int method;
	
	ip1811drv_dbg("ip1811: +getS1Method...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetS1Method(&method) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = method;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getS1Method...\n");
	return 0;
}
//------------------------------------------------
//common_storm
int switchdSetStormFunc(int storm, int porten)
{
	u8 u8dat=0;
	
	if (storm!=OP_STORM_BCST && storm!=OP_STORM_MCST && storm!=OP_STORM_DLF &&
			storm!=OP_STORM_ARP && storm!=OP_STORM_ICMP)
		return -EINVAL;
	if (porten<0 || (porten&0xFFFFF000))
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);
	ip1811drv_dbg("porten=0x%08x\n", (unsigned int)porten);

	IP2Page(1);
	switch (storm){
		case OP_STORM_BCST:
			u8dat = P1REG_BSTORMEN;
			break;
		case OP_STORM_MCST:
			u8dat = P1REG_MSTORMEN;
			break;

		case OP_STORM_DLF:
			u8dat = P1REG_DLFSTORMEN;
			break;

		case OP_STORM_ARP:
			u8dat = P1REG_ARPSTORMEN;
			break;

		case OP_STORM_ICMP:
			u8dat = P1REG_ICMPSTORMEN;
			break;
	}
	Write_Reg(u8dat, (u16)(porten & 0xFFFF));
	
	return 0;
}
EXPORT_SYMBOL(switchdSetStormFunc);
int setStormFunc(void *cdata, int len)
{
	u8 storm;
	long porten;

	ip1811drv_dbg("ip1811: +setStormFunc...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;
	porten= ((struct StormGeneralSetting *)cdata) ->sdata;

	if(switchdSetStormFunc(storm, porten) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setStormFunc...\n");
	return 0;
}

int switchdGetStormFunc(int storm, u32 *u32dat)
{
	u8 u8dat=0;
	
	if (storm!=OP_STORM_BCST && storm!=OP_STORM_MCST && storm!=OP_STORM_DLF &&
			storm!=OP_STORM_ARP && storm!=OP_STORM_ICMP)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);

	IP2Page(1);
	switch (storm){
		case OP_STORM_BCST:
			u8dat = P1REG_BSTORMEN;
			break;
		case OP_STORM_MCST:
			u8dat = P1REG_MSTORMEN;
			break;
		case OP_STORM_DLF:
			u8dat = P1REG_DLFSTORMEN;
			break;
		case OP_STORM_ARP:
			u8dat = P1REG_ARPSTORMEN;
			break;
		case OP_STORM_ICMP:
			u8dat = P1REG_ICMPSTORMEN;
			break;
	}
	*u32dat = (u32)Read_Reg(u8dat);

	ip1811drv_dbg("cdata ->sdata=0x%08x\n", *u32dat);
	return 0;
}
EXPORT_SYMBOL(switchdGetStormFunc);
int getStormFunc(void *cdata, int len)
{
	u8 storm;
	u32 u32dat;

	ip1811drv_dbg("ip1811: +getStormFunc...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;

	if(switchdGetStormFunc(storm, &u32dat) != 0)
		return -EINVAL;
	((struct StormGeneralSetting *)cdata) ->sdata = (long)u32dat;
	
	ip1811drv_dbg("ip1811: -getStormFunc...\n");
	return 0;
}

int switchdSetStormThreshold(u8 storm, long threshold)
{
	u8 u8dat=0;
	
	if (storm!=OP_STORM_BCST && storm!=OP_STORM_MCST && storm!=OP_STORM_DLF &&
			storm!=OP_STORM_ARP && storm!=OP_STORM_ICMP)
		return -EINVAL;
	if (threshold<0 || threshold>0xFF)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);
	ip1811drv_dbg("threshold=0x%08x\n", (unsigned int)threshold);

	switch (storm)
	{
		case OP_STORM_BCST:
		case OP_STORM_MCST:
		case OP_STORM_DLF:
			u8dat = P1REG_BSTORMTHRESH;	break;

		case OP_STORM_ARP:
			u8dat = P1REG_ARPSTORMCFG;	break;

		case OP_STORM_ICMP:
			u8dat = P1REG_ICMPSTORMCFG;	break;
	}
	_WriteRegBits(1, u8dat, 0, 8, (u16)threshold);

	return 0;
}
EXPORT_SYMBOL(switchdSetStormThreshold);
int setStormThreshold(void *cdata, int len)
{
	u8 storm;
	long threshold;

	ip1811drv_dbg("ip1811: +setStormThreshold...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;
	threshold = ((struct StormGeneralSetting *)cdata) ->sdata;
	
	if(switchdSetStormThreshold(storm, threshold) != 0)
		return -EINVAL;
	
	ip1811drv_dbg("ip1811: -setStormThreshold...\n");
	return 0;
}

int switchdGetStormThreshold(u8 storm, long *ptrLong)
{
	u8 u8dat=0;
	if (storm!=OP_STORM_BCST && storm!=OP_STORM_MCST && storm!=OP_STORM_DLF &&
			storm!=OP_STORM_ARP && storm!=OP_STORM_ICMP)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);

	switch (storm)
	{
		case OP_STORM_BCST:
		case OP_STORM_MCST:
		case OP_STORM_DLF:
			u8dat = P1REG_BSTORMTHRESH;	break;

		case OP_STORM_ARP:
			u8dat = P1REG_ARPSTORMCFG;	break;

		case OP_STORM_ICMP:
			u8dat = P1REG_ICMPSTORMCFG;	break;
	}
	*ptrLong = (long)_ReadRegBits(1, u8dat, 0, 8);

	return 0;
}
EXPORT_SYMBOL(switchdGetStormThreshold);
int getStormThreshold(void *cdata, int len)
{
	u8 storm;
	long threshold;

	ip1811drv_dbg("ip1811: +getStormThreshold...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;

	if(switchdGetStormThreshold(storm, &threshold) != 0)
		return -EINVAL;

	((struct StormGeneralSetting *)cdata) ->sdata = threshold;
	ip1811drv_dbg("cdata ->sdata=0x%08x\n", (unsigned int)((struct StormGeneralSetting *)cdata) ->sdata);
	ip1811drv_dbg("ip1811: -getStormThreshold...\n");
	return 0;
}

int switchdSetStormCntrClrPeriod(u8 storm, long period)
{
	u8 reg=0;
	
	if (		storm!=OP_STORM_BCST
			&&	storm!=OP_STORM_MCST
			&&	storm!=OP_STORM_DLF
			&&	storm!=OP_STORM_ARP
			&&	storm!=OP_STORM_ICMP)
		return -EINVAL;
	if (period<0 || period>3)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);
	ip1811drv_dbg("period=0x%X\n", (unsigned int)period);

	switch (storm)
	{
		case OP_STORM_BCST:
		case OP_STORM_MCST:
		case OP_STORM_DLF:
			reg = P1REG_BSTORMTHRESH;
			break;
		case OP_STORM_ARP:
			reg = P1REG_ARPSTORMCFG;
			break;
		case OP_STORM_ICMP:
			reg = P1REG_ICMPSTORMCFG;
			break;
	}
	ip1811drv_dbg("cdata ->sdata=0x%X\n", (s16)period);
	
	_WriteRegBits(1, reg, 8, 2, period);

	return 0;
}
EXPORT_SYMBOL(switchdSetStormCntrClrPeriod);
int setStormCntrClrPeriod(void *cdata, int len)
{
	u8 storm;
	long period;

	FUNC_MSG_IN;
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;
	period = ((struct StormGeneralSetting *)cdata) ->sdata;

	if(switchdSetStormCntrClrPeriod(storm, period) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdGetStormCntrClrPeriod(u8 storm, long *ptrInt)
{
	u8 reg =0;
	
	if (		storm!=OP_STORM_BCST
			&&	storm!=OP_STORM_MCST
			&&	storm!=OP_STORM_DLF
			&&	storm!=OP_STORM_ARP
			&&	storm!=OP_STORM_ICMP)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);
	
	switch (storm)
	{
		case OP_STORM_BCST:
		case OP_STORM_MCST:
		case OP_STORM_DLF:
			reg = P1REG_BSTORMTHRESH;
			break;
		case OP_STORM_ARP:
			reg = P1REG_ARPSTORMCFG;
			break;
		case OP_STORM_ICMP:
			reg = P1REG_ICMPSTORMCFG;
			break;
	}

	*ptrInt = _ReadRegBits(1, reg, 8, 2);
	
	ip1811drv_dbg("cdata ->sdata=0x%X\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetStormCntrClrPeriod);
int getStormCntrClrPeriod(void *cdata, int len)
{
	u8 storm;
	long period=0;

	FUNC_MSG_IN;
	ip1811drv_dbg("ip1811: +getStormCntrClrPeriod...\n");
	if (sizeof(struct StormGeneralSetting) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	storm = ((struct StormGeneralSetting *)cdata) ->storm;

	if(switchdGetStormCntrClrPeriod(storm, &period) != 0)
		return -EINVAL;

	((struct StormGeneralSetting *)cdata) ->sdata = period;
	
	ip1811drv_dbg("ip1811: -getStormCntrClrPeriod...\n");
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetStormBlockFrm2Cpu(int storm, int en)
{
	u8 u8dat=0;

	if (storm!=OP_STORM_BCST && storm!=OP_STORM_MCST && storm!=OP_STORM_ARP)
		return -EINVAL;
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);
	ip1811drv_dbg("en=0x%08x\n", (unsigned int)en);

	switch (storm)
	{
		case OP_STORM_BCST:
		case OP_STORM_MCST:
			u8dat = P1REG_BSTORMTHRESH;	break;

		case OP_STORM_ARP:
			u8dat = P1REG_ARPSTORMCFG;	break;
	}
	_WriteRegBits(1, u8dat, 10, 1, en);

	return 0;
}
EXPORT_SYMBOL(switchdSetStormBlockFrm2Cpu);
int setStormBlockFrm2Cpu(void *cdata, int len)
{
	u8 storm = 0;
	long en;

	ip1811drv_dbg("ip1811: +setStormBlockFrm2Cpu...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;
	en = ((struct StormGeneralSetting *)cdata) ->sdata;

	if(switchdSetStormBlockFrm2Cpu(storm, en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setStormBlockFrm2Cpu...\n");
	return 0;
}

int switchdGetStormBlockFrm2Cpu(u8 storm, int *ptrInt)
{
	u8 u8dat=0;
	
	if (storm!=OP_STORM_BCST && storm!=OP_STORM_MCST && storm!=OP_STORM_ARP)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);

	switch (storm)
	{
		case OP_STORM_BCST:
		case OP_STORM_MCST:
			u8dat = P1REG_BSTORMTHRESH;	break;

		case OP_STORM_ARP:
			u8dat = P1REG_ARPSTORMCFG;	break;
	}

	*ptrInt = (int)_ReadRegBits(1, u8dat, 10, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetStormBlockFrm2Cpu);
int getStormBlockFrm2Cpu(void *cdata, int len)
{
	u8 storm;
	int en;

	ip1811drv_dbg("ip1811: +getStormBlockFrm2Cpu...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;

	if(switchdGetStormBlockFrm2Cpu(storm, &en) != 0)
		return -EINVAL;

	((struct StormGeneralSetting *)cdata) ->sdata = en;
	ip1811drv_dbg("cdata ->sdata=0x%08x\n", (unsigned int)((struct StormGeneralSetting *)cdata) ->sdata);
	ip1811drv_dbg("ip1811: -getStormBlockFrm2Cpu...\n");
	return 0;
}

int switchdSetStormDropInterrupt(u8 storm, int en)
{
	if (storm!=OP_STORM_ARP && storm!=OP_STORM_ICMP)
		return -EINVAL;
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);
	ip1811drv_dbg("en=0x%08x\n", en);

	switch (storm)
	{
		case OP_STORM_ARP:
			_WriteRegBits(1, P1REG_ARPSTORMCFG, 11, 1, (en == OP_FUNC_DISABLE)?0:1);
			break;

		case OP_STORM_ICMP:
			_WriteRegBits(1, P1REG_ICMPSTORMCFG, 10, 1, (en == OP_FUNC_DISABLE)?0:1);
			break;
	}

	return 0;
}
EXPORT_SYMBOL(switchdSetStormDropInterrupt);
int setStormDropInterrupt(void *cdata, int len)
{
	u8 storm;
	int en;

	ip1811drv_dbg("ip1811: +setStormDropInterrupt...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;
	en = ((struct StormGeneralSetting *)cdata) ->sdata;

	if(switchdSetStormDropInterrupt(storm, en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setStormDropInterrupt...\n");
	return 0;
}

int switchdGetStormDropInterrupt(u8 storm, int *ptrInt)
{
	if (storm!=OP_STORM_ARP && storm!=OP_STORM_ICMP)
		return -EINVAL;
	ip1811drv_dbg("storm=0x%02X\n", storm);

	switch (storm)
	{
		case OP_STORM_ARP:
			*ptrInt = (int)_ReadRegBits(1, P1REG_ARPSTORMCFG, 11, 1);
			break;

		case OP_STORM_ICMP:
			*ptrInt = (int)_ReadRegBits(1, P1REG_ICMPSTORMCFG, 10, 1);
			break;
	}
	
	ip1811drv_dbg("cdata ->sdata=0x%08x\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetStormDropInterrupt);
int getStormDropInterrupt(void *cdata, int len)
{
	u8 storm;
	int en;

	ip1811drv_dbg("ip1811: +getStormDropInterrupt...\n");
	if (sizeof(struct StormGeneralSetting) != len)
		return -EINVAL;

	storm = ((struct StormGeneralSetting *)cdata) ->storm;

	if(switchdGetStormDropInterrupt(storm, &en) != 0)
		return -EINVAL;
		
	((struct StormGeneralSetting *)cdata) ->sdata = en;
	
	ip1811drv_dbg("ip1811: -getStormDropInterrupt...\n");
	return 0;
}

//------------------------------------------------
//common_loop_detect
int switchdSetLdFunc(unsigned int pm, int en)
{
	u16 u16dat;
	if (pm & 0xF000)
		return -EINVAL;

	ip1811drv_dbg("pm=0x%08x\n", pm);
	ip1811drv_dbg("en=%d\n", en);
	_WriteRegBits(1, P1REG_MISCCFG, 11, 1, en);

	IP2Page(0);
	u16dat = Read_Reg(P0REG_LDEN);
	u16dat = ((u16dat & 0xF000) | pm);
	Write_Reg(P0REG_LDEN, u16dat);

	return 0;
}
EXPORT_SYMBOL(switchdSetLdFunc);

int setLdFunc(void *cdata, int len)
{
	unsigned long pm;
	int en, ret;
	u32 u32dat;

	ip1811drv_dbg("ip1811: +setLdFunc...\n");
	if (sizeof(struct PortmapSetting) != len) {
		ret = -EINVAL;
		goto out_setLdFunc;
	}

	pm = ((struct PortmapSetting *)cdata) ->portmap;
	en = ((struct PortmapSetting *)cdata) ->pmdata;
	ret = switchdSetLdFunc(pm, en);

out_setLdFunc:
	ip1811drv_dbg("ip1811: -setLdFunc...\n");
	return ret;
}

int switchdGetLdFunc(unsigned long *portmap, int *pmdata)
{
	u16 u16dat;
	
	IP2Page(1);
	u16dat = Read_Reg(P1REG_MISCCFG);
	if(u16dat & 0x0800)
		*pmdata = OP_FUNC_ENABLE;
	else
		*pmdata = OP_FUNC_DISABLE;

	IP2Page(0);
	u16dat = Read_Reg(P0REG_LDEN);
	*portmap = (u16dat & 0xFFF);

	return 0;
}
EXPORT_SYMBOL(switchdGetLdFunc);

int getLdFunc(void *cdata, int len)
{
	int ret;
	int pmdata;
	unsigned long portmap;

	ip1811drv_dbg("ip1811: +getLdFunc...\n");
	if (sizeof(struct PortmapSetting) != len) {
		ret = -EINVAL;
		goto out_getLdFunc;
	}

	ret = switchdGetLdFunc(&portmap, &pmdata);

	((struct PortmapSetting *)cdata) ->portmap = portmap;
	((struct PortmapSetting *)cdata) ->pmdata = pmdata;

	ip1811drv_dbg("cdata ->portmap=0x%08x\n", ((struct PortmapSetting *)cdata) ->portmap);
	ip1811drv_dbg("cdata ->pmdata=%d\n", ((struct PortmapSetting *)cdata) ->pmdata);

out_getLdFunc:
	ip1811drv_dbg("ip1811: -getLdFunc...\n");
	return ret;
}

int switchdSetLdTimeUnit(int time_unit)
{
	if (time_unit!=OP_LD_TIME_UNIT_500MS && time_unit!=OP_LD_TIME_UNIT_10S)
		return -EINVAL;
	ip1811drv_dbg("tunit=%d\n", time_unit);

	_WriteRegBits(0, P0REG_LDCONFIG, 0, 1, time_unit);

	return 0;
}
EXPORT_SYMBOL(switchdSetLdTimeUnit);

int setLdTimeUnit(void *cdata, int len)
{
	int tunit, ret;

	ip1811drv_dbg("ip1811: +setLdTimeUnit...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
		goto out_setLdTimeUnit;
	}

	tunit = ((struct GeneralSetting *)cdata) ->gdata;
	ret = switchdSetLdTimeUnit(tunit);

out_setLdTimeUnit:
	ip1811drv_dbg("ip1811: -setLdTimeUnit...\n");
	return ret;
}

int switchdGetLdTimeUnit(int *time_unit_get)
{
	*time_unit_get = (int)_ReadRegBits(0, P0REG_LDCONFIG, 0, 1);
	return 0;
}
EXPORT_SYMBOL(switchdGetLdTimeUnit);

int getLdTimeUnit(void *cdata, int len)
{
	int val, ret;
	ip1811drv_dbg("ip1811: +getLdTimeUnit...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
	}

	ret = switchdGetLdTimeUnit(&val);
	((struct GeneralSetting *)cdata) ->gdata = val;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);

out_getLdTimeUnit:
	ip1811drv_dbg("ip1811: -getLdTimeUnit...\n");
	return ret;
}

int switchdSetLdPktSendTimer(int timer)
{
	if (timer < 0 || timer > 0xFF)
		return -EINVAL;
	ip1811drv_dbg("timer=%d\n", timer);

	_WriteRegBits(0, P0REG_LDTIMER, 0, 8, timer);

	return 0;
}
EXPORT_SYMBOL(switchdSetLdPktSendTimer);

int setLdPktSendTimer(void *cdata, int len)
{
	int timer, ret;

	ip1811drv_dbg("ip1811: +setLdPktSendTimer...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
		goto out_setLdPktSendTimer;
	}

	timer = ((struct GeneralSetting *)cdata) ->gdata;
	ret = switchdSetLdPktSendTimer(timer);

out_setLdPktSendTimer:
	ip1811drv_dbg("ip1811: -setLdPktSendTimer...\n");
	return ret;
}

int switchdGetLdPktSendTimer(int *send_timer_get)
{
	*send_timer_get = (int)_ReadRegBits(0, P0REG_LDTIMER, 0, 8);
	return 0;
}
EXPORT_SYMBOL(switchdGetLdPktSendTimer);

int getLdPktSendTimer(void *cdata, int len)
{
	int val, ret;
	ip1811drv_dbg("ip1811: +getLdPktSendTimer...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
		goto out_getLdPktSendTimer;
	}

	ret = switchdGetLdPktSendTimer(&val);
	((struct GeneralSetting *)cdata) ->gdata = val;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);

out_getLdPktSendTimer:
	ip1811drv_dbg("ip1811: -getLdPktSendTimer...\n");
	return ret;
}

int switchdSetLdBlockReleaseTimer(int timer)
{
	if (timer < 0 || timer > 0xFF)
		return -EINVAL;
	ip1811drv_dbg("timer=%d\n", timer);

	_WriteRegBits(0, P0REG_LDTIMER, 8, 8, timer);

	return 0;
}
EXPORT_SYMBOL(switchdSetLdBlockReleaseTimer);

int setLdBlockReleaseTimer(void *cdata, int len)
{
	int timer, ret;

	ip1811drv_dbg("ip1811: +setLdBlockReleaseTimer...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
		goto out_setLdBlockReleaseTimer;
	}

	timer = ((struct GeneralSetting *)cdata) ->gdata;
	ret = switchdSetLdBlockReleaseTimer(timer);

out_setLdBlockReleaseTimer:	
	ip1811drv_dbg("ip1811: -setLdBlockReleaseTimer...\n");
	return ret;
}

int switchdGetLdBlockReleaseTimer(int *release_timer_get)
{
	*release_timer_get = (int)_ReadRegBits(0, P0REG_LDTIMER, 8, 8);
	return 0;
}
EXPORT_SYMBOL(switchdGetLdBlockReleaseTimer);

int getLdBlockReleaseTimer(void *cdata, int len)
{
	int val, ret;
	ip1811drv_dbg("ip1811: +getLdBlockReleaseTimer...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
		goto out_getLdBlockReleaseTimer;
	}

	ret = switchdGetLdBlockReleaseTimer(&val);
	((struct GeneralSetting *)cdata) ->gdata = val;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);

out_getLdBlockReleaseTimer:
	ip1811drv_dbg("ip1811: -getLdBlockReleaseTimer...\n");
	return ret;
}

int switchdGetLdStatus(unsigned long *status)
{
	IP2Page(0);
	*status = Read_Reg(P0REG_LDSTATUS);
	return 0;
}
EXPORT_SYMBOL(switchdGetLdStatus);

int getLdStatus(void *cdata, int len)
{
	unsigned long val;
	int ret;

	ip1811drv_dbg("ip1811: +getLdStatus...\n");
	if (sizeof(struct PortMemberSetting) != len) {
		ret = -EINVAL;
		goto out_getLdStatus;
	}

	ret = switchdGetLdStatus(&val);
	((struct PortMemberSetting *)cdata) ->member = val;
	ip1811drv_dbg("cdata ->member=%08lX\n", ((struct PortMemberSetting *)cdata) ->member);

out_getLdStatus:
	ip1811drv_dbg("ip1811: -getLdStatus...\n");
	return ret;
}

//ip1811_loop_detect
int switchdSetLdDMAC(unsigned char *mac)
{
	int i;
	u16 u16dat;

	IP2Page(0);
	for (i=0; i<3; i++) {
		u16dat = (u16)( (mac[i*2] << 8) | mac[i*2+1] );
		Write_Reg(P0REG_LDDA0+2-i, u16dat);
	}
	return 0;
}
EXPORT_SYMBOL(switchdSetLdDMAC);

int setLdDMAC(void *cdata, int len)
{
	int i, ret;
	u8  da[6];

	ip1811drv_dbg("ip1811: +setLdDMAC...\n");
	if (sizeof(struct LDDASetting) != len) {
		ret = -EINVAL;
		goto out_setLdDMAC;
	}

	ip1811drv_dbg("da=[");
	for (i=0; i<6; i++) {
		da[i] = ((struct LDDASetting *)cdata) ->da[i];
		ip1811drv_dbg("0x%02X, ", da[i]);
	}
	ip1811drv_dbg("]\n");
	ret = switchdSetLdDMAC(da);

out_setLdDMAC:
	ip1811drv_dbg("ip1811: -setLdDMAC...\n");
	return 0;
}

int switchdSetLdSubType(int stype)
{
	IP2Page(0);
	Write_Reg(P0REG_LDSUBTYPE, (u16)stype);
	return 0;
}
EXPORT_SYMBOL(switchdSetLdSubType);

int setLdSubType(void *cdata, int len)
{
	int stype, ret;

	ip1811drv_dbg("ip1811: +setLdSubType...\n");
	if (sizeof(struct GeneralSetting) != len) {
		ret = -EINVAL;
		goto out_setLdSubType;
	}

	stype = ((struct GeneralSetting *)cdata) ->gdata;
	if (stype<0 && stype>0xFFFF) {
		ret = -EINVAL;
		goto out_setLdSubType;
	}
	ip1811drv_dbg("stype=%d\n", stype);

	ret = switchdSetLdSubType(stype);

out_setLdSubType:
	ip1811drv_dbg("ip1811: -setLdSubType...\n");
	return 0;
}
//------------------------------------------------
//common_stag
int switchdSetCpuPortLink(int clink)
{
	if (clink!=OP_CPU_PORT_NORMAL && clink!=OP_CPU_PORT_CPU)
		return -EINVAL;
	ip1811drv_dbg("clink=%d\n", clink);

	return 0;
}
EXPORT_SYMBOL(switchdSetCpuPortLink);
int setCpuPortLink(void *cdata, int len)
{
	int clink;

	ip1811drv_dbg("ip1811: +setCpuPortLink...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	clink = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetCpuPortLink(clink) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setCpuPortLink...\n");
	return 0;
}

int switchdSetSTagFunc(int en)
{
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("en=%d\n", en);

	if(en == OP_FUNC_ENABLE){
		_WriteRegBits(0xE, PEREG_CPUMODE, 0, 2 , 0x3);
	}else{
		_WriteRegBits(0xE, PEREG_CPUMODE, 0, 2 , 0x0);
	}

	return 0;
}
EXPORT_SYMBOL(switchdSetSTagFunc);
int setSTagFunc(void *cdata, int len)
{
	int en;

	ip1811drv_dbg("ip1811: +setSTagFunc...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetSTagFunc(en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setSTagFunc...\n");
	return 0;
}

void switchdGetSTagTypeLen(unsigned short *ptrLength, unsigned short *ptrType)
{
	IP2Page(0xE);
	*ptrType= Read_Reg(PEREG_SPTAG);
	*ptrLength = 0;
	ip1811drv_dbg("cdata ->length=%d\n", *ptrLength);
	ip1811drv_dbg("cdata ->type=0x%08x\n", *ptrType);
}
EXPORT_SYMBOL(switchdGetSTagTypeLen);
int getSTagTypeLen(void *cdata, int len)
{
	unsigned short type, length;

	ip1811drv_dbg("ip1811: +getSTagTypeLen...\n");
	if (sizeof(struct STagTypeLenSetting) != len)
		return -EINVAL;

	switchdGetSTagTypeLen(&length, &type);

	((struct STagTypeLenSetting *)cdata) ->length = (unsigned int)length;
	((struct STagTypeLenSetting *)cdata) ->type = (unsigned int)type;
	ip1811drv_dbg("ip1811: -getSTagTypeLen...\n");
	return 0;
}

//------------ PTP functions:common Start  -----------------------
int setPTPEnable(void *cdata, int len)
{
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 0);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPEnable(void *cdata, int len)
{
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 0);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPDA011B19000000(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 1);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPDA011B19000000(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 1);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPDA0180C200000E(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 2);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPDA0180C200000E(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 2);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPUdpDP(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 3);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPUdpDP(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 3);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPUdpSP(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 4);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPUdpSP(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_PTPCFG, 4);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPToCPU(void *cdata, int len)
{
	int gdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	gdata = ((struct GeneralSetting *)cdata) ->gdata;
	if( gdata != OP_CAP_ACT_TO_CPU && gdata != OP_CAP_ACT_FORWARD )
	{
		ip1811drv_err("Error: gdata=%X\n", gdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->gdata=%d\n", gdata);

	_WriteRegBits(0, P0REG_PTPCFG, 5, 1, gdata==OP_CAP_ACT_TO_CPU?0x0:0x1);

	FUNC_MSG_OUT;
	return 0;
}

int getPTPToCPU(void *cdata, int len)
{
	int gdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	gdata = (_ReadRegBits(0, P0REG_PTPCFG, 5, 1)==0x0?OP_CAP_ACT_TO_CPU:OP_CAP_ACT_FORWARD);
	((struct GeneralSetting *)cdata) ->gdata = gdata;

	ip1811drv_dbg("cdata ->gdata=%d\n", gdata);
	FUNC_MSG_OUT;
	return 0;
}

int setPTPSpecialTag(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x07, P7REG_TXDMA, 5);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPSpecialTag(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0x07, P7REG_TXDMA, 5);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPClockReset(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x09, P9REG_PTP_CLOCK_RESET, 0);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPTimeStamp(void *cdata, int len){
	unsigned int cmd=0, port=0;
	struct PTPReadSetting* ps=(struct PTPReadSetting*)cdata;

	if(sizeof(struct PTPReadSetting) != len)
		return -EINVAL;

	cmd=ps->addr;
	cmd|=(ps->in_out)<<4;
	port = ps->port;
#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	cmd|=(port)<<5;
	cmd|=0x8000;

	IP2Page(0x09);
	Write_Reg(P9REG_PTP_TIMESTAMP_READ, (u16)cmd);

	while((Read_Reg(P9REG_PTP_TIMESTAMP_READ) >> 15)&0x1);

	ps->second=Read_Reg(P9REG_PTP_TIMEDATA_SEC2);
	ps->second<<=16;
	ps->second=Read_Reg(P9REG_PTP_TIMEDATA_SEC1);
	ps->second<<=16;
	ps->second|=Read_Reg(P9REG_PTP_TIMEDATA_SEC0);
	ps->nanosecond=Read_Reg(P9REG_PTP_TIMEDATA_NANOSEC1);
	ps->nanosecond<<=16;
	ps->nanosecond|=Read_Reg(P9REG_PTP_TIMEDATA_NANOSEC0);

	return 0;
}

int setPTPClockEnable(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 0);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPClockEnable(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 0);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPOverwriteEnable(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 1);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPOverwriteEnable(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 1);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPProgrammable(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 2);
	FUNC_MSG_OUT;

	return ret;
}

int getPTPProgrammable(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 2);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPProgrammableOut(void *cdata, int len){
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x09, P9REG_PTP_CONFIGURATION, 9);
	FUNC_MSG_OUT;

	return ret;
}

int setPTPTimestampEnable(void *cdata, int len){
	unsigned int cmd=0, i=0;
	struct PTPPortTSSetting* pts=(struct PTPPortTSSetting*)cdata;

	if(sizeof(struct PTPPortTSSetting)!=len)
		return -EINVAL;
	IP2Page(0x09);
	for(i=0;i<MAX_PHY_NUM;i++){
		if((i%8)==0){
			cmd=Read_Reg(P9REG_PTP_PORT_TIMESTAMP0+(i/8));
		}

		if((pts->portmap&(0x01<<i))!=0){
			if(pts->pmdata==OP_FUNC_ENABLE){
				if(pts->in_out){
					//egress
					cmd|=0x01<<(1+(2*(i%8)));
				}
				else{
					//ingress
					cmd|=0x01<<(2*(i%8));
				}
			}
			else{
				if(pts->in_out){
					//egress
					cmd&=~(0x01<<(1+(2*(i%8))));
				}
				else{
					//ingress
					cmd&=~(0x01<<(2*(i%8)));
				}
			}
		}
		if((i%8)==7){
			Write_Reg(P9REG_PTP_PORT_TIMESTAMP0+(i/8), (u16)cmd);
		}
	}
	Write_Reg(P9REG_PTP_PORT_TIMESTAMP0+(i/8), (u16)cmd);

	return 0;
}

int getPTPTimestampEnable(void *cdata, int len){
	unsigned int cmd=0, i=0;
	struct PTPPortTSSetting* pts=(struct PTPPortTSSetting*)cdata;

	if(sizeof(struct PTPPortTSSetting)!=len)
		return -EINVAL;

	pts->pmdata=OP_FUNC_ENABLE;
	pts->portmap=0;
	IP2Page(0x09);
	for(i=0;i<MAX_PHY_NUM;i++){
		if((i%8)==0)
			cmd=Read_Reg(P9REG_PTP_PORT_TIMESTAMP0+(i/8));

		if(pts->in_out){
			//egress
			if((cmd&(0x01<<(1+(2*(i%8)))))!=0)
				pts->portmap|=(0x01<<i);
		}
		else{
			//ingress
			if((cmd&(0x01<<(2*(i%8))))!=0)
				pts->portmap|=(0x01<<i);
		}
	}

	return 0;
}

int setPTPTimestampClear(void *cdata, int len){
	unsigned int cmd=0, i=0;
	struct PTPPortTSSetting* pts=(struct PTPPortTSSetting*)cdata;

	if(sizeof(struct PTPPortTSSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	for(i=0;i<MAX_PHY_NUM;i++){
		if((pts->portmap&(0x01<<i))!=0){
			if(pts->in_out){
				//egress
				cmd|=0x01<<(1+(2*(i%8)));
			}
			else{
				//ingress
				cmd|=0x01<<(2*(i%8));
			}
		}
		if((i%8)==7 && cmd!=0){
			Write_Reg(P9REG_PTP_TIMESTAMP_CLEAR0+(i/8), (u16)cmd);
			cmd=0;
		}
	}
	if(cmd){
		Write_Reg(P9REG_PTP_TIMESTAMP_CLEAR0+(i/8), (u16)cmd);
	}

	return 0;
}

int setPTPTimeData(void *cdata, int len){
	struct PTPTimeSetting* ts=(struct PTPTimeSetting*)cdata;

	if(sizeof(struct PTPTimeSetting)!=len)
		return -EINVAL;
	
	IP2Page(0x09);
	Write_Reg(P9REG_PTP_TIMEDATA_SEC0, (u16)(ts->second&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_SEC1, (u16)((ts->second>>16)&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_SEC2, (u16)((ts->second>>32)&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_NANOSEC0, (u16)(ts->nanosecond&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_NANOSEC1, (u16)((ts->nanosecond>>16)&0x3FFF));
	Write_Reg(P9REG_PTP_CLOCK_CONTROL, 0x03);

	return 0;
}

int getPTPTimeData(void *cdata, int len){
	struct PTPTimeSetting* ts=(struct PTPTimeSetting*)cdata;

	if(sizeof(struct PTPTimeSetting)!=len)
		return -EINVAL;
	
	IP2Page(0x09);
	Write_Reg(P9REG_PTP_TIMESTAMP_READ, 0);
	Write_Reg(P9REG_PTP_CLOCK_CONTROL, 0x01);

	ts->second=Read_Reg(P9REG_PTP_TIMEDATA_SEC2);
	ts->second<<=16;
	ts->second=Read_Reg(P9REG_PTP_TIMEDATA_SEC1);
	ts->second<<=16;
	ts->second|=Read_Reg(P9REG_PTP_TIMEDATA_SEC0);

	ts->nanosecond=Read_Reg(P9REG_PTP_TIMEDATA_NANOSEC1);
	ts->nanosecond<<=16;
	ts->nanosecond|=Read_Reg(P9REG_PTP_TIMEDATA_NANOSEC0);

	return 0;
}

int addPTPTimeData(void *cdata, int len){
	struct PTPTimeSetting* ts=(struct PTPTimeSetting*)cdata;

	if(sizeof(struct PTPTimeSetting)!=len)
		return -EINVAL;
	
	IP2Page(0x09);
	Write_Reg(P9REG_PTP_TIMEDATA_SEC0, (u16)(ts->second&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_SEC1, (u16)((ts->second>>16)&0xFFFF));
//	Write_Reg(P9REG_PTP_TIMEDATA_SEC2, (u16)((ts->second>>32)&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_NANOSEC0, (u16)(ts->nanosecond&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_NANOSEC1, (u16)((ts->nanosecond>>16)&0x3FFF));
	Write_Reg(P9REG_PTP_CLOCK_CONTROL, 0x05);

	return 0;
}

int subPTPTimeData(void *cdata, int len){
	struct PTPTimeSetting* ts=(struct PTPTimeSetting*)cdata;

	if(sizeof(struct PTPTimeSetting)!=len)
		return -EINVAL;
	
	IP2Page(0x09);
	Write_Reg(P9REG_PTP_TIMEDATA_SEC0, (u16)(ts->second&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_SEC1, (u16)((ts->second>>16)&0xFFFF));
//	Write_Reg(P9REG_PTP_TIMEDATA_SEC2, (u16)((ts->second>>32)&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_NANOSEC0, (u16)(ts->nanosecond&0xFFFF));
	Write_Reg(P9REG_PTP_TIMEDATA_NANOSEC1, (u16)((ts->nanosecond>>16)&0x3FFF));
	Write_Reg(P9REG_PTP_CLOCK_CONTROL, 0x07);

	return 0;
}

int setPTPFrequencyAdd(void *cdata, int len){
	struct PTPFrequencySetting* fs=(struct PTPFrequencySetting*)cdata;

	if(sizeof(struct PTPFrequencySetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	Write_Reg(P9REG_PTP_FREQUENCY_ADD0, (u16)(fs->frequency&0xFFFF));
	Write_Reg(P9REG_PTP_FREQUENCY_ADD1, (u16)((fs->frequency>>16)&0xFFFF));

	return 0;
}

int getPTPFrequencyAdd(void *cdata, int len){
	struct PTPFrequencySetting* fs=(struct PTPFrequencySetting*)cdata;

	if(sizeof(struct PTPFrequencySetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	fs->frequency=Read_Reg(P9REG_PTP_FREQUENCY_ADD1);
	fs->frequency<<=16;
	fs->frequency|=Read_Reg(P9REG_PTP_FREQUENCY_ADD0);

	return 0;
}

int setPTPClockPeriod(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	Write_Reg(P9REG_PTP_CLOCK_PERIOD, (u16)(((struct GeneralSetting*)cdata)->gdata)&0xFFFF);

	return 0;
}

int getPTPClockPeriod(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_CLOCK_PERIOD);

	return 0;
}

int setPTPProgrammableConfig(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	Write_Reg(P9REG_PTP_PROGRAMMABLE_OUTPUT, (u16)(((struct GeneralSetting*)cdata)->gdata)&0xFFFF);

	return 0;
}

int setPTPDurationFrequencyCompensation(void *cdata, int len){
	struct PTPFrequencySetting* fs=(struct PTPFrequencySetting*)cdata;

	if(sizeof(struct PTPFrequencySetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION0, (u16)(fs->frequency&0xFFFF));
	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION1, (u16)((fs->frequency>>16)&0x3FF));
	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION2, (u16)(fs->clockcycle&0xFFFF));
	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION3, (u16)((fs->clockcycle>>16)&0x3FF));
	if(fs->type==1){
		//add
		Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION_CONTROL, 0x03);
	}
	else{
		//sub
		Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION_CONTROL, 0x07);
	}
	//Wait a period of time
	ndelay(fs->period_time);

	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION_CONTROL, 0x0);

	return 0;
}

int setPTPAlwaysFrequencyCompensation(void *cdata, int len){
	struct PTPFrequencyPPMSetting* fps=(struct PTPFrequencyPPMSetting*)cdata;

	if(sizeof(struct PTPFrequencyPPMSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION0, (u16)(fps->ppm_l));
	Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION1, (u16)(fps->ppm_h));
	if(fps->type==1){
		//add
		Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION_CONTROL, 0x01);
	}
	else{
		//Sub
		Write_Reg(P9REG_PTP_FREQUENCY_COMPENSATION_CONTROL, 0x05);
	}

	return 0;
}

int getPTPIngressLatency10(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_INGRESS_LATENCY_10TP);

	return 0;
}

int getPTPIngressLatency100(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_INGRESS_LATENCY_100TP);

	return 0;
}

int getPTPIngressLatencyFiber(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_INGRESS_LATENCY_FIBER);

	return 0;
}

int getPTPEgressLatency10(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_EGRESS_LATENCY_10TP);

	return 0;
}

int getPTPEgressLatency100(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_EGRESS_LATENCY_100TP);

	return 0;
}

int getPTPEgressLatencyFiber(void *cdata, int len){
	if(sizeof(struct GeneralSetting)!=len)
		return -EINVAL;

	IP2Page(0x09);
	((struct GeneralSetting*)cdata)->gdata=Read_Reg(P9REG_PTP_EGRESS_LATENCY_FIBER);

	return 0;
}
//------------ PTP functions:common end  -----------------------

int switchdConfigCpuPort(int portid)
{
	ip1811drv_dbg("portid=%d\n", portid);
	if (portid < 0 || portid >= 12)
		return -EINVAL;

	IP2Page(1);
	Write_Reg(P1REG_CONFIG_CPUPORT, (portid + 1) | 0x20);

	return 0;
}
EXPORT_SYMBOL(switchdConfigCpuPort);
int configCpuPort(void *cdata, int len)
{
	int portid;

	ip1811drv_dbg("ip1811: +configCpuPort...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	portid = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdConfigCpuPort(portid) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -configCpuPort...\n");
	return 0;
}

int switchdGetCpuPort(int *ptrVal)
{
	*ptrVal = Read_Reg(P1REG_CONFIG_CPUPORT);
	ip1811drv_dbg("portid=%d\n", *ptrVal);

	return 0;
}
EXPORT_SYMBOL(switchdGetCpuPort);
int getCpuPort(void *cdata, int len)
{
	int portid;

	ip1811drv_dbg("ip1811: +getCpuPort...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;


	if(switchdGetCpuPort(&portid) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = portid;
	ip1811drv_dbg("ip1811: -getCpuPort...\n");
	return 0;
}
//------------------------------------------------
//common_misc

int switchdSet8021xFunc(int en, unsigned long pm)
{
	unsigned long reg16;
	
	if (pm & 0xF0000000)
		return -EINVAL;
	if (en != OP_FUNC_ENABLE && en != OP_FUNC_DISABLE)
		return -EINVAL;

	IP2Page(0);
	if(en == OP_FUNC_ENABLE) {
		reg16 = Read_Reg(P0REG_PORTLOCKEN);
		Write_Reg(P0REG_PORTLOCKEN, (u16)(reg16 | pm));
	} else {//OP_FUNC_DISABLE
		reg16 = Read_Reg(P0REG_PORTLOCKEN);
		Write_Reg(P0REG_PORTLOCKEN, (u16)(reg16 & ~pm));
	}
	return 0;
}
EXPORT_SYMBOL(switchdSet8021xFunc);

int set8021xFunc(void *cdata, int len)
{
	unsigned long pm;
	int en, ret;

	ip1811drv_dbg("ip1811: +set8021xFunc...\n");
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;

	pm = ((struct PortmapSetting *)cdata) ->portmap;
	en = ((struct PortmapSetting *)cdata) ->pmdata;
	
	ip1811drv_dbg("pm=0x%08x\n", (unsigned int)pm);
	ip1811drv_dbg("en=%d\n", en);
	ret = switchdSet8021xFunc(en, pm);

	ip1811drv_dbg("ip1811: -set8021xFunc...\n");
	return ret;
}

int switchdGet8021xFunc(int *gdata_p)
{
	IP2Page(0);
	*gdata_p = (int)Read_Reg(P0REG_PORTLOCKEN);
	return 0;
}
EXPORT_SYMBOL(switchdGet8021xFunc);

int get8021xFunc(void *cdata, int len)
{
	int val, ret;

	ip1811drv_dbg("ip1811: +get8021xFunc...\n");
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;

	ret = switchdGet8021xFunc(&val);
	((struct PortmapSetting *)cdata) ->portmap = (val & ALL_PHY_PORTS_LIST);
	((struct PortmapSetting *)cdata) ->pmdata = val?OP_FUNC_ENABLE:OP_FUNC_DISABLE;
	ip1811drv_dbg("cdata ->portmap=0x%08x\n", (unsigned int)((struct PortmapSetting *)cdata) ->portmap);
	ip1811drv_dbg("cdata ->pmdata=%d\n", ((struct PortmapSetting *)cdata) ->pmdata);
	ip1811drv_dbg("ip1811: -get8021xFunc...\n");
	return ret;
}

int switchdSetReg(u8 page, u8 reg, u16 val)
{
	if (page > 0xE)
		return -EINVAL;
	ip1811drv_dbg("page=0x%x\n", page);
	ip1811drv_dbg("reg=0x%02X\n", reg);
	ip1811drv_dbg("val=0x%04x\n", val);

	_IP2Page(page);
	//	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, P2REG_VLANCFG,
	//				RegList[pg][P2REG_VLANCFG]);
	_Write_Reg(reg, val);

	//	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, P2REG_VLANCFG,
	//				RegList[pg][P2REG_VLANCFG]);
	ip1811drv_dbg("ip1811: -setReg...\n");

	return 0;
}
EXPORT_SYMBOL(switchdSetReg);
int setReg(void *cdata, int len)
{
	u8 page, reg;
	u16 val;

	ip1811drv_dbg("ip1811: +setReg...\n");
	if (sizeof(struct RegSetting) != len)
		return -EINVAL;

	page= ((struct RegSetting *)cdata) ->page;
	reg = ((struct RegSetting *)cdata) ->reg;
	val = ((struct RegSetting *)cdata) ->val;

	if(switchdSetReg(page, reg, val) != 0)
		return -EINVAL;

	return 0;
}


int switchdGetReg(u8 page, u8 reg, u16 *ptrVal)
{

	if (page > 0xE)
		return -EINVAL;
	ip1811drv_dbg("page=0x%x\n", page);
	printk("page=0x%x\n", page);
	ip1811drv_dbg("reg=0x%02X\n", reg);
	printk("reg=0x%02X\n", reg);

	_IP2Page(page);
	//	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, P2REG_VLANCFG,
	//				RegList[pg][P2REG_VLANCFG]);
	*ptrVal= _Read_Reg(reg);
	ip1811drv_dbg("u16dat=0x%04x\n", *ptrVal);
	printk("u16dat=0x%04x\n", *ptrVal);

	//	ip1811drv_dbg("RegList[%x][0x%02X]=0x%04x\n", pg, P2REG_VLANCFG,
	//				RegList[pg][P2REG_VLANCFG]);
	ip1811drv_dbg("cdata ->val=0x%04x\n", *ptrVal);
	ip1811drv_dbg("ip1811: -getReg...\n");

	return 0;
}
EXPORT_SYMBOL(switchdGetReg);
int getReg(void *cdata, int len)
{
	u8 page, reg;
	u16 u16dat;

	printk("ip1811: +getReg...\n");
	ip1811drv_dbg("ip1811: +getReg...\n");
	if (sizeof(struct RegSetting) != len)
		return -EINVAL;

	page= ((struct RegSetting *)cdata) ->page;
	reg = ((struct RegSetting *)cdata) ->reg;

	if(switchdGetReg(page, reg, &u16dat) != 0)
		return -EINVAL;

	((struct RegSetting *)cdata) ->val = (unsigned short)u16dat;
	return 0;
}

void switchdGetCPUReg(unsigned long reg, int * ptrVal)
{
	volatile unsigned int *p;

	p = (unsigned int *)(reg);
	*ptrVal = *p;

	ip1811drv_dbg("reg=%lX\n", reg);
	ip1811drv_dbg("get val=%X\n", *ptrVal);
}
EXPORT_SYMBOL(switchdGetCPUReg);
int getCPUReg(void *cdata, int len)
{
	unsigned long reg;
	int val;

	FUNC_MSG_IN;

	if (sizeof(struct PortmapSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	reg = ((struct PortmapSetting *)cdata) ->portmap;

	switchdGetCPUReg(reg, &val);

	((struct PortmapSetting *)cdata) ->pmdata = val;
	ip1811delay();
	FUNC_MSG_OUT;
	return 0;
}

void switchdSetCPUReg(unsigned long reg, int val)
{
	volatile unsigned int *p;

	p = (unsigned int *)(reg);
	*p = val;

	ip1811drv_dbg("reg=%lX\n", reg);
	ip1811drv_dbg("set val=%X\n", val);
}
EXPORT_SYMBOL(switchdSetCPUReg);
int setCPUReg(void *cdata, int len)
{
	unsigned long reg;
	int val;

	FUNC_MSG_IN;

	if (sizeof(struct PortmapSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	reg = ((struct PortmapSetting *)cdata) ->portmap;
	val = ((struct PortmapSetting *)cdata) ->pmdata;

	switchdSetCPUReg(reg, val);

	ip1811delay();


	FUNC_MSG_OUT;
	return 0;
}

int switchdSetSwitchRestart(int en)
{
	if(en!=OP_FUNC_ENABLE){
		ip1811drv_err("Error: en=%d\n", en);
		return -EINVAL;
	}
	ip1811drv_dbg("reset the switch of IP1811, all parameters are maintained\n");
	_WriteRegBits(0xE, PEREG_SW_RESET, 0, 1, en);

	return 0;
}
EXPORT_SYMBOL(switchdSetSwitchRestart);
int setSwitchRestart(void *cdata, int len)
{
	int en;
	FUNC_MSG_IN;

	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetSwitchRestart(en) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetSwitchReset(int en)
{

	if(en!=OP_FUNC_ENABLE){
		ip1811drv_err("Error: en=%d\n", en);
		return -EINVAL;
	}
	ip1811drv_dbg("reset the switch of IP1811, all parameters are reset to default\n");
	_WriteRegBits(0xE, PEREG_SW_RESET, 4, 1, en);

	return 0;
}
EXPORT_SYMBOL(switchdSetSwitchReset);
int setSwitchReset(void *cdata, int len)
{
	int en;

	FUNC_MSG_IN;

	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetSwitchReset(en) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

void switchdSetCpuIfSpeed(int type)
{
	CPU_IF_SPEED_NORMAL = type;
	printk("\nip1811: set CPU I/F speed to %s\n",CPU_IF_SPEED_NORMAL?"Normal":"High");
}
EXPORT_SYMBOL(switchdSetCpuIfSpeed);
int setCpuIfSpeed(void *cdata, int len)
{
	int type;
	FUNC_MSG_IN;

	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	switchdSetCpuIfSpeed(type);

	FUNC_MSG_OUT;
	return 0;
}
//------------ CoS functions:common -----------------------------
int setCosTcpUdpUserDefine(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;
	act = ((struct CapActSetting *)cdata) ->act;

	if( ptcl >= OP_TCPUDP_USER_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	if( act < 0x0 || act > 0xFFFF )
	{
		ip1811drv_err("Error: act=%X\n", act);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->ptcl=%X\n", ptcl);
	ip1811drv_dbg("cdata ->act=%X\n", act);

	IP2Page(0);
	Write_Reg(P0REG_TCPUDPUSERDEF + ptcl, (u16)act);

	FUNC_MSG_OUT;
	return 0;
}

int getCosTcpUdpUserDefine(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;

	if( ptcl >= OP_TCPUDP_USER_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	IP2Page(0);
	act = Read_Reg(P0REG_TCPUDPUSERDEF + ptcl);
	((struct CapActSetting *)cdata) ->act = act;

	ip1811drv_dbg("cdata ->protocol=%X\n", ((struct CapActSetting *)cdata) ->protocol);
	ip1811drv_dbg("cdata ->act=%X\n", ((struct CapActSetting *)cdata) ->act);
	FUNC_MSG_OUT;
	return 0;
}

int setCosTcpUdpQueue(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;
	act = ((struct CapActSetting *)cdata) ->act;

	if( ptcl >= OP_TCPUDP_PTCL_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	if( act < OP_TCPUDP_ACT_Q0 || act > OP_TCPUDP_ACT_ALL_PORT || act == 0x8)
	{
		ip1811drv_err("Error: act=%X\n", act);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->ptcl=%X\n", ptcl);
	ip1811drv_dbg("cdata ->act=%X\n", act);

	_WriteRegBits(0, P0REG_TCPUDPPRICFG + ptcl/4, (ptcl%4)*4, 4, act);

	FUNC_MSG_OUT;
	return 0;
}

int getCosTcpUdpQueue(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;

	if( ptcl >= OP_TCPUDP_PTCL_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	act = _ReadRegBits(0, P0REG_TCPUDPPRICFG + (ptcl/4), (ptcl%4)*4, 4);
	((struct CapActSetting *)cdata) ->act = act;

	ip1811drv_dbg("cdata ->protocol=%X\n", ((struct CapActSetting *)cdata) ->protocol);
	ip1811drv_dbg("cdata ->act=%X\n", ((struct CapActSetting *)cdata) ->act);
	FUNC_MSG_OUT;
	return 0;
}

int setCosTcpUdpEnable(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_TCPUDFUNCEN);
	FUNC_MSG_OUT;
	return ret;
}

int getCosTcpUdpEnable(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmapMask(cdata, len, 0, P0REG_TCPUDFUNCEN);
	FUNC_MSG_OUT;
	return ret;
}

int setCosTcpEnable(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;
	act = ((struct CapActSetting *)cdata) ->act;

	if( ptcl >= OP_TCPUDP_PTCL_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	if( act != OP_FUNC_ENABLE && act != OP_FUNC_DISABLE)
	{
		ip1811drv_err("Error: act=%X\n", act);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->ptcl=%X\n", ptcl);
	ip1811drv_dbg("cdata ->act=%X\n", act);

	/* check L3 TCP action */
	if(_ReadRegBits(0, P0REG_L3FRAMEGETCTRL, 2, 2) == OP_CAP_ACT_DROP)
	{
		ip1811drv_err("Error: L3 TCP action is drop\n");
		return -EINVAL;
	}

	/* set register */
	_WriteRegBits(0, P0REG_TCPCHECKEN + (ptcl/16), (ptcl%16), 1, act);

	FUNC_MSG_OUT;
	return 0;
}

int getCosTcpEnable(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;

	if( ptcl >= OP_TCPUDP_PTCL_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	act = _ReadRegBits(0, P0REG_TCPCHECKEN + (ptcl/16), (ptcl%16), 1);
	((struct CapActSetting *)cdata) ->act = act;

	ip1811drv_dbg("cdata ->protocol=%X\n", ((struct CapActSetting *)cdata) ->protocol);
	ip1811drv_dbg("cdata ->act=%X\n", ((struct CapActSetting *)cdata) ->act);
	FUNC_MSG_OUT;
	return 0;
}

int setCosUdpEnable(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;
	act = ((struct CapActSetting *)cdata) ->act;

	if( ptcl >= OP_TCPUDP_PTCL_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	if( act != OP_FUNC_ENABLE && act != OP_FUNC_DISABLE)
	{
		ip1811drv_err("Error: act=%X\n", act);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->ptcl=%X\n", ptcl);
	ip1811drv_dbg("cdata ->act=%X\n", act);

	/* check L3 UDP action */
	if(_ReadRegBits(0, P0REG_L3FRAMEGETCTRL, 4, 2) == OP_CAP_ACT_DROP)
	{
		ip1811drv_err("Error: L3 UDP action is drop\n");
		return -EINVAL;
	}

	/* set register */
	_WriteRegBits(0, (P0REG_UDPCHECKEN + ptcl/16), (ptcl%16), 1, act);

	FUNC_MSG_OUT;
	return 0;
}

int getCosUdpEnable(void *cdata, int len)
{
	unsigned int ptcl;
	int act;

	FUNC_MSG_IN;
	if (sizeof(struct CapActSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	ptcl = ((struct CapActSetting *)cdata) ->protocol;

	if( ptcl >= OP_TCPUDP_PTCL_TOTALNUM)
	{
		ip1811drv_err("Error: protocol=%X\n", ptcl);
		return -EINVAL;
	}

	act = _ReadRegBits(0, (P0REG_UDPCHECKEN + ptcl/16), (ptcl%16), 1);
	((struct CapActSetting *)cdata) ->act = act;

	ip1811drv_dbg("cdata ->protocol=%X\n", ((struct CapActSetting *)cdata) ->protocol);
	ip1811drv_dbg("cdata ->act=%X\n", ((struct CapActSetting *)cdata) ->act);
	FUNC_MSG_OUT;
	return 0;
}

int setCosTcpFlagDropNull(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_TCPFLGCFGGLB, 0);
	FUNC_MSG_OUT;
	return ret;
}

int getCosTcpFlagDropNull(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_TCPFLGCFGGLB, 0);
	FUNC_MSG_OUT;
	return ret;
}

int setCosTcpFlagDropAllset(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_TCPFLGCFGGLB, 1);
	FUNC_MSG_OUT;
	return ret;
}

int getCosTcpFlagDropAllset(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_TCPFLGCFGGLB, 1);
	FUNC_MSG_OUT;
	return ret;
}

int setCosTcpFlag(void *cdata, int len)
{
	unsigned int index;
	int fdata;

	FUNC_MSG_IN;
	if (sizeof(struct TcpFlagSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	index = ((struct TcpFlagSetting *)cdata) ->index;
	if( index > OP_TCPFLAG_FLAG3 )
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	fdata = ((struct TcpFlagSetting *)cdata) ->fdata;
	if( fdata < 0x0 || fdata > 0xFF )
	{
		ip1811drv_err("Error: flag=%X\n", fdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->index=%X\n", index);
	ip1811drv_dbg("cdata ->fdata=%X\n", fdata);

	_WriteRegBits(0, P0REG_TCPFLGCFG0 + index, 0, 8, fdata);

	FUNC_MSG_OUT;
	return 0;
}

int getCosTcpFlag(void *cdata, int len)
{
	unsigned int index;
	int fdata;

	FUNC_MSG_IN;
	if (sizeof(struct TcpFlagSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	index = ((struct TcpFlagSetting *)cdata) ->index;
	if( index > OP_TCPFLAG_FLAG3 )
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	fdata = _ReadRegBits(0, P0REG_TCPFLGCFG0 + index, 0, 8);
	((struct TcpFlagSetting *)cdata) ->index = fdata;
	ip1811drv_dbg("cdata ->index=%X\n", index);
	ip1811drv_dbg("cdata ->fdata=%X\n", fdata);
	FUNC_MSG_OUT;
	return 0;
}

int setCosTcpFlagAct(void *cdata, int len)
{
	unsigned int index;
	int fdata;

	FUNC_MSG_IN;
	if (sizeof(struct TcpFlagSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	index = ((struct TcpFlagSetting *)cdata) ->index;
	if( index > OP_TCPFLAG_FLAG3 )
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	fdata = ((struct TcpFlagSetting *)cdata) ->fdata;
	if( fdata < OP_TCPFLAG_ACT_NONE || fdata > OP_TCPFLAG_ACT_DROP )
	{
		ip1811drv_err("Error: act=%X\n", fdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->index=%X\n", index);
	ip1811drv_dbg("cdata ->fdata=%X\n", fdata);

	IP2Page(0);

	/* check L3 TCP action */
	if(_ReadRegBits(0, P0REG_L3FRAMEGETCTRL, 2, 2) == OP_CAP_ACT_DROP)
	{
		ip1811drv_err("Error: L3 TCP action is drop\n");
		return -EINVAL;
	}

	/* set register */
	_WriteRegBits(0, P0REG_TCPFLGCFG0 + index, 12, 2, fdata);

	FUNC_MSG_OUT;
	return 0;
}

int getCosTcpFlagAct(void *cdata, int len)
{
	unsigned int index;
	int fdata;

	FUNC_MSG_IN;
	if (sizeof(struct TcpFlagSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	index = ((struct TcpFlagSetting *)cdata) ->index;
	if( index > OP_TCPFLAG_FLAG3 )
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	fdata = _ReadRegBits(0, P0REG_TCPFLGCFG0 + index, 12, 2);
	((struct TcpFlagSetting *)cdata) ->fdata = fdata;
	ip1811drv_dbg("cdata ->index=%X\n", index);
	ip1811drv_dbg("cdata ->fdata=%X\n", fdata);
	FUNC_MSG_OUT;
	return 0;
}

int setCosTcpFlagPort(void *cdata, int len)
{
	unsigned int index;
	int fdata;

	FUNC_MSG_IN;
	if (sizeof(struct TcpFlagSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	index = ((struct TcpFlagSetting *)cdata) ->index;
	if( index > OP_TCPFLAG_FLAG3 )
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	fdata = ((struct TcpFlagSetting *)cdata) ->fdata;
	if( fdata & ~0xFFF )
	{
		ip1811drv_err("Error: portmap=%X\n", fdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->index=%X\n", index);
	ip1811drv_dbg("cdata ->fdata=%X\n", fdata);

	IP2Page(0);

	Write_Reg(P0REG_TCPFLGPORTEN+index*2, fdata&0xFFF);

	FUNC_MSG_OUT;
	return 0;
}

int getCosTcpFlagPort(void *cdata, int len)
{
	unsigned int index;
	int fdata;

	FUNC_MSG_IN;
	if (sizeof(struct TcpFlagSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	index = ((struct TcpFlagSetting *)cdata) ->index;
	if( index > OP_TCPFLAG_FLAG3 )
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	IP2Page(0);
	fdata = Read_Reg(P0REG_TCPFLGPORTEN+index*2);
	((struct TcpFlagSetting *)cdata) ->fdata = fdata;
	ip1811drv_dbg("cdata ->index=%X\n", index);
	ip1811drv_dbg("cdata ->fdata=%X\n", fdata);
	FUNC_MSG_OUT;
	return 0;
}
//------------ CoS functions:common end  ------------------------

//------------------------------------------------
//common_stp
int switchdSetMstpFunc(int en)
{
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(2, P2REG_VLANCFG, 6, 1, en); //MSTP enable
	_WriteRegBits(2, P2REG_VLANCFG, 2, 1, en); //IVL
	
	return 0;
}
EXPORT_SYMBOL(switchdSetMstpFunc);
int setMstpFunc(void *cdata, int len)
{
	int en;

	ip1811drv_dbg("ip1811: +setMstpFunc...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetMstpFunc(en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setMstpFunc...\n");
	return 0;
}

int switchdGetMstpFunc(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(2, P2REG_VLANCFG, 6, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetMstpFunc);
int getMstpFunc(void *cdata, int len)
{
	int en;
	
	ip1811drv_dbg("ip1811: +getMstpFunc...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetMstpFunc(&en) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = en;
	
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getMstpFunc...\n");
	return 0;
}

//common_lacp
int switchdSetTrunkHashMthd(int mthd)
{
	if (mthd < OP_TRUNK_HASH_METHOD_PORT_ID || mthd > OP_TRUNK_HASH_METHOD_SP)
		return -EINVAL;
	ip1811drv_dbg("mthd=%d\n", mthd);

	_WriteRegBits(1, P1REG_TRUNKCFG, 0, 3, mthd);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetTrunkHashMthd);
int setTrunkHashMthd(void *cdata, int len)
{
	int mthd;

	ip1811drv_dbg("ip1811: +setTrunkHashMthd...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	mthd = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetTrunkHashMthd(mthd) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setTrunkHashMthd...\n");
	return 0;
}

int switchdGetTrunkHashMthd(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_TRUNKCFG, 0, 3);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetTrunkHashMthd);
int getTrunkHashMthd(void *cdata, int len)
{
	int mthd;

	ip1811drv_dbg("ip1811: +getTrunkHashMthd...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetTrunkHashMthd(&mthd) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = mthd;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getTrunkHashMthd...\n");
	return 0;
}

int switchdSetTrunkMbr(unsigned long pmask, unsigned long state)
{
	unsigned long u32dat;
	
	if ((pmask & 0xFFFFF000) || !pmask)
		return -EINVAL;
	if ((state & 0xFFFFF000) || (state & ~pmask))
		return -EINVAL;
	ip1811drv_dbg("pmask=0x%08X\n", pmask);
	ip1811drv_dbg("state=0x%08X\n", state);

	IP2Page(1);
	u32dat= (unsigned long)( Read_Reg(P1REG_TRUNKGRP) );
	pmask = (unsigned long)( pmask&0xFFF );
	state = (unsigned long)( state&0xFFF );
	u32dat &= (~pmask);
	u32dat |= state;
#ifdef COMBINED_PORT
	u32dat |= 0x600;
#endif
	
	Write_Reg(P1REG_TRUNKGRP, (u32dat & 0xFFF));
	
	return 0;
}
EXPORT_SYMBOL(switchdSetTrunkMbr);
int setTrunkMbr(void *cdata, int len)
{
	unsigned long pmask, state, u32dat;

	ip1811drv_dbg("ip1811: +setTrunkMbr...\n");
	if (sizeof(struct TrunkMemberSetting) != len)
		return -EINVAL;

	pmask = ((struct TrunkMemberSetting *)cdata) ->portmask;
	state = ((struct TrunkMemberSetting *)cdata) ->tstate;

	if(switchdSetTrunkMbr(pmask, state) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setTrunkMbr...\n");
	return 0;
}

int switchdGetTrunkMbr(unsigned long pmask, unsigned long *ptrInt)
{
	if ((pmask & 0xFFFFF000) || !pmask)
		return -EINVAL;
	ip1811drv_dbg("pmask=0x%08X\n", pmask);

	IP2Page(1);
	*ptrInt = (unsigned long)( (Read_Reg(P1REG_TRUNKGRP) & 0xFFF) & pmask );

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetTrunkMbr);
int getTrunkMbr(void *cdata, int len)
{
	unsigned long pmask, u32dat;

	ip1811drv_dbg("ip1811: +getTrunkMbr...\n");
	if (sizeof(struct TrunkMemberSetting) != len)
		return -EINVAL;

	pmask = ((struct TrunkMemberSetting *)cdata) ->portmask;

	if(switchdGetTrunkMbr(pmask, &u32dat) != 0)
		return -EINVAL;

	((struct TrunkMemberSetting *)cdata) ->tstate = u32dat;
	ip1811drv_dbg("cdata ->tstate=0x%08x\n", (unsigned int)((struct TrunkMemberSetting *)cdata) ->tstate);
	ip1811drv_dbg("ip1811: -getTrunkMbr...\n");
	return 0;
}

int switchdSetCpuNCareTrunkAndVlan(int en)
{
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(1, P1REG_TRUNKCFG, 4, 1, en);

	return 0;
}
EXPORT_SYMBOL(switchdSetCpuNCareTrunkAndVlan);
int setCpuNCareTrunkAndVlan(void *cdata, int len)
{
	int en;

	ip1811drv_dbg("ip1811: +setCpuNCareTrunkAndVlan...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;
	en = ((struct GeneralSetting *)cdata) ->gdata;

	switchdSetCpuNCareTrunkAndVlan(en);

	ip1811drv_dbg("ip1811: -setCpuNCareTrunkAndVlan...\n");
	return 0;
}

int switchdGetCpuNCareTrunkAndVlan(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_TRUNKCFG, 4, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetCpuNCareTrunkAndVlan);
int getCpuNCareTrunkAndVlan(void *cdata, int len)
{
	int en;

	ip1811drv_dbg("ip1811: +getCpuNCareTrunkAndVlan...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetCpuNCareTrunkAndVlan(&en) != 0)
		return -EINVAL;
	
	((struct GeneralSetting *)cdata) ->gdata = en;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getCpuNCareTrunkAndVlan...\n");
	return 0;
}

//------------------------------------------------
//common_vlan
int switchdSetVlanEgressFrame(int mode)
{
	if (mode > 0x7 )
	{
		ip1811drv_err("Error: mode=%X\n", mode);
		return -EINVAL;
	}
	ip1811drv_dbg("mode=0x%08x\n", mode);

	_WriteRegBits(2, P2REG_VLAN_EGRESS_CFG1, 0, 3, mode);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEgressFrame);
int setVlanEgressFrame(void *cdata, int len)
{
	u16 mode;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	mode = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetVlanEgressFrame(mode) != 0)
		return -EINVAL;
			
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanEgressFrame(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(2,P2REG_VLAN_EGRESS_CFG1, 0, 3);
}
EXPORT_SYMBOL(switchdGetVlanEgressFrame);
int getVlanEgressFrame(void *cdata, int len)
{
	int ftype;
	
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;
	
	switchdGetVlanEgressFrame(&ftype);

	((struct GeneralSetting *)cdata) ->gdata = ftype;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanTagging(int mode)
{
	if ((mode != OP_VLAN_TAGGING_BY_PORT) && (mode != OP_VLAN_TAGGING_BY_VID))
	{
		ip1811drv_err("Error: mode=%X\n", mode);
		return -EINVAL;
	}

	ip1811drv_dbg("mode=0x%08x\n", mode);

	_WriteRegBits(2, P2REG_VLANCFG, 3, 1, mode);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanTagging);
int setVlanTagging(void *cdata, int len)
{
	u16 mode;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	mode = ((struct GeneralSetting *)cdata) ->gdata;

    if(switchdSetVlanTagging(mode) != 0)
		return -EINVAL;
		
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanType(int mode)
{
	if ((mode != OP_VLAN_TYPE_TAG) && (mode != OP_VLAN_TYPE_GROUP))
	{
		ip1811drv_err("Error: mode=%X\n", mode);
		return -EINVAL;
	}

	ip1811drv_dbg("mode=0x%08x\n", mode);

	/* set vlan type: port/tag base */
	_WriteRegBits(2, P2REG_VLANCFG, 1, 1, mode);
	/* set vlan protocol base */
	_WriteRegBits(2, P2REG_VLANCFG, 0, 1, mode);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanType);
int setVlanType(void *cdata, int len)
{
	u16 mode;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	mode = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetVlanType(mode) != 0)
		return -EINVAL;	

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanGroup(unsigned long pm, int option)
{
	u32 u32dat;
	int i;
	
	if (pm & ~(0x0FFF))
	{
		ip1811drv_err("Error: portmap=%08lX\n", pm);
		return -EINVAL;
	}
	if (option & ~0x1)
	{
		ip1811drv_err("Error: option=%X\n", option);
		return -EINVAL;
	}

	ip1811drv_dbg("pm=0x%08lx\n", pm);
	ip1811drv_dbg("option=%x\n", option);

	IP2Page(2);
	for(i=0;i<MAX_PHY_NUM; i++)
	{
		if(!((pm>>i)&0x1))
			continue;

		u32dat = (u32)Read_Reg(P2REG_VLANGROUP+2*i);
		if(option)
			u32dat |= pm;
		else
			u32dat &= ~pm;

		Write_Reg(P2REG_VLANGROUP+2*i, (u16)(u32dat & 0xFFFF));
		//Write_Reg(P2REG_VLANGROUP+1+2*i, (u16)(u32dat >> 16));
	}
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanGroup);
int setVlanGroup(void *cdata, int len)
{
	unsigned long pm;
	int option;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;
	
	pm = ((struct PortmapSetting *)cdata) ->portmap;
	option = ((struct PortmapSetting *)cdata) ->pmdata;
	
	if(switchdSetVlanGroup(pm, option) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQPType(int type)
{
	if (type&(~0xFFFF))
	{
		ip1811drv_err("Error: type=%d\n", type);
		return -EINVAL;
	}

	ip1811drv_dbg("type=0x%08x\n", type);

	IP2Page(7);
	Write_Reg(P7REG_QINQEGTYPELEN, type);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQPType);
int setVlanQinQPType(void *cdata, int len)
{
	int type;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	type = ((struct GeneralSetting *)cdata) ->gdata;
	
	if(switchdSetVlanQinQPType(type) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQPAddtag(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(7);
	Write_Reg(P7REG_QINQ_ADDTAG, (u16)(member & 0xFFFF));
	//Write_Reg(P7REG_QINQ_ADDTAG+1, (u16)(member >> 16));
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQPAddtag);
int setVlanQinQPAddtag(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanQinQPAddtag(member) != 0)
		return -EINVAL;
		
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanQinQPAddtag(u32 *u32dat)
{
	IP2Page(7);
	*u32dat = (u32)Read_Reg(P7REG_QINQ_ADDTAG);
}
EXPORT_SYMBOL(switchdGetVlanQinQPAddtag);
int getVlanQinQPAddtag(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanQinQPAddtag(&u32dat);
	
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQPRmvtag(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(7);
	Write_Reg(P7REG_QINQ_RMVTAG, (u16)(member & 0xFFFF));
	//Write_Reg(P7REG_QINQ_RMVTAG+1, (u16)(member >> 16));
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQPRmvtag);
int setVlanQinQPRmvtag(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanQinQPRmvtag(member) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanQinQPRmvtag(u32 *u32dat)
{
	IP2Page(7);
	*u32dat = (u32)Read_Reg(P7REG_QINQ_RMVTAG);
}
EXPORT_SYMBOL(switchdGetVlanQinQPRmvtag);
int getVlanQinQPRmvtag(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanQinQPRmvtag(&u32dat);
	
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQPRxdet(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(7);
	Write_Reg(P7REG_QINQ_DET_RX, (u16)(member & 0xFFFF));
	//Write_Reg(P7REG_QINQ_DET_RX+1, (u16)(member >> 16));
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQPRxdet);
int setVlanQinQPRxdet(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanQinQPRxdet(member) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanQinQPRxdet(u32 *u32dat)
{
	IP2Page(7);
	*u32dat = (u32)Read_Reg(P7REG_QINQ_DET_RX);
}
EXPORT_SYMBOL(switchdGetVlanQinQPRxdet);
int getVlanQinQPRxdet(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanQinQPRxdet(&u32dat);
	
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQPKeep(int member)
{
	int i;
	
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	for(i=0; i<MAX_PHY_NUM; i++)
	{
		_WriteRegBits(7, P7REG_QINQ_P_DATA+i, 12, 1, ((member>>i)&0x1));
	}
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQPKeep);
int setVlanQinQPKeep(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanQinQPKeep(member) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanQinQPKeep(u32 *u32dat)
{
	int i;
	u16 u16dat;
		
	IP2Page(7);
	for(i=0; i<MAX_PHY_NUM; i++)
	{
		u16dat = Read_Reg(P7REG_QINQ_P_DATA+i);
		*u32dat |= ((u16dat>>12)&0x1)<<i;
	}
}
EXPORT_SYMBOL(switchdGetVlanQinQPKeep);
int getVlanQinQPKeep(void *cdata, int len)
{
	u32 member=0;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanQinQPKeep(&member);
	
	((struct PortMemberSetting *)cdata) ->member = member;
	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQPIndex(int port, int index)
{
	if (port < 0 || port >= MAX_PHY_NUM)
	{
		ip1811drv_err("Error: port=%X\n", port);
		return -EINVAL;
	}

	if (index < 0 || index > 15)
	{
		ip1811drv_err("Error: pmdata=%X\n", index);
		return -EINVAL;
	}

	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("index=%d\n", index);

	//index |= (0x0001 << 8);
	_WriteRegBits(7, P7REG_QINQ_P_DATA+port, 0, 4, index);
#ifdef COMBINED_PORT
	if (port==9)
		_WriteRegBits(7, P7REG_QINQ_P_DATA+port+1, 0, 4, index);
#endif

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQPIndex);
int setVlanQinQPIndex(void *cdata, int len)
{
	int port, index;

	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;
	index= ((struct ByPortSetting *)cdata) ->pdata;
	
	if(switchdSetVlanQinQPIndex(port, index) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

int switchdGetVlanQinQPIndex(int port, int *index)
{
	if (port < 0 || port >= MAX_PHY_NUM)
	{
		ip1811drv_err("Error: port=%X\n", port);
		return -EINVAL;
	}

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*index= _ReadRegBits(7,P7REG_QINQ_P_DATA+port, 0, 4);
	return 0;
}
EXPORT_SYMBOL(switchdGetVlanQinQPIndex);
int getVlanQinQPIndex(void *cdata, int len)
{
	int port;
	int index;

	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;
	
	if(switchdGetVlanQinQPIndex(port, &index) != 0)
		return -EINVAL;	

	((struct ByPortSetting *)cdata) ->pdata = index;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanQinQIndex(int index, int value)
{
	if (index<0 || index>15) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	if (value & (~0xFFFF)) {
		ip1811drv_err("Error: data=%x\n", value);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("value=0x%x\n", value);

	IP2Page(7);

	Write_Reg(P7REG_QINQ_DATA+index, (u16)value);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQIndex);
int setVlanQinQIndex(void *cdata, int len)
{
	int type, data, ret;
	struct VlanSetting *vs = (struct VlanSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	type = vs ->vtype;
	data = vs ->vdata;
	ret = switchdSetVlanQinQIndex(type, data);

	FUNC_MSG_OUT;
	return ret;
}

int switchdSetVlanQinQStagSelectMethod(int port, int method)
{
	if (port<0 || port>=MAX_PHY_NUM) {
		ip1811drv_err("Error: port=%X\n", port);
		return -EINVAL;
	}

	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("method=%d\n", method);

	_WriteRegBits(7, P7REG_QINQ_P_DATA+port, 8, 4, method);
#ifdef COMBINED_PORT
	if (port==9)
		_WriteRegBits(7, P7REG_QINQ_P_DATA+port+1, 8, 4, method);
#endif

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanQinQStagSelectMethod);
int setVlanQinQStagSelectMethod(void *cdata, int len)
{
	int port, method, ret;
	struct ByPortSetting *bps = (struct ByPortSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	port = bps ->port;
	method = bps ->pdata;
	ret = switchdSetVlanQinQStagSelectMethod(port, method) ;

	FUNC_MSG_OUT;
	return ret;
}

int switchdSetVlanPortAddtag(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_ADDTAG, (u16)(member & 0xFFFF));
	//Write_Reg(P2REG_VLAN_ADDTAG+1, (u16)(member >> 16));

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortAddtag);
int setVlanPortAddtag(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanPortAddtag(member) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortAddtag(u32 *u32dat)
{
	IP2Page(2);
	*u32dat = (u32)Read_Reg(P2REG_VLAN_ADDTAG);
}
EXPORT_SYMBOL(switchdGetVlanPortAddtag);
int getVlanPortAddtag(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;
		
	switchdGetVlanPortAddtag(&u32dat);
	
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortRmvtag(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_RMVTAG, (u16)(member & 0xFFFF));
	//Write_Reg(P2REG_VLAN_RMVTAG+1, (u16)(member >> 16));

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortRmvtag);
int setVlanPortRmvtag(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanPortRmvtag(member) != 0)
		return -EINVAL;
		
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortRmvtag(u32 *u32dat)
{
	IP2Page(2);
	*u32dat = (u32)Read_Reg(P2REG_VLAN_RMVTAG);
}
EXPORT_SYMBOL(switchdGetVlanPortRmvtag);
int getVlanPortRmvtag(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;
		
	switchdGetVlanPortRmvtag(&u32dat);

	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortForce(int member)
{
	int i;
	
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	for(i=0; i<MAX_PHY_NUM; i++)
	{
		_WriteRegBits(2, P2REG_VLANGROUP+2*i, 12, 1, (member>>i)&0x1);
	}

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortForce);
int setVlanPortForce(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanPortForce(member) != 0)
		return -EINVAL;
		
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortForce(u32 *u32dat)
{
	u16 u16dat;
	int i;
	
	IP2Page(2);
	for(i=0; i<MAX_PHY_NUM; i++)
	{
		u16dat = Read_Reg(P2REG_VLANGROUP+2*i);
		*u32dat |= ((u16dat>>12)&0x1)<<i;
	}
}
EXPORT_SYMBOL(switchdGetVlanPortForce);
int getVlanPortForce(void *cdata, int len)
{
	u32 member=0;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

    switchdGetVlanPortForce(&member);
	
	((struct PortMemberSetting *)cdata) ->member = member;
	
	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortUplink(int member)
{
	//u16 u16dat;
	
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_UPLINK, (u16)((member & 0xFFFF) | 0x1000));
	//u16dat = (u16)(member >> 16);
	//u16dat |= (u16)0x1<<13;		//enable uplink
	//_WriteRegBits(2, P2REG_VLAN_UPLINK+1, 0, 14, u16dat);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortUplink);
int setVlanPortUplink(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanPortUplink(member) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortUplink(u32 *u32dat)
{
	IP2Page(2);
	*u32dat = (u32)Read_Reg(P2REG_VLAN_UPLINK);
	*u32dat &= 0x0FFF;
}
EXPORT_SYMBOL(switchdGetVlanPortUplink);
int getVlanPortUplink(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanPortUplink(&u32dat);
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortExclusive(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_EXCLUSIVE, (u16)(member & 0xFFFF));
	//Write_Reg(P2REG_VLAN_EXCLUSIVE+1, (u16)(member >> 16));

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortExclusive);
int setVlanPortExclusive(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;

	if(switchdSetVlanPortExclusive(member) != 0)
		return -EINVAL;
		
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortExclusive(u32 *u32dat)
{
	IP2Page(2);
	*u32dat = (u32)Read_Reg(P2REG_VLAN_EXCLUSIVE);
}
EXPORT_SYMBOL(switchdGetVlanPortExclusive);
int getVlanPortExclusive(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanPortExclusive(&u32dat);
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortEgress(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_EGRESS_CFG, (u16)(member & 0xFFFF));
	//_WriteRegBits(2, P2REG_VLAN_EGRESS_CFG+1, 0, 13, (u16)(member >> 16));

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortEgress);
int setVlanPortEgress(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanPortEgress(member) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortEgress(u32 *u32dat)
{
	IP2Page(2);
	*u32dat = (u32)Read_Reg(P2REG_VLAN_EGRESS_CFG);
	//u32dat &= 0x1FFFFFFF;
}
EXPORT_SYMBOL(switchdGetVlanPortEgress);
int getVlanPortEgress(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;
	
	switchdGetVlanPortEgress(&u32dat);
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortIngressFrame(int port, int pdata)
{
	if (port < 0 || port >= MAX_PHY_NUM)
	{
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}

	if (pdata < 0 || pdata > 0x3)
	{
		ip1811drv_err("Error: pdata=0x%X\n", pdata);
		return -EINVAL;
	}

	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("pdata=0x%X\n", pdata);

	_WriteRegBits(2, P2REG_VLAN_INGRESS_FRAME_0, port, 1, (pdata&0x1));
	_WriteRegBits(2, P2REG_VLAN_INGRESS_FRAME_1, port, 1, ((pdata>>1)&0x1));
#ifdef COMBINED_PORT
	if (port==9){
		_WriteRegBits(2, P2REG_VLAN_INGRESS_FRAME_0, port+1, 1, (pdata&0x1));
		_WriteRegBits(2, P2REG_VLAN_INGRESS_FRAME_1, port+1, 1, ((pdata>>1)&0x1));
	}
#endif	

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortIngressFrame);
int setVlanPortIngressFrame(void *cdata, int len)
{
	int port, pdata;

	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;
	pdata = ((struct ByPortSetting *)cdata) ->pdata;

    if(switchdSetVlanPortIngressFrame(port, pdata) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortIngressCheck(int member)
{
	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%08X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("member=0x%08x\n", member);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_INGRESS_CHK, (u16)(member & 0xFFFF));
	//Write_Reg(P2REG_VLAN_INGRESS_CHK+1, (u16)(member >> 16));

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortIngressCheck);
int setVlanPortIngressCheck(void *cdata, int len)
{
	int member;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	member = ((struct PortMemberSetting *)cdata) ->member;
	
	if(switchdSetVlanPortIngressCheck(member) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

void switchdGetVlanPortIngressCheck(u32 *u32dat)
{
	IP2Page(2);
	*u32dat = (u32)Read_Reg(P2REG_VLAN_INGRESS_CHK);
}
EXPORT_SYMBOL(switchdGetVlanPortIngressCheck);
int getVlanPortIngressCheck(void *cdata, int len)
{
	u32 u32dat;

	FUNC_MSG_IN;
	if (sizeof(struct PortMemberSetting) != len)
		return -EINVAL;

	switchdGetVlanPortIngressCheck(&u32dat);
	
	((struct PortMemberSetting *)cdata) ->member = (int)u32dat;

	ip1811drv_dbg("cdata ->gdata=%d\n", (u16)((struct PortMemberSetting *)cdata) ->member);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanPortVid(int port, int pvid)
{
	if (port < 0 || port >= MAX_PHY_NUM)
	{
		ip1811drv_err("Error: port=%X\n", port);
		return -EINVAL;
	}

	if (pvid < 0 || pvid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: pmdata=%X\n", pvid);
		return -EINVAL;
	}

	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("pvid=%d\n", pvid);

	_WriteRegBits(2, P2REG_VLAN_PVIDCFG+port, 0, 12, pvid);
#ifdef COMBINED_PORT
	if (port==9)
		_WriteRegBits(2, P2REG_VLAN_PVIDCFG+port+1, 0, 12, pvid);
#endif

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanPortVid);
int setVlanPortVid(void *cdata, int len)
{
	int port, pvid;

	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;
	pvid= ((struct ByPortSetting *)cdata) ->pdata;
	
	if(switchdSetVlanPortVid(port, pvid) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanProtocolMode(int index, int mode)
{
	if (index < 0 || index >= MAX_PRO_VLAN_ENTRY_NUM)
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	if(	(mode!=OP_VLAN_PROTOCOL_INVALID)
			&&	(mode!=OP_VLAN_PROTOCOL_ETHER)
			&&	(mode!=OP_VLAN_PROTOCOL_LLC)
			&&	(mode!=OP_VLAN_PROTOCOL_1042) )
	{
		ip1811drv_err("Error: mode=%X\n", mode);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("mode=%d\n", mode);

	_WriteRegBits(2, P2REG_VLAN_PROCOTOL_CFG+1+index*2, 12, 2, mode);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanProtocolMode);
int setVlanProtocolMode(void *cdata, int len)
{
	int index, mode;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len)
		return -EINVAL;

	index = (((struct VlanSetting *)cdata) ->vtype) - 1;
	mode= ((struct VlanSetting *)cdata) ->vdata;
	
	if(switchdSetVlanProtocolMode(index, mode) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanProtocolVid(int index, int vid)
{
	if (index < 0 || index >= MAX_PRO_VLAN_ENTRY_NUM)
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	if(	(vid < 0) || (vid>=MAX_PVID_NUM) )
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("vid=%d\n", vid);

	_WriteRegBits(2, P2REG_VLAN_PROCOTOL_CFG+1+index*2, 0, 12, vid);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanProtocolVid);
int setVlanProtocolVid(void *cdata, int len)
{
	int index, vid;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len)
		return -EINVAL;

	index = (((struct VlanSetting *)cdata) ->vtype) - 1;
	vid= ((struct VlanSetting *)cdata) ->vdata;
	
	if(switchdSetVlanProtocolVid(index, vid) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanProtocolType(int index, int type)
{
	if (index < 0 || index >= MAX_PRO_VLAN_ENTRY_NUM)
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	if (type & (~0xFFFF))
	{
		ip1811drv_err("Error: type=%X\n", type);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("type=%d\n", type);

	IP2Page(2);

	Write_Reg(P2REG_VLAN_PROCOTOL_CFG+index*2, (u16)type);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanProtocolType);
int setVlanProtocolType(void *cdata, int len)
{
	int index, type;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len)
		return -EINVAL;

	index = (((struct VlanSetting *)cdata) ->vtype) - 1;
	type= ((struct VlanSetting *)cdata) ->vdata;
	
	if(switchdSetVlanProtocolType(index, type) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanProtocolClear(int index)
{
	if (index < 0 || index >= MAX_PRO_VLAN_ENTRY_NUM)
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	ip1811drv_dbg("index=0x%08x\n", index);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_PROCOTOL_CFG+index*2, 0 );
	Write_Reg(P2REG_VLAN_PROCOTOL_CFG+index*2+1, 0 );

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanProtocolClear);
int setVlanProtocolClear(void *cdata, int len)
{
	int index;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	index = (((struct GeneralSetting *)cdata) ->gdata) - 1;
	
	if(switchdSetVlanProtocolClear(index) != 0)
		return -EINVAL;
	
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanMACBased(int mode)
{
	if (mode!=OP_FUNC_DISABLE && mode!=OP_FUNC_ENABLE){
		ip1811drv_err("Error: mode=%X\n", mode);
		return -EINVAL;
	}

	ip1811drv_dbg("mode=0x%08x\n", mode);

	_WriteRegBits(2, P2REG_VLANCFG, 11, 1, mode);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanMACBased);
int setVlanMACBased(void *cdata, int len)
{
	int mode;
	
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;
	
	mode = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetVlanMACBased(mode) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanMACBasedtableconfig(unsigned int index, unsigned int data)
{
	if (index < 0 || index >= MAX_FID_NUM)
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	if (data & (~0x1FFF))
	{
		ip1811drv_err("Error: data=%X\n", data);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d data=0x%08x\n", index, data);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_MACBASED_ENTRY_0+index, (u16)data);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanMACBasedtableconfig);
int setVlanMACBasedtableconfig(void *cdata, int len)
{
	unsigned int index, data;

	FUNC_MSG_IN;
	if (sizeof(struct MACVlanSetting) != len)
		return -EINVAL;

	index = ((struct MACVlanSetting *)cdata) ->index;
	data = ((struct MACVlanSetting *)cdata) ->mvdata;
	
	if(switchdSetVlanMACBasedtableconfig(index, data) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdGetVlanMACBasedtableconfig(unsigned int index, unsigned int *data)
{
	if (index < 0 || index >= MAX_FID_NUM)
	{
		ip1811drv_err("Error: index=%X\n", index);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	
	IP2Page(2);
	*data = (unsigned int)Read_Reg(P2REG_VLAN_MACBASED_ENTRY_0+index);
	
	return 0;
}
EXPORT_SYMBOL(switchdGetVlanMACBasedtableconfig);
int getVlanMACBasedtableconfig(void *cdata, int len)
{
	unsigned int index, data;
	
	FUNC_MSG_IN;
	if (sizeof(struct MACVlanSetting) != len)
		return -EINVAL;
	
	index = ((struct MACVlanSetting *)cdata) ->index;
	
	if(switchdGetVlanMACBasedtableconfig(index, &data) != 0)
		return -EINVAL;

	((struct MACVlanSetting *)cdata) ->mvdata = data;

	ip1811drv_dbg("cdata ->mvdata=%d\n", ((struct MACVlanSetting *)cdata) ->mvdata);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanMACBasedunknown(unsigned int data)
{
	if (data & (~0x1FFF))
	{
		ip1811drv_err("Error: data=%X\n", data);
		return -EINVAL;
	}

	ip1811drv_dbg("data=0x%08x\n", data);

	IP2Page(2);
	Write_Reg(P2REG_VLAN_MACBASED_UNKNOWN, (u16)data);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanMACBasedunknown);
int setVlanMACBasedunknown(void *cdata, int len)
{
	unsigned int data;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	data = ((struct GeneralSetting *)cdata) ->gdata;
	
	if(switchdSetVlanMACBasedunknown(data) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

//ip1811_vlan
int switchdSetVlanEntryMember(int vid, int member)
{
	u16 u16dat;
	
	if (vid < 0 || vid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	if (member & ~(0x0FFF))
	{
		ip1811drv_err("Error: member=%X\n", member);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);
	ip1811drv_dbg("member=%d\n", member);

	IP2Page(2);
	/* read data from VLAN table */
	u16dat = 0x8000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);


	/* set entry memeber */
	u16dat = Read_Reg(P2REG_VLANDAT0);
	u16dat &= ~0xFFF;
	u16dat |= (u16)member&0x0FFF;
	Write_Reg(P2REG_VLANDAT0, u16dat);
	
	u16dat = Read_Reg(P2REG_VLANDAT0+1);
	Write_Reg(P2REG_VLANDAT0+1, u16dat);
	u16dat = Read_Reg(P2REG_VLANDAT0+2);
	Write_Reg(P2REG_VLANDAT0+2, u16dat);

	/* set valid bit to 1 */
	u16dat = (u16)0x1;
	Write_Reg(P2REG_VLANDAT0+3, u16dat);

	/* Write data to VLAN table */
	u16dat = 0xC000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEntryMember);
int setVlanEntryMember(void *cdata, int len)
{
	int vid, member;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;

	vid = ((struct PortmapSetting *)cdata) ->pmdata;
	member= ((struct PortmapSetting *)cdata) ->portmap;
	
	if(switchdSetVlanEntryMember(vid, member) != 0)
		return -EINVAL;	

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanEntryAddtag(int vid, int addtag)
{
	u16 u16dat;
	
	if (vid < 0 || vid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	if (addtag & ~(0x0FFF))
	{
		ip1811drv_err("Error: addtag=%X\n", addtag);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);
	ip1811drv_dbg("addtag=%d\n", addtag);

	IP2Page(2);
	/* read data from VLAN table */
	u16dat = 0x8000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);


	/* set entry addtag */
	u16dat = Read_Reg(P2REG_VLANDAT0);
	u16dat &= ~0xF000;
	u16dat |= (u16)(addtag&0xF)<<12;
	Write_Reg(P2REG_VLANDAT0, u16dat);

	u16dat = Read_Reg(P2REG_VLANDAT0+1);
	u16dat &= ~0x00FF;
	u16dat |= (u16)(addtag>>4)&0x00FF;
	Write_Reg(P2REG_VLANDAT0+1, u16dat);

	u16dat = Read_Reg(P2REG_VLANDAT0+2);
	Write_Reg(P2REG_VLANDAT0+2, u16dat);

	/* set valid bit to 1 */
	u16dat = (u16)0x1;
	Write_Reg(P2REG_VLANDAT0+3, u16dat);

	/* Write data to VLAN table */
	u16dat = 0xC000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEntryAddtag);
int setVlanEntryAddtag(void *cdata, int len)
{
	int vid, addtag;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;

	vid = ((struct PortmapSetting *)cdata) ->pmdata;
	addtag= ((struct PortmapSetting *)cdata) ->portmap;
	
	if(switchdSetVlanEntryAddtag(vid, addtag) != 0)
		return -EINVAL;		

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanEntryRmvtag(int vid, int rmvtag)
{
	u16 u16dat;
	
	if (vid < 0 || vid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	if (rmvtag & ~(0x0FFF))
	{
		ip1811drv_err("Error: rmvtag=%X\n", rmvtag);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);
	ip1811drv_dbg("rmvtag=%d\n", rmvtag);

	IP2Page(2);
	/* read data from VLAN table */
	u16dat = 0x8000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	u16dat = Read_Reg(P2REG_VLANDAT0);
	Write_Reg(P2REG_VLANDAT0, u16dat);

	/* set entry rmvtag */
	u16dat = Read_Reg(P2REG_VLANDAT0+1);
	u16dat &= ~0xFF00;
	u16dat |= (u16)(rmvtag&0xFF)<<8;
	Write_Reg(P2REG_VLANDAT0+1, u16dat);

	u16dat = Read_Reg(P2REG_VLANDAT0+2);
	u16dat &= ~0xF;
	u16dat |= (u16)(rmvtag>>8)&0xF;
	Write_Reg(P2REG_VLANDAT0+2, u16dat);

	/* set valid bit to 1 */
	u16dat = (u16)0x1;
	Write_Reg(P2REG_VLANDAT0+3, u16dat);

	/* Write data to VLAN table */
	u16dat = 0xC000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEntryRmvtag);
int setVlanEntryRmvtag(void *cdata, int len)
{
	int vid, rmvtag;

	FUNC_MSG_IN;
	if (sizeof(struct PortmapSetting) != len)
		return -EINVAL;

	vid = ((struct PortmapSetting *)cdata) ->pmdata;
	rmvtag= ((struct PortmapSetting *)cdata) ->portmap;
	
	if(switchdSetVlanEntryRmvtag(vid, rmvtag) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanEntryPriority(int vid, int priority)
{
	u16 u16dat;
	
	if (vid < 0 || vid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	if (priority & ~(0xF))
	{
		ip1811drv_err("Error: priority=%X\n", priority);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);
	ip1811drv_dbg("priority=%d\n", priority);

	IP2Page(2);
	/* read data from VLAN table */
	u16dat = 0x8000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	u16dat = Read_Reg(P2REG_VLANDAT0);
	Write_Reg(P2REG_VLANDAT0, u16dat);
	u16dat = Read_Reg(P2REG_VLANDAT0+1);
	Write_Reg(P2REG_VLANDAT0+1, u16dat);

	/* set entry priority */
	u16dat = Read_Reg(P2REG_VLANDAT0+2);
	u16dat &= ~0x00F0;
	u16dat |= (u16)(priority&0xF)<<4;
	Write_Reg(P2REG_VLANDAT0+2, u16dat);

	/* set valid bit to 1 */
	u16dat = (u16)0x1;
	Write_Reg(P2REG_VLANDAT0+3, u16dat);

	/* Write data to VLAN table */
	u16dat = 0xC000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEntryPriority);
int setVlanEntryPriority(void *cdata, int len)
{
	int vid, priority;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len)
		return -EINVAL;

	vid = ((struct VlanSetting *)cdata) ->vtype;
	priority= ((struct VlanSetting *)cdata) ->vdata;
	
	if(switchdSetVlanEntryPriority(vid, priority) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanEntryFid(int vid, int fid)
{
	u16 u16dat;
	
	if (vid < 0 || vid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	if (fid & ~(0xF))
	{
		ip1811drv_err("Error: fid=%X\n", fid);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);
	ip1811drv_dbg("fid=%d\n", fid);

	IP2Page(2);
	/* read data from VLAN table */
	u16dat = 0x8000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	u16dat = Read_Reg(P2REG_VLANDAT0);
	Write_Reg(P2REG_VLANDAT0, u16dat);
	u16dat = Read_Reg(P2REG_VLANDAT0+1);
	Write_Reg(P2REG_VLANDAT0+1, u16dat);

	/* set entry fid */
	u16dat = Read_Reg(P2REG_VLANDAT0+2);
	u16dat &= ~0xFF00;
	u16dat |= (u16)(fid&0xF)<<8;
	u16dat |= (u16)(fid&0xF)<<12;
	Write_Reg(P2REG_VLANDAT0+2, u16dat);

	/* set valid bit to 1 */
	u16dat = (u16)0x1;
	Write_Reg(P2REG_VLANDAT0+3, u16dat);

	/* Write data to VLAN table */
	u16dat = 0xC000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEntryFid);
int setVlanEntryFid(void *cdata, int len)
{
	int vid, fid;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len)
		return -EINVAL;

	vid = ((struct VlanSetting *)cdata) ->vtype;
	fid= ((struct VlanSetting *)cdata) ->vdata;
	
	if(switchdSetVlanEntryFid(vid, fid) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdGetVlanEntryFid(int vid, int *ptrFid)
{
	u16 u16dat;

	if (vid < 0 || vid >= MAX_PVID_NUM){
		ip1811drv_err("Error: vtype=%X\n", vid);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);

	IP2Page(2);
	/* read data from VLAN table */
	u16dat = 0x8000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);

	/* get entry fid */
	u16dat = Read_Reg(P2REG_VLANDAT0+2);
	*ptrFid = (int)(u16dat>>8)&0xF;
	
	return 0;
}
EXPORT_SYMBOL(switchdGetVlanEntryFid);
int getVlanEntryFid(void *cdata, int len)
{
	int vid, fid=0;

	FUNC_MSG_IN;
	if (sizeof(struct VlanSetting) != len)
		return -EINVAL;

	vid = ((struct VlanSetting *)cdata) ->vtype;

	if(switchdGetVlanEntryFid(vid, &fid) != 0)
		return -EINVAL;

	((struct VlanSetting *)cdata) ->vdata = fid;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct VlanSetting *)cdata) ->vdata);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetVlanEntryClear(int vid)
{
	u16 u16dat;
	int i;

	if (vid < 0 || vid >= MAX_PVID_NUM)
	{
		ip1811drv_err("Error: vid=%X\n", vid);
		return -EINVAL;
	}

	ip1811drv_dbg("vid=%d\n", vid);

	IP2Page(2);

	/* clear entry data */
	for(i=0; i<4; i++)
		Write_Reg(P2REG_VLANDAT0+i, 0 );

	/* Write data from VLAN table */
	u16dat = 0xC000 | vid;
	Write_Reg(P2REG_VLANCMD, u16dat);
	/* wait for command ack */
	while(Read_Reg(P2REG_VLANCMD)&0x8000);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetVlanEntryClear);
int setVlanEntryClear(void *cdata, int len)
{
	int vid;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	vid = ((struct GeneralSetting *)cdata) ->gdata;
	
	if(switchdSetVlanEntryClear(vid) != 0)
		return -EINVAL;	

	FUNC_MSG_OUT;
	return 0;
}

//------------------------------------------------
//ip1811_lut
int switchdSetLutUnknownSARule(int rule)
{
	if ( !(	rule==OP_LUT_UNKNOWN_SA_DROP ||
			rule==OP_LUT_UNKNOWN_SA_FWD_2_CPU ||
			rule==OP_LUT_UNKNOWN_SA_FWD) )
		return -EINVAL;

	ip1811drv_dbg("rule=%d\n", rule);

	_WriteRegBits(1, P1REG_SRCLEARNCFG, 3, 2, rule);

	return 0;
}
EXPORT_SYMBOL(switchdSetLutUnknownSARule);
int setLutUnknownSARule(void *cdata, int len)
{
	int rule;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	rule = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetLutUnknownSARule(rule) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdSetLutEntry(struct IP1811LUTSetting *luts)
{
	int i;
	unsigned char f_notMatch = 0;
	u16 u16dat, index;
	u8 block;
	int temp_offset = -1;
	struct IP1811LUTSetting tmp_luts;
	
	if(		luts ->action!=OP_ENTRY_CREATE &&
			luts ->action!=OP_ENTRY_CONFIG &&
			luts ->action!=OP_ENTRY_DELETE &&
			luts ->action!=OP_ENTRY_CREATE_REG)
	{
		ip1811drv_err("action error:%d\n", luts ->action);
		return -EINVAL;
	}
	if(		luts ->action == OP_ENTRY_CREATE ||
			luts ->action == OP_ENTRY_CONFIG)
	{
		if(luts ->entry.fid > 15)
		{
			ip1811drv_err("fid error:%d\n", luts ->entry.fid);
			return -EINVAL;
		}
		if(luts ->entry.srcport > 31)
		{
			ip1811drv_err("srcport error:%d\n", luts ->entry.srcport);
			return -EINVAL;
		}
		if(luts ->entry.aging > 15)
		{
			ip1811drv_err("aging error:%d\n", luts ->entry.aging);
			return -EINVAL;
		}
		if(luts ->entry.priority > 15)
		{
			ip1811drv_err("priority error:%d\n", luts ->entry.priority);
			return -EINVAL;
		}
		if(luts ->entry.cfg > OP_LUT_CFG_MVT)
		{
			ip1811drv_err("cfg error:%d\n", luts ->entry.cfg);
			return -EINVAL;
		}
	}

	/* initialize retval value */ 
	luts ->retval = 0;
	/* calculate hash value */
	index = 0;//LUT_hash(luts ->entry.mac, luts ->entry.fid);

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("MAC=\n");
	for(i=0; i<6; i++)
		ip1811drv_dbg("[%02X]\n", luts ->entry.mac[i]);
	ip1811drv_dbg("fid=%d\n", luts ->entry.fid);
	ip1811drv_dbg("srcport=%d\n", luts ->entry.srcport);
	ip1811drv_dbg("aging=%d\n", luts ->entry.aging);
	ip1811drv_dbg("priority=%d\n", luts ->entry.priority);
	ip1811drv_dbg("drop=%d\n", luts ->entry.flag.drop);
	ip1811drv_dbg("snif=%d\n", luts ->entry.flag.snif);
	ip1811drv_dbg("sflow=%d\n", luts ->entry.flag.sflow);
	ip1811drv_dbg("cfg=%d\n", luts ->entry.cfg);

	IP2Page(1);
	if(luts ->action==OP_ENTRY_CREATE_REG)
	{
		ip1811drv_dbg("OP_ENTRY_CREATE_REG\n");
		for(i=0; i<5; i++)
			Write_Reg(P1REG_LUTDATA_0+i, luts ->data[i] );
		Write_Reg(P1REG_LUTDATA_0+5, luts ->data[5]|0x0800 );	//hw_calc

		u16dat = 0;
		u16dat |= (u16)0x3<<14;		//set write command & command trigger
		Write_Reg(P1REG_LUTCFG, u16dat );
		/* need to check does trigger bit has been pull up */
		while(!(Read_Reg(P1REG_LUTCFG)&0x8000));
		return 0;
	}

	/* search the index of target entry */
	/* cause use hw_calc bit can't get entry index */	
//	if((luts ->action==OP_ENTRY_CONFIG) || (luts ->action==OP_ENTRY_DELETE))
	{
		memset(&tmp_luts, 0, sizeof(struct IP1811LUTSetting));
		/* search all entries */
		tmp_luts.action = OP_LUT_STATE_ALL;
		tmp_luts.tarports = ALL_PHY_PORTS_LIST;
		while(1)
		{
			/* try to get a valid MAC entry */
			tmp_luts.retval = 0;
			getLutValidEntry(&tmp_luts, sizeof(struct IP1811LUTSetting));
			if(tmp_luts.retval != OP_ENTRY_EXISTS)
				break;
	
			/* get a valid static entry */

			/* check MAC address & FID */
			f_notMatch = 0;
			for(i=0; i<6; i++)
			{
				if(luts ->entry.mac[i] != tmp_luts.entry.mac[i])
				{
					f_notMatch = 1;
					break;
				}
			}
			if(luts ->entry.fid != tmp_luts.entry.fid)
				f_notMatch = 1;
	
			if(!f_notMatch){
				/* if match, record the index */
				temp_offset = tmp_luts.index;
				break;
			}
	
			/* search next valid entry */		
			tmp_luts.index++;
		}
	}

	if(luts ->action==OP_ENTRY_CREATE)
	{
		ip1811drv_dbg("OP_ENTRY_CREATE\n");
		if(tmp_luts.entry.aging == 0xf)
		{
			ip1811drv_dbg("target entry has existed!!\n");
			luts ->retval = OP_ENTRY_EXISTS;
			return 0;
		}
		for(i=0; i<3; i++)
		{
			u16dat = (u16)(luts ->entry.mac[4 - i*2])<<8 | (u16)(luts ->entry.mac[5 - i*2]);
			Write_Reg(P1REG_LUTDATA_0+i, u16dat );
		}
		u16dat = 0;
		u16dat = luts ->entry.fid;
		u16dat |= (u16)luts ->entry.srcport<<4;
		u16dat |= (u16)0x0f<<9;	//set aging to static
		u16dat |= (u16)((luts ->entry.priority & 0x7)<<13);
		Write_Reg(P1REG_LUTDATA_3, u16dat );
		
		u16dat = (u16)((luts ->entry.priority >> 3)&0x1);
		u16dat |= (u16)luts ->entry.flag.sflow<<1;
		u16dat |= (u16)luts ->entry.flag.snif<<2;
		u16dat |= (u16)luts ->entry.flag.drop<<3;
		if (luts ->entry.cfg < OP_LUT_CFG_TRAN)
			u16dat |= (u16)((luts ->entry.cfg & 0x3)<<4);
		else
		{
			u16dat |= (u16)0x0020;	// cfg[1] = 1
			if (luts ->entry.cfg == OP_LUT_CFG_MVT)
				u16dat |= (u16)0x0008;	// drop = 1
		}
		Write_Reg(P1REG_LUTDATA_4, u16dat );

		u16dat = 0x01<<11;//hw_calc
		Write_Reg(P1REG_LUTDATA_5, u16dat );

		u16dat = 0;					//set index
		u16dat |= (u16)0x3<<14;		//set write command & command trigger
		Write_Reg(P1REG_LUTCFG, u16dat );

		/* need to check does trigger bit has been pull up */
		while(!(Read_Reg(P1REG_LUTCFG)&0x8000));
	}
	else if(luts ->action==OP_ENTRY_CONFIG)
	{
		ip1811drv_dbg("OP_ENTRY_CONFIG\n");
		/* if MAC or FID isn't match, we should abort this configuration */
		if(f_notMatch)
		{
			ip1811drv_dbg("MAC or FID not match!!\n");
			luts ->retval = OP_ENTRY_NOT_MATCH;
			return 0;
		}

		for (i=0; i < 3; i++)
			Write_Reg(P1REG_LUTDATA_0+i, tmp_luts.data[i]);

		u16dat = luts ->entry.fid;
		u16dat |= (u16)luts ->entry.srcport<<4;
		u16dat |= (u16)0x0f<<9;	//set aging to static
		u16dat |= (u16)((luts ->entry.priority & 0x7)<<13);
		Write_Reg(P1REG_LUTDATA_3, u16dat );
		
		u16dat = (u16)((luts ->entry.priority >> 3)&0x1);
		u16dat |= (u16)luts ->entry.flag.sflow<<1;
		u16dat |= (u16)luts ->entry.flag.snif<<2;
		if (luts ->entry.cfg < OP_LUT_CFG_TRAN)
		{
			u16dat |= (u16)luts ->entry.flag.drop<<3;
			u16dat |= (u16)((luts ->entry.cfg & 0x3)<<4);
		}
		else
		{
			u16dat |= (u16)0x0020;	// cfg[1] = 1
			if (luts ->entry.cfg == OP_LUT_CFG_MVT)
				u16dat |= (u16)0x0008;	// drop = 1
		}
		Write_Reg(P1REG_LUTDATA_4, u16dat );

		u16dat = 0x01<<11;//hw_calc
		Write_Reg(P1REG_LUTDATA_5, u16dat );

		u16dat = 0;					//set index
		u16dat |= (u16)0x3<<14;		//set write command & command trigger
		Write_Reg(P1REG_LUTCFG, u16dat );
		
		/* need to check does trigger bit has been pull up */
		while(!(Read_Reg(P1REG_LUTCFG)&0x8000));
	}
	else if(luts ->action==OP_ENTRY_DELETE)
	{
		ip1811drv_dbg("OP_ENTRY_DELETE\n");
		if(f_notMatch)
		{
			ip1811drv_dbg("MAC or FID not match!!\n");
			luts ->retval = OP_ENTRY_NOT_MATCH;
			return 0;
		}
		if(tmp_luts.entry.aging != 0xf)
		{
			/* only static entry can be deleted */
			ip1811drv_dbg("not static entry!!\n");
			luts ->retval = OP_ENTRY_NOT_FOUND;
			return 0;
		}
		
		for (i=0; i < 3; i++)
			Write_Reg(P1REG_LUTDATA_0+i, tmp_luts.data[i]);

		u16dat = 0x0;	//set aging to invalid
		Write_Reg(P1REG_LUTDATA_3, u16dat );
		
		u16dat = 0x01<<11;//hw_calc
		Write_Reg(P1REG_LUTDATA_5, u16dat );

		u16dat = 0;					//set index
		u16dat |= (u16)0x3<<14;		//set write command & command trigger
		Write_Reg(P1REG_LUTCFG, u16dat );

		/* need to check does trigger bit has been pull up */
		while(!(Read_Reg(P1REG_LUTCFG)&0x8000));
	}
	
	return 0;
}
EXPORT_SYMBOL(switchdSetLutEntry);
int setLutEntry(void *cdata, const int len)
{
	struct IP1811LUTSetting *luts;

	FUNC_MSG_IN;
	/* check cdata length */
	if (sizeof(struct IP1811LUTSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	luts = (struct IP1811LUTSetting *)cdata;

	if(switchdSetLutEntry(luts) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

u8 getLutCfgFromReg(u16 reg)
{
	if (reg & 0x0020)	// cfg[1] = 1
	{
		if (reg & 0x8)	// drop = 1
			return (u8)OP_LUT_CFG_MVT;
		else
			return (u8)OP_LUT_CFG_TRAN;
	}
	else	// cfg[1] = 0
		return (u8)((reg >> 4) & 0x1);
}

int switchdGetLutEntry(struct IP1811LUTSetting *luts)
{
	int i;
	bool f_notMatch = 0;
	u16 u16dat, lutdat_3, lutdat_4;
	int val_aging;
	u8 op_cfg;

	/* check index range */
	if(luts ->index >= MAX_LUT_ENTRY_NUM){
		ip1811drv_err("Error: index=%d\n", luts ->index);
		return -EINVAL;
	}

	/* set to register page 1 */
	IP2Page(1);

	/* check command action */
	if(luts ->action == OP_ENTRY_GET_BY_INFO){
		if(luts ->entry.fid >= MAX_FID_NUM){
			ip1811drv_err("Error: fid=%d\n", luts ->entry.fid);
			return -EINVAL;
		}

		/* copy mac to register from cdata */
		for(i=0; i<3; i++){
			u16dat = (u16)(luts ->entry.mac[4 - i*2])<<8 | (u16)(luts ->entry.mac[5 - i*2]);
			Write_Reg(P1REG_LUTDATA_0 + i, u16dat );
		}

		/* set fid to register from cdata */
		Write_Reg(P1REG_LUTDATA_3, luts ->entry.fid );

		/* setup table address access method by HW */
		Write_Reg(P1REG_LUTDATA_5, 0x0800 );
	}
	else if(luts ->action == OP_ENTRY_GET_BY_INDEX){
		/* setup table address access method by CPU */
		Write_Reg(P1REG_LUTDATA_5, 0 );
	}
	else{
		ip1811drv_err("Error: action=%d\n", luts ->action);
		return -EINVAL;
	}

	/* initialize return value */
	luts ->retval = 0;

	u16dat = luts ->index;		//set index
	u16dat |= (u16)0x2<<14;		//set read command & command trigger
	Write_Reg(P1REG_LUTCFG, u16dat );

	/* check does trigger bit has been pull up */
	while(!(Read_Reg(P1REG_LUTCFG)&0x8000));

	/* catch aging time to check entry state */
	lutdat_3 = Read_Reg(P1REG_LUTDATA_3);
	lutdat_4 = Read_Reg(P1REG_LUTDATA_4);
	val_aging = (lutdat_3 >> 9) & 0x0F;
	if(val_aging  == 0x0){
		luts ->retval = OP_ENTRY_NOT_FOUND;
		return 0;
	}
	
	/* get lut cfg */
	op_cfg = getLutCfgFromReg(lutdat_4);

	if(luts ->action == OP_ENTRY_GET_BY_INFO){
		/* if action is get by entry info, check if register value is same with input data */
		/* catch MAC address */
		for(i=0; i<3; i++){
			u16dat = Read_Reg(P1REG_LUTDATA_0 + i);
			if( luts ->entry.mac[5 - i*2] != (u8)(u16dat&0xFF) )
				f_notMatch = 1;
			if( luts ->entry.mac[4 - i*2] != (u8)((u16dat>>8)&0xFF) )
				f_notMatch = 1;
		}

		/* check whether fid is matched to input cdata */
		if( luts ->entry.fid != (lutdat_3 & 0x000f))
			f_notMatch = 1;
			
		/* check whether cfg is matched to input cdata */
		if( luts ->entry.cfg != op_cfg)
			f_notMatch = 1;

		if(val_aging == 0xf){//static entry
			if(f_notMatch){
				ip1811drv_err("Error: MAC or FID is not match\n");
				luts ->retval = OP_ENTRY_NOT_MATCH;
				return 0;
			}
			else
				luts ->retval = OP_ENTRY_EXISTS;
		}
		else{//dynamic entry
			if(f_notMatch){
				ip1811drv_err("Error: MAC or FID is not match\n");
				luts ->retval = OP_ENTRY_NOT_MATCH;
				return 0;
			}
			else
				luts ->retval = OP_ENTRY_EXISTS_DYNAMIC;
		}
	}
	else{//if(luts ->action == OP_ENTRY_GET_BY_INDEX)
		if( ((lutdat_3 >> 9) & 0x000F ) == 0x000F )
			luts ->retval = OP_ENTRY_EXISTS;
		else
			luts ->retval = OP_ENTRY_EXISTS_DYNAMIC;

		/* if action is get by entry index, copy the register value into output data */
		/* catch MAC address */
		for(i=0; i<3; i++){
			u16dat = Read_Reg(P1REG_LUTDATA_0 + i);
			luts ->entry.mac[5 - i*2] = (u8)(u16dat&0xFF);
			luts ->entry.mac[4 - i*2] = (u8)((u16dat>>8)&0xFF);
		}

		lutdat_3 = Read_Reg(P1REG_LUTDATA_3);
		luts ->entry.fid	= lutdat_3 & 0x000F;
	}

	luts ->entry.priority	= ((lutdat_4 & 0x0001) << 3) | ((lutdat_3>>13) & 0x0007);
	if (op_cfg < OP_LUT_CFG_TRAN)
		luts ->entry.flag.drop	= (lutdat_4>>3) & 0x0001;
	else
		luts ->entry.flag.drop	= 0;
	luts ->entry.flag.sflow	= (lutdat_4>>1) & 0x0001;
	luts ->entry.flag.snif	= (lutdat_4>>2) & 0x0001;
	luts ->entry.srcport	= (lutdat_3>>4) & 0x001F;

	luts ->entry.aging	= val_aging;
	luts ->entry.cfg	= op_cfg;

	ip1811drv_dbg("cdata ->MAC=");
	for(i=0; i<6; i++)
		ip1811drv_dbg("[%02X]", luts ->entry.mac[i]);
	ip1811drv_dbg("\ncdata ->fid=%d\n", luts ->entry.fid);
	ip1811drv_dbg("cdata ->srcport=%d\n", luts ->entry.srcport);
	ip1811drv_dbg("cdata ->aging=%d\n", luts ->entry.aging);
	ip1811drv_dbg("cdata ->priority=%d\n", luts ->entry.priority);
	ip1811drv_dbg("cdata ->drop=%d\n", luts ->entry.flag.drop);
	ip1811drv_dbg("cdata ->snif=%d\n", luts ->entry.flag.snif);
	ip1811drv_dbg("cdata ->sflow=%d\n", luts ->entry.flag.sflow);
	ip1811drv_dbg("cdata ->cfg=%d\n", luts ->entry.cfg);

	return 0;
}
EXPORT_SYMBOL(switchdGetLutEntry);
int getLutEntry(void *cdata, const int len)
{
	struct IP1811LUTSetting *luts;

	FUNC_MSG_IN;
	/* check cdata length */
	if (sizeof(struct IP1811LUTSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	luts = (struct IP1811LUTSetting *)cdata;

	if(switchdGetLutEntry(luts) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdGetLutValidEntry(struct IP1811LUTSetting *luts)
{
	int i, retrytimes=25;
	u16 u16dat, lutdat[6];
	unsigned short index;
	unsigned char block;
	int temp_offset;
	
	u16 hashvid;
	
	/* check index range */
	if(luts ->index >= MAX_LUT_ENTRY_NUM)
	{
		ip1811drv_err("Error: index=%d\n", luts ->index);
		return -EINVAL;
	}
	index = luts ->index;

	ip1811drv_dbg("action=%d\n", luts ->action);
	/* set to register page 1 */
	IP2Page(1);

	/* setup table address access method by CPU */
	Write_Reg(P1REG_LUTDATA_5, 0 );

	/* initialize return value */
	luts ->retval = 0;
	
	u16dat = index;				//set index
	u16dat |= (u16)0x2000;		//sequential search for valid entry
	u16dat |= (u16)0x2<<14;		//set read command & command trigger
	Write_Reg(P1REG_LUTCFG, u16dat );

	while (1)
	{
		memset(lutdat, 0, sizeof(lutdat));
		
		/* check does trigger bit has been pull up */
		for (i=0; i < retrytimes; i++)
		{
			udelay(100);
			u16dat = Read_Reg(P1REG_LUTCFG);
			if (u16dat & 0x8000)
				break;
		}
		if (i == retrytimes)
			goto out_switchdGetLutValidEntry;
		
		/* read out all registers of lut data */
		for (i=0; i < 6; i++)
			lutdat[i] = Read_Reg(P1REG_LUTDATA_0+i);
			
		/* check if there is any entry data */
		if (lutdat[0]==0 && lutdat[1]==0 && lutdat[2]==0){
			/* no data in lut table */
			goto out_switchdGetLutValidEntry;
		}
		
		/* check if there is no more new data */
		if (!(u16dat & 0x2000)){
			/* lut table has been scanned to the end */
			goto out_switchdGetLutValidEntry;
		}
		
		/* catch aging time to check entry state */
		if((lutdat[3] &0x1e00) == 0x0){
			/* invalid entry */
			continue;
		}
		if(		((lutdat[3] >> 9) & 0xf) == 0xf &&
				!(luts ->action & OP_LUT_STATE_STATIC)
				)
		{
			/* action don't need static entry */
			continue;
		}
		if(		((lutdat[3] >> 9) & 0xf) != 0xf &&
				!(luts ->action & OP_LUT_STATE_DYNAMIC) )
		{
			/* action don't need dynamic entry */
			continue;
		}
	
		/* check whether source port bigger than CPU port num */
		if((((lutdat[3]>>4) & 0x001f) + 1) > MAX_PHY_NUM)
			continue;
	
		/* check whether this entry is in target portlist */
		if(!((1UL << ((lutdat[3]>>4) & 0x001f))&luts ->tarports))
			continue;
			
		break;
	}
		
	/* if find a valid entry, copy the register value into output data */
	/* catch MAC address */
	for(i=0; i<6; i++)
	{
		luts ->data[i] = lutdat[i];
		if (i < 3)
		{
			luts ->entry.mac[5 - i*2] = (u8)(lutdat[i]&0xFF);
			luts ->entry.mac[4 - i*2] = (u8)((lutdat[i]>>8)&0xFF);
		}
	}
	
	luts ->entry.fid		= lutdat[3] & 0x000f;
	luts ->entry.srcport	= (lutdat[3]>>4) & 0x001f;
	luts ->entry.aging		= (lutdat[3]>>9) & 0x000f;
	luts ->entry.priority	= (lutdat[3]>>13) & 0x0007;
	luts ->entry.priority	|= ((lutdat[4] & 0x0001) << 3);
	
	luts ->entry.flag.sflow	= (lutdat[4]>>1) & 0x0001;
	luts ->entry.flag.snif	= (lutdat[4]>>2) & 0x0001;
    luts -> entry.cfg		= getLutCfgFromReg(lutdat[4]);
    if (luts -> entry.cfg < OP_LUT_CFG_TRAN)
		luts ->entry.flag.drop	= (lutdat[4]>>3) & 0x0001;
	else
		luts ->entry.flag.drop	= 0;

	luts ->retval = OP_ENTRY_EXISTS;

	ip1811drv_dbg("=====================================\n");
	ip1811drv_dbg("index=%d\n", luts ->index);
	ip1811drv_dbg("retval=%lX\n", luts ->retval);
	ip1811drv_dbg("MAC=");
	for(i=0; i<6; i++)
		ip1811drv_dbg("[%02X]", luts ->entry.mac[i]);
	ip1811drv_dbg("\nfid=%d\n", luts ->entry.fid);
	ip1811drv_dbg("srcport=%d\n", luts ->entry.srcport);
	ip1811drv_dbg("aging=%d\n", luts ->entry.aging);
	ip1811drv_dbg("priority=%d\n", luts ->entry.priority);
	ip1811drv_dbg("drop=%d\n", luts ->entry.flag.drop);
	ip1811drv_dbg("snif=%d\n", luts ->entry.flag.snif);
	ip1811drv_dbg("sflow=%d\n", luts ->entry.flag.sflow);
	ip1811drv_dbg("cfg=%d\n", luts ->entry.cfg);

out_switchdGetLutValidEntry:
	return 0;
}
EXPORT_SYMBOL(switchdGetLutValidEntry);
int getLutValidEntry(void *cdata, const int len)
{
	struct IP1811LUTSetting *luts;

	FUNC_MSG_IN;
	/* check cdata length */
	if (sizeof(struct IP1811LUTSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	luts = (struct IP1811LUTSetting *)cdata;

	if(switchdGetLutValidEntry(luts) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

//------------------------------------------------
//ip1811_igmp
int switchdSetIGMPSnooping(int enable)
{
	switch(enable) {
	case OP_FUNC_ENABLE:
		ip1811drv_dbg("Enable IGMP\n");
		break;
	case OP_FUNC_DISABLE:
		ip1811drv_dbg("Disable IGMP\n");
		break;
	default:
		ip1811drv_dbg("Option can't find\n");
		return -EINVAL;
	}

	ip1811drv_dbg("Set IGMPSNOP: %x\n", enable);
	_WriteRegBits(1, P1REG_IGMPSNOP, 0, 1, enable);
	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPSnooping);

int setIGMPSnooping(void *cdata, int len)
{
	int ret, func_en;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPSnoopin.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	func_en = igmp ->gdata;
	ret = switchdSetIGMPSnooping(func_en);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPSnooping(int *gdata_p)
{
	*gdata_p = (int)_ReadRegBits(1, P1REG_IGMPSNOP, 0, 1)?OP_FUNC_ENABLE:OP_FUNC_DISABLE;
	ip1811drv_dbg("IGMP %s",(*gdata_p==OP_FUNC_ENABLE)?"ENABLE":"DISABLE");
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPSnooping);

int getIGMPSnooping(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPSnoopin.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	ret = switchdGetIGMPSnooping(&(igmp ->gdata))
	FUNC_MSG_OUT;
	return ret;
}

int switchdSetIGMPMctByCPU(int enable)
{
	switch(enable) {
	case OP_FUNC_ENABLE:
		ip1811drv_dbg("Enable MCT By CPU\n");
		break;
	case OP_FUNC_DISABLE:
		ip1811drv_dbg("Disable MCT By CPU\n");
		break;
	default:
		ip1811drv_dbg("Option can't find\n");
		return -EINVAL;
	}

	ip1811drv_dbg("Set MCT By CPU: %x\n", enable);
	_WriteRegBits(1, P1REG_IGMPSNOP, 1, 1, enable);
	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPMctByCPU);

int setIGMPMctByCPU(void *cdata, int len)
{
	int ret, func_en;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPMctByCPU.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	func_en = igmp ->gdata;
	ret = switchdSetIGMPMctByCPU(func_en);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPMctByCPU(int *gdata_p)
{
	*gdata_p = (int)_ReadRegBits(1, P1REG_IGMPSNOP, 1, 1)?OP_FUNC_ENABLE:OP_FUNC_DISABLE;
	ip1811drv_dbg("IGMPMctByCPU %s",(*gdata_p==OP_FUNC_ENABLE)?"ENABLE":"DISABLE");
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPMctByCPU);

int getIGMPMctByCPU(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPMctByCPU.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	ret = switchdGetIGMPMctByCPU(&(igmp ->gdata));
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdSetIGMPRltByCPU(int enable)
{
	switch(enable) {
	case OP_FUNC_ENABLE:
		ip1811drv_dbg("Enable router list by CPU\n");
		break;
	case OP_FUNC_DISABLE:
		ip1811drv_dbg("Disable router list by CPU\n");
		break;
	default:
		ip1811drv_dbg("Option can't find\n");
		return -EINVAL;
	}

	ip1811drv_dbg("Set router list by CPU: %x\n", enable);
	_WriteRegBits(1, P1REG_IGMPSNOP, 5, 1, enable);
	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPRltByCPU);

int setIGMPRltByCPU(void *cdata, int len)
{
	int ret, func_en;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPRltByCPU.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	func_en = igmp ->gdata;
	ret = switchdSetIGMPRltByCPU(func_en);
	FUNC_MSG_OUT;

	return 0;
}

int switchdGetIGMPRltByCPU(int *gdata_p)
{
	*gdata_p = (int)_ReadRegBits(1, P1REG_IGMPSNOP, 5, 1)?OP_FUNC_ENABLE:OP_FUNC_DISABLE;
	ip1811drv_dbg("IGMPRltByCPU %s",(*gdata_p==OP_FUNC_ENABLE)?"ENABLE":"DISABLE");
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPRltByCPU);

int getIGMPRltByCPU(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPRltByCPU.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	ret = switchdGetIGMPRltByCPU(&(igmp ->gdata));
	FUNC_MSG_OUT;

	return 0;
}

int switchdSetIGMPPktForward(unsigned int type, unsigned int rule)
{
	u16 regdata;
	u16 rule_t;

	IP2Page(1);
	switch(type){
	case OP_IGMP_PACKET_QUERY:
	case OP_IGMP_PACKET_LEAVE:
	case OP_IGMP_PACKET_UN_REG_DATA:
	case OP_IGMP_PACKET_UN_DEFINED:
		if(rule >= OP_IGMP_RULE_GROUP_MEM){
			ip1811drv_dbg("Select Type can't support Rule 'OP_IGMP_RULE_GROUP_MEM'.\n");
			return -EINVAL;
		}
		regdata = Read_Reg(P1REG_IGMPPKTFWD_0);
		ip1811drv_dbg("Read IGMPPktForward_0 : %x\n", regdata);
		rule_t = 0x000F<<type;
		regdata &= ~rule_t;
		regdata |= rule<<type;
		ip1811drv_dbg("type : %d\n", type);
		ip1811drv_dbg("rule : %x\n", rule);
		ip1811drv_dbg("Write IGMPPktForward_0 : %x\n",regdata);
		Write_Reg(P1REG_IGMPPKTFWD_0, regdata);
		break;
	case OP_IGMP_PACKET_REPORT:
	case OP_IGMP_PACKET_GROUP_SPECIFIC_QUERY:
	case OP_IGMP_PACKET_REG_DATA:
		regdata = Read_Reg(P1REG_IGMPPKTFWD_1);
		ip1811drv_dbg("Read IGMPPktForward_1 : %x\n", regdata);
		rule_t = 0x001F<<(type-1);
		regdata &= ~rule_t;
		regdata |=rule<<(type-1);
		ip1811drv_dbg("type : %d\n", type);
		ip1811drv_dbg("rule : %x\n", rule);
		ip1811drv_dbg("Write IGMPPktForward_1 : %x\n", regdata);
		Write_Reg(P1REG_IGMPPKTFWD_1, regdata);
		break;
	default:
		ip1811drv_dbg("Option can't find.\n");
		return -EINVAL;
		break;
	}
	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPPktForward);

int setIGMPPktForward(void *cdata, int len)
{
	int ret;
	struct IgmpPacketRule *igmp;
	unsigned int pkt_type;
	unsigned int pkt_rule;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPPktForward.\n");
	if (sizeof(struct IgmpPacketRule) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}
	igmp = (struct IgmpPacketRule *)cdata;
	pkt_type = igmp ->packet_type;
	pkt_rule = igmp ->rule;
	ret = switchdSetIGMPPktForward(pkt_type, pkt_rule);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPPktForward(unsigned int type, int *rule_p)
{
	u16 regdata;
	u16 rule_t;

	IP2Page(1);
	switch(type){
	case OP_IGMP_PACKET_QUERY:
	case OP_IGMP_PACKET_LEAVE:
	case OP_IGMP_PACKET_UN_REG_DATA:
	case OP_IGMP_PACKET_UN_DEFINED:
		regdata = Read_Reg(P1REG_IGMPPKTFWD_0);
		ip1811drv_dbg("Read IGMPPktForward_0 : %x\n", regdata);
		rule_t = 0x000F<<type;
		regdata &= rule_t;
		*rule_p = regdata>>(type);
		ip1811drv_dbg("type : %d\n", type);
		ip1811drv_dbg("Get rule : %x\n", *rule_p);
		break;
	case OP_IGMP_PACKET_REPORT:
	case OP_IGMP_PACKET_GROUP_SPECIFIC_QUERY:
	case OP_IGMP_PACKET_REG_DATA:
		regdata = Read_Reg(P1REG_IGMPPKTFWD_1);
		ip1811drv_dbg("Read IGMPPktForward_1 : %x\n", regdata);
		rule_t = 0x001F<<(type-1);
		regdata &= rule_t;
		*rule_p = regdata>>(type-1);
		ip1811drv_dbg("type : %d\n", type);
		ip1811drv_dbg("Get rule : %x\n", *rule_p);
		break;
	default:
		ip1811drv_dbg("Option can't find.\n");
		return -EINVAL;
		break;
	}
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPPktForward);

int getIGMPPktForward(void *cdata, int len)
{
	unsigned int pkt_type;
	struct IgmpPacketRule *igmp;
	int ret;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPPktForward.\n");
	if (sizeof(struct IgmpPacketRule) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}
	igmp = (struct IgmpPacketRule *)cdata;
	pkt_type = igmp ->packet_type;
	ret = switchdGetIGMPPktForward(pkt_type, &(igmp ->rule));
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetIGMPRlt(unsigned int map, unsigned int tstate)
{
	u16 regdata;
	u16 i, mask;
	
	IP2Page(1);
	regdata = Read_Reg(P1REG_ROUTLIST);
	ip1811drv_dbg("Read [12-01] : %x\n", regdata);
	mask = 0x01;
	for(i=0; i<12;i++){
		if((map&mask)!=0) {
			if((tstate&mask)!=0)
				regdata |= mask;
			else
				regdata &= ~mask;
		}
		mask <<= 1;
	}
	ip1811drv_dbg("Write new [12-01] : %x\n", regdata);
	Write_Reg(P1REG_ROUTLIST, regdata);
	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPRlt);

int setIGMPRlt(void *cdata, int len)
{
	u16 map, value;
	struct IgmpRouterListSetting *igmp;
	int ret;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPRlt.\n");
	if (sizeof(struct IgmpRouterListSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}
	
	igmp = (struct IgmpRouterListSetting *)cdata;
	map = 0xFFF&(igmp ->portmask);
	value = 0xFFF&(igmp ->tstate);

	ip1811drv_dbg("map [12-01] : %x\n", map);
	ip1811drv_dbg("val [12-01] : %x\n", value);

	ret = switchdSetIGMPRlt(map, value);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPRlt(unsigned int map, int *value_p)
{
	u16 regdata, value, i, mask;
	
	IP2Page(1);
	regdata = Read_Reg(P1REG_ROUTLIST);
	ip1811drv_dbg("Read [12-01] : %x\n", regdata&0xFFF);
	mask = 0x01;
	for(i=0; i<12; i++) {
		if((map&mask)!=0){
			if((regdata&mask)!=0)
				value |= mask;
			else
				value &= ~mask;
		}
		mask <<= 1;
	}

	*value_p = value;
	ip1811drv_dbg("Return value : %lx\n", *value_p);

	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPRlt);

int getIGMPRlt(void *cdata, int len)
{
	u16 map, value, i, mask;
	struct IgmpRouterListSetting *igmp;
	int ret;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPRlt.\n");
	if (sizeof(struct IgmpRouterListSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}
	igmp = (struct IgmpRouterListSetting *)cdata;

	map = 0xFFF&(igmp ->portmask);
	ip1811drv_dbg("map [12-01] : %x\n", map);

	ret = switchdGetIGMPRlt(map, &(igmp ->tstate));
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetIGMPHashMethod(int hash_method)
{
	if (!(hash_method==OP_HASH_DIRECT || hash_method==OP_HASH_CRC))
		return -EINVAL;

	ip1811drv_dbg("Set Hash Method: %s\n", (hash_method==OP_HASH_DIRECT)?"DIRECT":"CRC");
	_WriteRegBits(1, P1REG_IGMPSNOP, 6, 1,(hash_method==OP_HASH_DIRECT)?1:0);

	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPHashMethod);

int setIGMPHashMethod(void *cdata, int len)
{
	int hash, ret;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	hash = ((struct GeneralSetting *)cdata) ->gdata;
	ret = switchdSetIGMPHashMethod(hash);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPHashMethod(int *gdata_p)
{
	*gdata_p = (int)_ReadRegBits(1, P1REG_IGMPSNOP, 6, 1)?OP_HASH_DIRECT:OP_HASH_CRC;
	ip1811drv_dbg("HASH METHOD %s",(*gdata_p==OP_HASH_DIRECT)?"DIRECT":"CRC");
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPHashMethod);

int getIGMPHashMethod(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *igmp;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPHashMethod.\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	igmp = (struct GeneralSetting *)cdata;
	ret = switchdGetIGMPHashMethod(&(igmp ->gdata));
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetIGMPMldRule(int forwarding)
{

	ip1811drv_dbg("set ICMPv6 MLD forwarding: %x\n", forwarding);
	_WriteRegBits(0, P0REG_IPV6RLTFWD, 8, 2, forwarding);

	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPMldRule);

int setIGMPMldRule(void *cdata, int len)
{
	struct GeneralSetting *igmp;
	int ret, forward;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPMldRule.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	forward = igmp ->gdata;
	ret = switchdSetIGMPMldRule(forward);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPMldRule(int *gdata_p)
{
	*gdata_p = (int)_ReadRegBits(0, P0REG_IPV6RLTFWD, 8, 2);
	ip1811drv_dbg("get ICMPv6 MLD forwarding: %x\n", *gdata_p);
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPMldRule);

int getIGMPMldRule(void *cdata, int len)
{
	struct GeneralSetting *igmp;
	int ret;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPMldRule.\n");
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct GeneralSetting *)cdata;
	ret = switchdGetIGMPMldRule(&(igmp ->gdata));
	FUNC_MSG_OUT;

	return ret;
}

void makeTable(u16 *tmpbuf, u16 offset, u32 value, u8 len)
{
	u16 ptr, set, tmpvalue;

	ptr = offset/16;
	set = offset%16;
	ip1811drv_dbg("\n\nMakeTable:\noffset : %d\nvalue : %x\nlen : %d\n", offset, value, len);
	ip1811drv_dbg("\nbuf[%d]=%x buf[%d]=%x\n", ptr, tmpbuf[ptr], ptr+1, tmpbuf[ptr+1]);
	tmpvalue = (0xFFFF&value)<<set;
	tmpbuf[ptr] |= tmpvalue;
	ip1811drv_dbg("Result:\nbuf[%d] | %x = %x\n", ptr, tmpvalue, tmpbuf[ptr]);
	if(len>(16-set)) {
		len -= (16-set);
		tmpvalue = 0xFFFF&(value>>(16-set));
		tmpbuf[ptr+1] |= tmpvalue;
		ip1811drv_dbg("buf[%d] | %x = %x\n", ptr+1, tmpvalue, tmpbuf[ptr+1]);
		if(len>16){
			tmpvalue = 0xFFFF&(value>>(32-set));
			tmpbuf[ptr+2] |= tmpvalue;
			ip1811drv_dbg("buf[%d] | %x = %x\n", ptr+2, tmpvalue, tmpbuf[ptr+2]);
		}
	}
}

u32 getTable(u16 *tmpbuf, u16 offset, u8 len)
{
	u32 value;
	u16 ptr, set, tmpvalue, i, mask;
	u16 debug;
	ip1811drv_dbg("getTable:\n");
	ip1811drv_dbg("offset = %d, len = %d", offset, len);
	debug = offset/16;
	ip1811drv_dbg("tmpbuf[%d] offset value:\n", debug);
	for(i=0; i<3; i++)
		ip1811drv_dbg("%04x ", tmpbuf[debug+i]);
	ptr = (offset+len)/16;
	set = (offset+len)%16;

	if(len>=set){
		mask = 0;
		for(i=0; i<set; i++){
			mask <<= 1;
			mask |= 0x01;
		}
		tmpvalue = tmpbuf[ptr]&mask;
		value = tmpvalue;
		if((len-set)>=16) {
			value <<= 16;
			value |= tmpbuf[ptr-1];
			if((len-set-16)>0){
				value <<= (len-set-16);
				value |= tmpbuf[ptr-2]>>(16-(len-set-16));
			}
		} else {
			if(len!=set) {
				value <<= (len-set);
				value |= tmpbuf[ptr-1]>>(16-(len-set));
			}
		}
	} else {
		mask = 0;
		for(i=0; i<set; i++){
			mask <<= 1;
			mask |= 0x01;
		}
		tmpvalue = tmpbuf[ptr]&mask;
		value = tmpvalue>>(set-len);
	}
	ip1811drv_dbg("return %x\n",value);
	return value;
}

/*	ipv:	4:	IPv4
 *		6:	IPv6
 *	addr:	IP	address
 *	method:	1:	Direct
 *		0:	CRC
 * */
u8 tb_calc_index(u8 ipv, void *addr, u8 method)
{
	u8 index = 0;
	u8 *u8_addr = (u8*)addr;

	// Direct
	if(method) {
		if(ipv == 4) {
			index = u8_addr[3];
		} else if(ipv == 6) {
			index = u8_addr[15];
		}
	} else { // CRC
		int i;
		bool crc[8], d[32];
		bool c[8] = {1,1,1,1,1,1,1,1};

		// init data
		if(ipv == 4) {
			for(i=0; i<32; i++)
				d[i] = (bool)((u8_addr[i/8] >> (7-(i%8))) & 0x1);
		} else if(ipv == 6) {
			for(i=0; i<32; i++)
				d[i] = (bool)((u8_addr[12+(i/8)] >> (7-(i%8))) & 0x1);
		}

		// calculate crc
		crc[0] = d[31] ^ d[30] ^ d[28] ^ d[23] ^ d[21] ^ d[19] ^ d[18] ^ d[16] ^ d[14] ^ d[12] ^ d[8] ^ d[7] ^ d[6] ^ d[0] ^ c[4] ^ c[6] ^ c[7];

		crc[1] = d[30] ^ d[29] ^ d[28] ^ d[24] ^ d[23] ^ d[22] ^ d[21] ^ d[20] ^ d[18] ^ d[17] ^ d[16] ^ d[15] ^ d[14] ^ d[13] ^ d[12] ^ d[9] ^ d[6] ^ d[1] ^ d[0] ^ c[0] ^ c[4] ^ c[5] ^ c[6];

		crc[2] = d[29] ^ d[28] ^ d[25] ^ d[24] ^ d[22] ^ d[17] ^ d[15] ^ d[13] ^ d[12] ^ d[10] ^ d[8] ^ d[6]^ d[2] ^ d[1] ^ d[0] ^ c[0] ^ c[1] ^ c[4] ^ c[5];

		crc[3] = d[30] ^ d[29] ^ d[26] ^ d[25] ^ d[23] ^ d[18] ^ d[16] ^ d[14] ^ d[13] ^ d[11] ^ d[9] ^ d[7] ^ d[3] ^ d[2] ^ d[1] ^ c[1] ^ c[2] ^ c[5] ^ c[6];

		crc[4] = d[31] ^ d[30] ^ d[27] ^ d[26] ^ d[24] ^ d[19] ^ d[17] ^ d[15] ^ d[14] ^ d[12] ^ d[10] ^ d[8] ^ d[4] ^ d[3] ^ d[2] ^ c[0] ^ c[2] ^ c[3] ^ c[6] ^ c[7];

		crc[5] = d[31] ^ d[28] ^ d[27] ^ d[25] ^ d[20] ^ d[18] ^ d[16] ^ d[15] ^ d[13] ^ d[11] ^ d[9] ^ d[5] ^ d[4] ^ d[3] ^ c[1] ^ c[3] ^ c[4] ^ c[7];

		crc[6] = d[29] ^ d[28] ^ d[26] ^ d[21] ^ d[19] ^ d[17] ^ d[16] ^ d[14] ^ d[12] ^ d[10] ^ d[6] ^ d[5] ^ d[4] ^ c[2] ^ c[4] ^ c[5];

		crc[7] = d[30] ^ d[29] ^ d[27] ^ d[22] ^ d[20] ^ d[18] ^ d[17] ^ d[15] ^ d[13] ^ d[11] ^ d[7] ^ d[6] ^ d[5] ^ c[3] ^ c[5] ^ c[6];

		// get index
		for(i=0; i<8; i++)
			index |= ((u8)crc[i])<<i;
	}

	ip1811drv_dbg("tb_calc_index() index = %02u\n", index);
	return index;
}

int switchdSetIGMPMctTable(int index, struct mt_rule *mt_data)
{
	u16 regdata[6] = {0};
	u16 i, tmpvalue;

	memset(regdata, 0, 11);
	ip1811drv_dbg("driver:index: %x\n", index);
	ip1811drv_dbg("driver:group: %x : %x : %x : %x\n", mt_data->group[0], mt_data->group[1], mt_data->group[2], mt_data->group[3]);
	ip1811drv_dbg("driver:Set FID: %x\n", mt_data->fid);
	ip1811drv_dbg("driver:Set age port:: %lx\n", mt_data->port_mem);
	ip1811drv_dbg("driver:Set SIP: %x\n", mt_data->slt_index);
	ip1811drv_dbg("driver:Set flag: %x\n", mt_data->flag);

	//set Group
	regdata[0] = (mt_data->group[2] << 8) | mt_data->group[3];
	regdata[1] = (mt_data->group[0] << 8) | mt_data->group[1];
	//set FID
	makeTable(regdata, 32, mt_data->fid, 4);
	//set Aging Member
	for(i=0; i<12; i++) {
		if(mt_data->port_mem & BIT(i)) {
			makeTable(regdata, 36+i, 0x1, 1);
			makeTable(regdata, 36+i+12, 0x1, 1);
			makeTable(regdata, 36+i+24, 0x1, 1);
		}
	}
	//set Pri
	makeTable(regdata, 72, mt_data->pri, 4);
	//set SIP
	makeTable(regdata, 76, mt_data->slt_index, 5);
	//set ver and CPU
	makeTable(regdata, 81, mt_data->flag, 2);

	IP2Page(1);
	ip1811drv_dbg("driver:Write Mct Table Data:\n");
	for(i=0; i<6; i++) {
		ip1811drv_dbg("%04x ", regdata[i]);
		Write_Reg(P1REG_MEM_MCT_TABLE_0+i, regdata[i]);
	}
	ip1811drv_dbg("\n");

	tmpvalue = index;
	tmpvalue |= 0xC000;
	ip1811drv_dbg("\ndirver:Start Write [%04x]", tmpvalue);
	Write_Reg(P1REG_MEM_MCT_COMMAND, tmpvalue);

	tmpvalue = Read_Reg(P1REG_MEM_MCT_COMMAND);
	while((tmpvalue&0x8000)!=0)
		tmpvalue = Read_Reg(P1REG_MEM_MCT_COMMAND);

	return 0;
}
EXPORT_SYMBOL(switchdSetIGMPMctTable);

int setIGMPMctTable(void *cdata, int len){
	
	int ret, index;
	struct MtRuleSetting *igmp;
	struct mt_rule *mt;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPMctTable.\n");
	if (sizeof(struct MtRuleSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct MtRuleSetting *)cdata;
	index = igmp ->index;
	mt = &(igmp ->mt_data);
	ret = switchdSetIGMPMctTable(index, mt);
	FUNC_MSG_OUT;

	return 0;
}

int switchdGetIGMPMctTable(int index, struct mt_rule *mt_data)
{
	u16 regdata[6] = {0};
	u16 i, j, tmpvalue;
	u32 mask;
	
	tmpvalue = index;
	tmpvalue |= 0x8000;
	IP2Page(1);
	Write_Reg(P1REG_MEM_MCT_COMMAND, tmpvalue);
	ip1811drv_dbg("driver:start read: %x\n", tmpvalue);

	tmpvalue = Read_Reg(P1REG_MEM_MCT_COMMAND);
	while((tmpvalue&0x8000)!=0)
		tmpvalue = Read_Reg(P1REG_MEM_MCT_COMMAND);

	ip1811drv_dbg("driver:index: %x\n", index);
	ip1811drv_dbg("driver:Read Table Data:\n");
	for(i=0; i<6; i++) {
		regdata[i] = Read_Reg(P1REG_MEM_MCT_TABLE_0+i);
		ip1811drv_dbg("%04x ", regdata[i]);
	}
	ip1811drv_dbg("\nRead Group:\n");
	for(i=0; i<4; i++) {
		mt_data->group[i] = getTable(regdata, (0+(8*i)), 8);
		ip1811drv_dbg("%x ", mt_data->group[i]);
	}

	ip1811drv_dbg("\nRead FID:\n");
	mt_data->fid = getTable(regdata, 32, 4);
	ip1811drv_dbg("%x\n",mt_data->fid);

	ip1811drv_dbg("Read Aging:\n");
	mask = 0;
	for(i=0; i<12; i++){
		int val = 0;
		for(j=0; j<3; j++) {
			if(getTable(regdata, (36+i+(12*j)), 1)!=0 )
				val++;
		}
		if(val)
			mask |= 0x01<<i;
	}
	ip1811drv_dbg("%x\n", mask);
	mt_data->port_mem = mask;

	ip1811drv_dbg("Read Priority:\n");
	mt_data->pri = getTable(regdata, 72, 4);
	ip1811drv_dbg("%x\n",mt_data->pri);
	
	ip1811drv_dbg("Read SLT index:\n");
	mt_data->slt_index = getTable(regdata, 76, 5);
	ip1811drv_dbg("%x\n",mt_data->slt_index);

	ip1811drv_dbg("Read flag:\n");
	mt_data->flag = getTable(regdata, 81, 2);
	ip1811drv_dbg("%x\n",mt_data->flag);

	printk(KERN_ERR "\nGroup:");
	for(i=0;i<4;i++)
		printk(KERN_ERR " %d", mt_data->group[i]);
	printk(KERN_ERR "\nFID: %x", mt_data->fid);
	printk(KERN_ERR "\nPort member: %lx", (unsigned long)mt_data->port_mem);
	printk(KERN_ERR "\nPriority: %d", (mt_data->pri&0x07));
	printk(KERN_ERR "\nSLT index: %x", mt_data->slt_index);
	printk(KERN_ERR "\nFlag: %x\n", mt_data->flag);
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPMctTable);

int getIGMPMctTable(void *cdata, int len){
	int ret, index;
	struct MtRuleSetting *igmp;
	struct mt_rule *mt;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPMctTable.\n");
	if (sizeof(struct MtRuleSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct MtRuleSetting *)cdata;
	index = igmp ->index;
	mt = &(igmp ->mt_data);
	ret = switchdGetIGMPMctTable(index, mt);
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetIGMPSltTable(int index, struct slt_rule *slt_data)
{
	u16 regdata[19] = {0};
	u16 i, j, tmpvalue;

	if(slt_data->type == OP_IGMP_SLT_IPV4) {
		//set IP
		for(i=0; i<6; i++){
			regdata[i*2] = (slt_data->data.ipv4.ip[i][2] << 8) | slt_data->data.ipv4.ip[i][3];
			regdata[i*2+1] = (slt_data->data.ipv4.ip[i][0] << 8) | slt_data->data.ipv4.ip[i][1];
		}
		//set User Define
		for(i=0; i<6; i++)
			makeTable(regdata, (192+(12*i)), slt_data->data.ipv4.used_port[i], 12);
	}else{
		//set IP
		for(i=0; i<2; i++){
			for(j=0; j<8; j++)
				makeTable(regdata, ((128*i)+(16*j)), slt_data->data.ipv6.ip[i][7-j], 16);
		}
		//set User Define
		for(i=0; i<2 ;i++)
			makeTable(regdata, (256+(12*i)), slt_data->data.ipv6.used_port[i], 12);
	}

	ip1811drv_dbg("SLT Table Data:");
	IP2Page(1);
	for(i=0; i<19; i++) {
		if((i%16)==0)
			ip1811drv_dbg("\n");
		ip1811drv_dbg("%04x ", regdata[i]);
		Write_Reg(P1REG_MEM_SLT_TABLE_0+i, regdata[i]);
	}
	tmpvalue = index;
	tmpvalue |= 0xC000;
	ip1811drv_dbg("\ndirver:Start Write [%04x]", tmpvalue);
	Write_Reg(P1REG_MEM_SLT_COMMAND, tmpvalue);

    return 0;
}
EXPORT_SYMBOL(switchdSetIGMPSltTable);

int setIGMPSltTable(void *cdata, int len){
	int ret, index;
	struct SltRuleSetting *igmp;
	struct slt_rule *slt;

	FUNC_MSG_IN;
	ip1811drv_dbg("In setIGMPSltTable.\n");
	if (sizeof(struct SltRuleSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct SltRuleSetting *)cdata;
	index = igmp ->index;
	slt = &(igmp ->slt_data);
	ret = switchdSetIGMPSltTable(index, slt);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetIGMPSltTable(int index, struct slt_rule *slt_data)
{
	u16 regdata[19] = {0};
	u16 i, j, tmpvalue;
	
	tmpvalue = index;
	tmpvalue |= 0x8000;
	IP2Page(1);
	Write_Reg(P1REG_MEM_SLT_COMMAND, tmpvalue);

	tmpvalue = Read_Reg(P1REG_MEM_SLT_COMMAND);
	while( (tmpvalue&0x8000)!=0 )
		tmpvalue = Read_Reg(P1REG_MEM_SLT_COMMAND);

	ip1811drv_dbg("Read SLT Table:");
	for(i=0; i<19; i++) {
		regdata[i] = Read_Reg(P1REG_MEM_SLT_TABLE_0+i);
		if(i%16==0)
			ip1811drv_dbg("\n");
		ip1811drv_dbg("%04x ", regdata[i]);
	}

	if(slt_data->type == OP_IGMP_SLT_IPV4){
		ip1811drv_dbg("Read IPv4:\n");
		printk(KERN_ERR "\nRead IPv4:");
		for(i=0; i<6; i++) {
			printk(KERN_ERR "\n");
			for(j=0; j<4; j++) {
				slt_data->data.ipv4.ip[i][j] = getTable(regdata, ((32*i)+(8*j)), 8 );
				printk(KERN_ERR " %d", slt_data->data.ipv4.ip[i][j]);
			}
		}
		ip1811drv_dbg("Read Used Define:\n");
		printk(KERN_ERR "\nUsed Define:\n");
		for(i=0; i<6; i++) {
			slt_data->data.ipv4.used_port[i] = getTable(regdata, (192+(12*i)), 12);
			printk(KERN_ERR " %04lx", (unsigned long)slt_data->data.ipv4.used_port[i]);
		}
	}else{
		ip1811drv_dbg("Read IPv6:\n");
		printk(KERN_ERR "\nRead IPv6:");
		for(i=0; i<2; i++) {
			printk(KERN_ERR "\n");
			for(j=0; j<8; j++) {
				slt_data->data.ipv6.ip[i][j] = getTable(regdata, ((128*i)+(16*j)), 16);
				printk(KERN_ERR " %04x", slt_data->data.ipv6.ip[i][j]);
			}
		}
		ip1811drv_dbg("Read Used Define:\n");
		printk(KERN_ERR "\nUsed Define:\n");
		for(i=0; i<2;i++) {
			slt_data->data.ipv6.used_port[i] = getTable(regdata, (256+(12*i)), 12);
			printk(KERN_ERR " %04lx", (unsigned long)slt_data->data.ipv6.used_port[i]);
		}
	}
	printk(KERN_ERR "\n");
	return 0;
}
EXPORT_SYMBOL(switchdGetIGMPSltTable);

int getIGMPSltTable(void *cdata, int len){
	int ret, index;
	struct SltRuleSetting *igmp;
	struct slt_rule *slt;

	FUNC_MSG_IN;
	ip1811drv_dbg("In getIGMPSltTable.\n");
	if (sizeof(struct SltRuleSetting) != len) {
		ip1811drv_err("length error!\n");
		return -EINVAL;
	}

	igmp = (struct SltRuleSetting *)cdata;
	index = igmp ->index;
	slt = &(igmp ->slt_data);
	ret = switchdGetIGMPSltTable(index, slt);
	FUNC_MSG_OUT;

	return 0;
}

//------------------------------------------------
//ip1811_sniffer
int switchdSetS1PktModify(int modify)
{
	if (modify!=OP_SNIFFER1_PKT_MODIFY && modify!=OP_SNIFFER1_PKT_KEEP)
		return -EINVAL;
	ip1811drv_dbg("modify=%d\n", modify);

	_WriteRegBits(1, P1REG_SNIFCFG, 2, 1, modify);

	return 0;
}
EXPORT_SYMBOL(switchdSetS1PktModify);
int setS1PktModify(void *cdata, int len)
{
	int modify;

	ip1811drv_dbg("ip1811: +setS1PktModify...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	modify = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetS1PktModify(modify) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setS1PktModify...\n");
	return 0;
}

int switchdGetS1PktModify(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_SNIFCFG, 2, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetS1PktModify);
int getS1PktModify(void *cdata, int len)
{
	int modify;
	
	ip1811drv_dbg("ip1811: +getS1PktModify...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetS1PktModify(&modify) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = modify;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getS1PktModify...\n");
	return 0;
}

int switchdSetS1TM4CpuSTag(int modify)
{
	if (modify!=OP_SNIFFER1_TAG_KEEP && modify!=OP_SNIFFER1_TAG_MODIFY)
		return -EINVAL;
	ip1811drv_dbg("modify=%d\n", modify);

	_WriteRegBits(1, P1REG_SNIFCFG, 5, 1, modify);

	return 0;
}
EXPORT_SYMBOL(switchdSetS1TM4CpuSTag);
int setS1TM4CpuSTag(void *cdata, int len)
{
	int modify;

	ip1811drv_dbg("ip1811: +setS1TM4CpuSTag...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	modify = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetS1TM4CpuSTag(modify) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setS1TM4CpuSTag...\n");
	return 0;
}

int switchdGetS1TM4CpuSTag(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_SNIFCFG, 5, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetS1TM4CpuSTag);
int getS1TM4CpuSTag(void *cdata, int len)
{
	int modify;
	
	ip1811drv_dbg("ip1811: +getS1TM4CpuSTag...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetS1TM4CpuSTag(&modify) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = modify;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getS1TM4CpuSTag...\n");
	return 0;
}

int switchdSetS1TM4Acl2Cpu(int modify)
{
	if (modify!=OP_SNIFFER1_TAG_KEEP && modify!=OP_SNIFFER1_TAG_MODIFY)
		return -EINVAL;
	ip1811drv_dbg("modify=%d\n", modify);

	_WriteRegBits(1, P1REG_SNIFCFG, 6, 1, modify);

	return 0;
}
EXPORT_SYMBOL(switchdSetS1TM4Acl2Cpu);
int setS1TM4Acl2Cpu(void *cdata, int len)
{
	int modify;

	ip1811drv_dbg("ip1811: +setS1TM4Acl2Cpu...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	modify = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetS1TM4Acl2Cpu(modify) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setS1TM4Acl2Cpu...\n");
	return 0;
}

int switchdGetS1TM4Acl2Cpu(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_SNIFCFG, 6, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetS1TM4Acl2Cpu);
int getS1TM4Acl2Cpu(void *cdata, int len)
{
	int modify;
	
	ip1811drv_dbg("ip1811: +getS1TM4Acl2Cpu...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetS1TM4Acl2Cpu(&modify) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = modify;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getS1TM4Acl2Cpu...\n");
	return 0;
}

int switchdSetS1TM4Pkt2MPort(int modify)
{
	if (modify!=OP_SNIFFER1_TAG_KEEP && modify!=OP_SNIFFER1_TAG_MODIFY)
		return -EINVAL;
	ip1811drv_dbg("modify=%d\n", modify);

	_WriteRegBits(1, P1REG_SNIFCFG, 7, 1, modify);

	return 0;
}
EXPORT_SYMBOL(switchdSetS1TM4Pkt2MPort);
int setS1TM4Pkt2MPort(void *cdata, int len)
{
	int modify;

	ip1811drv_dbg("ip1811: +setS1TM4Pkt2MPort...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	modify = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetS1TM4Pkt2MPort(modify) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setS1TM4Pkt2MPort...\n");
	return 0;
}

int switchdGetS1TM4Pkt2MPort(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_SNIFCFG, 7, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetS1TM4Pkt2MPort);
int getS1TM4Pkt2MPort(void *cdata, int len)
{
	int modify;
	
	ip1811drv_dbg("ip1811: +getS1TM4Pkt2MPort...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetS1TM4Pkt2MPort(&modify) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = modify;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getS1TM4Pkt2MPort...\n");
	return 0;
}

int switchdSetS2LTT4Grp1(int ltt)
{
	if (ltt!=OP_SNIFFER2_LUT_TRIGGER_TARGET_DA && ltt!=OP_SNIFFER2_LUT_TRIGGER_TARGET_SA)
		return -EINVAL;
	ip1811drv_dbg("ltt=%d\n", ltt);

	_WriteRegBits(1, P1REG_SNIFCFG, 3, 1, ltt);

	return 0;
}
EXPORT_SYMBOL(switchdSetS2LTT4Grp1);
int setS2LTT4Grp1(void *cdata, int len)
{
	int ltt;

	ip1811drv_dbg("ip1811: +setS2LTT4Grp1...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	ltt = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetS2LTT4Grp1(ltt) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setS2LTT4Grp1...\n");
	return 0;
}

int switchdGetS2LTT4Grp1(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_SNIFCFG, 3, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetS2LTT4Grp1);
int getS2LTT4Grp1(void *cdata, int len)
{
	int ltt;
	
	ip1811drv_dbg("ip1811: +getS2LTT4Grp1...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetS2LTT4Grp1(&ltt) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = ltt;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getS2LTT4Grp1...\n");
	return 0;
}

//------------------------------------------------
//ip1811_storm
int switchdSetMStormNBlockIpPkt(int nb)
{
	if (nb!=OP_FUNC_DISABLE && nb!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("nb=%d\n", nb);

	_WriteRegBits(1, P1REG_BSTORMTHRESH, 11, 1, nb);

	return 0;
}
EXPORT_SYMBOL(switchdSetMStormNBlockIpPkt);
int setMStormNBlockIpPkt(void *cdata, int len)
{
	int nb;

	ip1811drv_dbg("ip1811: +setMStormNBlockIpPkt...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	nb = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetMStormNBlockIpPkt(nb) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setMStormNBlockIpPkt...\n");
	return 0;
}

int switchdGetMStormNBlockIpPkt(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_BSTORMTHRESH, 11, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetMStormNBlockIpPkt);
int getMStormNBlockIpPkt(void *cdata, int len)
{
	int nb;
	
	ip1811drv_dbg("ip1811: +getMStormNBlockIpPkt...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;
		
	if(switchdGetMStormNBlockIpPkt(&nb) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = nb;

	ip1811drv_dbg("ip1811: -getMStormNBlockIpPkt...\n");
	return 0;
}

int switchdSetMStormIgnr01005EXXXXXX(int ignr)
{
	if (ignr!=OP_FUNC_DISABLE && ignr!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("ignr=%d\n", ignr);

	_WriteRegBits(1, P1REG_BSTORMTHRESH, 12, 1, ignr);

	return 0;
}
EXPORT_SYMBOL(switchdSetMStormIgnr01005EXXXXXX);
int setMStormIgnr01005EXXXXXX(void *cdata, int len)
{
	int ignr;

	ip1811drv_dbg("ip1811: +setMStormIgnr01005EXXXXXX...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	ignr = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetMStormIgnr01005EXXXXXX(ignr) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setMStormIgnr01005EXXXXXX...\n");
	return 0;
}

int switchdGetMStormIgnr01005EXXXXXX(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_BSTORMTHRESH, 12, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetMStormIgnr01005EXXXXXX);
int getMStormIgnr01005EXXXXXX(void *cdata, int len)
{
	int en=0;
	
	ip1811drv_dbg("ip1811: +getMStormIgnr01005EXXXXXX...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;
		
	if(switchdGetMStormIgnr01005EXXXXXX(&en) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = en;

	ip1811drv_dbg("ip1811: -getMStormIgnr01005EXXXXXX...\n");
	return 0;
}

//ip1811_stp
int switchdSetBpduCapMode(int bcmode)
{
	if (bcmode!=OP_BPDU_CMODE_GLOBAL && bcmode!=OP_BPDU_CMODE_BY_PORT)
		return -EINVAL;
	ip1811drv_dbg("bcmode=%d\n", bcmode);

	_WriteRegBits(0, P0REG_MACBEHAVIOR, 10, 1, bcmode);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetBpduCapMode);
int setBpduCapMode(void *cdata, int len)
{
	int bcmode;

	ip1811drv_dbg("ip1811: +setBpduCapMode...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	bcmode = ((struct GeneralSetting *)cdata) ->gdata;
	
	if(switchdSetBpduCapMode(bcmode) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setBpduCapMode...\n");
	return 0;
}

int switchdGetBpduCapMode(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(0, P0REG_MACBEHAVIOR, 10, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetBpduCapMode);
int getBpduCapMode(void *cdata, int len)
{
	int bcmode;

	ip1811drv_dbg("ip1811: +getBpduCapMode...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetBpduCapMode(&bcmode) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = bcmode;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getBpduCapMode...\n");
	return 0;
}

int switchdSetBpduPortAct(int port, int state)
{
	u16 u16dat;
	
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if (state!=OP_CAP_ACT_FORWARD && state!=OP_CAP_ACT_TO_CPU && state!=OP_CAP_ACT_DROP)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("state=%d\n", state);

	IP2Page(0);
	u16dat = Read_Reg(P0REG_BPDUPORTCAPCFG);
	u16dat |= (u16)((state&0x1) << (port));
#ifdef COMBINED_PORT
	if (port==9)
		u16dat |= (u16)((state&0x1) << (port+1));
#endif
	Write_Reg(P0REG_BPDUPORTCAPCFG, u16dat);
	
	u16dat = Read_Reg(P0REG_BPDUPORTCAPCFG+2);
	u16dat |= (u16)(((state>>1)&0x1) << (port));
#ifdef COMBINED_PORT
	if (port==9)
		u16dat |= (u16)(((state>>1)&0x1) << (port+1));
#endif
	Write_Reg(P0REG_BPDUPORTCAPCFG+2, u16dat);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetBpduPortAct);
int setBpduPortAct(void *cdata, int len)
{
	int port, state;

	ip1811drv_dbg("ip1811: +setBpduPortAct...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;
	state= ((struct ByPortSetting *)cdata) ->pdata;

	if(switchdSetBpduPortAct(port, state) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setBpduPortAct...\n");
	return 0;
}

int switchdGetBpduPortAct(int port, int *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (int)(_ReadRegBits(0, P0REG_BPDUPORTCAPCFG+2, port, 1) | _ReadRegBits(0, P0REG_BPDUPORTCAPCFG, port, 1));

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetBpduPortAct);
int getBpduPortAct(void *cdata, int len)
{
	int port, state;

	ip1811drv_dbg("ip1811: +getBpduPortAct...\n");
	if (sizeof(struct ByPortSetting) != len)
		return -EINVAL;

	port = ((struct ByPortSetting *)cdata) ->port;

	if(switchdGetBpduPortAct(port, &state) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = state;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	ip1811drv_dbg("ip1811: -getBpduPortAct...\n");
	return 0;
}

int switchdSetStpPortState(int fid, int port, int state)
{
	u16 u16dat=0;
	
	if (fid < 1 || fid > 16)
		return -EINVAL;
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if (state < OP_STP_STATE_DISCARD || state > OP_STP_STATE_FORWARD)
		return -EINVAL;
	ip1811drv_dbg("fid=%d\n", fid);
	ip1811drv_dbg("port=%d\n", port);
	ip1811drv_dbg("state=%d\n", state);

	fid--;
	IP2Page(2);
	Write_Reg(P2REG_SPANTREE_PORTCMD, (u16)(0x8010 | fid));
	u16dat = Read_Reg(P2REG_SPANTREE_PORTDTA);
	switch(state){
		case OP_STP_STATE_DISCARD:
		case OP_STP_STATE_BLOCK:
			u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
			if (port==9)
				u16dat &= (u16)~(1 << port+1);
#endif
			break;
		case OP_STP_STATE_LEARN:
		case OP_STP_STATE_FORWARD:
			u16dat |= (u16)(1 << port);
#ifdef COMBINED_PORT
			if (port==9)
				u16dat |= (u16)(1 << port+1);
#endif
			break;
	}
	Write_Reg(P2REG_SPANTREE_PORTDTA, u16dat & 0xFFFF);
	Write_Reg(P2REG_SPANTREE_PORTCMD, (u16)(0xC010 | fid));
	
	Write_Reg(P2REG_SPANTREE_PORTCMD, (u16)(0x8000 | fid));
	u16dat = Read_Reg(P2REG_SPANTREE_PORTDTA);
	switch(state){
		case OP_STP_STATE_DISCARD:
		case OP_STP_STATE_LEARN:
			u16dat &= (u16)~(1 << port);
#ifdef COMBINED_PORT
			if (port==9)
				u16dat &= (u16)~(1 << port+1);
#endif
			break;
		case OP_STP_STATE_BLOCK:
		case OP_STP_STATE_FORWARD:
			u16dat |= (u16)(1 << port);
#ifdef COMBINED_PORT
			if (port==9)
				u16dat |= (u16)(1 << port+1);
#endif
			break;
	}
	Write_Reg(P2REG_SPANTREE_PORTDTA, u16dat & 0xFFFF);
	Write_Reg(P2REG_SPANTREE_PORTCMD, (u16)(0xC000 | fid));
	
	return 0;
}
EXPORT_SYMBOL(switchdSetStpPortState);
int setStpPortState(void *cdata, int len)
{
	int fid, port, state;

	ip1811drv_dbg("ip1811: +setStpPortState...\n");
	if (sizeof(struct StpByFPSetting) != len)
		return -EINVAL;

	fid = ((struct StpByFPSetting *)cdata) ->fid;
	port= ((struct StpByFPSetting *)cdata) ->port;
	state=((struct StpByFPSetting *)cdata) ->pstate;

	if(switchdSetStpPortState(fid, port, state) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setStpPortState...\n");
	return 0;
}

int switchdGetStpPortState(int fid, int port, int *ptrInt)
{
	int state;
	u16 u16dat=0;
	
	if (fid < 1 || fid > 16)
		return -EINVAL;
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	ip1811drv_dbg("fid=%d\n", fid);
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	fid--;
	IP2Page(2);
	Write_Reg(P2REG_SPANTREE_PORTCMD, (u16)(0x8010 | fid));
	u16dat = Read_Reg(P2REG_SPANTREE_PORTDTA);
	state = ((u16dat>>port)&0x1)<<1;
	Write_Reg(P2REG_SPANTREE_PORTCMD, (u16)(0x8000 | fid));
	u16dat = Read_Reg(P2REG_SPANTREE_PORTDTA);
	state |= ((u16dat>>port)&0x1);
	
	*ptrInt = state;

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetStpPortState);
int getStpPortState(void *cdata, int len)
{
	int fid, port, state;

	ip1811drv_dbg("ip1811: +getStpPortState...\n");
	if (sizeof(struct StpByFPSetting) != len)
		return -EINVAL;

	fid = ((struct StpByFPSetting *)cdata) ->fid;
	port= ((struct StpByFPSetting *)cdata) ->port;

	if(switchdGetStpPortState(fid, port, &state) != 0)
		return -EINVAL;

	((struct StpByFPSetting *)cdata) ->pstate = state;
	ip1811drv_dbg("cdata ->pstate=%d\n", ((struct StpByFPSetting *)cdata) ->pstate);
	ip1811drv_dbg("ip1811: -getStpPortState...\n");
	return 0;
}

//ip1811_lacp
int switchdSetTrunkHashMthdSeq(int en)
{
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(1, P1REG_TRUNKCFG, 3, 1, en);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetTrunkHashMthdSeq);
int setTrunkHashMthdSeq(void *cdata, int len)
{
	int en;

	ip1811drv_dbg("ip1811: +setTrunkHashMthdSeq...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	en = ((struct GeneralSetting *)cdata) ->gdata;

	if(switchdSetTrunkHashMthdSeq(en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setTrunkHashMthdSeq...\n");
	return 0;
}

int switchdGetTrunkHashMthdSeq(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(1, P1REG_TRUNKCFG, 3, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetTrunkHashMthdSeq);
int getTrunkHashMthdSeq(void *cdata, int len)
{
	int en;

	ip1811drv_dbg("ip1811: +getTrunkHashMthdSeq...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	if(switchdGetTrunkHashMthdSeq(&en) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata) ->gdata = en;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getTrunkHashMthdSeq...\n");
	return 0;
}

int switchdSetTrunkGrpCombine(int grps, int en)
{
	if (grps < OP_TRUNK_COMBINE_G1_G2 || grps > OP_TRUNK_COMBINE_G3_G4)
		return -EINVAL;
	if (en!=OP_FUNC_DISABLE && en!=OP_FUNC_ENABLE)
		return -EINVAL;
	ip1811drv_dbg("grps=%d\n", grps);
	ip1811drv_dbg("en=%d\n", en);

	_WriteRegBits(1, P1REG_TRUNKCFG, grps, 1, en);
	
	return 0;
}
EXPORT_SYMBOL(switchdSetTrunkGrpCombine);
int setTrunkGrpCombine(void *cdata, int len)
{
	int grps, en;

	ip1811drv_dbg("ip1811: +setTrunkGrpCombine...\n");
	if (sizeof(struct TrunkCombineSetting) != len)
		return -EINVAL;

	grps=((struct TrunkCombineSetting *)cdata) ->tgrps;
	en = ((struct TrunkCombineSetting *)cdata) ->cen;

	if(switchdSetTrunkGrpCombine(grps, en) != 0)
		return -EINVAL;

	ip1811drv_dbg("ip1811: -setTrunkGrpCombine...\n");
	return 0;
}

int switchdGetTrunkGrpCombine(int grps, int *ptrInt)
{
	if (grps < OP_TRUNK_COMBINE_G1_G2 || grps > OP_TRUNK_COMBINE_G3_G4)
		return -EINVAL;
	ip1811drv_dbg("grps=%d\n", grps);
	
	*ptrInt = (int)_ReadRegBits(1, P1REG_TRUNKCFG, grps, 1);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetTrunkGrpCombine);
int getTrunkGrpCombine(void *cdata, int len)
{
	int grps, en;

	ip1811drv_dbg("ip1811: +getTrunkGrpCombine...\n");
	if (sizeof(struct TrunkCombineSetting) != len)
		return -EINVAL;

	grps=((struct TrunkCombineSetting *)cdata) ->tgrps;

	if(switchdGetTrunkGrpCombine(grps, &en) != 0)
		return -EINVAL;

	((struct TrunkCombineSetting *)cdata) ->cen = en;
	ip1811drv_dbg("cdata ->cen=%d\n", ((struct TrunkCombineSetting *)cdata) ->cen);
	ip1811drv_dbg("ip1811: -getTrunkGrpCombine...\n");
	return 0;
}

//------------ MIB Counter functions:ip1811 ---------------------
int switchdSetMibCounterEnable(int en)
{
	if( en!=OP_FUNC_ENABLE && en!=OP_FUNC_DISABLE ){
		ip1811drv_err("Error: en=%X\n", en);
		return -EINVAL;
	}
	_WriteRegBits(0, P0REG_MACBEHAVIOR, 9, 1, en);
	return 0;
}
EXPORT_SYMBOL(switchdSetMibCounterEnable);

int setMibCounterEnable(void *cdata, int len)
{
	int ret, en;
	FUNC_MSG_IN;

	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	en = ((struct GeneralSetting *)cdata) ->gdata;

	ip1811drv_dbg("cdata ->gdata=%d\n", en);
	ret = switchdSetMibCounterEnable(en);
	
	FUNC_MSG_OUT;
	return ret;
}

int switchdGetMibCounterEnable(int *gdata_p)
{
	*gdata_p = _ReadRegBits(0, P0REG_MACBEHAVIOR, 9, 1);
	return 0;
}
EXPORT_SYMBOL(switchdGetMibCounterEnable);

int getMibCounterEnable(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;
	
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	ret = switchdGetMibCounterEnable(&(gs ->gdata));
	FUNC_MSG_OUT;
	return ret;
}

int switchdGetMibCounterAll(void *uptr)
{
	int i, j, ret=0;
	struct MIBCounterEntry_all *dptr;

	dptr = kmalloc(sizeof(struct MIBCounterEntry_all), GFP_KERNEL);
	if (!dptr) {
		ret =  -ENOMEM;
		goto out_mib_counter_all;
	}
	
	IP2Page(0);
	for(j=0; j<MAX_PHY_NUM; j++) {
		for(i=0; i<NUM_MIB_COUNTER_RX; i++) {
			//statistic counter read , read clear rx counter
			Write_Reg(POREG_MIBCOUN_CMD, 0xC000|(u16)i|((u16)j<<5));
			/* need to check does trigger bit has been put down */
			while((Read_Reg(POREG_MIBCOUN_CMD) >> 15)&0x1);
			
			dptr ->entry[j].RX_counter[i] =  (u32)Read_Reg(POREG_MIBCOUN_DATA_L);
			dptr ->entry[j].RX_counter[i] |= ((u32)Read_Reg(POREG_MIBCOUN_DATA_H)<<16);
		}
		for(i=0; i<NUM_MIB_COUNTER_TX; i++) {
			//statistic counter read , read clear tx counter
			Write_Reg(POREG_MIBCOUN_CMD,0xC400|(u16)i|((u16)j<<5));
			/* need to check does trigger bit has been put down */
			while((Read_Reg(POREG_MIBCOUN_CMD) >> 15)&0x1);
			
			dptr ->entry[j].TX_counter[i] =  (u32)Read_Reg(POREG_MIBCOUN_DATA_L);
			dptr ->entry[j].TX_counter[i] |= ((u32)Read_Reg(POREG_MIBCOUN_DATA_H)<<16);
		}
	}
	if (copy_to_user(uptr, dptr, sizeof(struct MIBCounterEntry_all))) {
		ret = -EFAULT;
		goto out_mib_counter_all;
	}
out_mib_counter_all:
	if(dptr){ 
		kfree(dptr);
	}
	return (ret < 0) ? ret : 0;
}
EXPORT_SYMBOL(switchdGetMibCounterAll);

int getMibCounterAll(void *cdata, int len)
{
	int ret;
	void *uptr;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	uptr = (void *)(((struct GeneralSetting *)cdata) ->gdata);
	ret = switchdGetMibCounterAll(uptr);

	FUNC_MSG_OUT;
	return ret;
}

int switchdGetMibCounterByPort(void *uptr, int port)
{
	int i, ret;
	struct MIBCounterEntry *dptr;
	
	dptr = kmalloc(sizeof(struct MIBCounterEntry), GFP_KERNEL);
	if (!dptr) {
		ret = -ENOMEM;
		goto out_mib_counter;
	}
	IP2Page(0);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	for(i=0; i<NUM_MIB_COUNTER_RX; i++) {
		//statistic counter read , read clear rx counter
		Write_Reg(POREG_MIBCOUN_CMD, 0xC000|(u16)i|((u16)port<<5));
		/* need to check does trigger bit has been put down */
		while((Read_Reg(POREG_MIBCOUN_CMD) >> 15)&0x1);
		dptr ->RX_counter[i] = (u32)(((u32)Read_Reg(POREG_MIBCOUN_DATA_H)<<16)|Read_Reg(POREG_MIBCOUN_DATA_L));
	}
	for(i=0; i<NUM_MIB_COUNTER_TX; i++) {
		//statistic counter read , read clear tx counter
		Write_Reg(POREG_MIBCOUN_CMD, 0xC400|(u16)i|((u16)port<<5));
		/* need to check does trigger bit has been put down */
		while((Read_Reg(POREG_MIBCOUN_CMD) >> 15)&0x1);
		dptr ->TX_counter[i] = (u32)(((u32)Read_Reg(POREG_MIBCOUN_DATA_H)<<16)|Read_Reg(POREG_MIBCOUN_DATA_L));
	}
	if (copy_to_user(uptr, dptr, sizeof(struct MIBCounterEntry))) {
		ret = -EFAULT;
		goto out_mib_counter;
	}
out_mib_counter:
	if(dptr) { 
		kfree(dptr);
	}

	return (ret < 0) ? ret : 0;
}
EXPORT_SYMBOL(switchdGetMibCounterByPort);

int getMibCounterByPort(void *cdata, int len)
{
	int port, ret;
	void *uptr;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	uptr = (void *)(((struct ByPortSetting *)cdata) ->pdata);
	port = ((struct ByPortSetting *)cdata) ->port;
	
	ret = switchdGetMibCounterByPort(uptr, port);
	
	FUNC_MSG_OUT;
	return ret;
}

int switchdGetMibCounterByItem(int port, int is_tx, int idx, unsigned long *cnt)
{
	IP2Page(0);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	//statistic counter read , read clear rx counter
	Write_Reg(POREG_MIBCOUN_CMD, (is_tx?0xC400:0xC000)|(u16)idx|((u16)port<<5));
	/* need to check does trigger bit has been put down */
	while((Read_Reg(POREG_MIBCOUN_CMD) >> 15)&0x1);

	*cnt = (u32)(((u32)Read_Reg(POREG_MIBCOUN_DATA_H)<<16)|Read_Reg(POREG_MIBCOUN_DATA_L));

	return 0;
}
EXPORT_SYMBOL(switchdGetMibCounterByItem);

int getMibCounterByItem(void *cdata, int len)
{
	int port, dir, idx, ret;
	unsigned long mibcnt;
	struct MIBCounterData *mcd = (struct MIBCounterData *)cdata;

	FUNC_MSG_IN;

	if (sizeof(struct MIBCounterData) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	port = mcd ->port;
	dir = mcd ->dir;
	idx = mcd ->idx;

	ret = switchdGetMibCounterByItem(port, dir, idx, &mibcnt);
	mcd ->counter = mibcnt; 

	FUNC_MSG_OUT;
	return ret;

}

//------------ MIB Counter functions:ip1811 end------------------
//------------ QOS functions:ip1811 -----------------------------
int setQOSAgingFunction(void *cdata, int len)
{
	int port,aging;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	port=((struct ByPortSetting *)cdata) ->port;
	aging =((struct ByPortSetting *)cdata) ->pdata;
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;

	if (aging < 0 || aging > 0xff)
		return -EINVAL;

	_WriteRegBits(8, P8REG_QOSPORTAGINGEN0+(port/2), (port%2)*8, 8, aging);
#ifdef COMBINED_PORT
	if (port==9){
		_WriteRegBits(8, P8REG_QOSPORTAGINGEN0+((port+1)/2), ((port+1)%2)*8, 8, aging);
	}
#endif

	FUNC_MSG_OUT;
	return 0;
}
int getQOSAgingFunction(void *cdata, int len)
{
	int port;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	port=((struct ByPortSetting *)cdata) ->port;
	if (port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	((struct ByPortSetting *)cdata) ->pdata=(u32)_ReadRegBits(8,P8REG_QOSPORTAGINGEN0+(port/2),(port%2)*8,8);

	FUNC_MSG_OUT;
	ip1811drv_dbg("cdata ->pdata=%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	return 0;
}
int setQOSAgingTime(void *cdata, int len)
{
	int aging;
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	aging = ((struct GeneralSetting *)cdata) ->gdata;
	if (aging < 0 || aging > 0xff)
		return -EINVAL;

	_WriteRegBits(8, P8REG_QOSAGINGTIME, 0, 8, aging);
	FUNC_MSG_OUT;
	return 0;
}
int getQOSAgingTime(void *cdata, int len)
{
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	((struct GeneralSetting *)cdata) ->gdata = (u16)_ReadRegBits(8, P8REG_QOSAGINGTIME, 0, 8);

	FUNC_MSG_OUT;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	return 0;
}
int setQOSFastAging(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 8, P8REG_QOSAGINGTIME, 8);
	FUNC_MSG_OUT;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	return ret;
}
int getQOSFastAging(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 8, P8REG_QOSAGINGTIME, 8);
	FUNC_MSG_OUT;
	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	return ret;
}
int setCOSIGMP(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COSIGMPBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSIGMP(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COSIGMPBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOSMACAddress(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COSMACBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSMACAddress(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COSMACBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOSVID(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COSVIDBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSVID(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COSVIDBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOSTCPUDPPort(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COSTCPUDPBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSTCPUDPPort(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COSTCPUDPBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOSDSCP(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COSDSCPBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSDSCP(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COSDSCPBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOS8021P(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COS8021PBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOS8021P(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COS8021PBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOSPhsicalPort(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 0, P0REG_COSPORTBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSPhsicalPort(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 0, P0REG_COSPORTBASEPRIEN);
	FUNC_MSG_OUT;
	return ret;
}
int setCOSPortQueue(void *cdata, int len)
{
	int port;
	u8 queue;

	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	port = ((struct ByPortSetting *)cdata) ->port;
	queue = ((struct ByPortSetting *)cdata) ->pdata;

	if ((port < 0) || (port >= MAX_PHY_NUM))
	{
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}
	if(queue>7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}
	
	_WriteRegBits(0, P0REG_COSPORTBASEQUEUE0+(port/5), (port%5)*3, 3, queue);
#ifdef COMBINED_PORT
	if (port==9)
		_WriteRegBits(0, P0REG_COSPORTBASEQUEUE0+((port+1)/5), ((port+1)%5)*3, 3, queue);
#endif
	FUNC_MSG_OUT;
	return 0;
}
int getCOSPortQueue(void *cdata, int len)
{
	int port;
	
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting *)cdata) ->port;
	if ((port < 0) || (port >= MAX_PHY_NUM))
	{
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}
	
#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	((struct ByPortSetting *)cdata) ->pdata = (u16)_ReadRegBits(0, P0REG_COSPORTBASEQUEUE0+(port/5), (port%5)*3, 3);
	ip1811drv_dbg("cdata ->pdata=0x%04X\n", ((struct ByPortSetting *)cdata) ->pdata);

	FUNC_MSG_OUT;
	return 0;
}
int setCOS8021PEdtion(void *cdata, int len)
{
	int gdata;
	u16 regdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	gdata = ((struct GeneralSetting *)cdata) ->gdata;
	if( gdata != OP_QOS_8021PEDTION_2005 && gdata != OP_QOS_8021PEDTION_2005_EX && gdata != OP_QOS_8021PEDTION_EARLY )
	{
		ip1811drv_err("Error: gdata=%X\n", gdata);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->gdata=%d\n", gdata);
	IP2Page(0);
	regdata = Read_Reg(P0REG_COS8021PBASEPRIEN);
	regdata &= (u16)~0x6000;
	switch(gdata)
	{
		case OP_QOS_8021PEDTION_2005:
			break;
		case OP_QOS_8021PEDTION_2005_EX:
			regdata |= 0x4000;  break;
		case OP_QOS_8021PEDTION_EARLY:
			regdata |= 0x2000;  break;
	}
	Write_Reg(P0REG_COS8021PBASEPRIEN,regdata);

	FUNC_MSG_OUT;
	return 0;
}
int getCOS8021PEdtion(void *cdata, int len)
{
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	u16dat =_ReadRegBits(0, P0REG_COS8021PBASEPRIEN, 13, 2);

	if(u16dat&0x1)
	{ ((struct GeneralSetting *)cdata) ->gdata = OP_QOS_8021PEDTION_EARLY; }
	else
	{
		if(u16dat&0x2)
		{ ((struct GeneralSetting *)cdata) ->gdata = OP_QOS_8021PEDTION_2005_EX; }
		else
		{ ((struct GeneralSetting *)cdata) ->gdata = OP_QOS_8021PEDTION_2005; }
	}
	ip1811drv_dbg("cdata ->gdata=0x%08x\n", ((struct GeneralSetting *)cdata) ->gdata);

	FUNC_MSG_OUT;
	return 0;
}
int setCOSDSCPBaseDSCP(void *cdata, int len)
{
	u8 entryno,value,queue;
	FUNC_MSG_IN;
	if (sizeof(struct qos_dscp_setting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}

	entryno = ((struct qos_dscp_setting *)cdata) ->dscpentry;
	value = ((struct qos_dscp_setting *)cdata) ->dscpvalue;
	queue = ((struct qos_dscp_setting *)cdata) ->dscpqueue;

	if(entryno<1 || entryno>8)
	{
		ip1811drv_err("Error: entryno=%d\n", entryno);
		return -EINVAL;
	}
	if(value & ~0x3f)
	{
		ip1811drv_err("Error: value=%X\n", value);
		return -EINVAL;
	}
	if(queue>7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}

	entryno-=1;

	_WriteRegBits(0, P0REG_COSDSCPVALUE0+(entryno/2), (entryno%2)*6, 6, value);
	_WriteRegBits(0, P0REG_COSDSCPPRISETTING0+(entryno/5), (entryno%5)*3, 3, queue);
	FUNC_MSG_OUT;
	return 0;
}
int getCOSDSCPBaseDSCP(void *cdata, int len)
{
	u8 entryno;
	FUNC_MSG_IN;
	if (sizeof(struct qos_dscp_setting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	entryno = ((struct qos_dscp_setting *)cdata) ->dscpentry;
	if(entryno>7)
	{
		ip1811drv_err("Error: entryno=%d\n", entryno);
		return -EINVAL;
	}
	((struct qos_dscp_setting *)cdata) ->dscpvalue = (u16)_ReadRegBits(0, P0REG_COSDSCPVALUE0+(entryno/2), (entryno%2)*5, 6);
	((struct qos_dscp_setting *)cdata) ->dscpqueue = (u16)_ReadRegBits(0, P0REG_COSDSCPPRISETTING0+(entryno/5), (entryno%5)*3, 3);
	ip1811drv_dbg("cdata ->dscpvalue=0x%04X\n", ((struct qos_dscp_setting *)cdata) ->dscpvalue);
	ip1811drv_dbg("cdata ->dscpqueue=0x%04X\n", ((struct qos_dscp_setting *)cdata) ->dscpqueue);
	FUNC_MSG_OUT;

	return 0;
}
int setCOSDSCPBaseNoMatchAction(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0, P0REG_COSDSCPPRISETTING1, 9);
	FUNC_MSG_OUT;
	return ret;
}
int getCOSDSCPBaseNoMatchAction(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0, P0REG_COSDSCPPRISETTING1, 9);
	FUNC_MSG_OUT;
	return ret;
}
int setQOSmodeGroupMember(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 8, P8REG_QOSGROUPSEL);
	FUNC_MSG_OUT;
	return ret;
}
int getQOSmodeGroupMember(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 8, P8REG_QOSGROUPSEL);
	FUNC_MSG_OUT;
	return ret;
}
int setQOSGroupBEn(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 8, P8REG_QOSMODESELGROUP2, 9);
	FUNC_MSG_OUT;
	return ret;
}
int getQOSGroupBEn(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 8, P8REG_QOSMODESELGROUP2, 9);
	FUNC_MSG_OUT;
	return ret;
}
int setQOSMode(void *cdata, int len)
{
	int gpnum,mode;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	mode = ((struct qos_modesettings *)cdata) ->modesettings;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	if(mode<OP_QOS_MODE_FIFO || mode>OP_QOS_MODE_SP8)
	{
		ip1811drv_err("Error: mode=%d\n", mode);
		return -EINVAL;
	}
	_WriteRegBits(8, (gpnum==OP_QOS_GROUP1)?P8REG_QOSMODESELGROUP1:P8REG_QOSMODESELGROUP2, 0, 3, mode);

	FUNC_MSG_OUT;
	return 0;
}
int getQOSMode(void *cdata, int len)
{
	int gpnum;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}

	((struct qos_modesettings *)cdata) ->modesettings= (int)_ReadRegBits(8,(gpnum==OP_QOS_GROUP1)?P8REG_QOSMODESELGROUP1:P8REG_QOSMODESELGROUP2, 0, 3);

	ip1811drv_dbg("cdata ->groupnum=0x%04X\n", ((struct qos_modesettings *)cdata) ->groupnum);
	ip1811drv_dbg("cdata ->modesettings=0x%04X\n", ((struct qos_modesettings *)cdata) ->modesettings);
	FUNC_MSG_OUT;

	return 0;
}
int setQOSMethod(void *cdata, int len)
{
	int gpnum,mode;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	mode = ((struct qos_modesettings *)cdata) ->modesettings;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	if(mode<OP_QOS_METHOD_WRR || mode>OP_QOS_METHOD_TWRR)
	{
		ip1811drv_err("Error: mode=%d\n", mode);
		return -EINVAL;
	}
	IP2Page(8);

	u16dat = Read_Reg((gpnum==OP_QOS_GROUP1)?P8REG_QOSMODESELGROUP1:P8REG_QOSMODESELGROUP2);
	u16dat &= 0xFF9F;
	switch(mode)
	{
		case OP_QOS_METHOD_WRR:
			break;
		case OP_QOS_METHOD_BW:
			u16dat |= ((u16)0x1<<5);
			break;
		case OP_QOS_METHOD_WFQ:
			u16dat |= ((u16)0x2<<5);
			break;
		case OP_QOS_METHOD_TWRR:
			u16dat |= ((u16)0x3<<5);
			break;
	}
	Write_Reg((gpnum==OP_QOS_GROUP1)?P8REG_QOSMODESELGROUP1:P8REG_QOSMODESELGROUP2,u16dat);


	if(mode==OP_QOS_METHOD_BW)
		Write_Reg(P8REG_QOSMODESELGROUP1,Read_Reg(P8REG_QOSMODESELGROUP1)|0x8000);//stop & hold pkt
	else
		Write_Reg(P8REG_QOSMODESELGROUP1,Read_Reg(P8REG_QOSMODESELGROUP1)&0x7FFF);

	ip1811drv_dbg("cdata ->groupnum=0x%04X\n", ((struct qos_modesettings *)cdata) ->groupnum);
	ip1811drv_dbg("cdata ->modesettings=0x%04X\n", ((struct qos_modesettings *)cdata) ->modesettings);
	FUNC_MSG_OUT;
	return 0;
}
int getQOSMethod(void *cdata, int len)
{
	int gpnum;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}

	u16dat = _ReadRegBits(8, (gpnum==OP_QOS_GROUP1)?P8REG_QOSMODESELGROUP1:P8REG_QOSMODESELGROUP2, 5, 3);

	((struct qos_modesettings *)cdata) ->modesettings = u16dat;

	ip1811drv_dbg("cdata ->groupnum=0x%04X\n", ((struct qos_modesettings *)cdata) ->groupnum);
	ip1811drv_dbg("cdata ->modesettings=0x%04X\n", ((struct qos_modesettings *)cdata) ->modesettings);
	FUNC_MSG_OUT;
	return 0;
}
int setQOSWeight(void *cdata, int len)
{
	int gpnum,mode,queue;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	queue = ((struct qos_modesettings *)cdata) ->queuenum;
	mode = ((struct qos_modesettings *)cdata) ->modesettings;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	if(queue<OP_QOS_NUM_Q0 || queue>OP_QOS_NUM_Q7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}
	if(mode & ~(int)0xff)
	{
		ip1811drv_err("Error: mode=%d\n", mode);
		return -EINVAL;
	}

	_WriteRegBits(8, (gpnum==OP_QOS_GROUP1)?(P8REG_QOSGP1_WEIGHT0+(queue/2)):(P8REG_QOSGP2_WEIGHT0+(queue/2)), (queue%2)*8, 8, mode);

	FUNC_MSG_OUT;
	return 0;
}
int getQOSWeight(void *cdata, int len)
{
	int gpnum,queue;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	queue = ((struct qos_modesettings *)cdata) ->queuenum;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	u16dat = _ReadRegBits(8,(gpnum==OP_QOS_GROUP1)?(P8REG_QOSGP1_WEIGHT0+(queue/2)):(P8REG_QOSGP2_WEIGHT0+(queue/2)), ((queue%2)*8), 8);

	((struct qos_modesettings *)cdata) ->modesettings=(int)u16dat;

	ip1811drv_dbg("cdata ->groupnum=0x%04X\n", ((struct qos_modesettings *)cdata) ->groupnum);
	ip1811drv_dbg("cdata ->queuenum=0x%04X\n", ((struct qos_modesettings *)cdata) ->queuenum);
	ip1811drv_dbg("cdata ->modesettings=0x%04X\n", ((struct qos_modesettings *)cdata) ->modesettings);
	FUNC_MSG_OUT;

	return 0;
}
int setQOSMaxBandwidth(void *cdata, int len)
{
	int gpnum,mode,queue;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	queue = ((struct qos_modesettings *)cdata) ->queuenum;
	mode = ((struct qos_modesettings *)cdata) ->modesettings;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	if(queue<OP_QOS_NUM_Q0 || queue>OP_QOS_NUM_Q7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}
	if(mode & ~(int)0xff)
	{
		ip1811drv_err("Error: mode=%d\n", mode);
		return -EINVAL;
	}

	_WriteRegBits(8, (gpnum==OP_QOS_GROUP1)?(P8REG_QOSGP1_MAXBDWT0+(queue/2)):(P8REG_QOSGP2_MAXBDWT0+(queue/2)), (queue%2)*8, 8, mode);

	FUNC_MSG_OUT;
	return 0;
}

int getQOSMaxBandwidth(void *cdata, int len)
{
	int gpnum,queue;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	queue = ((struct qos_modesettings *)cdata) ->queuenum;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	if(queue<OP_QOS_NUM_Q0 || queue>OP_QOS_NUM_Q7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}

	u16dat = _ReadRegBits(8, (gpnum==OP_QOS_GROUP1)?(P8REG_QOSGP1_MAXBDWT0+(queue/2)):(P8REG_QOSGP2_MAXBDWT0+(queue/2)), ((queue%2)*8), 8);

	((struct qos_modesettings *)cdata) ->modesettings=(int)u16dat;

	ip1811drv_dbg("cdata ->groupnum=0x%04X\n", ((struct qos_modesettings *)cdata) ->groupnum);
	ip1811drv_dbg("cdata ->queuenum=0x%04X\n", ((struct qos_modesettings *)cdata) ->queuenum);
	ip1811drv_dbg("cdata ->modesettings=0x%04X\n", ((struct qos_modesettings *)cdata) ->modesettings);
	FUNC_MSG_OUT;

	return 0;
}
int setQOSUnit(void *cdata, int len)
{
	int gpnum,mode;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	mode = ((struct qos_modesettings *)cdata) ->modesettings;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}
	if(mode<OP_QOS_UNIT_64KBS || mode>OP_QOS_UNIT_4MBS)
	{
		ip1811drv_err("Error: mode=%d\n", mode);
		return -EINVAL;
	}
	_WriteRegBits(8, (gpnum==OP_QOS_GROUP1)?(P8REG_QOSMODESELGROUP1):(P8REG_QOSMODESELGROUP2), 3, 2, mode);

	FUNC_MSG_OUT;
	return 0;
}
int getQOSUnit(void *cdata, int len)
{
	int gpnum;
	FUNC_MSG_IN;
	if (sizeof(struct qos_modesettings) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	gpnum = ((struct qos_modesettings *)cdata) ->groupnum;
	if(gpnum!=OP_QOS_GROUP1 && gpnum!=OP_QOS_GROUP2)
	{
		ip1811drv_err("Error: gpnum=%d\n", gpnum);
		return -EINVAL;
	}

	((struct qos_modesettings *)cdata) ->modesettings= (int)_ReadRegBits(8,(gpnum==OP_QOS_GROUP1)?P8REG_QOSMODESELGROUP1:P8REG_QOSMODESELGROUP2, 3, 2);

	ip1811drv_dbg("cdata ->groupnum=0x%04X\n", ((struct qos_modesettings *)cdata) ->groupnum);
	ip1811drv_dbg("cdata ->modesettings=0x%04X\n", ((struct qos_modesettings *)cdata) ->modesettings);
	FUNC_MSG_OUT;
	return 0;
}
int setQOSRatioValue0Def(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 8, P8REG_QOSMODESELGROUP1, 15);
	FUNC_MSG_OUT;
	return ret;
}
int getQOSRatioValue0Def(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 8, P8REG_QOSMODESELGROUP1, 15);
	FUNC_MSG_OUT;
	return ret;
}
int setQOSSBMDBM(void *cdata, int len)
{
	int port,mode;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting *)cdata) ->port;
	mode = ((struct ByPortSetting *)cdata) ->pdata;
	if(port < 0 || port >= MAX_PHY_NUM)
		return -EINVAL;
	if(mode!=OP_QOS_QBASE_DBM && mode!=OP_QOS_QBASE_SBM)
	{
		ip1811drv_err("Error: mode=%d\n", mode);
		return -EINVAL;
	}
	ip1811drv_dbg(" port=%d\n", port);
	ip1811drv_dbg(" mode=%d\n", mode);

	IP2Page(8);

	// set all queue(per port) to same mode
	u16dat=Read_Reg(P8REG_QOS_SBMDBMSEL0+(port/2));
	u16dat&=((port%2)?0x00FF:0xFF00);
	if(mode==OP_QOS_QBASE_SBM)
	{ u16dat|=((port%2)?0xFF00:0x00FF); }
	Write_Reg(P8REG_QOS_SBMDBMSEL0+(port/2),u16dat);
#ifdef COMBINED_PORT
	if (port==9){
		u16dat=Read_Reg(P8REG_QOS_SBMDBMSEL0+((port+1)/2));
		u16dat&=(((port+1)%2)?0x00FF:0xFF00);
		if(mode==OP_QOS_QBASE_SBM)
		{ u16dat|=(((port+1)%2)?0xFF00:0x00FF); }
		Write_Reg(P8REG_QOS_SBMDBMSEL0+((port+1)/2),u16dat);
	}
#endif

	FUNC_MSG_OUT;
	return 0;
}
int getQOSSBMDBM(void *cdata, int len)
{
	int port;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting *)cdata) ->port;
	if(port<0 || port>=MAX_PHY_NUM)
		return -EINVAL;
	
	IP2Page(8);
#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	u16dat=Read_Reg(P8REG_QOS_SBMDBMSEL0+(port/2));
	u16dat>>=((port%2)*8);
	if(u16dat&0xff)
	{ ((struct ByPortSetting *)cdata) ->pdata=OP_QOS_QBASE_SBM;  }
	else
	{ ((struct ByPortSetting *)cdata) ->pdata=OP_QOS_QBASE_DBM;  }

	ip1811drv_dbg("cdata ->port=0x%d\n", ((struct ByPortSetting *)cdata) ->port);
	ip1811drv_dbg("cdata ->pdata=0x%d\n", ((struct ByPortSetting *)cdata) ->pdata);
	FUNC_MSG_OUT;

	return 0;
}
int setQOSDBMEn(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _setPortmap(cdata, len, 8, P8REG_QOSQUEUEDBMEN);
	FUNC_MSG_IN;
	return ret;
}
int getQOSDBMEn(void *cdata, int len)
{
	int ret;
	FUNC_MSG_IN;
	ret = _getPortmap(cdata, len, 8, P8REG_QOSQUEUEDBMEN);
	FUNC_MSG_IN;
	return ret;
}
int setQOSRemap(void *cdata, int len)
{
	int port;
	u8 queue,remap;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct qos_remap) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	port = ((struct qos_remap *)cdata) ->port;
	queue = ((struct qos_remap *)cdata) ->queue;
	remap = ((struct qos_remap *)cdata) ->remap;

	if(port<0 || port>=MAX_PHY_NUM)
		return -EINVAL;
	if(queue>OP_QOS_REMAP_TX_Q7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}
	if(remap>7)
	{
		ip1811drv_err("Error: remap=%d\n", remap);
		return -EINVAL;
	}
	ip1811drv_dbg("cdata ->port=0x%d\n", ((struct qos_remap *)cdata) ->port);
	ip1811drv_dbg("cdata ->queue=0x%d\n", ((struct qos_remap *)cdata) ->queue);
	ip1811drv_dbg("cdata ->remap=0x%d\n", ((struct qos_remap *)cdata) ->remap);
	
	if(queue<=OP_QOS_REMAP_RX_Q7)//RX
	{
		if ((queue/5) == 0)
		{
			IP2Page(6);
			u16dat = Read_Reg(P6REG_QOS_REMAP_RX0+(port*2)+1);
		}
		_WriteRegBits(6, P6REG_QOS_REMAP_RX0+(port*2)+(queue/5), (queue%5)*3, 3, remap);
		if ((queue/5) == 0)
		{
			IP2Page(6);
			Write_Reg(P6REG_QOS_REMAP_RX0+(port*2)+1, u16dat);
		}
#ifdef COMBINED_PORT
		if (port==9)
		{
			if ((queue/5) == 0)
			{
				IP2Page(6);
				u16dat = Read_Reg(P6REG_QOS_REMAP_RX0+((port+1)*2)+1);
			}
			_WriteRegBits(6, P6REG_QOS_REMAP_RX0+((port+1)*2)+(queue/5), (queue%5)*3, 3, remap);
			if ((queue/5) == 0)
			{
				IP2Page(6);
				Write_Reg(P6REG_QOS_REMAP_RX0+((port+1)*2)+1, u16dat);
			}
		}
#endif
	}
	else//TX
	{
		queue-=8;
		if (port == 0)
		{
			_WriteRegBits(8, P8REG_QOS_REMAP_TX0+(port*2)+(queue/5), (queue%5)*3, 3, remap);
		}
		else if (port == 1)
		{
			if (queue / 5)
				_WriteRegBits(8, P8REG_QOS_REMAP_TX0+(port*2)+(queue/5)+1, (queue%5)*3, 3, remap);
			else
				_WriteRegBits(8, P8REG_QOS_REMAP_TX0+(port*2)+(queue/5), (queue%5)*3, 3, remap);
		}
		else
		{
			_WriteRegBits(8, P8REG_QOS_REMAP_TX0+(port*2)+(queue/5)+1, (queue%5)*3, 3, remap);
#ifdef COMBINED_PORT
			if (port==9)
				_WriteRegBits(8, P8REG_QOS_REMAP_TX0+((port+1)*2)+(queue/5)+1, (queue%5)*3, 3, remap);
#endif
		}
	}
	FUNC_MSG_OUT;
	return 0;
}
int getQOSRemap(void *cdata, int len)
{
	int port;
	u8 queue;
	u16 u16dat;
	FUNC_MSG_IN;
	if (sizeof(struct qos_remap) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	port = ((struct qos_remap *)cdata) ->port;
	queue = ((struct qos_remap *)cdata) ->queue;
	if(port<0 || port>=MAX_PHY_NUM)
		return -EINVAL;
	if(queue>OP_QOS_REMAP_TX_Q7)
	{
		ip1811drv_err("Error: queue=%d\n", queue);
		return -EINVAL;
	}
	ip1811drv_dbg("cdata ->port=0x%d\n", ((struct qos_remap *)cdata) ->port);
	ip1811drv_dbg("cdata ->queue=0x%d\n", ((struct qos_remap *)cdata) ->queue);
	
#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	if(queue<=OP_QOS_REMAP_RX_Q7)//RX
	{
		IP2Page(6);
		u16dat = Read_Reg(P6REG_QOS_REMAP_RX0+(port*2)+(queue/5));
	}
	else//TX
	{
		queue-=8;
		IP2Page(8);
		if (port == 0)
		{
			u16dat = Read_Reg(P8REG_QOS_REMAP_TX0+(port*2)+(queue/5));
		}
		else if (port == 1)
		{
			if (queue / 5)
				u16dat = Read_Reg(P8REG_QOS_REMAP_TX0+(port*2)+(queue/5)+1);
			else
				u16dat = Read_Reg(P8REG_QOS_REMAP_TX0+(port*2)+(queue/5));
		}
		else
		{
			u16dat = Read_Reg(P8REG_QOS_REMAP_TX0+(port*2)+(queue/5)+1);
		}
	}
	((struct qos_remap *)cdata) ->remap = (u8)((u16dat>>((queue%5)*3))&0x7);

	ip1811drv_dbg("cdata ->remap=0x%d\n", ((struct qos_remap *)cdata) ->remap);
	FUNC_MSG_OUT;
	return 0;
}
//------------ QOS functions:ip1811 end--------------------------

//------------ ACL functions:common ----------------------------
struct acl_man	*m_acl;	// acl golbal manage variable
int acl_write_table_0010(int block, int index, int link, struct acl_rule *r);
int acl_write_table_0100(int block, int index, int link, struct acl_rule *r);
int acl_write_table_0101(int block, int index, int link, struct acl_rule *r);
int acl_write_table_0110(int block, int index, int link, struct acl_rule *r);
int acl_write_table_0111(int block, int index, int link, struct acl_rule *r);
int acl_write_table_1x00(int block, int index, int link, struct acl_rule *r);
int acl_write_table_1x01(int block, int index, int link, struct acl_rule *r);
int acl_write_table_1x10(int block, int index, int link, struct acl_rule *r);
int acl_write_table_1x11(int block, int index, int link, struct acl_rule *r);
int (*acl_write_table_rule[])(int block, int index, int link, struct acl_rule *r) = {
	NULL,
	acl_write_table_0010,
	NULL,
	acl_write_table_0100,
	acl_write_table_0101,
	acl_write_table_0110,
	acl_write_table_0111,
	acl_write_table_1x00,
	acl_write_table_1x01,
	acl_write_table_1x10,
	acl_write_table_1x11
};
int acl_write_table_drop(int block, int index, int is_link, struct acl_rule *r);
int acl_write_table_a1(int block, int index, int is_link, struct acl_rule *r);
int acl_write_table_a2(int block, int index, int is_link, struct acl_rule *r);
int acl_write_table_a3(int block, int index, int is_link, struct acl_rule *r);
int (*acl_write_table_act[])(int block, int index, int is_link, struct acl_rule *r) = {
	acl_write_table_drop,
	acl_write_table_a1,
	acl_write_table_a2,
	acl_write_table_a3
};

int set_rule_index_remap(void);

void acl_init(void)
{
	int i;
	ip1811drv_dbg("<DBG_DR_ACL> acl_init()\n");

	m_acl = kmalloc(sizeof(struct acl_man), GFP_KERNEL);
	if(m_acl == NULL)
	{
		ip1811drv_err("Error: acl_init() acl_man malloc failed.\n");
		return;
	}

	INIT_LIST_HEAD(&m_acl ->rule_list);
	m_acl ->num_used_rules = 0;
	m_acl ->num_used_entries = 0;
	for(i=0; i<4; i++)
	{
		m_acl ->used_entry_mask[i] = 0;
	}
}

int acl_find_index(int num, int *block, int *index, int find_idx_blockn, int find_idx_rvs)
{
	int i=0, j=0;
	unsigned char m = 0;
	unsigned long t = 0;

	for(i=0; i<num; i++) {
		m |= BIT(i);
	}

	for(i=0; i<4; i++) {
		t = (unsigned long)m_acl ->used_entry_mask[(find_idx_blockn+i)%4];
		if(find_idx_rvs) { // find index in reverse
			for(j=15; j>=0; j--) {
				if((16-j) < num) // empty entry is not enough, find next block
					break;
				if(!((t>>j) & m)) {
					*block = (i+find_idx_blockn)%4;
					*index = j;
					return 0;
				}
			}
		} else {
			for(j=0; j<16; j++) {
				if((16-j) < num) // empty entry is not enough, find next block
					break;
				if(!((t>>j) & m)) {
					*block = (i+find_idx_blockn)%4;
					*index = j;
					return 0;
				}
			}
		}
	}

	return -ENOMEM;
}

int acl_clean_table_rule(int block, int index)
{
	IP2Page(1);

	Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, 0);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_clean_table_act(int block, int index)
{
	IP2Page(1);

	Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, 0);

	// act
	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC100|index|(block<<5));
	return 0;
}

int acl_clean_table(int block, int index)
{
	acl_clean_table_rule(block, index);
	acl_clean_table_act(block, index);
	return 0;
}

int acl_write_table_0010(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp=0;

	IP2Page(1);

	/* Set user define location D3 and D4 */
	if(r->location1)
		Write_Reg(P1REG_ACL_PATTEM_LOCATION_D3, r->location1);
	if(r->location2)
		Write_Reg(P1REG_ACL_PATTEM_LOCATION_D4, r->location2);

	/* E1 ~ E8 */
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->usr0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, r->mask0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->usr1);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, r->mask1);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, r->usr2);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, r->mask2);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, r->usr3);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, r->mask3);

	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT) {
		tmp |= r->ingress_port+1;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);

	//EA
	tmp=ACL_SELECT_MODE_0010<<6;
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}


int acl_write_table_0100(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp = 0;

	IP2Page(1);
	//E1 & E2
	if(r->rule_valid & ACL_RULE_VALID_SIP)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->sip4_addr&0xFFFF);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, (r->sip4_addr>>16)&0xFFFF);
		tmp |= ((u16)(r->sip_mask&0xF)<<7);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
		tmp |= (0xF<<7);		// any sip
	}
	//E3 & E4
	if(r->rule_valid & ACL_RULE_VALID_DP_R)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->dp_lo);
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, r->dp_hi);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
		tmp |= BIT(5);
	}
	//E5 & E6
	if(r->rule_valid & ACL_RULE_VALID_SP_R)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, r->sp_lo);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, r->sp_hi);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
		tmp |= BIT(6);
	}
	//E7
	if(r->rule_valid & ACL_RULE_VALID_VLAN)
	{
		if(r->rule_valid & ACL_RULE_VALID_COS)
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan | (r->cos<<12)));
		}
		else
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan|0x8000));
		}
	}
	else
	{
		tmp |= (0x3<<11);
		Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0x8000);
	}
	//E8
	tmp |= (0x3<<13);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0x8000);
	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SIP) {
		tmp |= 0x8000;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_0100<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_DP_R) {
		tmp |= 0x1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SP_R) {
		tmp |= 0x2;
	}
	if((r->rule_rvs&ACL_RULE_RVS_VLAN) && (r->rule_rvs&ACL_RULE_RVS_COS)) {
		tmp |= 0x4;
	}
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_0101(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp = 0;

	IP2Page(1);
	//E1 & E2
	if(r->rule_valid & ACL_RULE_VALID_DIP)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->dip4_addr&0xFFFF);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, (r->dip4_addr>>16)&0xFFFF);
		tmp |= ((u16)(r->dip_mask&0xF)<<7);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
		tmp |= (0xF<<7);		// any dip
	}
	//E3 & E4
	if(r->rule_valid & ACL_RULE_VALID_DP_R)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->dp_lo);
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, r->dp_hi);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
		tmp |= BIT(5);
	}
	//E5 & E6
	if(r->rule_valid & ACL_RULE_VALID_SP_R)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, r->sp_lo);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, r->sp_hi);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
		tmp |= BIT(6);
	}
	//E7
	if(r->rule_valid & ACL_RULE_VALID_VLAN)
	{
		if(r->rule_valid & ACL_RULE_VALID_COS)
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan | (r->cos<<12)));
		}
		else
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan|0x8000));
		}
	}
	else
	{
		tmp |= (0x3<<11);
		Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0x8000);
	}
	//E8
	tmp |= (0x3<<13);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0x8000);
	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_DIP) {
		tmp |= 0x8000;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_0101<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_DP_R) {
		tmp |= 0x1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SP_R) {
		tmp |= 0x2;
	}
	if((r->rule_rvs&ACL_RULE_RVS_VLAN) && (r->rule_rvs&ACL_RULE_RVS_COS)) {
		tmp |= 0x4;
	}
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_0110(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp = 0;

	IP2Page(1);
	//E1 ~ E8
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->sip6_addr16[7]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, r->sip6_addr16[6]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->sip6_addr16[5]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, r->sip6_addr16[4]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, r->sip6_addr16[3]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, r->sip6_addr16[2]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, r->sip6_addr16[1]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, r->sip6_addr16[0]);
	//E9
	tmp |= ((u16)(r->sip_mask&0x3FF)<<5);
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_0110<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_0111(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp = 0;

	IP2Page(1);
	//E1 ~ E8
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->dip6_addr16[7]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, r->dip6_addr16[6]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->dip6_addr16[5]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, r->dip6_addr16[4]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, r->dip6_addr16[3]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, r->dip6_addr16[2]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, r->dip6_addr16[1]);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, r->dip6_addr16[0]);
	//E9
	tmp |= ((u16)(r->dip_mask&0x3FF)<<5);
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_0111<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_1x00(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp=0, tmp2=0;

	IP2Page(1);
	//E1 & E2
	if(r->rule_valid & ACL_RULE_VALID_SIP)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->sip4_addr&0xFFFF);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, (r->sip4_addr>>16)&0xFFFF);
		tmp |= ((u16)(r->sip_mask&0xF)<<7);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
		tmp |= (0xF<<7);		// any sip
	}
	//E3
	if(r->rule_valid & ACL_RULE_VALID_ETH_TYPE)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->eth_type);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
		tmp |= BIT(5);
	}
	//E4 ~ E6
	if(r->rule_valid & ACL_RULE_VALID_SMAC)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, ((u16)(r->smac[4]&0xFF)<<8) | ((u16)(r->smac[5]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, ((u16)(r->smac[2]&0xFF)<<8) | ((u16)(r->smac[3]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, ((u16)(r->smac[0]&0xFF)<<8) | ((u16)(r->smac[1]&0xFF)));
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
		tmp |= (0x1<<6);		// any smac
	}
	//E7
	if(r->rule_valid & ACL_RULE_VALID_VLAN)
	{
		if(r->rule_valid & ACL_RULE_VALID_COS)
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan | (r->cos<<12)));
		}
		else
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan|0x8000));
		}
	}
	else
	{
		tmp |= (0x3<<11);
		Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0x8000);
	}
	//E8
	// ip_proto
	if(r->rule_valid & ACL_RULE_VALID_IP_PROT)
	{
		tmp2 |= ((u16)r->ip_prot&0xFF);
	}
	else
	{
		tmp |= BIT(13);		// any ip_prot
	}
	// dscp
	if(r->rule_valid & ACL_RULE_VALID_DSCP)
	{
		tmp2 |= ((u16)(r->r_dscp&0x3F)<<10);
	}
	else
	{
		tmp |= BIT(14);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, tmp2);
	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SIP) {
		tmp |= 0x8000;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_1x00<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_ETH_TYPE) {
		tmp |= 0x1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SMAC) {
		tmp |= 0x2;
	}
	if((r->rule_rvs&ACL_RULE_RVS_VLAN) && (r->rule_rvs&ACL_RULE_RVS_COS)) {
		tmp |= 0x4;
	}
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_1x01(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp=0, tmp2=0;

	IP2Page(1);
	//E1 & E2
	if(r->rule_valid & ACL_RULE_VALID_DIP)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->dip4_addr&0xFFFF);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, (r->dip4_addr>>16)&0xFFFF);
		tmp |= ((u16)(r->dip_mask&0xF)<<7);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
		tmp |= (0xF<<7);		// any dip
	}
	//E3
	if(r->rule_valid & ACL_RULE_VALID_ETH_TYPE)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->eth_type);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
		tmp |= BIT(5);
	}
	//E4 ~ E6
	if(r->rule_valid & ACL_RULE_VALID_SMAC)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, ((u16)(r->smac[4]&0xFF)<<8) | ((u16)(r->smac[5]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, ((u16)(r->smac[2]&0xFF)<<8) | ((u16)(r->smac[3]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, ((u16)(r->smac[0]&0xFF)<<8) | ((u16)(r->smac[1]&0xFF)));
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
		tmp |= (0x1<<6);		// any smac
	}
	//E7
	if(r->rule_valid & ACL_RULE_VALID_VLAN)
	{
		if(r->rule_valid & ACL_RULE_VALID_COS)
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan | (r->cos<<12)));
		}
		else
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan|0x8000));
		}
	}
	else
	{
		tmp |= (0x3<<11);
		Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0x8000);
	}
	//E8
	// ip_proto
	if(r->rule_valid & ACL_RULE_VALID_IP_PROT)
	{
		tmp2 |= ((u16)r->ip_prot&0xFF);
	}
	else
	{
		tmp |= BIT(13);		// any ip_prot
	}
	// dscp
	if(r->rule_valid & ACL_RULE_VALID_DSCP)
	{
		tmp2 |= ((u16)(r->r_dscp&0x3F)<<10);
	}
	else
	{
		tmp |= BIT(14);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, tmp2);
	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_DIP) {
		tmp |= 0x8000;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_1x01<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_ETH_TYPE) {
		tmp |= 0x1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SMAC) {
		tmp |= 0x2;
	}
	if((r->rule_rvs&ACL_RULE_RVS_VLAN) && (r->rule_rvs&ACL_RULE_RVS_COS)) {
		tmp |= 0x4;
	}
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_1x10(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp=0, tmp2=0;

	IP2Page(1);
	//E1 & E2
	if(r->rule_valid & ACL_RULE_VALID_SIP)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->sip4_addr&0xFFFF);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, (r->sip4_addr>>16)&0xFFFF);
		tmp |= ((u16)(r->sip_mask&0xF)<<7);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
		tmp |= (0xF<<7);		// any sip
	}
	//E3
	if(r->rule_valid & ACL_RULE_VALID_ETH_TYPE)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->eth_type);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
		tmp |= BIT(5);
	}
	//E4 ~ E6
	if(r->rule_valid & ACL_RULE_VALID_DMAC)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, ((u16)(r->dmac[4]&0xFF)<<8) | ((u16)(r->dmac[5]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, ((u16)(r->dmac[2]&0xFF)<<8) | ((u16)(r->dmac[3]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, ((u16)(r->dmac[0]&0xFF)<<8) | ((u16)(r->dmac[1]&0xFF)));
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
		tmp |= (0x1<<6);		// any dmac
	}
	//E7
	if(r->rule_valid & ACL_RULE_VALID_VLAN)
	{
		if(r->rule_valid & ACL_RULE_VALID_COS)
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan | (r->cos<<12)));
		}
		else
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan|0x8000));
		}
	}
	else
	{
		tmp |= (0x3<<11);
		Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0x8000);
	}
	//E8
	// ip_proto
	if(r->rule_valid & ACL_RULE_VALID_IP_PROT)
	{
		tmp2 |= ((u16)r->ip_prot&0xFF);
	}
	else
	{
		tmp |= BIT(13);		// any ip_prot
	}
	// dscp
	if(r->rule_valid & ACL_RULE_VALID_DSCP)
	{
		tmp2 |= ((u16)(r->r_dscp&0x3F)<<10);
	}
	else
	{
		tmp |= BIT(14);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, tmp2);
	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_SIP) {
		tmp |= 0x8000;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_1x10<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_ETH_TYPE) {
		tmp |= 0x1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_DMAC) {
		tmp |= 0x2;
	}
	if((r->rule_rvs&ACL_RULE_RVS_VLAN) && (r->rule_rvs&ACL_RULE_RVS_COS)) {
		tmp |= 0x4;
	}
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_1x11(int block, int index, int link, struct acl_rule *r)
{
	u16 tmp=0, tmp2=0;

	IP2Page(1);
	//E1 & E2
	if(r->rule_valid & ACL_RULE_VALID_DIP)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, r->dip4_addr&0xFFFF);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, (r->dip4_addr>>16)&0xFFFF);
		tmp |= ((u16)(r->dip_mask&0xF)<<7);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E1, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
		tmp |= (0xF<<7);		// any dip
	}
	//E3
	if(r->rule_valid & ACL_RULE_VALID_ETH_TYPE)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, r->eth_type);
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
		tmp |= BIT(5);
	}
	//E4 ~ E6
	if(r->rule_valid & ACL_RULE_VALID_DMAC)
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, ((u16)(r->dmac[4]&0xFF)<<8) | ((u16)(r->dmac[5]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, ((u16)(r->dmac[2]&0xFF)<<8) | ((u16)(r->dmac[3]&0xFF)));
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, ((u16)(r->dmac[0]&0xFF)<<8) | ((u16)(r->dmac[1]&0xFF)));
	}
	else
	{
		Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
		Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
		tmp |= (0x1<<6);		// any dmac
	}
	//E7
	if(r->rule_valid & ACL_RULE_VALID_VLAN)
	{
		if(r->rule_valid & ACL_RULE_VALID_COS)
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan | (r->cos<<12)));
		}
		else
		{
			Write_Reg(P1REG_ACL_TABLE_DATA_E7, (r->vlan|0x8000));
		}
	}
	else
	{
		tmp |= (0x3<<11);
		Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0x8000);
	}
	//E8
	// ip_proto
	if(r->rule_valid & ACL_RULE_VALID_IP_PROT)
	{
		tmp2 |= ((u16)r->ip_prot&0xFF);
	}
	else
	{
		tmp |= BIT(13);		// any ip_prot
	}
	// dscp
	if(r->rule_valid & ACL_RULE_VALID_DSCP)
	{
		tmp2 |= ((u16)(r->r_dscp&0x3F)<<10);
	}
	else
	{
		tmp |= BIT(14);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, tmp2);
	//E9
	if(r->rule_valid & ACL_RULE_VALID_INGRESS_PORT)
	{
		tmp |= r->ingress_port+1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_DIP) {
		tmp |= 0x8000;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, tmp);
	//EA
	tmp = ((ACL_SELECT_MODE_1x11<<6) | (link<<4));
	if(r->rule_rvs & ACL_RULE_RVS_ETH_TYPE) {
		tmp |= 0x1;
	}
	if(r->rule_rvs & ACL_RULE_RVS_DMAC) {
		tmp |= 0x2;
	}
	if((r->rule_rvs&ACL_RULE_RVS_VLAN) && (r->rule_rvs&ACL_RULE_RVS_COS)) {
		tmp |= 0x4;
	}
	if(r->rule_rvs & ACL_RULE_RVS_INGRESS_PORT) {
		tmp |= 0x8;
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int acl_write_table_drop(int block, int index, int is_link, struct acl_rule *r)
{
	u16 tmp = 0;

	IP2Page(1);
	//E1
	tmp = 0x1F;
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, tmp);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, 0);
	if(is_link) {
		tmp = ((ACL_SELECT_MODE_0001<<6) | (ACL_LINK_TYPE_11<<4));
		Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);
		Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	} else {
		Write_Reg(P1REG_ACL_TABLE_DATA_EA, 0);
		Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC100|index|(block<<5));
	}

	return 0;
}

int acl_write_table_a1(int block, int index, int is_link, struct acl_rule *r)
{
	u16 tmp = 0;
	u16 tmp2 = 0;

	IP2Page(1);
	//E1
	if(r->act_valid & ACL_ACT_VALID_REDIR)
	{
		tmp |= ((r->redir)&0x1F);
	}
	if(r->act_valid & ACL_ACT_VALID_CTAG)
	{
		tmp |= ((r->ctag&0x7F)<<5);
	}
	if(r->act_valid & ACL_ACT_VALID_STAG)
	{
		tmp |= ((r->stag&0xF)<<12);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, tmp);
	
	//E2
	tmp = 0;
	if(r->act_valid & ACL_ACT_VALID_STAG)
	{
		tmp |= ((r->stag&0x70)>>4);
	}
	if(r->act_valid & ACL_ACT_VALID_PRI)
	{
		tmp |= ((BIT(3)|(r->pri&0x7))<<3);
	}
	if(r->act_valid & ACL_ACT_VALID_DSCP)
	{
		tmp |= ((BIT(3)|(r->a_dscp&0x7))<<7);
	}
	if(r->act_valid & ACL_ACT_VALID_BW)
	{
		if(is_link)
			tmp2 |= ((BIT(2)|(r->bw&0x3))<<4);
		else
			tmp |= ((BIT(2)|(r->bw&0x3))<<11);
	}
	if(r->act_valid & ACL_ACT_VALID_SNIFFER)
	{
		if(is_link)
			tmp |= BIT(15);
		else
			tmp |= BIT(14);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, tmp);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, tmp2);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, 0);
	if(is_link) {
		tmp = ((ACL_SELECT_MODE_0001<<6) | (ACL_LINK_TYPE_11<<4));
		Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);
		Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	} else {
		Write_Reg(P1REG_ACL_TABLE_DATA_EA, 0);
		Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC100|index|(block<<5));
	}
	
	return 0;
}

int acl_write_table_a2(int block, int index, int is_link, struct acl_rule *r)
{
	u16 tmp = 0;
	u16 tmp2 = 0;

	IP2Page(1);
	//E1
	if(r->act_valid & ACL_ACT_VALID_REDIR)
	{
		tmp |= ((r->redir)&0x1F);
	}
	if(r->act_valid & ACL_ACT_VALID_CTAG)
	{
		tmp |= ((r->ctag&0x7F)<<5);
	}
	if(r->act_valid & ACL_ACT_VALID_STAG)
	{
		tmp |= ((r->stag&0xF)<<12);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, tmp);
	
	//E2
	tmp = 0;
	if(r->act_valid & ACL_ACT_VALID_STAG)
	{
		tmp |= ((r->stag&0x70)>>4);
	}
	if(r->act_valid & ACL_ACT_VALID_PRI)
	{
		tmp |= ((BIT(3)|(r->pri&0x7))<<3);
	}
	if(r->act_valid & ACL_ACT_VALID_STORM)
	{
		if(is_link)
			tmp2 |= (BIT(r->storm-1)<<1);
		else
			tmp |= (BIT(r->storm-1)<<7);
	}
	if(r->act_valid & ACL_ACT_VALID_CPU)
	{
		if(is_link)
			tmp2 |= BIT(0);
		else
			tmp |= BIT(10);
	}
	if(r->act_valid & ACL_ACT_VALID_MIB_COUNTER)
	{
		tmp |= ((BIT(1)|((r->mib_counter-1)&0x1))<<11);
	}
	if(r->act_valid & ACL_ACT_VALID_PTP)
	{
		tmp |= BIT(13);
	}
	if(r->act_valid & ACL_ACT_VALID_SFLOW)
	{
		tmp |= BIT(14);
	}
	tmp |= BIT(15);
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, tmp);
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, tmp2);
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0);
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, 0);
	if(is_link) {
		tmp = ((ACL_SELECT_MODE_0001<<6) | (ACL_LINK_TYPE_11<<4));
		Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);
		Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	} else {
		Write_Reg(P1REG_ACL_TABLE_DATA_EA, 0);
		Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC100|index|(block<<5));
	}

	return 0;
}

int acl_write_table_a3(int block, int index, int is_link, struct acl_rule *r)
{
	u16 tmp = 0;

	IP2Page(1);
	//E1
	if(r->act_valid & ACL_ACT_VALID_REDIR)
	{
		tmp |= ((r->redir)&0x1F);
	}
	if(r->act_valid & ACL_ACT_VALID_CTAG)
	{
		tmp |= ((r->ctag&0x7F)<<5);
	}
	if(r->act_valid & ACL_ACT_VALID_STAG)
	{
		tmp |= ((r->stag&0xF)<<12);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E1, tmp);
	
	//E2
	tmp = 0;
	if(r->act_valid & ACL_ACT_VALID_STAG)
	{
		tmp |= ((r->stag&0x70)>>4);
	}
	if(r->act_valid & ACL_ACT_VALID_PRI)
	{
		tmp |= ((BIT(3)|(r->pri&0x7))<<3);
	}
	if(r->act_valid & ACL_ACT_VALID_DSCP)
	{
		tmp |= ((BIT(3)|(r->a_dscp&0x7))<<7);
	}
	if(r->act_valid & ACL_ACT_VALID_MIB_COUNTER)
	{
		tmp |= ((BIT(1)|(r->mib_counter&0x1))<<11);
	}
	if(r->act_valid & ACL_ACT_VALID_PTP)
	{
		tmp |= BIT(13);
	}
	if(r->act_valid & ACL_ACT_VALID_SFLOW)
	{
		tmp |= BIT(14);
	}
	if(r->act_valid & ACL_ACT_VALID_SNIFFER)
	{
		tmp |= BIT(15);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E2, tmp);

	//E3
	tmp = 0;
	if(r->act_valid & ACL_ACT_VALID_CPU)
	{
		tmp |= BIT(0);
	}
	if(r->act_valid & ACL_ACT_VALID_STORM)
	{
		tmp |= (BIT(r->storm-1)<<1);
	}
	if(r->act_valid & ACL_ACT_VALID_BW)
	{
		tmp |= ((BIT(2)|(r->bw&0x3))<<4);
	}
	Write_Reg(P1REG_ACL_TABLE_DATA_E3, tmp);
	
	//E4
	Write_Reg(P1REG_ACL_TABLE_DATA_E4, 0);
	//E5
	Write_Reg(P1REG_ACL_TABLE_DATA_E5, 0);
	//E6
	Write_Reg(P1REG_ACL_TABLE_DATA_E6, 0);
	//E7
	Write_Reg(P1REG_ACL_TABLE_DATA_E7, 0);
	//E8
	Write_Reg(P1REG_ACL_TABLE_DATA_E8, 0);
	//E9
	Write_Reg(P1REG_ACL_TABLE_DATA_E9, 0);
	//EA
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, 0);

	tmp = ((ACL_SELECT_MODE_0001<<6) | (ACL_LINK_TYPE_11<<4));
	Write_Reg(P1REG_ACL_TABLE_DATA_EA, tmp);

	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|index|(block<<5));
	return 0;
}

int switchdSetAclRule(struct AclRuleSetting *ars)
{
	struct acl_rule *r = &ars ->rule;
	unsigned long rule_v = r->rule_valid;
	int s_mode = 0, s_num = 0, flag = 0, i = 0, block = 0, index = 0, link = 0;
	struct acl_man_rule *mr;
	int ret = 0;
	int find_idx_blockn;
	int find_idx_rvs;

	ip1811drv_dbg("<DBG_DR_ACL> switchdSetAclRule(): ars ->rule_index = %i\n", ars ->rule_index);
	// check index
	list_for_each_entry(mr, &m_acl ->rule_list, rule_entry) {
		if(mr->rule_index == ars ->rule_index) {
			if((mr->func_used) & (ars->func_used)) {
				for(i = mr->start_index; i<(mr->start_index+mr->num_entries); i++) {
					block = mr->start_block;
					index = i&0xF;
					acl_clean_table(block, index);
					m_acl ->used_entry_mask[block] &= ~BIT(i&0xF);
					m_acl ->num_used_entries--;
				}
				m_acl ->num_used_rules--;
				flag = 1;
				break;
			}
		}
	}

	if(!flag) {
		mr = NULL;
	}

	if(rule_v==0) {
		ars->rule_index_res=0;
		ars->reserved=0;
		m_acl->num_used_rules++;
		if(mr!=NULL) {
			list_del(&mr->rule_entry);
			kfree(mr);
		}
		return 0;
	}

	// selection logic
	if((rule_v & ACL_RULE_VALID_SIP6) || (rule_v & ACL_RULE_VALID_DIP6)) {
		if(rule_v & ACL_RULE_VALID_SIP6) {
			// 0110
			s_mode |= ACL_SELECT_MODE_BIT_0110;
			s_num += 1;
		}

		if(rule_v & ACL_RULE_VALID_DIP6) {
			// 0111
			s_mode |= ACL_SELECT_MODE_BIT_0111;
			s_num += 1;
		}

		if((rule_v & ACL_RULE_VALID_SP_R) || (rule_v & ACL_RULE_VALID_DP_R)) {
			// 0101
			s_mode |= ACL_SELECT_MODE_BIT_0101;
			s_num += 1;
		}
		goto out_select_logic;
	} else if(rule_v & ACL_RULE_VALID_USERDEF_OFFSET) {
		//0010
		s_mode=ACL_SELECT_MODE_BIT_0010;
		s_num=1;
		goto out_select_logic;
	}

	if((rule_v & ACL_RULE_VALID_SP_R) || (rule_v & ACL_RULE_VALID_DP_R)) {
		if(rule_v & ACL_RULE_VALID_DIP) {
			// 0101 
			s_mode |= ACL_SELECT_MODE_BIT_0101;
			s_num += 1;

			if( (rule_v & ACL_RULE_VALID_SIP)
				|| (rule_v & ACL_RULE_VALID_DMAC)
				|| (rule_v & ACL_RULE_VALID_SMAC)
				|| (rule_v & ACL_RULE_VALID_ETH_TYPE)
				|| (rule_v & ACL_RULE_VALID_DSCP)
				|| (rule_v & ACL_RULE_VALID_IP_PROT)
			) {
				if(rule_v & ACL_RULE_VALID_DMAC) {
					// 1x10
					s_mode |= ACL_SELECT_MODE_BIT_1x10;
					s_num += 1;
				
					if(rule_v & ACL_RULE_VALID_SMAC) { 
						// 1x00
						s_mode |= ACL_SELECT_MODE_BIT_1x00;
						s_num += 1;
					}
				} else { 
					// 1x00
					s_mode |= ACL_SELECT_MODE_BIT_1x00;
					s_num += 1;
				}
			}
		} else {
			// 0100 
			s_mode |= ACL_SELECT_MODE_BIT_0100;
			s_num += 1;
			if( (rule_v & ACL_RULE_VALID_DMAC)
				|| (rule_v & ACL_RULE_VALID_SMAC)
				|| (rule_v & ACL_RULE_VALID_ETH_TYPE)
				|| (rule_v & ACL_RULE_VALID_DSCP)
				|| (rule_v & ACL_RULE_VALID_IP_PROT)
			) {
				if(rule_v & ACL_RULE_VALID_DMAC) {
					// 1x10
					s_mode |= ACL_SELECT_MODE_BIT_1x10;
					s_num += 1;
				
					if(rule_v & ACL_RULE_VALID_SMAC) { 
						// 1x00
						s_mode |= ACL_SELECT_MODE_BIT_1x00;
						s_num += 1;
					}
				} else { 
					// 1x00
					s_mode |= ACL_SELECT_MODE_BIT_1x00;
					s_num += 1;
				}
			}
		}
	} else {
		if(rule_v & ACL_RULE_VALID_DIP) {
			if(rule_v & ACL_RULE_VALID_DMAC) {
				// 1x11
				s_mode |= ACL_SELECT_MODE_BIT_1x11;
				s_num += 1;
				
				if((rule_v & ACL_RULE_VALID_SMAC) || (rule_v & ACL_RULE_VALID_SIP)) { 
					// 1x00
					s_mode |= ACL_SELECT_MODE_BIT_1x00;
					s_num += 1;
				}
			} else { 
				// 1x01
				s_mode |= ACL_SELECT_MODE_BIT_1x01;
				s_num += 1;
				if(rule_v & ACL_RULE_VALID_SIP) { 
					// 1x00
					s_mode |= ACL_SELECT_MODE_BIT_1x00;
					s_num += 1;
				}
			}
		} else {
			if(rule_v & ACL_RULE_VALID_DMAC) {
				// 1x10
				s_mode |= ACL_SELECT_MODE_BIT_1x10;
				s_num += 1;
				if(rule_v & ACL_RULE_VALID_SMAC) { 
					// 1x00
					s_mode |= ACL_SELECT_MODE_BIT_1x00;
					s_num += 1;
				}
			} else { 
				// 1x00
				s_mode |= ACL_SELECT_MODE_BIT_1x00;
				s_num += 1;
			}
		}
	}

out_select_logic:
	ip1811drv_dbg("<DBG_SWD_ACL> s_mode = %02x, s_num = %i\n", s_mode, s_num);

	if((r->act_type==ACL_ACT_TYPE_3) || (s_num>=2)) {
		s_num++;
	}

	find_idx_blockn = ars->find_index_blockn;
	find_idx_rvs = ars->find_index_rvs;

	ret = acl_find_index(s_num, &block, &index, find_idx_blockn, find_idx_rvs);

	if(ret < 0) { // if acl_find_index return <0, remap acl rule index and find index again
		set_rule_index_remap();
		ret = acl_find_index(s_num, &block, &index, find_idx_blockn, find_idx_rvs);
	}

	if(ret < 0) {
		if(mr != NULL) {
			list_del(&mr->rule_entry);
			kfree(mr);
		}
		ars ->rule_index_res = -2;
		ars ->reserved = s_num;
		return 0;
		//return -ENOMEM;
	}
	ip1811drv_dbg("<DBG_SWD_ACL> block, index = %i, %i\n", block, index);

	ars->find_index_blockn = block;
	if(mr == NULL) {
		mr = kmalloc(sizeof(struct acl_man_rule), GFP_KERNEL);
		if(mr == NULL) {
			ip1811drv_err("Error: switchdSetAclRule() acl_man_rule malloc failed.\n");
			return -ENOMEM;
		}
		list_add_tail(&mr->rule_entry, &m_acl ->rule_list);
	}

	mr->start_block = block;
	mr->start_index = index;
	mr->num_entries = s_num;
	mr->rule_index = ars ->rule_index;
	mr->func_used = ars ->func_used;
	if(s_num == 1) {
		link = ACL_LINK_TYPE_00;
		// write rule table
		for(i=2; i<12; i++) {
			if(s_mode & BIT(i)) {
				acl_write_table_rule[i-1](block, index, link, r);
				s_num--;
				break;
			}
		}
		// write action table
		acl_write_table_act[r->act_type](block, index, s_num, r);
	} else {
		link = ACL_LINK_TYPE_01;
		// write rule table
		for(i=2; i<12; i++) {
			if(s_mode & BIT(i)) {
				acl_write_table_rule[i-1](block, index, link, r);
				index++;
				s_num--;
				if(s_num == 1) {
					break;
				} else {
					link = ACL_LINK_TYPE_10;
				}
			}
		}
		// write action table
		//acl_write_table_act[r->act_type](block, index, s_num, r);
		acl_write_table_act[3](block, index, s_num, r);
	}

	for(i=0; i<mr->num_entries; i++) {
		m_acl ->used_entry_mask[mr->start_block] |= BIT((i+mr->start_index)&0xF);
		m_acl ->num_used_entries++;
	}
	m_acl ->num_used_rules++;
	ars ->rule_index_res = 0;
	ars ->reserved = mr->num_entries;

	return 0;
}
EXPORT_SYMBOL(switchdSetAclRule);

int setAclRule(void *cdata, int len)
{
	int ret;
	struct AclRuleSetting *ars = (struct AclRuleSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct AclRuleSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdSetAclRule(ars);
	FUNC_MSG_OUT;

	return ret;
}

int getAclRule(void *cdata, int len)
{
	return 0;
}

int switchdAclCleanTable(int rule_index, int func_used)
{
	int i = 0;
	struct acl_man_rule *mr, *nmr;
	int block, index;

	if ((rule_index<1 || rule_index>64) && (rule_index!=128)) {
		ip1811drv_err("Error: rule index=%d\n", rule_index);
		return -EINVAL;
	}

	ip1811drv_dbg("<DBG_DR_ACL> aclCleanTable()\n");

	if(rule_index == 128) {
		ip1811drv_dbg("<DBG_DR_ACL> aclCleanTable() 111111\n");
		if(list_empty(&m_acl ->rule_list)) {
			ip1811drv_dbg("<DBG_DR_ACL> aclCleanTable() 222222\n");
			return 0;
		}

		list_for_each_entry_safe(mr, nmr, &m_acl ->rule_list, rule_entry)
		{
			for(i=0; i<mr->num_entries; i++) {
				block = mr->start_block;
				index = mr->start_index;
				acl_clean_table(block, index+i);
				m_acl ->used_entry_mask[block] &= ~BIT((index+i)&0xF);
				m_acl ->num_used_entries--;
			}
			m_acl ->num_used_rules--;
			list_del(&mr->rule_entry);
			kfree(mr);
		}

		INIT_LIST_HEAD(&m_acl ->rule_list);

		if((m_acl ->num_used_rules!=0) || (m_acl ->num_used_entries!=0))
			ip1811drv_err("<DBG_SWD_ACL> aclCleanTable something error!\n");
	} else {
		list_for_each_entry(mr, &m_acl ->rule_list, rule_entry)
		{
			if(mr->rule_index == rule_index) {
				if((mr->func_used) & func_used) {
					for(i=0; i<mr->num_entries; i++) {
						block = mr->start_block;
						index = mr->start_index;
						acl_clean_table(block, index+i);
						m_acl ->used_entry_mask[block] &= ~BIT((index+i)&0xF);
						m_acl ->num_used_entries--;
					}
					m_acl ->num_used_rules--;
					list_del(&mr->rule_entry);
					kfree(mr);
					break;
				}
			}
		}
	}

	return 0;
}
EXPORT_SYMBOL(switchdAclCleanTable);

int aclCleanTable(void *cdata, int len)
{
	int ret, rule_index, func_used;
	struct AclTableCleanSetting *atcs = (struct AclTableCleanSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct AclTableCleanSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	rule_index = atcs ->rule_idx;
	func_used = atcs ->func_used;
	ret = switchdAclCleanTable(rule_index, func_used);
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdSetAclFunctionEn(int enable)
{
	if ((enable!=OP_FUNC_ENABLE) && (enable!=OP_FUNC_DISABLE)) {
		ip1811drv_err("Error: value=%d\n", enable);
		return -EINVAL;
	}
	_WriteRegBits(1, P1REG_MISCCFG, 0, 1, enable);
	return 0;
}
EXPORT_SYMBOL(switchdSetAclFunctionEn);

int setAclFunctionEn(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;
	int func_en;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	func_en = gs ->gdata;
	ret = switchdSetAclFunctionEn(func_en);
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdGetAclFunctionEn(int *gdata_p)
{
	*gdata_p = _ReadRegBits(1, P1REG_MISCCFG, 0, 1);
	return 0;
}
EXPORT_SYMBOL(switchdGetAclFunctionEn);

int getAclFunctionEn(void *cdata, int len)
{
	int ret; 
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdGetAclFunctionEn(&(gs ->gdata));
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdSetAclEtherAfterTag(int is_after_tag)
{
	if ((is_after_tag!=OP_FUNC_ENABLE) && (is_after_tag!=OP_FUNC_DISABLE)) {
		ip1811drv_err("Error: value=%d\n", is_after_tag);
		return -EINVAL;
	}
	_WriteRegBits(1, P1REG_MISCCFG, 1, 1, is_after_tag);
	return 0;
}
EXPORT_SYMBOL(switchdSetAclEtherAfterTag);

int setAclEtherAfterTag(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;
	int loca_v;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	loca_v = gs ->gdata;
	ret = switchdSetAclEtherAfterTag(loca_v);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetAclEtherAfterTag(int *gdata_p)
{
	*gdata_p = _ReadRegBits(1, P1REG_MISCCFG, 1, 1);
	return 0;
}
EXPORT_SYMBOL(switchdGetAclEtherAfterTag);

int getAclEtherAfterTag(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdGetAclEtherAfterTag(&(gs ->gdata));
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetAclUsedRules(int *gdata_p)
{
	*gdata_p = m_acl ->num_used_rules;
	return 0;
}
EXPORT_SYMBOL(switchdGetAclUsedRules);

int getAclUsedRules(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdGetAclUsedRules(&(gs ->gdata));
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdGetAclUsedEntries(int *gdata_p)
{
	*gdata_p = m_acl ->num_used_entries;
	return 0;
}
EXPORT_SYMBOL(switchdGetAclUsedEntries);

int getAclUsedEntries(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdGetAclUsedEntries(&(gs ->gdata));
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetAclUsedEntryMask(unsigned short *gmask_p)
{
	memcpy(gmask_p, m_acl->used_entry_mask, 4*sizeof(unsigned short));
	return 0;
}
EXPORT_SYMBOL(switchdGetAclUsedEntryMask);

int getAclUsedEntryMask(void *cdata, int len)
{
	int ret;
	struct AclEntryMaskGetting *aemg = (struct AclEntryMaskGetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct AclEntryMaskGetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdGetAclUsedEntryMask(aemg ->mask);
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetAclBW(int index, int in_rate)
{
	u16 rate = 0;
	
	if (index<0 || index>3) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	if (in_rate<0 || in_rate>2540) {
		ip1811drv_err("Error: rate=%d\n", in_rate);
		return -EINVAL;
	}

	if(in_rate > 163) {
		rate |= BIT(7);
		rate |= (in_rate*100/2000);
		if(in_rate*100%2000) 
			rate++;
	} else {
		rate = (in_rate*100/128);
		if(in_rate*100%128) 
			rate++;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("value=0x%x\n", rate);
	// set 4 block
	_WriteRegBits(1, P1REG_ACL_BW_01+(index/2)+0, 8*(index%2), 8, rate);
	_WriteRegBits(1, P1REG_ACL_BW_01+(index/2)+2, 8*(index%2), 8, rate);
	_WriteRegBits(1, P1REG_ACL_BW_01+(index/2)+4, 8*(index%2), 8, rate);
	_WriteRegBits(1, P1REG_ACL_BW_01+(index/2)+6, 8*(index%2), 8, rate);

	return 0;
}
EXPORT_SYMBOL(switchdSetAclBW);

int setAclBW(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int bw_index;
	int bw_v;

	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	bw_index = ags ->index;
	bw_v = ags ->data;
	ret = switchdSetAclBW(bw_index, bw_v);
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdGetAclBW(int index, int *gdata_p)
{
	u16 tmp = 0;
	u32 c_rate;
	
	if (index<0 || index>3) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	tmp = _ReadRegBits(1, P1REG_ACL_BW_01+(index/2), (8*(index%2)), 8);

	if(tmp&BIT(7)) {
		c_rate = (tmp&(0x7F))*2000;
	} else {
		c_rate = (tmp&(0x7F))*128;
	}

	*gdata_p = c_rate/100;

	return 0;
}
EXPORT_SYMBOL(switchdGetAclBW);

int getAclBW(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int bw_index;

	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	bw_index = ags ->index;
	ret = switchdGetAclBW(bw_index, &(ags ->data));
	ip1811drv_dbg("cdata ->data=%d\n", ags ->data);
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetAclDscp(int index, int value)
{
	if (index<0 || index>7) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	if (value & (~0x3F)) {
		ip1811drv_err("Error: value=%x\n", value);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("value=0x%x\n", value);

	_WriteRegBits(7, P7REG_DSCP_REMARKING_01+(index/2), 8*(index%2), 8, value);

	return 0;
}
EXPORT_SYMBOL(switchdSetAclDscp);

int setAclDscp(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int dscp_index;
	int dscp_v;

	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	dscp_index = ags ->index;
	dscp_v = ags ->data;
	ret = switchdSetAclDscp(dscp_index, dscp_v);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetAclDscp(int index, int *gdata_p)
{
	if (index<0 || index>7) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}
	*gdata_p = _ReadRegBits(7, P7REG_DSCP_REMARKING_01+(index/2), (8*(index%2)), 8);
	return 0;
}
EXPORT_SYMBOL(switchdGetAclDscp);

int getAclDscp(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int dscp_index;

	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	dscp_index = ags ->index;
	ret = switchdGetAclDscp(dscp_index, &(ags ->data));
	ip1811drv_dbg("cdata ->data=%d\n", ags ->data);
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdSetAclVidRemark(int index, int value)
{
	
	if (index<0 || index>15) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	if (value & (~0x7FFF)) {
		ip1811drv_err("Error: value=%x\n", value);
		return -EINVAL;
	}

	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("value=0x%x\n", value);

	_WriteRegBits(2, P2REG_ACL_VID_REMARK_00+index, 0, 15, value);

	return 0;
}
EXPORT_SYMBOL(switchdSetAclVidRemark);

int setAclVidRemark(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int vid_index;
	int vid_v;
	
	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	vid_index = ags ->index;
	vid_v = ags ->data;
	ret = switchdSetAclVidRemark(vid_index, vid_v);
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdGetAclVidRemark(int index, int *gdata_p)
{
	
	if (index<0 || index>15) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	*gdata_p = _ReadRegBits(2, P2REG_ACL_VID_REMARK_00+index, 0, 15);

	return 0;
}
EXPORT_SYMBOL(switchdGetAclVidRemark);

int getAclVidRemark(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int vid_index;
	
	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	vid_index = ags ->index;
	ret = switchdGetAclVidRemark(vid_index, &(ags ->data));
	ip1811drv_dbg("cdata ->data=%d\n", ags ->data);
	FUNC_MSG_OUT;
	
	return ret;
}

int acl_write_table_move(int from_block, int from_index, int to_block, int to_index)
{
	int i;
	u16 u16array[10];
	u16 u16dat;

	IP2Page(1);

	// rule
	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0x8000|from_index|((from_block&0x3)<<5));
	for(i=0; i<10; i++) {
		u16dat = Read_Reg(P1REG_ACL_TABLE_DATA_E1+i);
		u16array[i] = u16dat;
	}
	acl_clean_table_rule(from_block, from_index);
	for(i=0; i<10; i++) {
		Write_Reg(P1REG_ACL_TABLE_DATA_E1+i, u16array[i]);
	}
	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC000|to_index|((to_block&0x3)<<5));
	
	// act 
	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0x8100|from_index|((from_block&0x3)<<5));
	for(i=0; i<10; i++) {
		u16dat = Read_Reg(P1REG_ACL_TABLE_DATA_E1+i);
		u16array[i] = u16dat;
	}
	acl_clean_table_act(from_block, from_index);
	for(i=0; i<10; i++) {
		Write_Reg(P1REG_ACL_TABLE_DATA_E1+i, u16array[i]);
	}
	Write_Reg(P1REG_ACL_TABLE_ACCESS, 0xC100|to_index|((to_block&0x3)<<5));

	m_acl ->used_entry_mask[to_block] |= BIT(to_index);
	m_acl ->used_entry_mask[from_block] &= ~BIT(from_index);

	return 0;
}

int set_rule_index_remap(void)
{
	int i, j;
	int index_move_to;
	int block_move_to;
	int index_move_from;
	int block_move_from;
	int index_move_range;
	struct acl_man_rule *mr;

	ip1811drv_dbg("<DBG_DR_ACL> set_rule_index_remap()\n");

	for(i=0; i<64; i++) {
		if(m_acl ->used_entry_mask[i>>4] & BIT(i%16)) { // entry i rule exist
		} else { // entry i rule not exist
			int no_entry = 1;
			block_move_to = (i>>4)&0x3;
			index_move_to = i&0xF;
			block_move_from = 3;
			index_move_from = 16;
			index_move_range= 0;
			// scan closest entry
			list_for_each_entry(mr, &m_acl ->rule_list, rule_entry) { 
				if(mr->func_used != ACL_RULE_FUNC_USED_SNOOP) {
					if((16*mr->start_block+mr->start_index)>i) {
						if(((16*mr->start_block+mr->start_index)<(block_move_from*16+index_move_from)) && (mr->num_entries<=(16-index_move_to))) {
							block_move_from = mr->start_block;
							index_move_from = mr->start_index;
							index_move_range = mr->num_entries;
							no_entry = 0;
						}
					}
				}
			}

			if(no_entry)
				continue;

			// move exist entry to empty rule index
			for(j=0; j<index_move_range; j++) {
				acl_write_table_move(block_move_from, index_move_from+j, block_move_to, index_move_to+j);
			}
		
			// modify entry info	
			list_for_each_entry(mr, &m_acl ->rule_list, rule_entry) {
				if((mr->start_block==block_move_from) && (mr->start_index==index_move_from)) {
					mr->start_block = block_move_to;
					mr->start_index = index_move_to;
				}
			}
			// assign i to be link entry end
			i += (index_move_range-1);
		}
		ip1811drv_dbg("<DBG_DR_ACL> set_rule_index_remap(): entry from block(%d)/index(%d) to block(%d)/index(%d)\n", block_move_from, index_move_from, block_move_to, index_move_to);

	}

	return 0;
}

int switchdSetAclStormPeriod(int period)
{
	if (period& (~0x3)) {
		ip1811drv_err("Error: period=0x%x\n", period);
		return -EINVAL;
	}
	ip1811drv_dbg("clear period=0x%x\n", period);
	_WriteRegBits(1, P1REG_MISCCFG, 4, 2, period);
	return 0;
}
EXPORT_SYMBOL(switchdSetAclStormPeriod);

int setAclStormPeriod(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;
	int period;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	period = gs ->gdata;
	ret = switchdSetAclStormPeriod(period);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetAclStormPeriod(int *gdata_p)
{
	*gdata_p = _ReadRegBits(1, P1REG_MISCCFG, 4, 2);
	return 0;
}
EXPORT_SYMBOL(switchdGetAclStormPeriod);

int getAclStormPeriod(void *cdata, int len)
{
	int ret;
	struct GeneralSetting *gs = (struct GeneralSetting *)cdata;

	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	ret = switchdGetAclStormPeriod(&(gs ->gdata));
	ip1811drv_dbg("cdata ->gdata=%d\n", gs ->gdata);
	FUNC_MSG_OUT;
	
	return ret;
}

int switchdSetAclStorm(int index, int value)
{
	if (index<0 || index>2) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}

	if (value & (~0xFFFF)) {
		ip1811drv_err("Error: value=%x\n", value);
		return -EINVAL;
	}
	_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 1);
	ip1811drv_dbg("index=%d\n", index);
	ip1811drv_dbg("value=0x%x\n", value);
	_WriteRegBits(1, P1REG_ACL_STORM_0+index, 0, 16, value);
	_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 0);
	return 0;
}
EXPORT_SYMBOL(switchdSetAclStorm);

int setAclStorm(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int storm_index;
	int storm_v;

	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	storm_index = ags ->index;
	storm_v = ags ->data;
	ret = switchdSetAclStorm(storm_index, storm_v);
	FUNC_MSG_OUT;

	return ret;
}

int switchdGetAclStorm(int index, int *gdata_p)
{
	if (index<0 || index>2) {
		ip1811drv_err("Error: index=%d\n", index);
		return -EINVAL;
	}
	_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 1);
	*gdata_p = _ReadRegBits(1, P1REG_ACL_STORM_0+index, 0, 16);
	_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 0);
	return 0;
}
EXPORT_SYMBOL(switchdGetAclStorm);

int getAclStorm(void *cdata, int len)
{
	int ret;
	struct AclGeneralSetting *ags = (struct AclGeneralSetting *)cdata;
	int storm_index;

	FUNC_MSG_IN;
	if (sizeof(struct AclGeneralSetting) != len) {
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}

	storm_index = ags ->index;
	ret = switchdGetAclStorm(storm_index, &(ags ->data));
	ip1811drv_dbg("cdata ->data=%d\n", ags ->data);
	FUNC_MSG_OUT;
	
	return ret;
}
//------------ ACL functions:common end  -----------------------

//------------------------------------------------
//common_bandwidth
int switchdSetBandwidthIngressRate(int port, unsigned long rate)
{
	if (port < 0 || port >= MAX_PHY_NUM)
	{
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}
	if (rate > MAX_GIGA_SPEED)
	{
		ip1811drv_err("Error: pdata=0x%08X\n", (u16)rate);
		return -EINVAL;
	}

	IP2Page(0);
	if (rate == 0 || rate == MAX_GIGA_SPEED || (port < MAX_PHY_TP_NUM && rate >= MAX_TP_SPEED))
	{	Write_Reg(P0REG_INGRESS_RATE_CTRL0+port,0);	}
	else if(rate > 0 && rate < MAX_GIGA_SPEED)
	{
		if(port < MAX_PHY_TP_NUM && rate >= (MAX_TP_SPEED/RATE_SCALE_UNIT)*RATE_SCALE_UNIT)
		{	Write_Reg(P0REG_INGRESS_RATE_CTRL0+port,0);	}
		else if(rate >= (MAX_GIGA_SPEED/RATE_SCALE_UNIT)*RATE_SCALE_UNIT)
		{	
			Write_Reg(P0REG_INGRESS_RATE_CTRL0+port,0);
#ifdef COMBINED_PORT
			if (port==9)
				Write_Reg(P0REG_INGRESS_RATE_CTRL0+port+1,0);
#endif
		}
		else
		{
			if(rate%RATE_SCALE_UNIT)
			{
				Write_Reg(P0REG_INGRESS_RATE_CTRL0+port,rate/RATE_SCALE_UNIT+1);
#ifdef COMBINED_PORT
				if (port==9)
					Write_Reg(P0REG_INGRESS_RATE_CTRL0+port+1,rate/RATE_SCALE_UNIT+1);
#endif
			}
			else
			{
				Write_Reg(P0REG_INGRESS_RATE_CTRL0+port,rate/RATE_SCALE_UNIT);
#ifdef COMBINED_PORT
				if (port==9)
					Write_Reg(P0REG_INGRESS_RATE_CTRL0+port+1,rate/RATE_SCALE_UNIT);
#endif
			}
		}
	}

	return 0;
}
EXPORT_SYMBOL(switchdSetBandwidthIngressRate);
int setBandwidthIngressRate(void *cdata, int len)
{
	int port;	//1-28
	unsigned long rate;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting32) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting32 *)cdata)->port;
	rate = ((struct ByPortSetting32 *)cdata)->pdata;

	if(switchdSetBandwidthIngressRate(port, rate) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdGetBandwidthIngressRate(int port, unsigned long *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM){
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (unsigned long)(_ReadRegBits(0, P0REG_INGRESS_RATE_CTRL0+port, 0, 14)*64000);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetBandwidthIngressRate);
int getBandwidthIngressRate(void *cdata, int len)
{
	int port;
	unsigned long rate;
	
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting32) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting32 *)cdata)->port;
	
	if(switchdGetBandwidthIngressRate(port, &rate) != 0)
		return -EINVAL;

	((struct ByPortSetting32 *)cdata)->pdata = rate;
	ip1811drv_dbg("cdata->port=%d\n", ((struct ByPortSetting32 *)cdata)->port);
	ip1811drv_dbg("cdata->pdata=0x%08X\n", (u16)((struct ByPortSetting32 *)cdata)->pdata);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetBandwidthEgressRate(int port, unsigned long rate)
{
	if (port < 0 || port >= MAX_PHY_NUM)
	{
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}
	if (rate > MAX_GIGA_SPEED)
	{
		ip1811drv_err("Error: pdata=0x%08X\n", (u16)rate);
		return -EINVAL;
	}
	IP2Page(8);
	if (rate == 0 || rate == MAX_GIGA_SPEED || (port < MAX_PHY_TP_NUM && rate >= MAX_TP_SPEED))
	{	Write_Reg(P8REG_EGRESS_RATE_CTRL0+port,0);	}
	else if(rate > 0 && rate < MAX_GIGA_SPEED)
	{
		if(port < MAX_PHY_TP_NUM && rate >= (MAX_TP_SPEED/RATE_SCALE_UNIT)*RATE_SCALE_UNIT)
		{	Write_Reg(P8REG_EGRESS_RATE_CTRL0+port,0);	}
		else if(rate >= (MAX_GIGA_SPEED/RATE_SCALE_UNIT)*RATE_SCALE_UNIT)
		{	
			Write_Reg(P8REG_EGRESS_RATE_CTRL0+port,0);
#ifdef COMBINED_PORT
			if (port==9)
				Write_Reg(P8REG_EGRESS_RATE_CTRL0+port+1,0);
#endif
		}
		else
		{
			if(rate%RATE_SCALE_UNIT)
			{
				Write_Reg(P8REG_EGRESS_RATE_CTRL0+port,rate/RATE_SCALE_UNIT+1);
#ifdef COMBINED_PORT
				if (port==9)
					Write_Reg(P8REG_EGRESS_RATE_CTRL0+port+1,rate/RATE_SCALE_UNIT+1);
#endif
			}
			else
			{
				Write_Reg(P8REG_EGRESS_RATE_CTRL0+port,rate/RATE_SCALE_UNIT);
#ifdef COMBINED_PORT
				if (port==9)
					Write_Reg(P8REG_EGRESS_RATE_CTRL0+port+1,rate/RATE_SCALE_UNIT+1);
#endif
			}
		}
	}

	return 0;
}
EXPORT_SYMBOL(switchdSetBandwidthEgressRate);
int setBandwidthEgressRate(void *cdata, int len)
{
	int port;
	unsigned long rate;
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting32) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting32 *)cdata)->port;
	rate = ((struct ByPortSetting32 *)cdata)->pdata;
	
	if(switchdSetBandwidthEgressRate(port, rate) != 0)
		return -EINVAL;
		
	FUNC_MSG_OUT;
	return 0;
}

int switchdGetBandwidthEgressRate(int port, unsigned long *ptrInt)
{
	if (port < 0 || port >= MAX_PHY_NUM){
		ip1811drv_err("Error: port=%d\n", port);
		return -EINVAL;
	}
	ip1811drv_dbg("port=%d\n", port);

#ifdef COMBINED_PORT
	if (port==9 && _ReadRegBits(3, 0x15, 0, 1)) //port==9 && port10 link
		port++;
#endif
	*ptrInt = (unsigned long)(_ReadRegBits(8, P8REG_EGRESS_RATE_CTRL0+port, 0, 14)*64000);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetBandwidthEgressRate);
int getBandwidthEgressRate(void *cdata, int len)
{
	int port;
	unsigned long rate;
	
	FUNC_MSG_IN;
	if (sizeof(struct ByPortSetting32) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	port = ((struct ByPortSetting32 *)cdata)->port;
	
	if(switchdGetBandwidthEgressRate(port, &rate) != 0)
		return -EINVAL;

	((struct ByPortSetting32 *)cdata)->pdata = rate;
	ip1811drv_dbg("cdata->port=%d\n", ((struct ByPortSetting32 *)cdata)->port);
	ip1811drv_dbg("cdata->pdata=0x%08X\n", (u16)((struct ByPortSetting32 *)cdata)->pdata);
	FUNC_MSG_OUT;
	return 0;
}

int switchdSetBandwidthEgressPeriod(int period)
{
	if (period < 0 || period > 7){
		ip1811drv_err("Error: gdata=%d\n", period);
		return -EINVAL;
	}
	_WriteRegBits(8, P8REG_OUT_QUEUE_PARAM, 4, 3, period);

	return 0;
}
EXPORT_SYMBOL(switchdSetBandwidthEgressPeriod);
int setBandwidthEgressPeriod(void *cdata, int len)
{
	int period;
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len)
	{
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	
	period = ((struct GeneralSetting *)cdata)->gdata;
	
	if(switchdSetBandwidthEgressPeriod(period) != 0)
		return -EINVAL;

	FUNC_MSG_OUT;
	return 0;
}

int switchdGetBandwidthEgressPeriod(int *ptrInt)
{
	*ptrInt = (int)_ReadRegBits(8,P8REG_OUT_QUEUE_PARAM,4,3);

	ip1811drv_dbg("cdata ->pdata=%d\n", *ptrInt);

	return 0;
}
EXPORT_SYMBOL(switchdGetBandwidthEgressPeriod);
int getBandwidthEgressPeriod(void *cdata, int len)
{
	int period=0;
	
	FUNC_MSG_IN;
	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	
	if(switchdGetBandwidthEgressPeriod(&period) != 0)
		return -EINVAL;

	((struct GeneralSetting *)cdata)->gdata = period;
	
	ip1811drv_dbg("cdata->gdata=0x%08X\n", ((struct GeneralSetting *)cdata)->gdata);
	FUNC_MSG_OUT;
	return 0;
}

//------------ EEPROM functions:common start  -----------------
#define CMD_EEPROM_READ		0x8000
#define CMD_EEPROM_WRITE	0xC000
#define EEPROM_BIT_COMPLETE	0x8000
#define REG_RETRY_COUNT		200

u8 EE_Type = OP_EE_TYPE_Unknow;
u8 EE_Data [OP_EEPROM_LEN_24C32] = {0x0};
u8 EE_Flag [OP_EEPROM_LEN_24C32] = {0x0};

u8 getEepromType(void)
{
	unsigned short val, i;
	
	IP2Page(0xE);
	Write_Reg(PEREG_EEPROM_CMD+1, (unsigned short)(Read_Reg(PEREG_EEPROM_CMD+1)&0xFF00));
	IP2Page(0xE);
	Write_Reg(PEREG_EEPROM_CMD, (CMD_EEPROM_READ + 0x1));

	IP2Page(0xE);
	val = Read_Reg(PEREG_EEPROM_CMD);
	for(i = 0 ; 0 == (val&EEPROM_BIT_COMPLETE) && i < REG_RETRY_COUNT ; i++)
	{
		IP2Page(0xE);
		val = Read_Reg(PEREG_EEPROM_CMD);
	}
			
	if(i == REG_RETRY_COUNT)
	{
		ip1811drv_err("Error: get EEPROM type REG_RETRY_COUNT reached\n");
		return -EINVAL;
	}
		
	IP2Page(0xE);
	val = Read_Reg(PEREG_EEPROM_DATA) & 0xFF;
	
	udelay(5000);
	
	if(val == 0x0B)
		return OP_EE_TYPE_C16;
	else if(val == 0x0D)
		return OP_EE_TYPE_C32;
	else
		return OP_EE_TYPE_Unknow;
}

// EEPROM READ/WRITE
int setEepromByte(void *cdata, int len)
{
	unsigned short addr2write, i, val;
	unsigned char val2write;
	
	FUNC_MSG_IN;
	if (sizeof(struct EepromSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	
	if(EE_Type==OP_EE_TYPE_Unknow)
	{
		EE_Type = getEepromType();
		if(EE_Type==OP_EE_TYPE_Unknow)
		{
			ip1811drv_err("Error: setEEPROM get type failed\n");
			return -EINVAL;
		}
		ip1811drv_dbg("set EEPROM type->%X\n", EE_Type);
	}
	
	addr2write = ((struct EepromSetting *)cdata)->addr;
	val2write = ((struct EepromSetting *)cdata)->value;
	if (addr2write > (EE_Type?OP_EEPROM_LEN_24C32:OP_EEPROM_LEN_24C16))
	{
		ip1811drv_err("Error: addr=0x%04X\n", addr2write);
		return -EINVAL;
	}
	ip1811drv_dbg("type %X set addr:%04X , value:%02X\n", EE_Type, addr2write, val2write);
	
	// update eeprom hardware
	IP2Page(0xE);
	Write_Reg(PEREG_EEPROM_DATA, val2write);
	IP2Page(0xE);
	if(EE_Type==OP_EE_TYPE_C16)
	{
		Write_Reg(PEREG_EEPROM_CMD, (CMD_EEPROM_WRITE + addr2write));
	}
	else
	{
		Write_Reg(PEREG_EEPROM_CMD+1, (unsigned short)((Read_Reg(PEREG_EEPROM_CMD+1)&0xFF00)|((addr2write>>8)&0xFF)));
		IP2Page(0xE);
		Write_Reg(PEREG_EEPROM_CMD, (CMD_EEPROM_WRITE + (addr2write&0xFF)));
	}
	
	IP2Page(0xE);
	val = Read_Reg(PEREG_EEPROM_CMD);
	for(i = 0 ; 0 == (val&EEPROM_BIT_COMPLETE) && i < REG_RETRY_COUNT ; i++)
	{
		IP2Page(0xE);
		val = Read_Reg(PEREG_EEPROM_CMD);
	}
		
	if(i == REG_RETRY_COUNT)
	{
		ip1811drv_err("Error: set EEPROM REG_RETRY_COUNT reached %04X\n", addr2write);
		return -EINVAL;
	}
	
//	udelay(5000);
	
	// update eeprom driver mem
	EE_Flag[addr2write] = 0x1;
	EE_Data[addr2write] = val2write;

	ip1811drv_dbg("EE set done\n");
	FUNC_MSG_OUT;
	return 0;
}

int getEepromByte(void *cdata, int len)
{
	unsigned short addr2read, i, val;
	unsigned char val2return;
	
	FUNC_MSG_IN;
	if (sizeof(struct EepromSetting) != len)
	{
		ip1811drv_err("Error: length=%d\n", len);
		return -EINVAL;
	}
	
	if(EE_Type==OP_EE_TYPE_Unknow)
	{
		EE_Type = getEepromType();
		if(EE_Type==OP_EE_TYPE_Unknow)
		{
			ip1811drv_err("Error: getEEPROM get type failed\n");
			return -EINVAL;
		}
		ip1811drv_dbg("set EEPROM type->%X\n", EE_Type);
	}
	
	addr2read = ((struct EepromSetting *)cdata)->addr;
	if (addr2read > (EE_Type?OP_EEPROM_LEN_24C32:OP_EEPROM_LEN_24C16))
	{
		ip1811drv_err("Error: addr=0x%04X\n", addr2read);
		return -EINVAL;
	}
	ip1811drv_dbg("type %X get addr:%04X\n", EE_Type, addr2read);
	
	if(EE_Flag[addr2read]==0x1) // return driver value
	{
		val2return = EE_Data[addr2read];
	}
	else // update driver memory
	{
		IP2Page(0xE);
		if(EE_Type==OP_EE_TYPE_C16)
		{
			Write_Reg(PEREG_EEPROM_CMD, (CMD_EEPROM_READ + addr2read));
		}
		else
		{
			Write_Reg(PEREG_EEPROM_CMD+1, (unsigned short)((Read_Reg(PEREG_EEPROM_CMD+1)&0xFF00)|((addr2read>>8)&0xFF)));
			IP2Page(0xE);
			Write_Reg(PEREG_EEPROM_CMD, (CMD_EEPROM_READ + (addr2read & 0xFF)));
		}
		
		IP2Page(0xE);
		val = Read_Reg(PEREG_EEPROM_CMD);
		for(i = 0 ; 0 == (val&EEPROM_BIT_COMPLETE) && i < REG_RETRY_COUNT ; i++)
		{
			IP2Page(0xE);
			val = Read_Reg(PEREG_EEPROM_CMD);
		}
			
		if(i == REG_RETRY_COUNT)
		{
			ip1811drv_err("Error: get EEPROM REG_RETRY_COUNT reached %04X\n", addr2read);
			return -EINVAL;
		}
		
		IP2Page(0xE);
		val2return = Read_Reg(PEREG_EEPROM_DATA) & 0xFF;
		
		EE_Flag[addr2read] = 0x1;
		EE_Data[addr2read] = val2return;
		
//		udelay(5000);
	}

	((struct EepromSetting *)cdata)->value = val2return;
	ip1811drv_dbg("EE get done and value:%04X\n", val2return);
	FUNC_MSG_OUT;
	return 0;
}
//------------ EEPROM functions:common end  -----------------

//------------ HSR functions:common Start  -----------------------
int setHSREnable(void *cdata, int len)
{
	int ret;

	FUNC_MSG_IN;
	ret = _setGeneralEnable(cdata, len, 0x02, P2REG_HSR_REG_SETTING_1, 0);
	FUNC_MSG_OUT;

	return ret;
}

int getHSREnable(void *cdata, int len)
{
	int ret;

	FUNC_MSG_IN;
	ret = _getGeneralEnable(cdata, len, 0x02, P2REG_HSR_REG_SETTING_1, 0);
	FUNC_MSG_OUT;

	return ret;
}

int switchdSetHSRMode(int mode)
{
	if( mode != OP_HSR_MANDATORY && mode != OP_HSR_UNICAST ){
		ip1811drv_err("Error: mode=%X\n", mode);
		return -EINVAL;
	}

	ip1811drv_dbg("cdata ->mode=%d\n", mode);

	if(mode==OP_HSR_MANDATORY){
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_1, 10, 2, 0x3);
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_2, 8, 1, 0x1);
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_2, 11, 1, 0x1);
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_2, 0, 2, 0x0);
		_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 0x1);
		IP2Page(0x1);
		Write_Reg(P1REG_LUTAGINGTIME, 0x0003);
		_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 0x0);
	}
	else if(mode==OP_HSR_UNICAST){
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_1, 10, 2, 0x3);
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_2, 8, 1, 0x1);
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_2, 11, 1, 0x1);
		_WriteRegBits(2, P2REG_HSR_REG_SETTING_2, 0, 2, 0x3);
		_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 0x1);
		IP2Page(0x1);
		Write_Reg(P1REG_LUTAGINGTIME, 0x00A3);
		_WriteRegBits(1, P1REG_MISCCFG, 13, 1, 0x0);
	}

	return 0;
}
EXPORT_SYMBOL(switchdSetHSRMode);
int setHSRMode(void *cdata, int len)
{
	int gdata;

	if (sizeof(struct GeneralSetting) != len){
		ip1811drv_err("Error: lengtn=%d\n", len);
		return -EINVAL;
	}
	gdata = ((struct GeneralSetting *)cdata) ->gdata;

	FUNC_MSG_IN;
	if(switchdSetHSRMode(gdata) != 0)
		return -EINVAL;
	FUNC_MSG_OUT;
	
	return 0;
}

void switchdGetHSRMode(int *ptrInt)
{
	int val;
	
	val=(int)_ReadRegBits(2, P2REG_HSR_REG_SETTING_2, 0, 2);
	if(val==0x3)
		*ptrInt = OP_HSR_MANDATORY;
	else if(val==0x0)
		*ptrInt = OP_HSR_UNICAST;
}
EXPORT_SYMBOL(switchdGetHSRMode);
int getHSRMode(void *cdata, int len)
{
	int ret;

	ip1811drv_dbg("ip1811: +getHSRMode...\n");
	if (sizeof(struct GeneralSetting) != len)
		return -EINVAL;

	FUNC_MSG_IN;
	switchdGetHSRMode(&ret);
	FUNC_MSG_OUT;

	((struct GeneralSetting *)cdata) ->gdata = ret;

	ip1811drv_dbg("cdata ->gdata=%d\n", ((struct GeneralSetting *)cdata) ->gdata);
	ip1811drv_dbg("ip1811: -getHSRMode...\n");
	return 0;
}
//------------ HSR functions:common end  -----------------------

void noFunc(void)
{}