UTS6710/drivers/i2c/i2cap/i2cap.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
//#include <curses.h>
#include <drv_i2c_external.h>
#include <unistd.h>

typedef enum
{
	TYPE_M0_100K_MODE=0,
	TYPE_M0_400K_MODE,
	TYPE_M1_100K_MODE,
	TYPE_M1_400K_MODE,
	TYPE_SW_MODE
}TYPE_MODE;
/*
0: Master0 100K
1: Master0 400K
2: Master1 100K
3: Master1 400K
other value: Software Mode
*/

#define SH3_CPU
#define i2cmmap	1

#define I2C_HARDWARE_MODE_MASTER 0
#define I2C_SOFTWARE_MODE_MASTER 1
#define I2C_MODE I2C_HARDWARE_MODE_MASTER
unsigned char revert_print=0;
unsigned char reverse(unsigned char b) {
       b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
          b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
             b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
                return b;
}
unsigned char StrToHexFun(char *ch)
{
	int		i;
	unsigned char	Result,tmp;

	Result = 0;
	for(i=0;i<2;i++)
	{
		if(i==0)
		{
			tmp = 16;
		}
		else
		{
			tmp = 1;
		}
		if(ch[i]>='0' && ch[i]<='9')
		{
			Result += (ch[i]-'0')*tmp;
		}
		else if(ch[i]>='a' && ch[i]<='f')
		{
			Result += (ch[i]-'a'+10)*tmp;
		}
		else if(ch[i]>='A' && ch[i]<='F')
		{
			Result += (ch[i]-'A'+10)*tmp;
		}
		else
		{
			printf("StrToHexFun:Invalid value!\n");
			return 0;
		}
	}
	return Result;
}

unsigned char I2cReadByteFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char Addr)
{
	unsigned char Info[2];
	Info[0]=Id;
	Info[1]=Addr;
	if(I2cMode==TYPE_M0_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_READ_BYTE_100K,&Info[0])<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xff;
		}
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_READ_BYTE_400K,&Info[0])<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xff;
		}
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_READ_BYTE_100K,&Info[0])<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xff;
		}
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_READ_BYTE_400K,&Info[0])<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xff;
		}
	}
	else
	{
		if(ioctl(fd,IOC_SW_I2C_MASTER0_READ_BYTE,&Info[0])<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xff;
		}
	}
	return Info[0];
}

unsigned short I2cReadWordFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char Addr)
{
	unsigned short Info;
	Info = (unsigned short)Id | ((unsigned short)Addr)<<8;
	if(I2cMode==TYPE_M0_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_READ_WORD_100K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffff;
		}
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_READ_WORD_400K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffff;
		}
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_READ_WORD_100K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffff;
		}
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_READ_WORD_400K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffff;
		}
	}
	else
	{
		printf("Not Support\n");
		return 0xffff;
	}
	return Info;
}

unsigned int I2cReadDwordFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char Addr)
{
	unsigned int Info;
	Info = (unsigned int)Id | ((unsigned int)Addr)<<8;
	if(I2cMode==TYPE_M0_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_READ_DWORD_100K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffffffff;
		}
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_READ_DWORD_400K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffffffff;
		}
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_READ_DWORD_100K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffffffff;
		}
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_READ_DWORD_400K,&Info)<0)
		{
			printf("Read 0x%02x 0x%02x fails!! : ",Id,Addr);
			return 0xffffffff;
		}
	}
	else
	{
		printf("Not Support\n");
		return 0xffffffff;
	}
	return Info;
}

void GPIOI2cReadFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,unsigned int Addr,int Length)
{
	I2C_INFO	I2cInfo;
	unsigned char *pData;
	int i;

//	printf("fd=%d i2cmode=%d id=%02x AddrType=%d Addr=%02x Length=%d\n",fd,I2cMode,Id,BaseAddrType,Addr,Length);
//	return;
	if(Length < 0)
	{
		printf("Invalid Length %d\n",Length);
		return;
	}

	memset(&I2cInfo,0,sizeof(I2C_INFO));

	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
		return;
	}

	pData = malloc(Length);
	if(!pData)
	{
		printf("No enough memory\n");
		return;
	}

	I2cInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cInfo.BaseAddress=0;
	}
	else
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
		I2cInfo.BaseAddress=Addr;
	}
	I2cInfo.Data = pData;
	I2cInfo.DataLength = (unsigned short)Length;
	if(ioctl(fd,IOC_GPIOI2C_MASTER_READ,&I2cInfo)<0)
	{
		printf("Read ID 0x%02x fails!!\n",Id);
		free(pData);
		return;
	}

	if(BaseAddrType==ADDRESS_TYPE_NONE)
		printf("Read ID=0x%02x, Length=%d\n",Id,Length);
	else
		printf("Read ID=0x%02x Addr=0x%02x Length=%d\n",Id,Addr,Length);

	for(i=0;i<Length;)
	{
		if (revert_print==1)
            printf("%02x ",reverse(pData[i]));
        else    
            printf("%02x ",pData[i]);
		i++;
		if((i&0xF)==0)
			printf("\n");
		else if((i&3)==0)
			printf("  ");
	}
	if((i&0xF)!=0)
		printf("\n");
	free(pData);
}
void I2cReadFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,unsigned int Addr,int Length)
{
	I2C_INFO	I2cInfo;
	unsigned char *pData;
	int i;

//	printf("fd=%d i2cmode=%d id=%02x AddrType=%d Addr=%02x Length=%d\n",fd,I2cMode,Id,BaseAddrType,Addr,Length);
//	return;
	if(Length < 0)
	{
		printf("Invalid Length %d\n",Length);
		return;
	}

	memset(&I2cInfo,0,sizeof(I2C_INFO));

	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
		return;
	}

	pData = malloc(Length);
	if(!pData)
	{
		printf("No enough memory\n");
		return;
	}

	I2cInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cInfo.BaseAddress=0;
	}
	else
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
		I2cInfo.BaseAddress=Addr;
	}
	I2cInfo.Data = pData;
	I2cInfo.DataLength = (unsigned short)Length;
	if(ioctl(fd,IOC_I2C_MASTER_READ,&I2cInfo)<0)
	{
		printf("Read ID 0x%02x fails!!\n",Id);
		free(pData);
		return;
	}

	if(BaseAddrType==ADDRESS_TYPE_NONE)
		printf("Read ID=0x%02x, Length=%d\n",Id,Length);
	else
		printf("Read ID=0x%02x Addr=0x%02x Length=%d\n",Id,Addr,Length);

	for(i=0;i<Length;)
	{
		if (revert_print==1)
            printf("%02x ",reverse(pData[i]));
        else    
            printf("%02x ",pData[i]);
		i++;
		if((i&0xF)==0)
			printf("\n");
		else if((i&3)==0)
			printf("  ");
	}
	if((i&0xF)!=0)
		printf("\n");
	free(pData);
}

void I2cSwReadFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,unsigned int Addr,int Length)
{
	I2C_INFO	I2cInfo;
	unsigned char *pData;
	int i;

//	printf("fd=%d i2cmode=%d id=%02x AddrType=%d Addr=%02x Length=%d\n",fd,I2cMode,Id,BaseAddrType,Addr,Length);
//	return;
	if(Length < 0)
	{
		printf("Invalid Length %d\n",Length);
		return;
	}

	memset(&I2cInfo,0,sizeof(I2C_INFO));

	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
		return;
	}

	pData = malloc(Length);
	if(!pData)
	{
		printf("No enough memory\n");
		return;
	}

	I2cInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cInfo.BaseAddress=0;
	}
	else
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
		I2cInfo.BaseAddress=Addr;
	}
	I2cInfo.Data = pData;
	I2cInfo.DataLength = (unsigned short)Length;
	if(ioctl(fd,IOC_SW_I2C_MASTER_READ,&I2cInfo)<0)
	{
		printf("Read ID 0x%02x fails!!\n",Id);
		free(pData);
		return;
	}

	if(BaseAddrType==ADDRESS_TYPE_NONE)
		printf("Read ID=0x%02x, Length=%d\n",Id,Length);
	else
		printf("Read ID=0x%02x Addr=0x%02x Length=%d\n",Id,Addr,Length);

	for(i=0;i<Length;)
	{
		if (revert_print==1)
            printf("%02x ",reverse(pData[i]));
        else    
            printf("%02x ",pData[i]);
		i++;
		if((i&0xF)==0)
			printf("\n");
		else if((i&3)==0)
			printf("  ");
	}
	if((i&0xF)!=0)
		printf("\n");
	free(pData);
}

void I2cReadMultiAddrFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,int AddrLength,int DataLength,char *Str)
{
	I2C_TEMP_INFO	I2cTempInfo;
	unsigned char *pData;
	unsigned char Addr[4];
	int i;

//	printf("fd=%d i2cmode=%d id=%02x AddrType=%d Addr=%02x Length=%d\n",fd,I2cMode,Id,BaseAddrType,Addr,Length);
//	return;
	if(DataLength < 0)
	{
		printf("Invalid Data Length %d\n",DataLength);
		return;
	}

	memset(&I2cTempInfo,0,sizeof(I2C_TEMP_INFO));

	for(i=0;i<AddrLength;i++)
	{
		Addr[i] = StrToHexFun(&Str[i*2]);
		printf("Addr[%d]=0x%02x\n",i,Addr[i]);
	}


	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cTempInfo.MasterIndex=0;
		I2cTempInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cTempInfo.MasterIndex=0;
		I2cTempInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cTempInfo.MasterIndex=1;
		I2cTempInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cTempInfo.MasterIndex=1;
		I2cTempInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
		return;
	}

	pData = malloc(DataLength);
	if(!pData)
	{
		printf("No enough memory\n");
		return;
	}

	I2cTempInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cTempInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cTempInfo.BaseAddress=0;
	}
	else
	{
		if (AddrLength ==4)
		{
			I2cTempInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
			AddrLength =4;
			I2cTempInfo.BaseAddress=(unsigned long)(Addr[0]<<24)|(unsigned long)(Addr[1]<<16)|(unsigned long)(Addr[2]<<8)|(unsigned long)(Addr[3]);
		}
		else if (AddrLength ==2)
		{
			I2cTempInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
			I2cTempInfo.AddrLength =2;
			I2cTempInfo.BaseAddress=(unsigned long)(Addr[0]<<8)|(unsigned long)(Addr[1]);
		}
		else if (AddrLength ==1)
		{
			I2cTempInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
			I2cTempInfo.AddrLength =1;
			I2cTempInfo.BaseAddress=(unsigned long)(Addr[0]);
		}
		else
		{
			printf("Invalid Address Length %d\n",AddrLength);
		}
	}
	//printf("Addr=0x%08x \n",I2cTempInfo.BaseAddress);
	I2cTempInfo.Data = pData;
	I2cTempInfo.DataLength = DataLength;

#if (I2C_MODE==I2C_HARDWARE_MODE_MASTER)
	printf("I2C_HARDWARE_MODE_MASTER\n");
	if (AddrLength > 3)
	{
		printf("I2c hardware mode can't support more than 3 bytes address!!");
		free(pData);
		return;
	}
	if (AddrLength ==3)
	{
		I2cTempInfo.BaseAddress =0x03000000| (unsigned long)(Addr[0]<<16)|(unsigned long)(Addr[1]<<8)|(unsigned long)(Addr[2]);
	}
	else if (AddrLength ==2)
	{
		I2cTempInfo.BaseAddress=0x02000000|(unsigned long)(Addr[0]<<8)|(unsigned long)(Addr[1]);
	}
	else if (AddrLength ==1)
	{
		I2cTempInfo.BaseAddress=0x01000000|(unsigned long)(Addr[0]);
	}

	#if 0 //20140725
	if(ioctl(fd,IOC_I2C_MASTER_READ_MULTI_ADDR,&I2cTempInfo)<0)
	{
		printf("Read ID 0x%02x fails!!\n",Id);
		free(pData);
		return;
	}
	#endif

#elif (I2C_MODE==I2C_SOFTWARE_MODE_MASTER)
	printf("I2C_SOFTWARE_MODE_MASTER\n");
	
	if(ioctl(fd,IOC_SW_I2C_MASTER_READ_TEMP,&I2cTempInfo)<0)
	{
		printf("Read ID 0x%02x fails!!\n",Id);
		free(pData);
		return;
	}
#endif

/*	if(BaseAddrType==ADDRESS_TYPE_NONE)
		printf("Read ID=0x%02x, Length=%d\n",Id,Length);
	else
		printf("Read ID=0x%02x Addr=0x%08x Length=%d\n",Id,Addr,Length);
*/
	for(i=0;i<DataLength;)
	{
		printf("%02x ",pData[i]);
		i++;
		if((i&0xF)==0)
			printf("\n");
		else if((i&3)==0)
			printf("  ");
	}
	if((i&0xF)!=0)
		printf("\n");   
	free(pData);
	
}


void I2cWriteByteFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char Addr,unsigned char Data)
{
	unsigned char Info[3];
	Info[0]=Id;
	Info[1]=Addr;
	Info[2]=Data;
	if(I2cMode==TYPE_M0_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_100K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%02x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_400K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%02x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_WRITE_BYTE_100K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%02x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_WRITE_BYTE_400K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%02x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else
	{
		if(ioctl(fd,IOC_SW_I2C_MASTER0_WRITE_BYTE,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%02x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
}

void I2cWriteWordFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char Addr,unsigned short Data)
{
	unsigned char Info[4];
	Info[0]=Id;
	Info[1]=Addr;
	memcpy(&Info[2],&Data,sizeof(Data));
	if(I2cMode==TYPE_M0_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_100K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%04x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_400K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%04x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_WRITE_WORD_100K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%04x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_WRITE_WORD_400K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%04x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else
	{
		printf("Not Support\n");
	}
}

void I2cWriteDwordFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char Addr,unsigned int Data)
{
	unsigned char Info[6];
	Info[0]=Id;
	Info[1]=Addr;
	memcpy(&Info[2],&Data,sizeof(Data));
	if(I2cMode==TYPE_M0_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_DWORD_100K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%08x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_DWORD_400K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%08x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_WRITE_DWORD_100K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%08x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		if(ioctl(fd,IOC_I2C_MASTER1_WRITE_DWORD_400K,&Info[0])<0)
		{
			printf("Write 0x%02x 0x%02x 0x%08x fails!!\n",Id,Addr,Data);
		}
		else
		{
			printf("Write OK\n");
		}
	}
	else
	{
		printf("Not Support\n");
	}
}

void GPIOI2cWriteFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,unsigned int Addr,char *Str)
{
	I2C_INFO	I2cInfo;
	unsigned char Data[128];
	unsigned short len;
	int i;
	//printf("[I2CAP] ==> I2cWriteFun!!   Addr = 0x%02x\n", BaseAddrType ,Addr);

	len = strlen(Str);
	printf("%s,len=%u\n",Str,len);
	if((len%2)!=0 || len>256)
	{
		printf("Invalid Data Length %u\n",len);
		return;
	}

	memset(&I2cInfo,0,sizeof(I2C_INFO));

	for(i=0;i<128&&i*2<len;i++)
	{
		Data[i] = StrToHexFun(&Str[i*2]);
		printf("Data[%d]=0x%02x\n",i,Data[i]);
	}

	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
	}
	I2cInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cInfo.BaseAddress=0;
	}
	else
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
		I2cInfo.BaseAddress=Addr;
	}
	I2cInfo.Data=Data;
	I2cInfo.DataLength=len/2;
	if(ioctl(fd,IOC_GPIOI2C_MASTER_WRITE,&I2cInfo)<0)
	{
		printf("Write 0x%02x fails!!\n",Id);
	}
	else
	{
		printf("Write OK\n");
	}
}
void I2cWriteFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,unsigned int Addr,char *Str)
{
	I2C_INFO	I2cInfo;
	unsigned char Data[128];
	unsigned short len;
	int i;
	//printf("[I2CAP] ==> I2cWriteFun!!   Addr = 0x%02x\n", BaseAddrType ,Addr);

	len = strlen(Str);
	printf("%s,len=%u\n",Str,len);
	if((len%2)!=0 || len>256)
	{
		printf("Invalid Data Length %u\n",len);
		return;
	}

	memset(&I2cInfo,0,sizeof(I2C_INFO));

	for(i=0;i<128&&i*2<len;i++)
	{
		Data[i] = StrToHexFun(&Str[i*2]);
		printf("Data[%d]=0x%02x\n",i,Data[i]);
	}

	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
	}
	I2cInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cInfo.BaseAddress=0;
	}
	else
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_MULTIPLE;
		I2cInfo.BaseAddress=Addr;
	}
	I2cInfo.Data=Data;
	I2cInfo.DataLength=len/2;
	if(ioctl(fd,IOC_I2C_MASTER_WRITE,&I2cInfo)<0)
	{
		printf("Write 0x%02x fails!!\n",Id);
	}
	else
	{
		printf("Write OK\n");
	}
}

void I2cWriteDataFun(int fd,TYPE_MODE I2cMode,unsigned char Id,unsigned char BaseAddrType,unsigned char Addr,int DataLength,unsigned char *pData)
{
	I2C_INFO	I2cInfo;
	//unsigned short len;
	//int i;


	if(I2cMode==TYPE_M0_100K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M0_400K_MODE)
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else if(I2cMode==TYPE_M1_100K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_100K;
	}
	else if(I2cMode==TYPE_M1_400K_MODE)
	{
		I2cInfo.MasterIndex=1;
		I2cInfo.Speed=I2C_SPEED_400K;
	}
	else
	{
		printf("Not Support\n");
	}
	I2cInfo.SlaveAddress=Id;
	if(BaseAddrType==ADDRESS_TYPE_NONE)
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
		I2cInfo.BaseAddress=0;
	}
	else
	{
		I2cInfo.BaseAddrType=ADDRESS_TYPE_BYTE;
		I2cInfo.BaseAddress=Addr;
	}
	I2cInfo.Data=pData;
	I2cInfo.DataLength=DataLength;
	if(ioctl(fd,IOC_I2C_MASTER_WRITE,&I2cInfo)<0)
	{
		printf("Write byte data 0x%02x fails!!\n",Id);
	}
	else
	{
		printf("Write OK\n");
	}
}

void I2cReadEEPROM(int fd, unsigned char deviceID,unsigned int addr, unsigned int len, const char* Filename)
{
	FILE			*pFile;
    I2C_INFO	I2cInfo;
    unsigned char *pData;
    unsigned int i=0;
    int res=0;

	memset(&I2cInfo,0,sizeof(I2C_INFO));
	{
		I2cInfo.MasterIndex=0;
		I2cInfo.Speed=I2C_SPEED_100K;
	}

	pData = malloc(len);
	if(!pData)
	{
		printf("No enough memory\n");
		return;
	}

	I2cInfo.SlaveAddress = deviceID;
	I2cInfo.BaseAddrType = ADDRESS_TYPE_MULTIPLE;

	pFile = fopen(Filename,"wb");
	if(pFile)
	{
        for( i=0 ; i<len ; i+=16)
        {
	        I2cInfo.BaseAddress  = 0x02000000|(((addr+i)& 0xff00) >> 8)|(((addr+i)& 0x00ff) << 8); 
            I2cInfo.Data         = pData+i;
            I2cInfo.DataLength   = 16;
            if(ioctl(fd,IOC_I2C_MASTER_READ,&I2cInfo)<0)
            {
                printf("Read ID 0x%02x fails!!\n",deviceID);
                free(pData);
                fclose(pFile);
                return;
            }
        }
        res = fwrite(pData,1,len,pFile);
		if(res!=(int)len)
        {
            printf("fwrite error %d \n", res);
        }
		fclose(pFile);
	}
    else
    {
        printf("open file error\n");
    }

    free(pData);
}
void I2cWriteEEPROM(int fd, unsigned char deviceID,unsigned int addr, unsigned int len, const char* Filename)
{
    unsigned char	*pData;
    I2C_INFO		I2cInfo;
    FILE			*pFile;
    int res=0;
    int i=0;
    unsigned char  DataBuff[18]={0};
    unsigned short targetAddr=0;

    pData = malloc(len);
    if(pData==NULL)
    {
        printf("%s %d No Resource!\n",__FUNCTION__,__LINE__);
        return;
    }
    memset(pData,0,len);

    pFile = fopen(Filename,"rb");
    if(pFile)
    {
        memset(&I2cInfo,0,sizeof(I2C_INFO));
        I2cInfo.MasterIndex=0;
        I2cInfo.SlaveAddress=deviceID;
        I2cInfo.Speed=I2C_SPEED_100K;
        I2cInfo.BaseAddrType=ADDRESS_TYPE_NONE;
        //I2cInfo.Data=pData;
        //I2cInfo.DataLength= len+2;

        res = fread(pData, 1, len, pFile);
        if(res!=(int)len)
        {
            printf("fread ret %d \n", res);
        }

        I2cInfo.Data         = DataBuff;
        for( i=0 ; i<(int)len ; i+=16)
        {
            I2cInfo.DataLength   = 16+2;
        
            targetAddr = addr + i;
            DataBuff[0] = (targetAddr & 0xff00)>>8;
            DataBuff[1] = (targetAddr & 0xff);
            memcpy(DataBuff+2,pData+i,sizeof(char)*16);
            if(ioctl(fd,IOC_I2C_MASTER_WRITE,&I2cInfo)<0)
            {
                printf("Write [%d][%d] fails!!\n",addr,len);
            }
            usleep(5000);
        }
        fclose(pFile);
    }
    printf("Load File %s, Size=%d\n",Filename,len);
    free(pData);
}
void I2cDumpMemFun(int fd, unsigned long Address, int Length)
{
	I2C_DUMP I2cDump;

//	printf("%s Addr=0x%08x Length=%u\n",__FUNCTION__,Address,Length);
	if(Length<0)
	{
		printf("Invalid Length %d",Length);
		return;
	}

	I2cDump.Addr = (void *)Address;
	I2cDump.Length = Length;
	if(ioctl(fd,IOC_I2C_DUMP_MEM,&I2cDump)<0)
	{
		printf("dump memory Addr=0x%08lx Len=%d fails!! \n",Address,Length);
	}
}

#ifdef SH3_CPU

#define CHECK_DATA				0
#define BURST_MODE				1
#define BURST_MODE_SIZE			0x8000
#define MAX_ROM_SIZE			0x10000
#define MAX_RAM_SIZE			0x8000

#define ___swab32(x) \
({ \
	unsigned int __x = (x); \
	((unsigned int)( \
		(((unsigned int)(__x) & (unsigned int)0x000000ffUL) << 24) | \
		(((unsigned int)(__x) & (unsigned int)0x0000ff00UL) <<  8) | \
		(((unsigned int)(__x) & (unsigned int)0x00ff0000UL) >>  8) | \
		(((unsigned int)(__x) & (unsigned int)0xff000000UL) >> 24) )); \
})

void RunBinaryFun(int fd, unsigned char DeviceID, const char* Filename)
{
#if BURST_MODE
	unsigned char	*pData;
	unsigned int	tmpData;
	I2C_INFO		I2cInfo;
	FILE			*pFile;
	int				Addr;

	pData = malloc(BURST_MODE_SIZE+0x10);
	if(pData==NULL)
	{
		printf("%s %d No Resource!\n",__FUNCTION__,__LINE__);
		return;
	}

	pFile = fopen(Filename,"rb");
	if(pFile)
	{
	    unsigned char Info[4];
        int Length;

		Info[0] = DeviceID;
		Info[1] = 0x01;
		Info[2] = 0xDD;
		Info[3] = 0x05;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_400K,&Info[0])<0)
		{
		    free(pData);
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
			fclose(pFile);
			return;
		}

		memset(&I2cInfo,0,sizeof(I2C_INFO));
		I2cInfo.MasterIndex=0;
		I2cInfo.SlaveAddress=DeviceID;
		I2cInfo.Speed=I2C_SPEED_400K;
		I2cInfo.BaseAddrType=ADDRESS_TYPE_BYTE;
		I2cInfo.BaseAddress=0x03;
		I2cInfo.Data=pData;

		Addr = 0;
		Length = 0;
		while(!feof(pFile) && Addr<MAX_ROM_SIZE)
		{
		    int res;

			res = fread(&tmpData,1, 4, pFile);
			if(res==0 && Length==0)
			{
				break;
			}
			else
			{
				if(res!=0)
				{
					tmpData = ___swab32(tmpData);
					memcpy(&pData[Length+2],&tmpData,4);
					Length += 4;
//					Length += res;
				}

				if(res<4 || Length>(BURST_MODE_SIZE-4))
				{
					memcpy(&pData[0], &Addr, 2); // Addr
					I2cInfo.DataLength = Length + 2;
					if(ioctl(fd,IOC_I2C_MASTER_WRITE,&I2cInfo)<0)
					{
						printf("Write r16[%d][%d] fails!!\n",Addr,Length);
						break;
					}
#if 0
					printf("%02x %02x %02x %02x\n",pData[0],pData[1],pData[2],pData[3]);
					printf("%02x %02x %02x %02x ",pData[4],pData[5],pData[6],pData[7]);
					printf("%02x %02x %02x %02x\n",pData[8],pData[9],pData[10],pData[11]);
#endif
					Addr += Length;
					Length = 0;

					if(res < 4)
					{
						break;
					}
				}
			}
		}

		Info[0] = DeviceID;
		Info[1] = 0x01;
		Info[2] = 0xD2;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_400K,&Info[0])<0)
		{
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
		}

		printf("Load File %s, Size=%d\n",Filename,Addr);
		fclose(pFile);
	}
	free(pData);
#else
	unsigned char	Data[6],Info[6];
	unsigned int	tmpData;
	I2C_INFO		I2cInfo;
	FILE			*pFile;
	int				res,i;

	pFile = fopen(Filename,"rb");
	if(pFile)
	{
		Info[0] = DeviceID;
		Info[1] = 0x01;
		Info[2] = 0xD9;
		Info[3] = 0x05;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_100K,&Info[0])<0)
		{
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
			fclose(pFile);
			return;
		}
//		I2cWriteWordFun(fd,TYPE_M0_100K_MODE,DeviceID,0x01,0x05D9);

		memset(&I2cInfo,0,sizeof(I2C_INFO));
		I2cInfo.MasterIndex=0;
		I2cInfo.SlaveAddress=DeviceID;
		I2cInfo.Speed=I2C_SPEED_100K;
		I2cInfo.BaseAddrType=ADDRESS_TYPE_BYTE;
		I2cInfo.BaseAddress=0x03;
		I2cInfo.DataLength=sizeof(Data);

		i = 0;
		while(!feof(pFile) && i<MAX_ROM_SIZE)
		{
			memcpy(Data, &i, 2);
			res = fread(&tmpData,1, 4, pFile);
			tmpData = ___swab32(tmpData);
			memcpy(&Data[2],&tmpData,4);
			if(res==0)
			{
				break;
			}
			else
			{
				I2cInfo.Data=Data;
				if(ioctl(fd,IOC_I2C_MASTER_WRITE,&I2cInfo)<0)
				{
					printf("Write r16[%d] fails!!\n",i);
					break;
				}
#if CHECK_DATA
				Info[0] = DeviceID;
				Info[1] = 0x01;
				Info[2] = 0xDA;
				Info[3] = 0x05;
				memcpy(&Info[4], &i, 2);
				if(ioctl(fd,IOC_I2C_MASTER0_WRITE_DWORD_100K,&Info[0])<0)
				{
					printf("%s %d Fail\n",__FUNCTION__,__LINE__);
					break;
				}

				Info[0] = DeviceID;
				Info[1] = 0x05;
				if(ioctl(fd,IOC_I2C_MASTER0_READ_DWORD_100K,&Info[0])<0)
				{
					printf("%s %d Fail\n",__FUNCTION__,__LINE__);
					break;
				}

				if(memcmp(&Info[0], &Data[2], 4)!=0)
				{
					printf("%s %d: 0x%04x Compare Fail\n",__FUNCTION__,__LINE__,i);
				}
#endif
				i += res;
				if(res < 4)
				{
					printf("res=%d, %02x %02x %02x %02x\n",res,Data[2],Data[3],Data[4],Data[5]);
					break;
				}
			}
		}

		Info[0] = DeviceID;
		Info[1] = 0x01;
		Info[2] = 0xD2;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_100K,&Info[0])<0)
		{
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
		}
//		I2cWriteByteFun(fd,TYPE_M0_100K_MODE,DeviceID,0x01,0xD1);

		printf("Load File %s, Size=%d\n",Filename,i);
		fclose(pFile);
	}
#endif
}

void DumpRomFun(int fd, unsigned char DeviceID, const char* Filename)
{
	unsigned int	Data;
	FILE			*pFile;

	pFile = fopen(Filename,"wb");
	if(pFile)
	{
		int				i;

		Data = (unsigned int)DeviceID | 0x05DA0100;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_400K,&Data)<0)
		{
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
			fclose(pFile);
			return;
		}

		for(i=0;i<MAX_ROM_SIZE;i+=4)
		{
			Data = (unsigned int)DeviceID | 0x0300 | i<<16;
			if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_400K,&Data)<0)
			{
				printf("%s %d Fail\n",__FUNCTION__,__LINE__);
				break;
			}

			Data = (unsigned int)DeviceID | 0x0500;
			if(ioctl(fd,IOC_I2C_MASTER0_READ_DWORD_400K,&Data)<0)
			{
				printf("%s %d Fail\n",__FUNCTION__,__LINE__);
				break;
			}

			Data = ___swab32(Data);
			fwrite(&Data,1,4,pFile);
		}
		fclose(pFile);
	}
}

void R16TestFun(int fd, int TestMode, unsigned char DeviceID, unsigned int TestNumber)
{
	unsigned char	*pData,Info[4],ref;
	unsigned int	refData,readData,i;
	I2C_INFO		I2cInfo;
	int				MaxSize,Addr;

	pData = malloc(BURST_MODE_SIZE+0x10);
	if(pData==NULL)
	{
		printf("%s %d No Resource!\n",__FUNCTION__,__LINE__);
		return;
	}

	Info[0] = DeviceID;
	Info[1] = 0x02;
	if(TestMode==0) // Rom
	{
		printf("Rom test:\n");
		Info[2] = 0x05;
		MaxSize = MAX_ROM_SIZE;
	}
	else if(TestMode==1) // Ram
	{
		printf("Ram test:\n");
		Info[2] = 0x06;
		MaxSize = MAX_RAM_SIZE;
	}
	else // Rom
	{
		printf("%s %d Invalid mode=%d\n",__FUNCTION__,__LINE__,TestMode);
		free(pData);
		return;
	}

	if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_400K,&Info[0])<0)
	{
		printf("%s %d Fail\n",__FUNCTION__,__LINE__);
		free(pData);
		return;
	}

	memset(&I2cInfo,0,sizeof(I2C_INFO));
	I2cInfo.MasterIndex = 0;
	I2cInfo.SlaveAddress = DeviceID;
	I2cInfo.Speed = I2C_SPEED_400K;
	I2cInfo.BaseAddrType = ADDRESS_TYPE_BYTE;
	I2cInfo.BaseAddress = 0x03;
	I2cInfo.DataLength = BURST_MODE_SIZE + 2;
	I2cInfo.Data = pData;

	ref = 1;
//	ref = rand()&0xFF;
	for(i=0;i<TestNumber;i++)
	{
		Info[0] = DeviceID;
		Info[1] = 0x01;
		Info[2] = 0xDD;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_400K,&Info[0])<0)
		{
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
			free(pData);
			return;
		}

		printf("test%u writing 0x%02x\n",i,ref);
		memset(&pData[2],ref,BURST_MODE_SIZE);
		for(Addr=0;Addr<MaxSize;Addr+=BURST_MODE_SIZE)
		{
			memcpy(&pData[0], &Addr, 2); // Addr
			if(ioctl(fd,IOC_I2C_MASTER_WRITE,&I2cInfo)<0)
			{
				printf("Write r16[%d] fails!!\n",Addr);
				free(pData);
				return;
			}
		}

		memset(&refData,ref,sizeof(refData));
		Info[0] = DeviceID;
		Info[1] = 0x01;
		Info[2] = 0xDA;
		if(ioctl(fd,IOC_I2C_MASTER0_WRITE_BYTE_400K,&Info[0])<0)
		{
			printf("%s %d Fail\n",__FUNCTION__,__LINE__);
			free(pData);
			return;
		}
		for(Addr=0;Addr<MaxSize;Addr+=4)
		{
			Info[1] = 0x03;
			memcpy(&Info[2],&Addr,2);
			if(ioctl(fd,IOC_I2C_MASTER0_WRITE_WORD_400K,&Info[0])<0)
			{
				printf("%s %d Fail\n",__FUNCTION__,__LINE__);
				free(pData);
				return;
			}

			Info[1] = 0x05;
			memcpy(&readData,&Info[0],2);
			if(ioctl(fd,IOC_I2C_MASTER0_READ_DWORD_400K,&readData)<0)
			{
				printf("%s %d Fail\n",__FUNCTION__,__LINE__);
				free(pData);
				return;
			}

			if(readData!=refData)
			{
				printf("Compare %04x fail, %08x not equal %08x !\n",Addr,readData,refData);
			}
#if 0
			else
			{
				printf("Compare %04x OK (%08x)\n",Addr,readData);
			}
#endif
		}
		if(i<0xFF)
			ref++;
		else
			ref = rand()&0xFF;
	}
	free(pData);
	printf("Test Finish.\n");
}

#endif //end SH3_CPU

void ShowHelpFun(void)
{
	printf("Usage: i2cap/i2c100k/i2c400k/swi2c\n");
	printf("1. [i2cap/i2c100k/i2c400k] ([m0/m1]) [byte/word/dword] DeviceID Address (Data)\n");
	printf("2. [i2cap/i2c100k/i2c400k] ([m0/m1]) [write] DeviceID (Address) Data\n");
	printf("3. [i2cap/i2c100k/i2c400k] ([m0/m1]) [read/readr] DeviceID (Address) Length\n");
	printf("4. [i2cap] [readmultiaddr] DeviceID AddressLength DataLength Address\n");
	printf("5. [i2cap] [bytedata] DeviceID byte1 byte2 byte3 byte4.....\n");
	printf("6. [swi2c] [byte] DeviceID Address (Data)\n");
	printf("7. [i2cap] [dump] MemAddr MemLen\n");
#ifdef SH3_CPU
	printf("8. [i2cap] [run] DeviceID Filename\n");
	printf("9. [i2cap] [dumprom] DeviceID Filename\n");
	printf("10. [i2cap] [r16test] [rom/ram/all] DeviceID TestNumber\n");
	printf("11. [i2cap] [rom] [w/r] DeviceID Address Len FileName\n");
	printf("12. [gpioi2c] ([m0/m1]) [write] DeviceID (Address) Data\n");
	printf("13. [gpioi2c] ([m0/m1]) [read] DeviceID (Address) Length\n");
#else
	printf("8. Reserved\n");
	printf("9. Reserved\n");
	printf("10. Reserved\n");
#endif
}

int main(int argc, char *argv[])
{
	int fd;
	unsigned int DeviceID,Address = 0;
	unsigned int Data;

	if(argc==1)
	{
		ShowHelpFun();
		return 0;
	}

	fd = open("/dev/sisi2c", O_RDWR);
	if(fd == -1)
	{
		printf("open sisi2c fails!!\n");
		return 0;
	}

	if(strcmp(argv[0],"i2c100k")==0 || strcmp(argv[0],"i2cap")==0
		|| strcmp(argv[0],"./i2c100k")==0 || strcmp(argv[0],"./i2cap")==0)
	{
		if(strcmp(argv[1],"m0")==0)
		{
			if(strcmp(argv[2],"byte")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteByteFun(fd,TYPE_M0_100K_MODE,DeviceID,Address,(unsigned char)Data);
				}
				else
				{
					printf("0x%02x\n",I2cReadByteFun(fd,TYPE_M0_100K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"word")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteWordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address,(unsigned short)Data);
				}
				else
				{
					printf("0x%04x\n",I2cReadWordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"dword")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteDwordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address,Data);
				}
				else
				{
					printf("0x%08x\n",I2cReadDwordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"write")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					I2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[5]);
				}
				else
				{
					I2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[4]);
				}
			}
			else if(((strcmp(argv[2],"read")==0) || (strcmp(argv[2],"readr")==0)) && argc>4)
			{
				int	Length;
				sscanf(argv[3], "%x\n", &DeviceID);
		        if(strcmp(argv[2],"readr")==0){revert_print=1;}
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
					sscanf(argv[5], "%i\n", &Length);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					I2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
				}
				else
				{
					sscanf(argv[4], "%i\n", &Length);
					I2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
				}
			}
			else
			{
				printf("Not support\n");
			}
		}
		else if(strcmp(argv[1],"m1")==0)
		{
			if(strcmp(argv[2],"byte")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteByteFun(fd,TYPE_M1_100K_MODE,DeviceID,Address,(unsigned char)Data);
				}
				else
				{
					printf("0x%02x\n",I2cReadByteFun(fd,TYPE_M1_100K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"word")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteWordFun(fd,TYPE_M1_100K_MODE,DeviceID,Address,(unsigned short)Data);
				}
				else
				{
					printf("0x%04x\n",I2cReadWordFun(fd,TYPE_M1_100K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"dword")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteDwordFun(fd,TYPE_M1_100K_MODE,DeviceID,Address,Data);
				}
				else
				{
					printf("0x%08x\n",I2cReadDwordFun(fd,TYPE_M1_100K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"write")==0 && argc>4)
			{

				sscanf(argv[3], "%x\n", &DeviceID);
				if(argc>5)
				{
                    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					I2cWriteFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[5]);
				}
				else
				{
					I2cWriteFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[4]);
				}
			}
			else if(((strcmp(argv[2],"read")==0) || (strcmp(argv[2],"readr")==0)) && argc>4)
			{
				int	Length;
				sscanf(argv[3], "%x\n", &DeviceID);
		        if(strcmp(argv[2],"readr")==0){revert_print=1;}
				if(argc>5)
				{
                    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
					sscanf(argv[5], "%i\n", &Length);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					I2cReadFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
				}
				else
				{
					sscanf(argv[4], "%i\n", &Length);
					I2cReadFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
				}
			}
			else
			{
				printf("Not support\n");
			}
		}
		else if(strcmp(argv[1],"byte")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteByteFun(fd,TYPE_M0_100K_MODE,DeviceID,Address,(unsigned char)Data);
			}
			else
			{
				printf("0x%02x\n",I2cReadByteFun(fd,TYPE_M0_100K_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"word")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteWordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address,(unsigned short)Data);
			}
			else
			{
				printf("0x%04x\n",I2cReadWordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"dword")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteDwordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address,Data);
			}
			else
			{
				printf("0x%08x\n",I2cReadDwordFun(fd,TYPE_M0_100K_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"write")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			if(argc>4)
			{
			    int addrLen;

				sscanf(argv[3], "%x\n", &Address);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				I2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[4]);
			}
			else
			{
				I2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[3]);
			}
		}
		else if(((strcmp(argv[1],"read")==0) || (strcmp(argv[1],"readr")==0)) && argc>3)
		{
			int	Length;
			sscanf(argv[2], "%x\n", &DeviceID);
		    if(strcmp(argv[1],"readr")==0){revert_print=1;}
			if(argc>4)
			{
			    int addrLen;

				sscanf(argv[3], "%x\n", &Address);
				sscanf(argv[4], "%i\n", &Length);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				I2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
			}
			else
			{
				sscanf(argv[3], "%i\n", &Length);
				I2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
			}
		}
		else if(strcmp(argv[1],"readmultiaddr")==0)   //20081011 lwhite test
		{
			int AddrLength;
			int DataLength;
			sscanf(argv[2], "%x\n", &DeviceID);
			if(argc>3)
			{
				sscanf(argv[3], "%i\n", &AddrLength);
				sscanf(argv[4], "%i\n", &DataLength);
				I2cReadMultiAddrFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,AddrLength,DataLength,argv[5]);
			}
			else
			{
				//sscanf(argv[3], "%i\n", &Length);
				//I2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
			}
		}
		else if(strcmp(argv[1],"mmap")==0)  //20091209 lwhite test mmap
		{
			unsigned char *mmapBuf = 0;
			unsigned int mmapSize = 4096;
			unsigned char Data[128];
			unsigned short len;
			char *Str;
			int i;

			mmapBuf =  mmap (0, mmapSize, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_LOCKED, fd, 0);
			if (MAP_FAILED == mmapBuf)
			{
				printf("i2cap: mmap fail!\n");
				close(fd);
				return 0;
			}

			PI2C_INFO pI2cInfo = (PI2C_INFO)mmapBuf;

			sscanf(argv[2], "%x\n", &DeviceID);	
			sscanf(argv[3], "%x\n", &Address);
			Str = argv[4];

			//printf("[I2CAP] ==> I2cWriteFun!!   Addr = 0x%02x\n", BaseAddrType ,Addr);

			len = strlen(Str);
			printf("%s,len=%u\n",Str,len);
			if((len%2)!=0 || len>256)
			{
				printf("Invalid Data Length %u\n",len);
				return 0;
			}

			memset(pI2cInfo,0,sizeof(I2C_INFO));

			for(i=0;i<128&&i*2<len;i++)
			{
				Data[i] = StrToHexFun(&Str[i*2]);
				printf("Data[%d]=0x%02x\n",i,Data[i]);
			}

			pI2cInfo->MasterIndex=0;
			pI2cInfo->Speed=I2C_SPEED_100K;
			pI2cInfo->SlaveAddress=DeviceID;	
			pI2cInfo->BaseAddrType=ADDRESS_TYPE_BYTE;
			pI2cInfo->BaseAddress=Address;
			pI2cInfo->Data=Data;
			pI2cInfo->DataLength=len/2;


		
/*		
			unsigned char	*pData;
			int data_length,i;

			pData = malloc(100);
			if(pData==NULL)
			{
				printf("%s %d No Resource!\n",__FUNCTION__,__LINE__);
				return;
			}

			//printf("argc = %d\n",argc);

			if (argc > 3)
			{
				data_length = argc - 3;
				sscanf(argv[2], "%x\n", &DeviceID);
			
				for (i = 0; i < data_length; i++)
				{
					sscanf(argv[i+3], "%x\n", &pData[i]);	
				}
				//printf("DeviceID = %x,data_length = %d, pData[0] = %x, pData[1] = %x\n",DeviceID,data_length,pData[0],pData[1]);

				I2cWriteDataFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,data_length,pData);

			}
			
			free(pData);
*/
		}
		else if(strcmp(argv[1],"bytedata")==0)   //20090512 lwhite test 
		{
			unsigned char	*pData;

			pData = malloc(100);
			if(pData==NULL)
			{
				printf("%s %d No Resource!\n",__FUNCTION__,__LINE__);
				close(fd);
				return 0;
			}

			//printf("argc = %d\n",argc);

			if (argc > 3)
			{
				int data_length,i;

				data_length = argc - 3;
				sscanf(argv[2], "%x\n", &DeviceID);
			
				for (i = 0; i < data_length; i++)
				{
					sscanf(argv[i+3], "%x\n",(unsigned int*)&pData[i]);	
				}
				//printf("DeviceID = %x,data_length = %d, pData[0] = %x, pData[1] = %x\n",DeviceID,data_length,pData[0],pData[1]);

				I2cWriteDataFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,data_length,pData);

			}
			
			free(pData);

		}
		else if(strcmp(argv[1],"dump")==0 && argc>3)
		{
			unsigned long Addr;
			int Length;
			sscanf(argv[2], "%lx\n", &Addr); //4 bytes alignment
			sscanf(argv[3], "%i\n", &Length); //4 bytes alignment
			I2cDumpMemFun(fd,Addr,Length);
		}
#ifdef SH3_CPU
		else if(strcmp(argv[1],"run")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			RunBinaryFun(fd,DeviceID,argv[3]);
		}
		else if(strcmp(argv[1],"dumprom")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			DumpRomFun(fd,DeviceID,argv[3]);
		}
		else if(strcmp(argv[1],"r16test")==0 && argc>4)
		{
			sscanf(argv[3], "%x\n", &DeviceID);
			sscanf(argv[4], "%x\n", &Data);
			if(strcmp(argv[2],"rom")==0)
			{
				R16TestFun(fd, 0, DeviceID, Data);
			}
			else if(strcmp(argv[2],"ram")==0)
			{
				R16TestFun(fd, 1, DeviceID, Data);
			}
			else if(strcmp(argv[2],"all")==0)
			{
				R16TestFun(fd, 0, DeviceID, Data);
				R16TestFun(fd, 1, DeviceID, Data);
			}
			else
			{
				printf("Not support\n");
			}
		}
#endif
		else if(strcmp(argv[1],"rom")==0 && argc>6)
        {
			int	Length;
			int	bRead=0;
            int addrLen=0;
			if(strcmp(argv[2],"w")==0)
            {
                bRead =0;
            }
            else if(strcmp(argv[2],"r")==0)
            {
                bRead =1;
            }
            sscanf(argv[3], "%x\n", &DeviceID);
            sscanf(argv[4], "%x\n", &Address);
            sscanf(argv[5], "%x\n", &Length);
            
            addrLen = strlen(argv[4]);
            //printf("strlen = %d\n",addrLen);
            addrLen = (addrLen + 1)>>1;
            if(addrLen == 2)
                Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
            else
                printf("wrong addr\n");
            //printf("Address = %x\n",Address);
            if(bRead == 1)
            {
                I2cReadEEPROM(fd,DeviceID,Address,Length,argv[6]);
            }
            else
            {
                I2cWriteEEPROM(fd,DeviceID,Address,Length,argv[6]);
            }

        }
		else
		{
			printf("Not support\n");
			ShowHelpFun();
		}
	}
	else if(strcmp(argv[0],"i2c400k")==0 || strcmp(argv[0],"./i2c400k")==0)
	{
		if(strcmp(argv[1],"m0")==0)
		{
			if(strcmp(argv[2],"byte")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteByteFun(fd,TYPE_M0_400K_MODE,DeviceID,Address,(unsigned char)Data);
				}
				else
				{
					printf("0x%02x\n",I2cReadByteFun(fd,TYPE_M0_400K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"word")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteWordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address,(unsigned short)Data);
				}
				else
				{
					printf("0x%04x\n",I2cReadWordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"dword")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteDwordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address,Data);
				}
				else
				{
					printf("0x%08x\n",I2cReadDwordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"write")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
					I2cWriteFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[5]);
				}
				else
				{
					I2cWriteFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[4]);
				}
			}
			else if(((strcmp(argv[2],"read")==0) || (strcmp(argv[2],"readr")==0)) && argc>4)
			{
				int	Length;
				sscanf(argv[3], "%x\n", &DeviceID);
		        if(strcmp(argv[2],"readr")==0){revert_print=1;}
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
					sscanf(argv[5], "%i\n", &Length);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
					I2cReadFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
				}
				else
				{
					sscanf(argv[4], "%i\n", &Length);
					I2cReadFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
				}
			}
			else
			{
				printf("Not support\n");
			}
		}
		else if(strcmp(argv[1],"m1")==0)
		{
			if(strcmp(argv[2],"byte")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteByteFun(fd,TYPE_M1_400K_MODE,DeviceID,Address,(unsigned char)Data);
				}
				else
				{
					printf("0x%02x\n",I2cReadByteFun(fd,TYPE_M1_400K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"word")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteWordFun(fd,TYPE_M1_400K_MODE,DeviceID,Address,(unsigned short)Data);
				}
				else
				{
					printf("0x%04x\n",I2cReadWordFun(fd,TYPE_M1_400K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"dword")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				sscanf(argv[4], "%x\n", &Address);
				if(argc>5)
				{
					sscanf(argv[5], "%x\n", &Data);
					I2cWriteDwordFun(fd,TYPE_M1_400K_MODE,DeviceID,Address,Data);
				}
				else
				{
					printf("0x%08x\n",I2cReadDwordFun(fd,TYPE_M1_400K_MODE,DeviceID,Address));
				}
			}
			else if(strcmp(argv[2],"write")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					I2cWriteFun(fd,TYPE_M1_400K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[5]);
				}
				else
				{
					I2cWriteFun(fd,TYPE_M1_400K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[4]);
				}
			}
			else if(((strcmp(argv[2],"read")==0) || (strcmp(argv[2],"readr")==0)) && argc>4)
			{
				int	Length;

				sscanf(argv[3], "%x\n", &DeviceID);
		        if(strcmp(argv[2],"readr")==0){revert_print=1;}
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
					sscanf(argv[5], "%i\n", &Length);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					I2cReadFun(fd,TYPE_M1_400K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
				}
				else
				{
					sscanf(argv[4], "%i\n", &Length);
					I2cReadFun(fd,TYPE_M1_400K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
				}
			}
			else
			{
				printf("Not support\n");
			}
		}
		else if(strcmp(argv[1],"byte")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteByteFun(fd,TYPE_M0_400K_MODE,DeviceID,Address,(unsigned char)Data);
			}
			else
			{
				printf("0x%02x\n",I2cReadByteFun(fd,TYPE_M0_400K_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"word")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteWordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address,(unsigned short)Data);
			}
			else
			{
				printf("0x%04x\n",I2cReadWordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"dword")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteDwordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address,Data);
			}
			else
			{
				printf("0x%08x\n",I2cReadDwordFun(fd,TYPE_M0_400K_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"write")==0 && argc>3)
		{            
			sscanf(argv[2], "%x\n", &DeviceID);
			if(argc>4)
			{
    			int addrLen;

				sscanf(argv[3], "%x\n", &Address);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				I2cWriteFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[4]);
			}
			else
			{
				I2cWriteFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[3]);
			}
		}
		else if(((strcmp(argv[1],"read")==0) || (strcmp(argv[1],"readr")==0)) && argc>3)
		{
            int	Length;
			sscanf(argv[2], "%x\n", &DeviceID);
		    if(strcmp(argv[1],"readr")==0){revert_print=1;}
			if(argc>4)
			{
			    int addrLen;
                
				sscanf(argv[3], "%x\n", &Address);
				sscanf(argv[4], "%i\n", &Length);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				I2cReadFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
			}
			else
			{
				sscanf(argv[3], "%i\n", &Length);
				I2cReadFun(fd,TYPE_M0_400K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
			}
		}
		else
		{
			printf("Not support\n");
			ShowHelpFun();
		}
	}
	else if(strcmp(argv[0],"swi2c")==0)
	{
		if(strcmp(argv[1],"byte")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			sscanf(argv[3], "%x\n", &Address);
			if(argc>4)
			{
				sscanf(argv[4], "%x\n", &Data);
				I2cWriteByteFun(fd,TYPE_SW_MODE,DeviceID,Address,(unsigned char)Data);
			}
			else
			{
				printf("0x%02x\n",I2cReadByteFun(fd,TYPE_SW_MODE,DeviceID,Address));
			}
		}
		else if(strcmp(argv[1],"write")==0 && argc>3)
		{
            #if 0
			sscanf(argv[2], "%x\n", &DeviceID);
			if(argc>4)
			{
			    int addrLen;

				sscanf(argv[3], "%x\n", &Address);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				I2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[4]);
			}
			else
			{
				I2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[3]);
			}
            #else
                printf("nSupport\n");
            #endif
		}
		else if(((strcmp(argv[1],"read")==0) || (strcmp(argv[1],"readr")==0)) && argc>3)
		{
			int	Length;
			sscanf(argv[2], "%x\n", &DeviceID);
		    if(strcmp(argv[1],"readr")==0){revert_print=1;}
			if(argc>4)
			{
			    int addrLen;

				sscanf(argv[3], "%x\n", &Address);
				sscanf(argv[4], "%i\n", &Length);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				I2cSwReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
			}
			else
			{
				sscanf(argv[3], "%i\n", &Length);
				I2cSwReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
			}
		}
	}
	else if(strcmp(argv[0],"gpioi2c")==0)
	{
		if(strcmp(argv[1],"m0")==0)
		{
			if(strcmp(argv[2],"write")==0 && argc>4)
			{
				sscanf(argv[3], "%x\n", &DeviceID);
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					GPIOI2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[5]);
				}
				else
				{
					GPIOI2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[4]);
				}
			}
			else if(((strcmp(argv[2],"read")==0) || (strcmp(argv[2],"readr")==0)) && argc>4)
			{
				int	Length;
				sscanf(argv[3], "%x\n", &DeviceID);
		        if(strcmp(argv[2],"readr")==0){revert_print=1;}
				if(argc>5)
				{
				    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
					sscanf(argv[5], "%i\n", &Length);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					GPIOI2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
				}
				else
				{
					sscanf(argv[4], "%i\n", &Length);
					GPIOI2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
				}
			}
			else
			{
				printf("Not support\n");
			}
		}
		else if(strcmp(argv[1],"m1")==0)
		{
			if(strcmp(argv[2],"write")==0 && argc>4)
			{

				sscanf(argv[3], "%x\n", &DeviceID);
				if(argc>5)
				{
                    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					GPIOI2cWriteFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[5]);
				}
				else
				{
					GPIOI2cWriteFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[4]);
				}
			}
			else if(((strcmp(argv[2],"read")==0) || (strcmp(argv[2],"readr")==0)) && argc>4)
			{
				int	Length;
				sscanf(argv[3], "%x\n", &DeviceID);
		        if(strcmp(argv[2],"readr")==0){revert_print=1;}
				if(argc>5)
				{
                    int addrLen;

					sscanf(argv[4], "%x\n", &Address);
					sscanf(argv[5], "%i\n", &Length);
                    addrLen = strlen(argv[4]);
                    //printf("strlen = %d\n",addrLen);
                    addrLen = (addrLen + 1)>>1;
                    if(addrLen == 1)
                        Address = (addrLen << 24) | (Address&0xff);   
                    else if(addrLen == 2)
                        Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                    else if(addrLen == 3)
                        Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                    //printf("Address = %x\n",Address);
					GPIOI2cReadFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
				}
				else
				{
					sscanf(argv[4], "%i\n", &Length);
					GPIOI2cReadFun(fd,TYPE_M1_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
				}
			}
			else
			{
				printf("Not support\n");
			}
		}
		else if(strcmp(argv[1],"write")==0 && argc>3)
		{
			sscanf(argv[2], "%x\n", &DeviceID);
			if(argc>4)
			{
			    int addrLen;

				sscanf(argv[3], "%x\n", &Address);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				GPIOI2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,argv[4]);
			}
			else
			{
				GPIOI2cWriteFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,argv[3]);
			}
		}
		else if(((strcmp(argv[1],"read")==0) || (strcmp(argv[1],"readr")==0)) && argc>3)
		{
			int	Length;
			sscanf(argv[2], "%x\n", &DeviceID);
		    if(strcmp(argv[1],"readr")==0){revert_print=1;}
			if(argc>4)
			{
			    int addrLen;

				sscanf(argv[3], "%x\n", &Address);
				sscanf(argv[4], "%i\n", &Length);
                addrLen = strlen(argv[3]);
                //printf("strlen = %d\n",addrLen);
                addrLen = (addrLen + 1)>>1;
                if(addrLen == 1)
                    Address = (addrLen << 24) | (Address&0xff);   
                else if(addrLen == 2)
                    Address = (addrLen << 24) | ((Address & 0xff00) >> 8)| ((Address & 0xff) << 8) ;   
                else if(addrLen == 3)
                    Address = (addrLen << 24) | ((Address & 0xff0000) >> 16) | (Address & 0xff00)| ((Address & 0xff) << 16) ;   
                //printf("Address = %x\n",Address);
				GPIOI2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_MULTIPLE,Address,Length);
			}
			else
			{
				sscanf(argv[3], "%i\n", &Length);
				GPIOI2cReadFun(fd,TYPE_M0_100K_MODE,DeviceID,ADDRESS_TYPE_NONE,0,Length);
			}
		}
	}
	else
	{
		printf("Not support\n");
		ShowHelpFun();
	}

	close(fd);
	return 0;
}