ad9380.c

Sample code for use on smp 863x processor.

	err=read_i2c(pInstance,delay,dev,regAdd,&regVal);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	if (regVal & 0x60) {
		*isRGB=0;
	}else
		*isRGB=1; //Y[1:0] = 00
	return err;
}

RMstatus ad9380_getHdmiCSCInput(struct RUA *pInstance,
								  RMuint8 dev, 
								  RMuint8 delay,
								  RMuint8 *idCSC)
{
	RMstatus err=RM_OK;
	RMuint32 regAdd=0;
	RMuint32 regVal=0;
	regAdd=0x81;
	err=read_i2c(pInstance,delay,dev,regAdd,&regVal);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	/*
	printf("reg 0x81 = 0x%lx\n -> (regVal&0x60)>>5 = ",regVal);
		printBinary((regVal&0x60)>>5,8);
		printf("\n");*/
	
	switch((regVal&0x60)>>5) {
	case 0: //RGB
		*idCSC=0;
		break;
	case 1: //YCbCr 4:2:2
		*idCSC=1;
		break;
	case 2: //YCbCr 4:4:4
		*idCSC=2;
		break;
	default:
		printf("Unknown CSC input format \n");
		break;
	}
	
	return err;
}

RMstatus ad9380_setHdmiCSCOutput(struct RUA *pInstance,
								RMuint8 dev, 
								RMuint8 delay,
								RMuint8 idCSCInput)
{
	RMstatus err=RM_OK;
	switch(idCSCInput) {
	case 0: //RGB
		//printf("CSC RGB Input detected \n");
		err=ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,0);
		break;
	case 1: //YCbCr 4:2:2		
		printf("CSC YCbCr 4:2:2 Input detected \n");
		err=ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,1);
		break;
	case 2: //YCbCr 4:4:4
		printf("CSC YCbCr 4:4:4 Input detected \n");
		err=ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,1);			
		//err=ad9380_setColorSpaceConverter_test(pInstance,dev,delay,45);
		break;
	default:
		printf("Invalid CSC detected !");
		err=RM_ERROR;
	}

	return err;
}

RMstatus ad9380_setMacrovisionOverSampleStatus(struct RUA *pInstance,
						   RMuint8 dev, 
						   RMuint8 delay,
						   RMuint8 isEnable)
{
	RMstatus err=RM_OK;
	RMuint32 regAdd=0;
	RMuint32 regValue=0;
	regAdd=0x32;
	err = read_i2c(pInstance, delay, dev, regAdd, &regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
	if (isEnable) {
		regValue |= 0x80;
		err = write_i2c(pInstance, delay, dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Can't enable Macrovision over sample . \nFailed to write reg 0x%lx\n",regAdd);
			return err;
		}
	}else {
		regValue &= (~0x80);
		err = write_i2c(pInstance, delay, dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Can't disavle Macrovision over sample . \nFailed to write reg 0x%lx\n",regAdd);
			return err;
		}
	}
	return err;
}
#if AUTODETECT_BY_EM
RMstatus ad9380_getCaptureStandardHDMI(
									  struct RUA *pInstance, 
									  RMuint8 dev, 
									  RMuint8 delay,
									  RMuint32 numHsyncPerVsync,
									  enum EMhwlibTVStandard *hdmiId)
{
	RMstatus err=RM_OK;
	enum EMhwlibTVStandard oldTVStandard;
	enum EMhwlibTVStandard hdmiTVStandartSupportedList[]= 
	{
		ad9380_hdmi_480i,
		ad9380_hdmi_480p, 
		ad9380_hdmi_576p, 
		ad9380_hdmi_720p60,
		ad9380_hdmi_1080i59,
		ad9380_hdmi_1080i60,
		ad9380_hdmi_1080p60,							
	};
	RMuint32 regValue=0x0;	
	RMuint32 regAdd=0x0;
	oldTVStandard=*hdmiId;
	
	err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,hdmiTVStandartSupportedList,(sizeof(hdmiTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),hdmiId);
	if (err!=RM_OK) {
		printf("Can not get TV standard YUV!\n");
	}else
	{
		if (*hdmiId!=oldTVStandard) {
			printf("Read I2C to make sure that capture standard change\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;
			}		
			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;
			
			err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,hdmiTVStandartSupportedList,(sizeof(hdmiTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),hdmiId);
			if (err!=RM_OK) {
				printf("Can not get TV standard HDMI!\n");
			}
		}else
		{
			//printf("Not read I2C AD . NumHS = 0x%lx\n",numHsyncPerVsync);
		}
	}
	return err;
}
#else

RMstatus ad9380_getCaptureStandardHDMI_ByNumHsyncPerVsync(
									   struct RUA *pInstance, 
									   RMuint8 dev, 
									   RMuint8 delay,
									   RMuint32 numHsyncPerVsync,
									   enum EMhwlibTVStandard *hdmiId)
{
	RMstatus err=RM_OK;
	enum EMhwlibTVStandard hdmiTVStandartSupportedList[]= 
	{
		ad9380_hdmi_480i,
			ad9380_hdmi_480p,
			ad9380_hdmi_480p59,
			ad9380_hdmi_576p, 
			ad9380_hdmi_720p60,
			ad9380_hdmi_1080i59,
			ad9380_hdmi_1080i60,
			ad9380_hdmi_1080p60,							
	};
	
	err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,hdmiTVStandartSupportedList,(sizeof(hdmiTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),hdmiId);
	if (err!=RM_OK) {
		printf("Can not get TV standard YUV!\n");
	}
	return err;
}
RMstatus ad9380_getCaptureStandardHDMI(
									  struct RUA *pInstance, 
									  RMuint8 dev, 
									  RMuint8 delay,
									  enum EMhwlibTVStandard *hdmiId)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x0;
	RMuint32 regAdd=0x0;	

	if (1) {
		enum EMhwlibTVStandard hdmiIdNew=*hdmiId;
		enum EMhwlibTVStandard hdmiIdOld=*hdmiId;
		
		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_getCaptureStandardHDMI_ByNumHsyncPerVsync(pInstance,dev,delay,numHsyncPerVsync,&hdmiIdNew)!=RM_OK) {
				printf("Error ad9380_getCaptureStandardVGA_ByNumHsyncPerVsync!\n");
			}
			if (hdmiIdNew != hdmiIdOld) {
				hdmiIdOld=hdmiIdNew;
				changeCount =0;
			}else{				
				changeCount ++;
			}
			
			usleep(100);
		}
		
		if (changeCount >= 9  ) { //IF SIGNAL DETECT OK.
			*hdmiId = hdmiIdNew;
			//printf("\n****Count Change = %d \n",changeCount);
		}
		
		
	}else{

			regAdd=0x18;
		usleep(300);
		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: //480i60
		case 0x07: //480i59
		case 0x38:
		case 0x39:
		case 0x40:
			*hdmiId=ad9380_hdmi_480i;
			break;		*/


		case 0x0c:
		case 0x0d: //480p
		case 0x0e:
	//	case 0x77:
			*hdmiId=ad9380_hdmi_480p;
			break;
		case 0x70:
		case 0x71://576p (PAL)
		case 0x72:
			*hdmiId=ad9380_hdmi_576p;
			break;
		case 0xed:
		case 0xee://720p	
		case 0xef:
			*hdmiId=ad9380_hdmi_720p60;
			break;
		case 0x32:
		case 0x33://1080i
		case 0x34:
			*hdmiId=ad9380_hdmi_1080i59;
			//*hdmiId=ad9380_hdmi_1080i60;
			break;
		case 0x65:
			//*hdmiId=ad9380_hdmi_1080p59;
		//	break;
		case 0x64:
			//*hdmiId=ad9380_hdmi_480i;
			//*hdmiId=ad9380_hdmi_480p;
			//*hdmiId=ad9380_hdmi_1080i59;		
			//*hdmiId=ad9380_hdmi_720p60;
			//*hdmiId=ad9380_hdmi_1080p60;
			*hdmiId=ad9380_hdmi_1080p59;
			break;		
			
		case 0:
	//		printf("NO SYGNAL DETECTED !\n 0x18=0");
		default:
		
			*hdmiId=ad9380_invalid_standard;
			fprintf(stderr, "Invalid standard regVal=  0x%lx\n",regValue);
			//err=RM_ERROR;
		}

	}
	return err;
}
#endif

RMstatus ad9380_setCaptureStandardHDMI(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,enum EMhwlibTVStandard hdmiId)
{
	RMstatus err=RM_OK;
		if (0) {
				ad9380_setCaptureStandard(pInstance,dev,delay,hdmiId);
			}
				
	switch(hdmiId) {		
	case ad9380_hdmi_720p59:
	case ad9380_hdmi_720p60:
		err=init_i2c(pInstance,delay,dev,AD9380_HDMI_720p_I2CDATA,sizeof(AD9380_HDMI_720p_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard HDMI \n");
			return err;
		}
		break;	
	
		
	case ad9380_hdmi_480i:
	case ad9380_hdmi_480p:
	case ad9380_hdmi_576p:
	case ad9380_hdmi_480p59:
		if (0) {
			err=init_i2c(pInstance,delay,dev,AD9380_HDMI_TESTING_I2CDATA,sizeof(AD9380_HDMI_TESTING_I2CDATA)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard HDMI \n");
				return err;
			}
		}else{
			err=init_i2c(pInstance,delay,dev,AD9380_HDMI_480_I2CDATA,sizeof(AD9380_HDMI_480_I2CDATA)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard HDMI \n");
				return err;
			}
		}
		
		break;	
	case ad9380_hdmi_1080i60:
	case ad9380_hdmi_1080i59:
		err=init_i2c(pInstance,delay,dev,AD9380_HDMI_1080i_I2CDATA,sizeof(AD9380_HDMI_1080i_I2CDATA)/2/sizeof(RMuint8));
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to set capture standard HDMI \n");
			return err;
		}
		break;	
	case ad9380_hdmi_1080p59:
	case ad9380_hdmi_1080p60:
		if (1) {
			err=init_i2c(pInstance,delay,dev,AD9380_HDMI_TESTING_I2CDATA,sizeof(AD9380_HDMI_TESTING_I2CDATA)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard HDMI \n");
				return err;
			}
			
		}else {
			err=init_i2c(pInstance,delay,dev,AD9380_HDMI_1080p_I2CDATA,sizeof(AD9380_HDMI_1080p_I2CDATA)/2/sizeof(RMuint8));
			if (RMFAILED(err)) {
				fprintf(stderr, "Failed to set capture standard HDMI \n");
				return err;
			}
		}
		
		break;	
	default:
		err=RM_ERROR;
		if (RMFAILED(err)) {
			fprintf(stderr, "No support current capture standard HDMI !\n");
		}
		break;
	}
	
	return err;
}
#if	AUTODETECT_BY_EM
RMstatus ad9380_autoUpdateCaptureStandardHDMI(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint32 numHsyncPerVsync,enum EMhwlibTVStandard *cur_std)
{
	RMstatus err=RM_OK;
	RMuint8 idCSC=0;
	enum EMhwlibTVStandard old_std;
	
	old_std=*cur_std;
				
	if (isUpdateCSC) {
		err	= ad9380_getHdmiCSCInput(pInstance,dev,delay,&idCSC);
		
		
		if (err==RM_OK) {
			//err=ad9380_setHdmiCSCOutput(pInstance,dev,delay,idCSC);
			
			if (idCSC && (*cur_std)) {
				if (isUpdateCSCTable) {

					ad9380_setColorSpaceConverter(pInstance,dev,delay,*cur_std);
					isUpdateCSCTable=0;
				}				
			}
		}		
		isUpdateCSC=0;
	}

	if (ad9380_getCaptureStandardHDMI(pInstance,dev,delay,numHsyncPerVsync,cur_std)!=RM_OK) {
		//printf("No Standard detected \n");
		return RM_ERROR;
	}
	

	if((*cur_std != old_std) && (*cur_std!=EMhwlibTVStandard_Custom)) {	
		
		
		
		printf("Detected change capture HDMI standard %d, old = %d\n",*cur_std,old_std);
		ad9380_setCaptureStandardHDMI(pInstance,dev,delay,*cur_std);
		
		//ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,0);
		ad9380_setMacrovisionOverSampleStatus(pInstance,dev,delay,1);
		
		//ad9380_setColorSpaceConverter(pInstance,dev,delay,*cur_std);
		err	= ad9380_getHdmiCSCInput(pInstance,dev,delay,&idCSC);
		if(0){//Test
			
			int i=0;
			//while(0){		
			while(i<20) {
				RMuint32 regAdd=0;
				RMuint32 regVal;
				regAdd=0x84;
				if (read_i2c(pInstance,10,0x98>>1,regAdd,&regVal)==RM_OK) {
					printf("read 0x%lx :  0x%lx\n",regAdd,regVal);
				}
				regVal=0;
				if (regVal) {
					printf("Signal OK !\n");
					break;
				}
				sleep(1);
				i++;
			}
		}//test
		if (err==RM_OK) {
			err=ad9380_setHdmiCSCOutput(pInstance,dev,delay,idCSC);
		}
		isUpdateCSC=1; //Re update CSC
		}
	
				
	

	return err;
}
#else
RMstatus ad9380_autoUpdateCaptureStandardHDMI(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,enum EMhwlibTVStandard *cur_std)
{
	RMstatus err=RM_OK;
	RMuint8 idCSC=0;
	RMuint8 old_std;
	old_std=*cur_std;
	
	if (isUpdateCSC) {
		err	= ad9380_getHdmiCSCInput(pInstance,dev,delay,&idCSC);
		if (err==RM_OK) {
			err=ad9380_setHdmiCSCOutput(pInstance,dev,delay,idCSC);
			if (idCSC && (*cur_std)) {
				if (isUpdateCSCTable) {
					ad9380_setColorSpaceConverter(pInstance,dev,delay,*cur_std);
					isUpdateCSCTable=0;
				}