#include "FreeRTOS.h"
#include "board.h"
#include "chip.h"
#include "Ark7116M.h"

#ifdef VIDEO_DECODER_ARK7116M

#define ARK7116M_RST_GPIO 110


#define _ARK7116M_DRV_C_


#define I2C_ACCESS_LOOP_TIME   	20
#define I2C_NON_ACK                  	1

typedef struct _PanlstaticPara
{
    unsigned int addr;
    unsigned char dat;
}PanlstaticPara;


PanlstaticPara Ark7116M_staticPara[]=
{

//GLOBAL
    {0XFD02,0X00}, 
    {0XFD0A,0X30}, 
    {0XFD0B,0X27}, 
    {0XFD0C,0X33}, 
    {0XFD0D,0XE0}, 
    {0XFD0E,0X2C}, 
    {0XFD0F,0X06}, 
    {0XFD10,0X04}, 
    {0XFD11,0XFF}, 
    {0XFD12,0XFF}, 
    {0XFD13,0XFF}, 
    {0XFD14,0X02}, 
    {0XFD15,0X02}, 
    {0XFD16,0X02}, 
    {0XFD1A,0X45}, 
    {0XFD19,0X02}, 

//DECODER
    {0XFE00,0X80}, 
    {0XFE01,0X02}, 
    {0XFE06,0X02}, 
    {0XFE07,0X80}, 
    {0XFE0C,0X01}, 
    {0XFE0F,0X07}, 
    {0XFE13,0X16}, 
    {0XFE14,0X22}, 
    {0XFE15,0X05}, 
    {0XFE48,0X07}, 
    {0XFE54,0X40}, 
    {0XFE55,0X0A}, 
    {0XFE63,0XC0}, 
    {0XFE83,0XBF}, 
    {0XFED5,0XB1}, 
    {0XFED7,0XF7}, 
    {0XFEDC,0X00}, 
    {0XFE44,0X20}, 
    {0XFE45,0X80}, 
    {0XFE43,0X80}, 
    {0XFE56,0X07}, 
    {0XFEC9,0X01}, 
    {0XFE46,0X00}, 
    {0XFE42,0X00}, 
    {0XFE47,0X8A}, 
    
//VP
    {0XFFB0,0X67}, 
    {0XFFB1,0X0F}, 
    {0XFFB2,0X10}, 
    {0XFFB3,0X10}, 
    {0XFFB4,0X10}, 
    {0XFFB7,0X10}, 
    {0XFFB8,0X10}, 
    {0XFFB9,0X22}, 
    {0XFFBA,0X20}, 
    {0XFFBB,0X22}, 
    {0XFFBC,0X20}, 
    {0XFFC7,0X31}, 
    {0XFFC8,0X03}, 
    {0XFFC9,0X10}, 
    {0XFFCB,0X80}, 
    {0XFFCC,0X80}, 
    {0XFFCD,0X2D}, 
    {0XFFCE,0X13}, 
    {0XFFCF,0XDD}, 
    {0XFFD0,0X72}, 
    {0XFFD2,0X4F}, 
    {0XFFD3,0X80}, 
    {0XFFD4,0X80}, 
    {0XFFD5,0X00}, 
    {0XFFD6,0X30}, 
    {0XFFD7,0X05},
    {0XFFD8,0X80}, 
    {0XFFE7,0X50}, 
    {0XFFE8,0X10}, 
    {0XFFE9,0X22}, 
    {0XFFEA,0X20}, 
    {0XFFF0,0X33}, 
    {0XFFF1,0XE7}, 
    {0XFFF2,0XE7}, 
    {0XFFF3,0XE0}, 
    {0XFFF4,0XFD}, 
    {0XFFF5,0X33}, 
    {0XFFF6,0XED}, 
    {0XFFF7,0XDF}, 
    {0XFFF8,0XEC}, 
    {0XFFF9,0XFD}, 
    {0XFFFA,0X33}, 
    {0XFFFB,0X81}, 

//TCON
    {0XFC00,0X40}, 
    {0XFC01,0X00}, 
    {0XFC02,0X00}, 
    {0XFC09,0X00}, 
    {0XFC0A,0X00}, 
//SCALE
    {0XFC90,0X02}, 
    {0XFC91,0X00}, 
    {0XFC92,0X00}, 
    {0XFC93,0X0C}, 
    {0XFC94,0X00}, 
    {0XFC95,0X00}, 
    {0XFC96,0XFF}, 
    {0XFC97,0X03}, 
    {0XFC98,0XFF}, 
    {0XFC99,0X03}, 
    {0XFC9A,0X5A}, 
    {0XFC9B,0X03}, 
    {0XFC9C,0X01}, 
    {0XFC9D,0X00}, 
    {0XFC9E,0X06}, 
    {0XFC9F,0X00}, 
    {0XFCA0,0X20}, 
    {0XFCA1,0X00}, 
    {0XFCA2,0XF2}, 
    {0XFCA3,0X02}, 
    {0XFCA4,0X01}, 
    {0XFCA5,0X00}, 
    {0XFCA6,0X03}, 
    {0XFCA7,0X00}, 
    {0XFCA8,0X0A}, 
    {0XFCA9,0X00}, 
    {0XFCAA,0XFB}, 
    {0XFCAB,0X00}, 
    {0XFCAC,0X00}, 
    {0XFCAD,0X01},
    {0XFCAE,0X00}, 
    {0XFCAF,0X00}, 
    {0XFCB0,0X00}, 
    {0XFCB1,0X14}, 
    {0XFCB2,0X00}, 
    {0XFCB3,0X00}, 
    {0XFCB4,0X00}, 
    {0XFCB5,0X00}, 
    {0XFCB7,0X06}, 
    {0XFCB8,0X01}, 
    {0XFCBB,0X38}, 
    {0XFCBC,0X01}, 
    {0XFCBD,0X00}, 
    {0XFCBE,0X00}, 
    {0XFCBF,0X0C}, 
    {0XFCC0,0X00}, 
    {0XFCC1,0X00}, 
    {0XFCC2,0XFF}, 
    {0XFCC3,0X03}, 
    {0XFCC4,0XFF}, 
    {0XFCC5,0X03}, 
    {0XFCC6,0X60}, 
    {0XFCC7,0X03}, 
    {0XFCC8,0X01}, 
    {0XFCC9,0X00}, 
    {0XFCCA,0X06}, 
    {0XFCCB,0X00}, 
    {0XFCCC,0X20}, 
    {0XFCCD,0X00}, 
    {0XFCCE,0XF2}, 
    {0XFCCF,0X02}, 
    {0XFCD1,0X00}, 
    {0XFCD2,0X03}, 
    {0XFCD3,0X00}, 
    {0XFCD4,0X0E}, 
    {0XFCD5,0X00}, 
    {0XFCD6,0X2F}, 
    {0XFCD7,0X01}, 
    {0XFCD8,0X00}, 
    {0XFCD9,0X08}, 
    {0XFCDA,0X00}, 
    {0XFCDB,0X00}, 
    {0XFCDC,0X00}, 
    {0XFCDD,0X00}, 
    {0XFCDE,0X00}, 
    {0XFCDF,0X00}, 
    {0XFCE0,0X00}, 
    {0XFCE1,0X00}, 
    {0XFCE3,0X11}, 
    {0XFCE4,0X02}, 
    {0XFCD0,0X01}, 
    {0XFCE2,0X03}, 
    {0XFCB6,0X02}, 
    {0XFB35,0X00}, 
    {0XFB89,0X00}, 

//PAD MUX
    {0XFD30,0X22}, 
    {0XFD32,0X00}, 
    {0XFD33,0X00}, 
    {0XFD34,0X44}, 
    {0XFD35,0X40}, 
    {0XFD36,0X44}, 
    {0XFD37,0X44}, 
    {0XFD38,0X44}, 
    {0XFD39,0X44}, 
    {0XFD3A,0X00}, 
    {0XFD3B,0X00}, 
    {0XFD3C,0X00}, 
    {0XFD3D,0X00}, 
    {0XFD3E,0X00}, 
    {0XFD3F,0X00}, 
    {0XFD40,0X00}, 
    {0XFD41,0X00}, 
    {0XFD44,0X01}, 
    {0XFD45,0X00}, 
    {0XFD46,0X00}, 
    {0XFD47,0X00}, 
    {0XFD48,0X00}, 
    {0XFD49,0X00}, 
    {0XFD4A,0X00}, 
    {0XFD4B,0X00}, 
    {0XFD50,0X0B}, 
    {0XFD51,0X00}, 
    {0XFD52,0X00}, 
    {0XFD53,0XFC}, 
    {0XFD54,0XFF}, 
    {0XFD55,0XFF}, 
    {0XFD56,0X03}, 
    {0XFD57,0X00}, 
    {0XFD58,0X00}, 
    {0XFD59,0X00}, 
    {0XFD5A,0X00}, 
    
//GAMMA
    {0XFF00,0X03}, 
    {0XFF01,0X0C}, 
    {0XFF02,0X15}, 
    {0XFF03,0X1D}, 
    {0XFF04,0X25}, 
    {0XFF05,0X2D}, 
    {0XFF06,0X36}, 
    {0XFF07,0X3E}, 
    {0XFF08,0X46}, 
    {0XFF09,0X4E}, 
    {0XFF0A,0X56}, 
    {0XFF0B,0X5E}, 
    {0XFF0C,0X66}, 
    {0XFF0D,0X6E}, 
    {0XFF0E,0X76}, 
    {0XFF0F,0X7D}, 
    {0XFF10,0X85}, 
    {0XFF11,0X8C}, 
    {0XFF12,0X93}, 
    {0XFF13,0X9B}, 
    {0XFF14,0XA2}, 
    {0XFF15,0XA9}, 
    {0XFF16,0XB0}, 
    {0XFF17,0XB7}, 
    {0XFF18,0XBF}, 
    {0XFF19,0XC6}, 
    {0XFF1A,0XCE}, 
    {0XFF1B,0XD6}, 
    {0XFF1C,0XDE}, 
    {0XFF1D,0XE6}, 
    {0XFF1E,0XEE}, 
    {0XFF1F,0XF7}, 
    {0XFF20,0X0C}, 
    {0XFF21,0X15}, 
    {0XFF22,0X1D}, 
    {0XFF23,0X25}, 
    {0XFF24,0X2D}, 
    {0XFF25,0X36}, 
    {0XFF26,0X3E}, 
    {0XFF27,0X46}, 
    {0XFF28,0X4E}, 
    {0XFF29,0X56}, 
    {0XFF2A,0X5E}, 
    {0XFF2B,0X66}, 
    {0XFF2C,0X6E}, 
    {0XFF2D,0X76}, 
    {0XFF2E,0X7D}, 
    {0XFF2F,0X85}, 
    {0XFF30,0X8C}, 
    {0XFF31,0X93}, 
    {0XFF32,0X9B}, 
    {0XFF33,0XA2}, 
    {0XFF34,0XA9}, 
    {0XFF35,0XB0}, 
    {0XFF36,0XB7}, 
    {0XFF37,0XBF}, 
    {0XFF38,0XC6}, 
    {0XFF39,0XCE}, 
    {0XFF3A,0XD6}, 
    {0XFF3B,0XDE}, 
    {0XFF3C,0XE6}, 
    {0XFF3D,0XEE}, 
    {0XFF3E,0XF7}, 
    {0XFF3F,0X0C}, 
    {0XFF40,0X15}, 
    {0XFF41,0X1D}, 
    {0XFF42,0X25}, 
    {0XFF43,0X2D}, 
    {0XFF44,0X36}, 
    {0XFF45,0X3E}, 
    {0XFF46,0X46}, 
    {0XFF47,0X4E}, 
    {0XFF48,0X56}, 
    {0XFF49,0X5E}, 
    {0XFF4A,0X66}, 
    {0XFF4B,0X6E}, 
    {0XFF4C,0X76}, 
    {0XFF4D,0X7D}, 
    {0XFF4E,0X85}, 
    {0XFF4F,0X8C}, 
    {0XFF50,0X93}, 
    {0XFF51,0X9B}, 
    {0XFF52,0XA2}, 
    {0XFF53,0XA9}, 
    {0XFF54,0XB0}, 
    {0XFF55,0XB7}, 
    {0XFF56,0XBF}, 
    {0XFF57,0XC6}, 
    {0XFF58,0XCE}, 
    {0XFF59,0XD6}, 
    {0XFF5A,0XDE}, 
    {0XFF5B,0XE6}, 
    {0XFF5C,0XEE}, 
    {0XFF5D,0XF7}, 
    {0XFF5E,0XFF}, 
    {0XFF5F,0XFF}, 
    {0XFF60,0XFF},
};

#define STATIC_NUM 307

#if 0
void  Ark_WriteReg(UINT RegAddr,UCHAR RegVal)
{
	UCHAR XDATA ucLoop;
	UCHAR XDATA ucDeviceAddr;
	UCHAR XDATA uctmpDeviceAddr;
	UCHAR XDATA ucSubAddr;

	ucLoop = I2C_ACCESS_LOOP_TIME;		/*循环20次等待ACK*/
	uctmpDeviceAddr = (UCHAR)((RegAddr>>8)&0XFF);		/*设备地址*/
	ucSubAddr = (UCHAR)(RegAddr&0XFF);		/*寄存器地址*/

	 switch(uctmpDeviceAddr)
		 {
		    case 0XFD:
				 ucDeviceAddr= 0XB0;
				 break;

		    case 0XFA:
				 ucDeviceAddr= 0XBE;
				 break;
				 	
		    case 0XFB:
				 ucDeviceAddr= 0XB6;
				 break;

		     case 0XFC:
				 ucDeviceAddr= 0XB8;
				 break;

		     case 0XFE:
				 ucDeviceAddr= 0XB2;
				 break;

		     case 0XFF:
				 ucDeviceAddr= 0XB4;
				 break;
	 
		     case 0X00:
			       ucDeviceAddr = 0XBE;
			     break;
			
			default:
				 ucDeviceAddr= 0XB0;
				 break;	
		 	}
	 while(ucLoop--)
	 {
	    I2CStart();    /*I2C开始*/
	    I2CWrite(ucDeviceAddr);
		if(ACKCheck()==I2C_NON_ACK) /*没有读到ACK，继续下一次*/
		{ 
		  continue;
		}
		
	    I2CWrite(ucSubAddr);
		if(ACKCheck()== I2C_NON_ACK)
		{
		  continue;
		}
	    I2CWrite(RegVal);
		if(ACKCheck()== I2C_NON_ACK)
		{
       	   continue;
		}
		break;
	}
    I2CStop(); /*I2C结束*/
}
#else
static int ark7116M_i2c_write (struct i2c_adapter *adap, UINT16 RegAddr, unsigned int data)
{
	struct i2c_msg msg;
	int ret = -1;
	u8 retries = 0;
	u8 buf[2];
    	UINT8 ucDeviceAddr;
	UINT8 uctmpDeviceAddr;
	UINT8 ucSubAddr;

	uctmpDeviceAddr = (unsigned char)((RegAddr>>8)&0XFF);
	ucSubAddr = (UINT8)(RegAddr&0XFF);

	switch(uctmpDeviceAddr)
	{
	   case 0XFD:
			ucDeviceAddr= 0XB0;
			break;

	   case 0XFA:
			ucDeviceAddr= 0XBE;
			break;
			   
	   case 0XFB:
			ucDeviceAddr= 0XB6;
			break;

		case 0XFC:
			ucDeviceAddr= 0XB8;
			break;

		case 0XFE:
			ucDeviceAddr= 0XB2;
			break;

		case 0XFF:
			ucDeviceAddr= 0XB4;
			break;

		case 0X00:
			  ucDeviceAddr = 0XBE;
			break;
	   
	   default:
			ucDeviceAddr= 0XB0;
			break; 
	   }
   
	buf[0] = (ucSubAddr);
	buf[1] = (data & 0xFF);

	msg.flags = !I2C_M_RD;
	msg.addr  = (ucDeviceAddr>>1);
	msg.len   = sizeof(buf);
	msg.buf   = buf;
	//printf("msg.addr is %x\n", msg.addr);
	//printf("msg.ucSubAddr is %x\n",buf[0]);
	//printf("msg.data is %x\n", buf[1]);
	while(retries < 10)
	{
	    //printf("retries is %x\n", retries);
		ret = i2c_transfer(adap, &msg, 1);
		//printf("ret is %x\n", ret);
		if (ret == 1)
			break;
		retries++;
		vTaskDelay (20);
	}
		
	if (retries >= 10)
	{
		printf("%s timeout11\n", __FUNCTION__);
		return -1;
	}

	return 0;
}
#endif 


static int i2c_write_byte (struct i2c_adapter *adapter,unsigned int slvaddr, unsigned int addr, char rxdata)
{
	struct i2c_msg msg;
	int ret = -1;
	u8 retries = 0;
	u8 buf[2];
	u8 data = rxdata;

	buf[0] = (addr & 0xFF);
	buf[1] = (data & 0xFF);

	msg.flags = !I2C_M_RD;
	msg.addr  = (unsigned char)(slvaddr >> 1);
	msg.len   = sizeof(buf);
	msg.buf   = buf;

	while(retries < 5)
	{
		ret = i2c_transfer(adapter, &msg, 1);
		if (ret == 1)
			break;
		retries++;
	}

	if (retries >= 5)
	{
		printf("%s timeout\n", __FUNCTION__);
		return -1;
	}

	return 0;
}


static int i2c_read_byte(struct i2c_adapter *adapter,unsigned int slvaddr, unsigned int addr,char *rxdata)
{
	struct i2c_msg msgs[2];
	int retries = 0;
	int ret = -1;
	u8 buf = addr & 0xFF;

	msgs[0].flags = !I2C_M_RD;
	msgs[0].addr  = (unsigned char)(slvaddr >> 1);
	msgs[0].len   = 1;
	msgs[0].buf   = &buf;
	msgs[1].flags = I2C_M_RD;
	msgs[1].addr  = (unsigned char)(slvaddr >> 1);
	msgs[1].len   = 1;
	msgs[1].buf   = (uint8_t *)rxdata;

	while(retries < 5)
	{
		ret = i2c_transfer(adapter, msgs, 2);
		if(ret == 2)
			break;
		retries++;
	}

	if (retries >= 5)
	{
		printf( "%s timeout\n", __FUNCTION__);
		return 0;
	}

	return msgs[1].len;
}




#if 0
void Ark_WriteStaticPara(PanlstaticPara * dataPt,UINT num)
{
	UCHAR XDATA ucLoop;
	UCHAR XDATA ucDeviceAddr;
	UCHAR XDATA uctmpDeviceAddr;
	UCHAR XDATA ucSubAddr;
	UCHAR XDATA ucRegVal;

	 while(num--)
	 {
	     ucLoop = I2C_ACCESS_LOOP_TIME;
		 uctmpDeviceAddr = (UCHAR)((((*dataPt).addr)>>8)&0XFF);
		 ucSubAddr = (UCHAR)(((*dataPt).addr)&0XFF);
		 ucRegVal = (*dataPt).dat;
		 	
		 switch(uctmpDeviceAddr)
		 {
		       case 0XFD:
				 ucDeviceAddr= 0XB0;
				 break;

			case 0XFA:
				 ucDeviceAddr= 0XBE;
				 break;
				 	
			case 0XFB:
				 ucDeviceAddr= 0XB6;
				 break;

		       case 0XFC:
				 ucDeviceAddr= 0XB8;
				 break;

			case 0XFE:
				 ucDeviceAddr= 0XB2;
				 break;

			case 0XFF:
				 ucDeviceAddr= 0XB4;
				 break;

		       case 0X00:
			       ucDeviceAddr = 0XBE;
			       break;
			
			default:
				 ucDeviceAddr= 0XB0;
				 break;	
		 	}
		 while(ucLoop--)
		 {
		    I2CStart();    
		    Delay(2);
		    I2CWrite(ucDeviceAddr);
		    Delay(1);
			if(ACKCheck()==I2C_NON_ACK)
			{
			  continue;
			}
		    I2CWrite(ucSubAddr);
		    Delay(1);
			if(ACKCheck()== I2C_NON_ACK)
			{  
			   continue;
			}
		    I2CWrite(ucRegVal);
		    Delay(1);
			if(ACKCheck()== I2C_NON_ACK)
			{
			   continue;
			}
			break;
			
		}
		dataPt++;
	}
	I2CStop();
}
#else
int ark7116M_WriteStaticPara(struct i2c_adapter *adap,PanlstaticPara * dataPt,UINT16 num)
{
	struct i2c_msg msg;
	int ret = -1;
	u8 retries = 0;
	u8 buf[2];
    	u8 ucDeviceAddr;
	u8 uctmpDeviceAddr;
	u8 ucSubAddr;
	u8 ucRegVal;

	while(num--)
	{
		uctmpDeviceAddr = (unsigned char)(((*dataPt).addr>>8)&0XFF);
		ucSubAddr = (unsigned char)(((*dataPt).addr)&0XFF);
		ucRegVal = (*dataPt).dat;

		switch(uctmpDeviceAddr)
		{
			  case 0XFD:
				ucDeviceAddr= 0XB0;
				break;

		   case 0XFA:
				ucDeviceAddr= 0XBE;
				break;
				   
		   case 0XFB:
				ucDeviceAddr= 0XB6;
				break;

			  case 0XFC:
				ucDeviceAddr= 0XB8;
				break;

		   case 0XFE:
				ucDeviceAddr= 0XB2;
				break;

		   case 0XFF:
				ucDeviceAddr= 0XB4;
				break;

			  case 0X00:
				  ucDeviceAddr = 0XBE;
				  break;
		   
		   default:
				ucDeviceAddr= 0XB0;
				break; 
		   }


		buf[0] = (ucSubAddr);
		buf[1] = (ucRegVal & 0xFF);

		msg.flags = !I2C_M_RD;
		msg.addr  = (ucDeviceAddr>>1);
		msg.len   = sizeof(buf);
		msg.buf   = buf;

		while(retries < 10)
		{
			ret = i2c_transfer(adap, &msg, 1);
			if (ret == 1)
			break;
			retries++;
			vTaskDelay (20);
		}

		if (retries >= 10)
		{
			return -1;
		}
		dataPt++;
	}	

	return 0;
}


#endif



unsigned char Ark_ReadReg(struct i2c_adapter *adap,unsigned int RegAddr)
{
	 unsigned char ucLoop;
	 unsigned char ucRegVal;
	 unsigned char ucDeviceAddr;
	 unsigned char uctmpDeviceAddr;
	 unsigned char ucSubAddr;

	ucLoop = I2C_ACCESS_LOOP_TIME;
	uctmpDeviceAddr = (unsigned char)((RegAddr>>8)&0XFF);
	ucSubAddr = (unsigned char)(RegAddr&0XFF);

	 switch(uctmpDeviceAddr)
	{
		  
		      case 0XFD:
				 ucDeviceAddr= 0XB0;
				 break;

			case 0XFA:
				 ucDeviceAddr= 0XBE;
				 break;
				 	
			case 0XFB:
				 ucDeviceAddr= 0XB6;
				 break;

		      case 0XFC:
				 ucDeviceAddr= 0XB8;
				 break;

			case 0XFE:
				 ucDeviceAddr= 0XB2;
				 break;

			case 0XFF:
				 ucDeviceAddr= 0XB4;
				 break;

		      case 0X00:
			     ucDeviceAddr = 0XBE;
			     break;
			
			default:
				 ucDeviceAddr= 0XB0;
				 break;	
		 	}
	 
	 i2c_read_byte(adap,uctmpDeviceAddr, ucSubAddr,&ucRegVal);

	return(ucRegVal);
}

#if 0
void Ark_mipiRegWrite(UINT RegAddr,UCHAR RegVal)
{
	UCHAR XDATA ucLoop;
	UCHAR XDATA ucDeviceAddr;
	UCHAR XDATA ucSubAddr;

	 ucLoop = I2C_ACCESS_LOOP_TIME;		/*循环20次等待ACK*/
	 ucDeviceAddr = (UCHAR)((RegAddr>>8)&0XFF);		/*设备地址*/
	 ucSubAddr = (UCHAR)(RegAddr&0XFF);		/*寄存器地址*/


	 while(ucLoop--)
	 {
	    I2CStart();    /*I2C开始*/
	    I2CWrite(ucDeviceAddr);
		if(ACKCheck()==I2C_NON_ACK)/*没有读到ACK，继续下一次*/
		{ 
		  continue;
		}
		
	    I2CWrite(ucSubAddr);
		if(ACKCheck()== I2C_NON_ACK)
		{
		   continue;
		}
	    I2CWrite(RegVal);
		if(ACKCheck()== I2C_NON_ACK)
		{
		   continue;
		}
		break;
	}
    I2CStop(); /*I2C结束*/
}
#else
static int Ark_mipiRegWrite (struct i2c_adapter *adap, UINT16 RegAddr, unsigned char data)
{
	struct i2c_msg msg;
	int ret = -1;
	u8 retries = 0;
	u8 buf[2];
    	UINT8 ucDeviceAddr;
	UINT8 uctmpDeviceAddr;
	UINT8 ucSubAddr;

	uctmpDeviceAddr = (unsigned char)((RegAddr>>8)&0XFF);
	ucSubAddr = (UINT8)(RegAddr&0XFF);
  
	buf[0] = (ucSubAddr);
	buf[1] = (data & 0xFF);

	msg.flags = !I2C_M_RD;
	msg.addr  = (uctmpDeviceAddr>>1);
	msg.len   = sizeof(buf);
	msg.buf   = buf;
	//printf("msg.addr is %x\n", msg.addr);
	//printf("msg.ucSubAddr is %x\n",buf[0]);
	//printf("msg.data is %x\n", buf[1]);
	while(retries < 20)
	{
	    //printf("retries is %x\n", retries);
		ret = i2c_transfer(adap, &msg, 1);
		//printf("ret is %x\n", ret);
		if (ret == 1)
			break;
		retries++;
		vTaskDelay (20);
	}
		
	if (retries >= 20)
	{
		printf("%s timeout11\n", __FUNCTION__);
		return -1;
	}

	return 0;
}

#endif

#if 0
UCHAR Ark_mipiRegRead(UINT RegAddr)
{
	 UCHAR XDATA ucLoop;
	 UCHAR XDATA ucRegVal;
	 UCHAR XDATA ucDeviceAddr;
	 UCHAR XDATA ucSubAddr;

	ucLoop = I2C_ACCESS_LOOP_TIME;
	ucDeviceAddr = (UCHAR)((RegAddr>>8)&0XFF);
	ucSubAddr = (UCHAR)(RegAddr&0XFF);

	 while(ucLoop--)
	 {
	    I2CStart();    
	    I2CWrite(ucDeviceAddr);
		if(ACKCheck()==I2C_NON_ACK)
		{
		  continue;
		}
	    I2CWrite(ucSubAddr);
		if(ACKCheck()== I2C_NON_ACK)
		{
		   continue;
		}
		I2CStart();    
	    I2CWrite(ucDeviceAddr|0X01);
		if(ACKCheck()== I2C_NON_ACK)
		{
		  continue;
		}
		ucRegVal = I2CRead(); 
	    NACKSend();
		break;
	}
    I2CStop(); 
	return(ucRegVal);
}
#else
unsigned char Ark_mipiRegRead(struct i2c_adapter *adap,unsigned int RegAddr)
{
	 unsigned char ucLoop;
	 unsigned char ucRegVal;
	 unsigned char ucDeviceAddr;
	 unsigned char ucSubAddr;
	 unsigned int retries = 0;
	int ret = -1;
	char data=0;

	ucLoop = I2C_ACCESS_LOOP_TIME;
	ucDeviceAddr = (unsigned char)((RegAddr>>8)&0XFF);
	ucSubAddr = (unsigned char)(RegAddr&0XFF);

	while(retries < I2C_ACCESS_LOOP_TIME)
	{
		ret = i2c_read_byte(adap,ucDeviceAddr, ucSubAddr,&data);
		if(ret == 1)
			break;

		retries++;
	}
	if(retries >= I2C_ACCESS_LOOP_TIME)
	{
		printf("%s i2c read dev:%x addr:%x error\n",__func__,ucDeviceAddr,ucSubAddr);
		ret = -1;
	}

	if(ret < 0)
		return 0xFF;
	else
		return data;

}


#endif

//void ConfigDecoderStaticPara(void)
int ConfigDecoderStaticPara(struct i2c_adapter *adap)
{    unsigned char data;
     printf("7116M ConfigDecoderPara\n");		
//	Ark_WriteStaticPara(Ark7116M_staticPara,STATIC_NUM);
	 ark7116M_WriteStaticPara(adap,Ark7116M_staticPara,STATIC_NUM);
	
//	Ark_WriteReg(0xFEA0,0X03);//DECODER RESET
	ark7116M_i2c_write(adap,0xFEA0,0X03);

	mdelay(50);
//	Ark_WriteReg(0xFEA0,0X02);
	ark7116M_i2c_write(adap,0xFEA0,0X02);

}

void Ark7116M_reset(void)
{
	gpio_direction_output(ARK7116M_RST_GPIO, 1);
    vTaskDelay(10);	

	gpio_direction_output(ARK7116M_RST_GPIO, 0);
    vTaskDelay(10);	
}

void ConfigSlaveMode(struct i2c_adapter *adap)
{   
    
    unsigned char AddrBuff[6] = {0xa1,0xa2,0xa3,0xa4,0xa5,0xa6};
    unsigned char DataBuff[6] = {0x00,0x00,0x00,0x00,0x00,0x00};
    unsigned char i;
		
    DataBuff[0] = 0X55;
    DataBuff[1] = 0xAA;
    DataBuff[2] = 0X03;
    DataBuff[3] = 0X50;  //slave mode
    DataBuff[4] = 0;     // crc val
    DataBuff[5] = DataBuff[2]^DataBuff[3]^DataBuff[4];

    printf("7116M ConfigSlaveMode\n");	
//	Ark_WriteReg(0xC6,0X40);	
//   Ark_WriteReg(0xAF, 0x00);  //I2c Write Start

	ark7116M_i2c_write(adap,0xC6,0X40);
	
	ark7116M_i2c_write(adap,0xAF, 0x00);

	for(i =0;i < 6;i++)
	{
	  // Ark_WriteReg(AddrBuff[i], DataBuff[i]);
	  ark7116M_i2c_write(adap,AddrBuff[i], DataBuff[i]);
	}
//	   Ark_WriteReg(0xAF, 0x11);  //I2c Write End
	   ark7116M_i2c_write(adap,0xFEA0,0X03);

	vTaskDelay (200);

}


void mipiphyreg_write(struct i2c_adapter *adap,unsigned char addr,unsigned char phy)    
{       
     printf("mipiphyreg_write     \n"); 
	   
	Ark_mipiRegWrite(adap,0xA24D,0x00);                                   
	Ark_mipiRegWrite(adap,0xA24F,0x01);                                   
	Ark_mipiRegWrite(adap,0xA24D,0x02);                                   
	Ark_mipiRegWrite(adap,0xA24E,addr);                                   
	Ark_mipiRegWrite(adap,0xA24D,0x00);                                   
	Ark_mipiRegWrite(adap,0xA24F,0x00);                                   
	Ark_mipiRegWrite(adap,0xA24E,phy);                                   
	Ark_mipiRegWrite(adap,0xA24D,0x02);                                   
	Ark_mipiRegWrite(adap,0xA24D,0x00);                                   
}                                                            


void Ark7116M_mipi_init(struct i2c_adapter *adap)
     {   

	unsigned char phy_status;   

	printf("Ark7116m_mipi_init start \n"); 


	Ark_mipiRegWrite(adap,0xA00F,0x07); 
	
	Ark_mipiRegWrite(adap,0xA004,0x01);   /*奇偶场标志放入指定行使能*/
	
	Ark_mipiRegWrite(adap,0xA007,0x06);
	Ark_mipiRegWrite(adap,0xA008,0x05);
	

#if 0 // PAL 720x288	
	Ark_mipiRegWrite(0xA009,0x20);   /*奇偶场标志所在行设定*/
	Ark_mipiRegWrite(0xA00A,0x01);
#else // NTSC 720x240 
	Ark_mipiRegWrite(adap,0xA009,0xF0);   /*奇偶场标志所在行设定*/
	Ark_mipiRegWrite(adap,0xA00A,0x00);
#endif
	
	Ark_mipiRegWrite(adap,0xA260,0x1E);  
	Ark_mipiRegWrite(adap,0xA261,0x00);   
	Ark_mipiRegWrite(adap,0xA265,0x00);                                   
	Ark_mipiRegWrite(adap,0xA264,0x02);                                   
	Ark_mipiRegWrite(adap,0xA263,0xD0);                                   
	Ark_mipiRegWrite(adap,0xA26F,0x00);                                   
	Ark_mipiRegWrite(adap,0xA26E,0x00);                             
	Ark_mipiRegWrite(adap,0xA26D,0x01);  
	//Ark_mipiRegWrite(0xA26C,0x38);  //PAL 
	Ark_mipiRegWrite(adap,0xA26C,0x08);    //NTSC
	                                                     
	Ark_mipiRegWrite(adap,0xA240,0x00);  
	Ark_mipiRegWrite(adap,0xA240,0x04);
	Ark_mipiRegWrite(adap,0xA240,0x05);
	Ark_mipiRegWrite(adap,0xA240,0x07);                                   
	Ark_mipiRegWrite(adap,0xA241,0x00);                                   
	Ark_mipiRegWrite(adap,0xA245,0x02);                                   

#if 1 // TEST PATTERN COLOR BAR
	Ark_mipiRegWrite(adap,0xA223,0x1E);
	Ark_mipiRegWrite(adap,0xA226,0x02);								   
	Ark_mipiRegWrite(adap,0xA225,0xD0);	
	Ark_mipiRegWrite(adap,0xA227,0x0A); 
	Ark_mipiRegWrite(adap,0xA229,0x0A); 
	Ark_mipiRegWrite(adap,0xA22C,0x02);	
	Ark_mipiRegWrite(adap,0xA22B,0xf8);	 
	Ark_mipiRegWrite(adap,0xA22D,0x02); 
	Ark_mipiRegWrite(adap,0xA22F,0x0A);
	Ark_mipiRegWrite(adap,0xA231,0x0A);
	Ark_mipiRegWrite(adap,0xA233,0xE0);
	Ark_mipiRegWrite(adap,0xA234,0x01);	
	Ark_mipiRegWrite(adap,0xA220,0x01);
#endif
	                                                         
	mipiphyreg_write(adap,0xA244,0x06);        
	mipiphyreg_write(adap,0xA219,0x30);         
	mipiphyreg_write(adap,0xA217,0x02);         
	mipiphyreg_write(adap,0xA218,0x17);  
	mipiphyreg_write(adap,0xA218,0x80); 
	mipiphyreg_write(adap,0xA210,0x89);  
	mipiphyreg_write(adap,0xA211,0x12);
	mipiphyreg_write(adap,0xA212,0xC2);  
															 
	Ark_mipiRegWrite(adap,0xA243,0x00);                                
	Ark_mipiRegWrite(adap,0xA200,0x01);    

     
	while(1)
	{
		mdelay(50);
		phy_status = Ark_mipiRegRead(adap,0xA24B); //phy status
		printf("    phy status = %x\r\n",phy_status);
		if((phy_status & 0x03) == 0x03) 
		{       
			printf("Ark7116m_mipi_init OK \n"); 
			break;
		}
	 }
	
	mdelay(50);
	Ark_mipiRegWrite(adap,0xA243,0x01);    
  
	Ark_mipiRegWrite(adap,0xA003,0x01);  // Data EN

	printf("0xA003>>>>>0x%x\n",Ark_mipiRegRead(adap,0xA003));
	  
      } 


unsigned char ARK7116M_ResolutionDetect(struct i2c_adapter *adap)
{
	unsigned char video_format = 0;
	unsigned char Camera_Video_Format = 0xff;
	
	video_format = Ark_ReadReg(adap,0xFE2A);

	if((video_format&07) == 0x00)
	{
		Camera_Video_Format = PAL;
	}else  if((video_format&07) == 0x01){
		Camera_Video_Format = NTSC;
	}else{
		Camera_Video_Format = NULL_SYS;
	}

	return Camera_Video_Format;
}

void InitArk7116MChip(struct i2c_adapter *adap)
{     
     	
	printf("InitArk7116MChip start\n");  
	
	Ark7116M_reset();            // 110脚 硬件复位

	ConfigSlaveMode(adap);          // 配置从模式           

	ConfigDecoderStaticPara(adap);  // 配置静态参数
 
	Ark7116M_mipi_init(adap);       // 初始化mipi 模块
	
	printf("InitArk7116Chip end\n");
	
}

int ark7116M_init(void)
{
	struct i2c_adapter *adap = NULL;

	if (!(adap = i2c_open("i2c0"))) {
		printf("open i2c0 fail.\n");
		return -1;
	}
	
	InitArk7116MChip(adap);

	return 0;
}



#endif