tw9919eid.c

Sample code for use on smp 863x processor.

			err=init_i2c(pInstance,delay,dev,TW9919E_AMCLK_32KHZ_PAL,sizeof(TW9919E_AMCLK_32KHZ_PAL)/2/sizeof(RMuint8));
			if (err!=RM_OK) {
				printf("tw9919eid_setAudioClock Error <7>\n");
			}
			break;
		case audio_frequency_8khz:
			err=init_i2c(pInstance,delay,dev,TW9919E_AMCLK_8KHZ_PAL,sizeof(TW9919E_AMCLK_8KHZ_PAL)/2/sizeof(RMuint8));
			if (err!=RM_OK) {
				printf("tw9919eid_setAudioClock Error <8\n");
			}
			break;	
		}
		
	}
	
	return err;
}

RMstatus tw9919eid_setStandardAutoDetect(struct RUA *pInstance, 								  
										 RMuint8 dev, 
										 RMuint8 delay )
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	RMuint32 regAdd=0x1c;
	err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	err=write_i2c(pInstance,delay,dev,regAdd,regValue | 0x07); //Auto standard
	//err=write_i2c(pInstance,delay,dev,0x07,0x10);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
		return err;
	}
	return err;
}

//Use H
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;
		
}

RMstatus tw9919eid_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=96;
	float curH=0;	
	RMuint8 i=0;
	
	*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);	
	
	return err;
}

RMstatus tw9919eid_checkStandardDetected(struct RUA *pInstance, 								  
										 RMuint8 dev, 
										 RMuint8 delay )
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	err = read_i2c(pInstance,delay,dev,0x1c,&regValue);	
	if (err!=RM_OK) {
		printf("setSizeOfSDRAM Error <1>  \n");
		return err;
	}
	fprintf(stderr, "TW9919	: Detected 60Hz %s, setting up CC\n", 
		(((regValue & 0x70)>>4) == 0) ? "NTSC(M)" : 
	(((regValue & 0x70)>>4) == 1) ? "PAL (B,D,G,H,I)" : 
	(((regValue & 0x70)>>4) == 2) ? "SECAM" : 
	(((regValue & 0x70)>>4) == 3) ? "NTSC4.43" :
	(((regValue & 0x70)>>4) == 4) ? "PAL (M)" :
	(((regValue & 0x70)>>4) == 5) ? "PAL (CN)" :
	(((regValue & 0x70)>>4) == 6) ? "PAL 60" :  "Not valid" );
	return err;
}

RMstatus tw9919eid_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");
	
	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(" { 0x%lx , 0x%lx },\n",addr,reg);	
	}
	printf("};\n");
	printf("\n---------------------------\n");
	return err;
}

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

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

	*contrastValue=regValue & 0xff;

	return err;
}

RMstatus tw9919eid_isContrastValid(struct RUA *pInstance, 								  
								RMuint8 dev, 
								RMuint8 delay,
								RMuint32 contrastValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	if ((contrastValue<0)||(contrastValue>255)) {
		err=RM_ERROR;
	}
	return err;
}
RMstatus tw9919eid_setBrightness(struct RUA *pInstance, 								  
							   RMuint8 dev, 
							   RMuint8 delay,
							   RMint32 brightnessValue)
{
	RMstatus err=RM_OK;
	// if contrastValue = 0x80 or 0x90 -> No effect on the video data
	if ((brightnessValue>=-128)&&(brightnessValue<=127)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x10;
		regValue=brightnessValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}


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

RMstatus tw9919eid_isBrightnessValid(struct RUA *pInstance, 								  
								  RMuint8 dev, 
								  RMuint8 delay,
								  RMint32 brightnessValue)
{
	RMstatus err=RM_OK;
	// if brightnessValue = 0x80 or 0x90 -> No effect on the video data
	if ((brightnessValue<-128)||(brightnessValue>127)) {
		err=RM_ERROR;
	}
	return err;
}

RMstatus tw9919eid_setSaturationU(struct RUA *pInstance, 								  
								 RMuint8 dev, 
								 RMuint8 delay,
								 RMuint32 saturationUValue)
{
	RMstatus err=RM_OK;
	
	if ((saturationUValue>=0)&&(saturationUValue<=255)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x13;
		regValue=saturationUValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus tw9919eid_setSaturationV(struct RUA *pInstance, 								  
								  RMuint8 dev, 
								  RMuint8 delay,
								  RMuint32 saturationVValue)
{
	RMstatus err=RM_OK;
	
	if ((saturationVValue>=0)&&(saturationVValue<=255)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x14;
		regValue=saturationVValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus tw9919eid_setSaturation(struct RUA *pInstance, 								  
								  RMuint8 dev, 
								  RMuint8 delay,
								  RMuint32 saturationValue)
{
	RMstatus err=RM_OK;
	
	if ((saturationValue>=0)&&(saturationValue<=255)) {
		err=tw9919eid_setSaturationU(pInstance,dev,delay,saturationValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to setSaturationU\n");
			return err;
		}
		err=tw9919eid_setSaturationV(pInstance,dev,delay,saturationValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to setSaturationV\n");
			return err;
		}
	}
	return err;
}
RMstatus tw9919eid_setHue(struct RUA *pInstance, 								  
						  RMuint8 dev, 
						  RMuint8 delay,
						  RMint32 hueValue)
{
	RMstatus err=RM_OK;	
	if ((hueValue>=-128)&&(hueValue<=127)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x15;
		regValue=hueValue & 0xff;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}
RMstatus tw9919eid_setSharpness(struct RUA *pInstance, 								  
								RMuint8 dev, 
								RMuint8 delay,
								RMuint32 sharpnessValue)
{
	RMstatus err=RM_OK;	
	if ((sharpnessValue>=0)&&(sharpnessValue<=15)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x12;
		err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
			return err;
		}
		regValue=regValue & 0xf0;
		regValue=regValue | (sharpnessValue & 0xff);

		printf("reg 0x12 = 0x%lx\n",regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus tw9919eid_setCTI(struct RUA *pInstance, 								  
						  RMuint8 dev, 
						  RMuint8 delay,
						  RMuint32 ctiValue)
{
	RMstatus err=RM_OK;	
	if ((ctiValue>=0)&&(ctiValue<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x12;
		err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
			return err;
		}
		regValue=regValue & 0xcf;
		regValue=regValue | ((ctiValue & 0xff)<<4);
		printf("reg 0x12 = 0x%lx\n",regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}


RMstatus tw9919eid_setYGain(struct RUA *pInstance, 								  
							RMuint8 dev, 
							RMuint8 delay,
							RMuint32 value)
{
	RMstatus err=RM_OK;	
	if ((value>=0)&&(value<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x70;
		err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
			return err;
		}
		regValue=regValue & 0x0f;
		regValue=regValue | ((value & 0xff)<<4);
		printf("write to 0x%lx value 0x%lx\n",regAdd,regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}
RMstatus tw9919eid_setCGain(struct RUA *pInstance, 								  
							RMuint8 dev, 
							RMuint8 delay,
							RMuint32 value)
{
	RMstatus err=RM_OK;	
	if ((value>=0)&&(value<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x71;
		err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
			return err;
		}
		regValue=regValue & 0x0f;
		regValue=regValue | ((value & 0xff)<<4);
		printf("write to 0x%lx value 0x%lx\n",regAdd,regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}
RMstatus tw9919eid_setMDLevel1(struct RUA *pInstance, 								  
							   RMuint8 dev, 
							   RMuint8 delay,
							   RMuint32 value)
{
	RMstatus err=RM_OK;	
	if ((value>=0)&&(value<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x73;
		err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
			return err;
		}
		regValue=regValue & 0xf0;
		regValue=regValue | (value & 0xff);
		printf("write to 0x%lx value 0x%lx\n",regAdd,regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}
RMstatus tw9919eid_setMDLevel2(struct RUA *pInstance, 								  
							   RMuint8 dev, 
							   RMuint8 delay,
							   RMuint32 value)
{
	RMstatus err=RM_OK;	
	if ((value>=0)&&(value<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x74;
		regValue=(value & 0xff);
		printf("write to 0x%lx value 0x%lx\n",regAdd,regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus tw9919eid_setMDLevel3(struct RUA *pInstance, 								  
							   RMuint8 dev, 
							   RMuint8 delay,
							   RMuint32 value)
{
	RMstatus err=RM_OK;	
	if ((value>=0)&&(value<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x75;
		regValue=(value & 0xff);
		printf("write to 0x%lx value 0x%lx\n",regAdd,regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}

RMstatus tw9919eid_setMIX(struct RUA *pInstance, 								  
						  RMuint8 dev, 
						  RMuint8 delay,
							   RMuint32 value)
{
	RMstatus err=RM_OK;	
	if ((value>=0)&&(value<=3)) {
		RMuint32 regValue=0;
		RMuint32 regAdd=0x76;
		err = read_i2c(pInstance, delay, dev, regAdd, &regValue); 
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
			return err;
		}
		regValue=regValue & 0x8f;
		regValue=regValue | ((value & 0xff)<<4);
		printf("write to 0x%lx value 0x%lx\n",regAdd,regValue);
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);