#include "ad9380.h"#include "ad9380yuvdata.h"#include "ad9380vgadata.h"#include "ad9380hdmidata.h"#include "ad9380cscdata.h"#include "i2c.h"static RMuint8 isUpdateCSC=0;static RMuint8 isUpdateCSCTable=0;static void printBinary(RMuint32 val,RMuint8 bits){	RMuint8 i=0;	RMuint32 tmp=0;	for(i=1;i<=bits;i++)	{		tmp=val >> (bits-i);		tmp=tmp & 0x01;		printf("%ld",tmp);	}}RMstatus ad9380_checkRegisterSet(struct RUA *pInstance,										   RMuint32 dev ,										   RMuint8 delay){	RMstatus err=RM_OK;	RMuint32 addr;	//		RMuint32 *data;	RMuint32 reg;/*		for(addr=0x00;addr<=0xed;addr++)	{		err = read_i2c(pInstance, delay, dev, addr, &reg);		if (RMFAILED(err))		{			printf("Can't Read I2C \n");			return err;		}		printf(" reg %lx = %lx \n",addr,reg);				}*/	printf("\n---------------------------\n");	printf("RMuint8 i2c_data[][2] = { \n");	printf("<devicevalues name=\"AD9880 Family\">\n");	//for(addr=0x00;addr<=0x95;addr++)	for(addr=0x00;addr<=0xee;addr++)	{		err = read_i2c(pInstance, delay, dev, addr, &reg);		if (RMFAILED(err))		{			printf("Can't Read I2C \n");			//return err;		}		//printf(" { 0x%lx , 0x%lx },\n",addr,reg);			//printf("0x%2lx,",reg);			//printf("	<registerval addr=\"%lX\" value=\"%lX\"/>\n",addr,reg);		printf("	<registerval addr=\"%2lX\" value=\"%2lX\" ( dec = %3ld , bin = ",addr,reg,reg);		printBinary(reg,8);		printf(")\\>\n");	}	printf("};\n");	printf("\n---------------------------\n");if(0){		RMuint8 hex_val[]={0x13,0x00,0x40,0x54,0x80,0x80,0x80,0x80,0x00,0x80,0x00,0x80,0x00,0x80,0x20,0x40,0x40,0x02,0xa9,0x00,0x00,0x00,0xdb,0x02,0xee,0x08,0x14,0x06,0x4e,0xff,0x20,0x32,0x14,0xec,0x08,0x14,0x20,0x52,0x08,0x80,0x82,0x00,0x05,0x00,0x02,0xd0,0x18,0x6f,0xf0,0x96,0x0d,0x95,0x82,0x2c,0x52,0x08,0x00,0x00,0x00,0x19,0xd7,0x1c,0x54,0x08,0x00,0x1e,0x89,0x02,0x92,0x00,0x00,0x08,0x00,0x0e,0x87,0x18,0xbd,0x3b,0x6d,0x54,0x90,0x40,0x01,0x3f,0x00,0x00,0x0f,0x00,0x91,0x20,0x03,0x0b,0x54,0x81,0x00,0x99,0x00,0x02,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x22,0x55,0x10,0x2d,0x80,0x02,0x11,0x28,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x05,0x00,0x00,0x0b,0x00,		};		for(addr=0x00;addr<=0x95;addr++)		{			reg=hex_val[addr];			switch(addr) {			case 0x00:			case 0x15:			case 0x16:			case 0x17:			case 0x18:			case 0x2f:			case 0x30:						break;			default:				if (addr<0x5a) {					printf(" { 0x%lx , 0x%lx },\n",addr,reg);					}			}						//printf("0x%2lx,",reg);				//printf("	<registerval addr=\"%lX\" value=\"%ld\"/>\n",addr,reg);		}	}	return err;}//Use H#if 0static float H(float curVal,float matchVal,float maxPoint){	float result=0;	float minus=0;		//minus = abs(Curval-matchVal);	if ((curVal==0) || (matchVal==0)) {		result = 0; 	}else		if (curVal >= matchVal) {			minus=curVal-matchVal;			result=maxPoint-(minus/curVal)*maxPoint;			if (result<maxPoint/2) {				result=0;			}		}else{			minus=matchVal-curVal;					result=maxPoint-(minus/matchVal)*maxPoint;			if (result<maxPoint/2) {				result=0;			}		}		return result;		}#elsestatic float H(float curVal,float matchVal,float maxPoint){	float result=0;	float minus=0;		//minus = abs(Curval-matchVal);	if ((curVal==0) || (matchVal==0)) {		result = 0; 	}else		if (curVal >= matchVal) {			minus=curVal-matchVal;			result=maxPoint-minus;			if (result<maxPoint/2) {				result=0;			}		}else{			minus=matchVal-curVal;					result=maxPoint-minus;			if (result<maxPoint/2) {				result=0;			}		}		return result;		}#endifRMstatus ad9380_getCaptureStandard(	struct RUA *pInstance,								   RMuint32 numHsyncPerVsync,								   enum EMhwlibTVStandard tvStandartSupportedList[],								   RMuint8 sizeOftvStandartSupportedList,								   enum EMhwlibTVStandard *newTVStandard){	RMstatus err=RM_OK;	struct EMhwlibTVFormatDigital formatDigital;	RMuint32 curLinesPerField;	float maxH=0;	float curH=0;		RMuint8 i=0;	enum EMhwlibTVStandard oldTVStandard;	oldTVStandard=*newTVStandard;		*newTVStandard=EMhwlibTVStandard_Custom;			for(i=0;i<sizeOftvStandartSupportedList;i++)	{				curH=0; 		err = RUAExchangeProperty(pInstance, DisplayBlock, 			RMDisplayBlockPropertyID_TVFormatDigital, 			&tvStandartSupportedList[i], sizeof(tvStandartSupportedList[i]), 			&formatDigital, sizeof(formatDigital));		if RMFAILED(err) {			fprintf(stderr, "Can not get format!\n");			return err;		}		curLinesPerField = formatDigital.VTotalSize;		if (formatDigital.TopFieldHeight) curLinesPerField /= 2;				//printf("%d > compare %ld with %ld\n",i,numHsyncPerVsync,curLinesPerField);		curH += H((float)numHsyncPerVsync,(float)curLinesPerField,100);		if (maxH<curH) {			*newTVStandard=tvStandartSupportedList[i];			maxH=curH;					}	}		//printf("H = %f\n",maxH);		if (maxH<80) {		*newTVStandard=EMhwlibTVStandard_Custom;	}else		if (maxH<97) {			*newTVStandard=oldTVStandard;		}	return err;}RMstatus ad9380_getCaptureStandardYUV_ByNumHsyncPerVsync(									  struct RUA *pInstance, 									  RMuint8 dev, 									  RMuint8 delay,									  RMuint32 numHsyncPerVsync,									  enum EMhwlibTVStandard *yuvId){	RMstatus err=RM_OK;		enum EMhwlibTVStandard yuvTVStandartSupportedList[]= {		ad9380_yuv_ntsc,//ad9380_yuv_480i,			ad9380_yuv_pal, //ad9380_yuv_576i,						ad9380_yuv_480p,			ad9380_yuv_1080i30,			ad9380_yuv_576p,			ad9380_yuv_720p60,			//		ad9380_yuv_1080i25,					ad9380_yuv_1080p60			//EMhwlibTVStandard_480p59,			//		EMhwlibTVStandard_720p60,			//		EMhwlibTVStandard_1080i60,			//		EMhwlibTVStandard_ITU_Bt656_525,			//		EMhwlibTVStandard_ITU_Bt656_625,						};	err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,yuvTVStandartSupportedList,(sizeof(yuvTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),yuvId);	if (err!=RM_OK) {		printf("Can not get TV standard YUV!\n");	}		return err;}#if AUTODETECT_BY_EMRMstatus ad9380_getCaptureStandardYUV(									  struct RUA *pInstance, 									  RMuint8 dev, 									  RMuint8 delay,									  RMuint32 numHsyncPerVsync,									  enum EMhwlibTVStandard *yuvId){	RMstatus err=RM_OK;	enum EMhwlibTVStandard oldTVStandard;	enum EMhwlibTVStandard yuvTVStandartSupportedList[]= {		ad9380_yuv_ntsc,//ad9380_yuv_480i,		ad9380_yuv_pal, //ad9380_yuv_576i,					ad9380_yuv_480p,		ad9380_yuv_1080i30,		ad9380_yuv_576p,		ad9380_yuv_720p60,//		ad9380_yuv_1080i25,				ad9380_yuv_1080p60		//EMhwlibTVStandard_480p59,		//		EMhwlibTVStandard_720p60,		//		EMhwlibTVStandard_1080i60,		//		EMhwlibTVStandard_ITU_Bt656_525,		//		EMhwlibTVStandard_ITU_Bt656_625,					};	RMuint32 regValue=0x0;		RMuint32 regAdd=0x0;	oldTVStandard=*yuvId;		err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,yuvTVStandartSupportedList,(sizeof(yuvTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),yuvId);	if (err!=RM_OK) {		printf("Can not get TV standard YUV!\n");	}else	{		if (*yuvId!=oldTVStandard) {			printf("Using I2C bus to detect YUV Mode\n");			numHsyncPerVsync=0;						regAdd=0x17;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}					numHsyncPerVsync |= regValue << 8;			usleep(100);			regAdd=0x18;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}			numHsyncPerVsync |= regValue;						err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,yuvTVStandartSupportedList,(sizeof(yuvTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),yuvId);			if (err!=RM_OK) {				printf("Can not get TV standard YUV!\n");			}		}else		{			//printf("Not read I2C AD . NumHS = 0x%lx\n",numHsyncPerVsync);		}	}	return err;}#elseRMstatus ad9380_getCaptureStandardYUV(									  struct RUA *pInstance, 									  RMuint8 dev, 									  RMuint8 delay,									  enum EMhwlibTVStandard *yuvId){	RMstatus err=RM_OK;	RMuint32 regValue=0x0;	RMuint32 regAdd=0x0;	if (1) {		enum EMhwlibTVStandard yuvIdNew=*yuvId;		enum EMhwlibTVStandard yuvIdOld=*yuvId;				RMuint32 numHsyncPerVsync=0;		RMuint8 samples=10;		RMuint8 i;		RMuint8 changeCount=0;		for(i=0;i<samples;i++)		{			regAdd=0x17;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}					regValue &= 0x0f;//Only use 4 low bits			numHsyncPerVsync |= regValue << 8;			usleep(100);			regAdd=0x18;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}			numHsyncPerVsync |= regValue;			if (ad9380_getCaptureStandardYUV_ByNumHsyncPerVsync(pInstance,dev,delay,numHsyncPerVsync,&yuvIdNew)!=RM_OK) {				printf("Error ad9380_getCaptureStandardVGA_ByNumHsyncPerVsync!\n");			}			if (yuvIdNew != yuvIdOld) {				yuvIdOld=yuvIdNew;				changeCount =0;			}else{								changeCount ++;			}						usleep(100);		}				if (changeCount >= 9  ) { //IF SIGNAL DETECT OK.			*yuvId = yuvIdNew;			//printf("\n****Count Change = %d \n",changeCount);		}					}else{			regAdd=0x15;	usleep(100);	err = read_i2c(pInstance, delay, dev, regAdd, &regValue);	if (RMFAILED(err)) {		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);		return err;	}		usleep(100);	switch(regValue) {	case 0x04:	case 0xac://YUV+VGA		regAdd=0x17;		err = read_i2c(pInstance, delay, dev, regAdd, &regValue);		if (RMFAILED(err)) {			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);			return err;		}				usleep(100);		switch(regValue) {		case 0x01:			regAdd=0x18;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}			switch(regValue) {			case 0x06:			case 0x07:				*yuvId=ad9380_yuv_ntsc;				break;			case 0x39:			case 0x38:				*yuvId=ad9380_yuv_pal;				break;			default:				*yuvId=ad9380_invalid_standard;//				fprintf(stderr, "0x04 - 0x01 - 0x%lx\n",regValue);				//err=RM_ERROR;			}			break;		case 0x02:			regAdd=0x18;						err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}			switch(regValue) {			case 0x0d:			case 0x41:				*yuvId=ad9380_yuv_480p;				break;			case 0x32: //1080i30			case 0x33:				*yuvId=ad9380_yuv_1080i30;				break;			case 0xee:			case 0x18:			case 0x15:				*yuvId=ad9380_yuv_720p60;				break;			case 0x71:				*yuvId=ad9380_yuv_576p;				break;			default:				*yuvId=ad9380_invalid_standard;//				fprintf(stderr, "0x04 - 0x02 - 0x%lx\n",regValue);				//err=RM_ERROR;			}			break;				case 0x04:			regAdd=0x18;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}			switch(regValue) {			case 0x6d:				*yuvId=ad9380_yuv_480p;				break;			case 0x8a:				*yuvId=ad9380_yuv_1080i30;				break;			case 0x65:				*yuvId=ad9380_yuv_1080p60;				break;							default:				*yuvId=ad9380_invalid_standard;//				fprintf(stderr, "0x04 - 0x04 - 0x%lx\n",regValue);				//err=RM_ERROR;			}			break;		default:			*yuvId=ad9380_invalid_standard;//			fprintf(stderr, "0x04 - 0x%lx\n",regValue);			//err=RM_ERROR;		}		break;	case 0x08:			regAdd=0x17;		err = read_i2c(pInstance, delay, dev, regAdd, &regValue);		if (RMFAILED(err)) {			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);			return err;		}		usleep(100);		switch(regValue) {		case 0x01:			regAdd=0x18;			err = read_i2c(pInstance, delay, dev, regAdd, &regValue);			if (RMFAILED(err)) {				fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);				return err;			}			switch(regValue) {			case 0x07:				regAdd=0x5e;				err = read_i2c(pInstance, delay, dev, regAdd, &regValue);				if (RMFAILED(err)) {					fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);					return err;