ad9380.c

Sample code for use on smp 863x processor.

#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 0
static 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;
		
}
#else
static 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;		
}
#endif

RMstatus 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_EM

RMstatus 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;
}
#else
RMstatus 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;