ad9380.c

Sample code for use on smp 863x processor.

			}
		}		
		isUpdateCSC=0;
	}
	
	
	
	if (ad9380_getCaptureStandardHDMI(pInstance,dev,delay,cur_std)!=RM_OK) {
		//printf("No Standard detected \n");
		return RM_ERROR;
	}
	
	if (*cur_std != old_std) {		
		//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;
}
#endif
#if AUTODETECT_BY_EM
RMstatus ad9380_autoUpdateCaptureStandardYUV(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint32 numHsyncPerVsync,enum EMhwlibTVStandard *cur_std)
{
	RMstatus err=RM_OK;	
	enum EMhwlibTVStandard old_std;
	old_std=*cur_std;
	
	if (ad9380_getCaptureStandardYUV(pInstance,dev,delay,numHsyncPerVsync,cur_std)!=RM_OK) {
		
		//printf("No Standard detected \n");
		return RM_ERROR;
	}
	
	if (*cur_std != old_std) {		
		printf("Detected change capture YUV standard %d\n",*cur_std);
		ad9380_setCaptureStandardYUV(pInstance,dev,delay,*cur_std);		
		ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,0);	
		ad9380_setAudioClockYUV(pInstance,dev,delay,1);
	}				
				
	return err;
}
#else
RMstatus ad9380_autoUpdateCaptureStandardYUV(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,enum EMhwlibTVStandard *cur_std)
{
	RMstatus err=RM_OK;	
	enum EMhwlibTVStandard old_std;
	old_std=*cur_std;	
	if (ad9380_getCaptureStandardYUV(pInstance,dev,delay,cur_std)!=RM_OK) {
		
		//printf("No Standard detected \n");
		return RM_ERROR;
	}
	
	if (*cur_std != old_std) {		
		printf("Detected change capture YUV standard %d\n",*cur_std);
		ad9380_setCaptureStandardYUV(pInstance,dev,delay,*cur_std);		
		ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,0);	
		ad9380_setAudioClockYUV(pInstance,dev,delay,1);
		ad9380_setAutoOffset(pInstance,dev,delay,1);
	}				
				
	return err;
}

#endif
#if	AUTODETECT_BY_EM
RMstatus ad9380_autoUpdateCaptureStandardVGA(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,RMuint32 numHsyncPerVsync,enum EMhwlibTVStandard *cur_std)
{
	RMstatus err=RM_OK;
	RMuint8 old_std;
	old_std=*cur_std;
	
	
	if (ad9380_getCaptureStandardVGA(pInstance,dev,delay,numHsyncPerVsync,cur_std)!=RM_OK) {
		//printf("No Standard detected \n");
		//return RM_ERROR;
	}
	
	if (*cur_std != old_std) {		
		printf("Detected change capture VGA standard %d\n",*cur_std);
		ad9380_setCaptureStandardVGA(pInstance,dev,delay,*cur_std);		
		ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,0);	
		//		ad9380_setAudioClockYUV(pInstance,dev,delay);
	}				
				
	return err;
}
#else
RMstatus ad9380_autoUpdateCaptureStandardVGA(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,enum EMhwlibTVStandard *cur_std)
{
	RMstatus err=RM_OK;
	enum EMhwlibTVStandard old_std;
	old_std=*cur_std;
	
	
	if (ad9380_getCaptureStandardVGA(pInstance,dev,delay,cur_std)!=RM_OK) {
		//printf("No Standard detected \n");
		//return RM_ERROR;
	}
	
	if (*cur_std != old_std) {		
		printf("Detected change capture VGA standard %d\n",*cur_std);
		ad9380_setCaptureStandardVGA(pInstance,dev,delay,*cur_std);		
		ad9380_setColorSpaceConverterStatus(pInstance,dev,delay,1);	
		//ad9380_setColorSpaceConverter(pInstance,dev,delay,*cur_std);
		ad9380_setColorSpaceConverter_test(pInstance,dev,delay,48);
//		ad9380_setAudioClockYUV(pInstance,dev,delay);
	}				
				
	return err;
}
#endif

RMstatus ad9380_getAudioFrequency(struct RUA *pInstance, 								  
							RMuint8 dev, 
							RMuint8 delay,
							RMuint32 *pclk)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	RMuint32 regValue=0;
	RMuint32 regAdd=0x5f;	
	RMuint32 Channelstatus=0;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
//	printf("0x%lx = 0x%lx\n",regAdd,regValue);
	Channelstatus = regValue;
	regValue=0;
	regAdd=0x60;	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}	
//	printf("0x%lx = 0x%lx\n",regAdd,regValue);
	Channelstatus += regValue;
	if (!Channelstatus) {
		return RM_ERROR;
	}
	regValue=0;
	regAdd=0x61;	
	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	*pclk=regValue & 0x0f;
	
	return err;
}


RMstatus ad9380_getPacketDetect(struct RUA *pInstance,
								  RMuint8 dev, 
								  RMuint8 delay,
								  RMuint32 *packetID)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	RMuint32 regValue=0;
	RMuint32 regAdd=0x5a;	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	*packetID=regValue;
	return err;
}

RMstatus ad9380_getAudioSampleRateHDMI(
									struct RUA *pInstance, 
									RMuint8 dev, 
									RMuint8 delay,
									RMuint32 *sampleRate)
{
	RMstatus err;
	RMuint32 pclk;
	
	err = ad9380_getAudioFrequency(pInstance,dev,delay,&pclk);
	if (err !=RM_OK) {
		//printf("can't get Audio Frequency \n");
		*sampleRate=0;
		return err;
	}
	
	pclk &= 0x0F;
/*
	fprintf(stderr, "\n\n\tAudio fs: %s\n\n\n", 
		(pclk == 0) ? "44.1 kHz" : 
	(pclk == 1) ? "<unknown>" : 
	(pclk == 2) ? "48 kHz" : 
	(pclk == 3) ? "32 kHz" : 
	(pclk == 4) ? "22.05 kHz <invalid>" : 
	(pclk == 5) ? "11.025 kHz <invalid>" : 
	(pclk == 6) ? "24 kHz <invalid>" : 
	(pclk == 7) ? "16 kHz <invalid>" : 
	(pclk == 8) ? "88.2 kHz" : 
	(pclk == 9) ? "8 kHz <invalid>" : 
	(pclk == 10) ? "96 kHz" : 
	(pclk == 11) ? "<reserved>" : 
	(pclk == 12) ? "176.4 kHz" : 
	(pclk == 13) ? "12 kHz <invalid>" : 
	(pclk == 14) ? "192 kHz" : 
	(pclk == 15) ? "<not indicated>" : "-");*/




	if (0) {
		switch (pclk) {
		case  0: *sampleRate =  44100; break;
		case  1: 
			*sampleRate =      0; 
			//*sampleRate =  44100;
			break;  // no audio
		case  2: *sampleRate =  48000; break;
		case  3: *sampleRate =  32000; break;
			//case  4: *sampleRate =  22050; break;
			//case  5: *sampleRate =  11025; break;
			//case  6: *sampleRate =  24000; break;
			//case  7: *sampleRate =  16000; break;
		case  8: *sampleRate =  88200; break;
			//case  9: *sampleRate =   8000; break;
		case 10: *sampleRate =  96000; break;
		case 12: *sampleRate = 176400; break;
			//case 13: *sampleRate =  12000; break;
		case 14: *sampleRate = 192000; break;
		default: 
			//*sampleRate =  44100;
			*sampleRate =  0;
			//return RM_ERROR;
			return RM_OK;
		}
	}else{
		switch (pclk) {//Only support 44 Khz and 48 Khz.
		case  0x00: *sampleRate =  44100; break;
//		case  1: *sampleRate =      0; 	break;  // no audio
		case  0x02: *sampleRate =  48000; break;
//		case  3: *sampleRate =  32000; break;
			//case  4: *sampleRate =  22050; break;
			//case  5: *sampleRate =  11025; break;
			//case  6: *sampleRate =  24000; break;
			//case  7: *sampleRate =  16000; break;
//		case  8: *sampleRate =  88200; break;
			//case  9: *sampleRate =   8000; break;
		case 0x0a: *sampleRate =  96000; break;
//		case 12: *sampleRate = 176400; break;
			//case 13: *sampleRate =  12000; break;
		case 0x0d: *sampleRate = 192000; break;
		default: 
			//*sampleRate =  44100;
			*sampleRate =  0;
			//return RM_ERROR;
			return RM_OK;
		}
	}
	
	return err;
}

//VGA CAPTURE////////////////////////////////////////////////////////////////////////

RMstatus ad9380_getCaptureStandardVGA_ByNumHsyncPerVsync(
									  struct RUA *pInstance, 
									  RMuint8 dev, 
									  RMuint8 delay,
									  RMuint32 numHsyncPerVsync,
									  enum EMhwlibTVStandard *vgaId)
{
	RMstatus err=RM_OK;
	enum EMhwlibTVStandard vgaTVStandartSupportedList[]= 
	{
		ad9380_vga_25mhz_60hz,
			ad9380_vga_25mhz_75hz, 
			ad9380_vga_25mhz_85hz, 
			ad9380_vga_40mhz_60hz,
			//		ad9380_vga_40mhz_75hz,
			//		ad9380_vga_40mhz_85hz,
			ad9380_vga_65mhz_60hz,
			//		ad9380_vga_78mhz_75hz,
			//		ad9380_vga_94mhz_85hz,
			ad9380_vga_1280_768,
			ad9380_vga_108mhz_60hz,
			ad9380_vga_157mhz_85hz,					
	};
	err=ad9380_getCaptureStandard(pInstance,numHsyncPerVsync,vgaTVStandartSupportedList,(sizeof(vgaTVStandartSupportedList) / sizeof(enum EMhwlibTVStandard)),vgaId);
	if (err!=RM_OK) {
		printf("Can not get TV standard YUV!\n");
	}
	return err;
}

RMstatus ad9380_getCaptureStandardVGA(
									  struct RUA *pInstance, 
									  RMuint8 dev, 
									  RMuint8 delay,
									  enum EMhwlibTVStandard *vgaId)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x0;
	RMuint32 regAdd=0x0;
	
	if (1) {
		enum EMhwlibTVStandard vgaIdNew=*vgaId;
		enum EMhwlibTVStandard vgaIdOld=*vgaId;

		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_getCaptureStandardVGA_ByNumHsyncPerVsync(pInstance,dev,delay,numHsyncPerVsync,&vgaIdNew)!=RM_OK) {
				printf("Error ad9380_getCaptureStandardVGA_ByNumHsyncPerVsync!\n");
			}
			if (vgaIdNew != vgaIdOld) {
				vgaIdOld=vgaIdNew;
				changeCount =0;
			}else{				
				changeCount ++;
			}

			usleep(100);
		}

		if (changeCount >= 9  ) { //IF SIGNAL DETECT OK.
			*vgaId = vgaIdNew;
			//printf("\n****Count Change = %d \n",changeCount);
		}
		
		
	}else{



	regAdd=0x15;
	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 0xa0:
	case 0xa8:
	case 0xac: //VGA+YUV
		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;
		}
		switch(regValue) {
		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:
				*vgaId=ad9380_vga_25mhz_60hz;
				break;
			case 0x74: //60 hz
				*vgaId=ad9380_vga_40mhz_60hz;
			case 0x71: //75 hz				
				*vgaId=ad9380_vga_40mhz_75hz;
			case 0x77: //85 hz
				*vgaId=ad9380_vga_40mhz_85hz;
				break;			
			default:
				*vgaId=ad9380_invalid_standard;				
			}
			break;
		case 0x03:
				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 0x1e:
				case 0x1b: //1280x768x60
					*vgaId=ad9380_vga_1280_768;
					break;
				case 0x26:
					*vgaId=ad9380_vga_65mhz_60hz;
					break;			
				case 0x20:
					*vgaId=ad9380_vga_78mhz_75hz;
					break;			
				case 0x28:
					*vgaId=ad9380_vga_94mhz_85hz;
					break;	
					
				default:
					*vgaId=ad9380_invalid_standard;
				}
				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 0x2a: //1280x1024x60
				*vgaId=ad9380_vga_108mhz_60hz;
				//*vgaId=ad9380_vga_135mhz_75hz; //Same
				break;			
			
			case 0x30:
				*vgaId=ad9380_vga_157mhz_85hz;
				break;			
				
			default:
				*vgaId=ad9380_invalid_standard;
			}
			break;
		default:
			*vgaId=ad9380_invalid_standard;
		}
		break;
	default:
		*vgaId=ad9380_invalid_standard;
		break;
	}
	}
	
	return err;
}


RMstatus ad9380_setCaptureStandardVGA(struct RUA *pInstance, RMuint8 dev, RMuint8 delay,enum EMhwlibTVStandard vgaId)