tw9919eid.c

Sample code for use on smp 863x processor.

		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}		
	}
	return err;
}
//3D FILTER ////////////////////////////////////////////////////////////////////////

static RMstatus SetNRGain(struct RUA *pInstance, 								  
			   RMuint8 dev, 
			   RMuint8 delay,
			   RMuint32 val){
	
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x77;	
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}	
	regValue &= 0xcf ;
	regValue |= (val<<4) ;
	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;
}

static RMstatus SetNRLevel(struct RUA *pInstance, 								  
				RMuint8 dev, 
				RMuint8 delay,
				RMuint32 val){

	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x77;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	regValue &= 0xf0;
	regValue |= val;
	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_Enable3DNRDemo(struct RUA *pInstance, 								  
					RMuint8 dev, 
					RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	
	SetNRGain(pInstance,dev,delay,0x00);					// NR gain 0
	SetNRLevel(pInstance,dev,delay,0x0f);				// NR Max
	//SetNRLevel(pInstance,dev,delay,0x0e);

	regAdd=0x82;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
//	regValue |= 0x40 ;						// NR Demo mode : bit 6
	regValue |= 0x02 ;						// NR double : bit 2
		
	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_Disable3DNRDemo(struct RUA *pInstance, 								  
					 RMuint8 dev, 
					 RMuint8 delay)
{
	
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	
	SetNRGain(pInstance,dev,delay,0x01);					// NR gain default
	SetNRLevel(pInstance,dev,delay,0x04);				// NR level default

	regAdd=0x82;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	
	regValue &= ~0x40;					// NR Demo mode : bit 6 
	regValue &= ~0x02;					// NR double : bit 2
	
	err=write_i2c(pInstance,delay,dev,regAdd,(regValue & 0xbf));
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
		return err;
	}
	
	return err;	
}

RMstatus tw9919eid_Enable3DCombFilter(struct RUA *pInstance, 								  
									  RMuint8 dev, 
									  RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	regAdd=0x72;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	//100xxxxx 3D  Adaptive mode
	regValue &= 0x9c;					
	regValue |= 0x80; 
	
	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_Disable3DCombFilter(struct RUA *pInstance, 								  
									   RMuint8 dev, 
									   RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	regAdd=0x72;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	//001xxxxx 2D Adaptive Mode
	regValue &= 0x3c;
	regValue |= 0x20;
	
	//011xxxxx 2D Fixed Mode
	regValue &= 0x7c;
	regValue |= 0x60;
	
	
	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_PowerDown(struct RUA *pInstance, 								  
									   RMuint8 dev, 
									   RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	regAdd=0x06;
	regValue=0x27;
	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_PowerUp(struct RUA *pInstance, 								  
							 RMuint8 dev, 
							 RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	regAdd=0x06;
	regValue=0x0;
	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_EnableBlueScreen(struct RUA *pInstance, 								  
						   RMuint8 dev, 
						   RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	regAdd=0x2f;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	regValue |= 0x06;
	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_DisableBlueScreen(struct RUA *pInstance, 								  
									RMuint8 dev, 
									RMuint8 delay)
{
	RMstatus err=RM_OK;
	RMuint32 regValue=0x00;
	RMuint32 regAdd=0x00;
	regAdd=0x2f;
	err=read_i2c(pInstance,delay,dev,regAdd,&regValue);
	if (RMFAILED(err)) {
		fprintf(stderr, "Failed to read reg 0x%lx\n",regAdd);
		return err;
	}
	regValue &= 0xf9;
	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;
}

static RMstatus tw9919eid_TestRegister(struct RUA *pInstance, 								  
									   RMuint8 dev, 
									   RMuint8 delay,
									   RMuint32 regAdd,
									   RMuint32 isAsc)
{

	RMstatus err=RM_OK;
	RMuint32 regValue=0;
	RMuint32 i=0;

	for(i=0;i<=255;i++)
	{
		if (!isAsc) 
			regValue=255-i;
		else
			regValue=i;
		err=write_i2c(pInstance,delay,dev,regAdd,regValue);
		if (RMFAILED(err)) {
			fprintf(stderr, "Failed to write reg 0x%lx\n",regAdd);
			return err;
		}
		usleep(50000);
		printf("0x%lx = 0x%lx\n",regAdd,regValue);
		
	}
	return err;
}

void tw9919eid_Debug(struct 
					 RUA *pInstance, 								  
					 RMuint8 dev, 
					 RMuint8 delay,
					 RMuint8 key)
{
	switch(key) {
	case 'w':
		{
			
			RMuint32 regAdd;
			RMuint32 regValue;
			printf("Write regAdd = ");scanf("%lx",&regAdd);
			printf("regValue = ");scanf("%lx",&regValue);
			write_i2c(pInstance,delay,dev,regAdd,regValue);
			printf("Write to 0x%lx value 0x%lx\n",regAdd,regValue);
			break;
		}
	case 'r':
		{
			
			RMuint32 regAdd;
			RMuint32 regValue;
			printf("Read regAdd = ");scanf("%lx",&regAdd);							
			read_i2c(pInstance,delay,dev,regAdd,&regValue);
			printf("Read to 0x%lx value 0x%lx\n",regAdd,regValue);
			break;
		}
	case 'a':
		{
			
			tw9919eid_checkRegisterSet(pInstance,dev,delay);
			break;
		}	
	case '3':
		
		if (tw9919eid_Enable3DCombFilter(pInstance,dev,delay)==RM_OK) {
			printf("Enable 3D CombFilter \n");
		}
		
		break;
	case '2':
		if (tw9919eid_Disable3DCombFilter(pInstance,dev,delay)==RM_OK) {
			printf("Disable 3D CombFilter \n");
		}
		break;
		
	case '6':
		
		if (tw9919eid_Enable3DNRDemo(pInstance,dev,delay)==RM_OK) {
			printf("Enable 3D Noise Reduction \n");
		}
		
		break;
	case '4':
		if (tw9919eid_Disable3DNRDemo(pInstance,dev,delay)==RM_OK) {
			printf("Disable 3D Noise Reduction \n");
		}
		break;

	case '0':
		{
		
			RMuint32 regAdd;
			printf("Write regAdd = ");scanf("%lx",&regAdd);			
			tw9919eid_TestRegister(pInstance,dev,delay,regAdd,1);
			break;
		}
	case '1':
		{
			
			RMuint32 regAdd;
			printf("Write regAdd = ");scanf("%lx",&regAdd);			
			tw9919eid_TestRegister(pInstance,dev,delay,regAdd,0);
			break;
		}
	default:
		break;
	}
}

RMstatus tw9919eid_setManualColorSystem(struct RUA *pInstance,
						  RMuint8 dev, 
						  RMuint8 delay,
						  RMuint8 isNTSC
						  )
{
	   		
	RMstatus err=RM_OK;
//	RMuint32 regValue=0;
	RMuint32 Reg1C, Reg30;//, Colorsystem, LastColorSystem; // PAL	
	
	//delay(50);
	usleep(50);		
	err = read_i2c(pInstance, delay, dev, 0x1c, &Reg1C); 
	if (RMFAILED(err)) {
		fprintf(stderr, "setManualColorSystem() Error <2>\n");
		return err;
	}
	printf("reg 0x1c = 0x%02lx\n",Reg1C);
	err = read_i2c(pInstance, delay, dev, 0x30, &Reg30); 
	if (RMFAILED(err)) {
		fprintf(stderr, "setManualColorSystem() Error <3>\n");
		return err;
	}
	printf("reg 0x30 = 0x%02lx\n",Reg30);
	printf("setManualColorSystem <0>\n");
	{
			if( !isNTSC ) // 50Hz ? Pal 
			{
				printf("setManualColorSystem <1>\n");
				switch( Reg1C & 0x07) {
					case 0x01 : // PAL
						printf("setManualColorSystem <0>\n");
						if( ( Reg30 & 0xF0 ) == 0x50 ) 
						{
							printf(" ==> Changed Colorsystem to SECAM \r\n");
							err=write_i2c(pInstance,delay,dev,0x1c,0x02);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <4>\n");
								return err;
							}
							
						}
						else if ( (( Reg30 & 0xF0 ) == 0x20 ) )
						{
							printf(" ==> Changed Colorsystem to PAL-N \r\n");
							err=write_i2c(pInstance,delay,dev,0x1c,0x05);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <5>\n");
								return err;
							}
						}
						break;	
					case 0x02 : // SECAM
						if( (( Reg30 & 0xF0 ) == 0xD0 ) ) // Weak signal
						{
							printf(" ==> Changed Colorsystem to PAL \r\n");
							err=write_i2c(pInstance,delay,dev,0x1c,0x01);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <6>\n");
								return err;
							}
							usleep(1);
							err = read_i2c(pInstance, delay, dev, 0x30, &Reg30); 
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <7>\n");
								return err;
							}
							
							if(((Reg30 &0xF0) == 0x20))
							{
								printf(" ==> Changed Colorsystem to PAL-N \r\n");
								//MonWriteI2C(0x88, 0x1c, 0x05);	// Go to PAL-N
								err=write_i2c(pInstance,delay,dev,0x1c,0x05);
								if (RMFAILED(err)) {
									fprintf(stderr, "setManualColorSystem() Error <7>\n");
									return err;
								}
							}
						}
						else if( ( Reg30 & 0xF0 ) == 0xF0 ) 
						{
							printf(" ==> Changed Colorsystem to PAL-N \r\n");
							//MonWriteI2C(0x88, 0x1c, 0x05);	// Go to PAL-N
							err=write_i2c(pInstance,delay,dev,0x1c,0x05);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <8>\n");
								return err;
							}
						}
						break;

					case 0x00 : // NTSC
						if( (( Reg30 & 0xF0 ) == 0x20 ) 
							|| (( Reg30 & 0xF0 ) == 0x00 )
							|| (( Reg30 & 0xF0 ) == 0x10 ) )	// Weak signal
						{
							printf(" ==> Changed Colorsystem to PAL \r\n");
							//MonWriteI2C(0x88, 0x1c, 0x01);	// Go to PAL
							err=write_i2c(pInstance,delay,dev,0x1c,0x01);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <9>\n");
								return err;
							}
							
							//delay(10);
							usleep(10);
							//Reg30 = ReadTW99(0x30);
							err = read_i2c(pInstance, delay, dev, 0x30, &Reg30); 
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <10>\n");
								return err;
							}
							if(((Reg30 &0xF0) == 0x50))
							{
								printf(" ==> Changed Colorsystem to SECAM \r\n");
								//MonWriteI2C(0x88, 0x1c, 0x02);	// Go to SECAM
								err=write_i2c(pInstance,delay,dev,0x1c,0x02);
								if (RMFAILED(err)) {
									fprintf(stderr, "setManualColorSystem() Error <11>\n");
									return err;
								}
							}
						}
						else if( ( Reg30 & 0xF0 ) == 0x30 ) 
						{
							printf(" ==> Changed Colorsystem to SECAM \r\n");
							//MonWriteI2C(0x88, 0x1c, 0x02);	// Go to SECAM
							err=write_i2c(pInstance,delay,dev,0x1c,0x02);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <12>\n");
								return err;
							}
						}
						else if( ( Reg30 & 0xF0 ) == 0x50 ) 
						{
							printf(" ==> Changed Colorsystem to PAL-N \r\n");
							//MonWriteI2C(0x88, 0x1c, 0x05);	// Go to PAL-N
							err=write_i2c(pInstance,delay,dev,0x1c,0x05);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <13>\n");
								return err;
							}
						}
						break;
						
					case 0x04 : // PAL-M
						if( (( Reg30 & 0xF0 ) == 0x20 ) 
							|| (( Reg30 & 0xF0 ) == 0x10 )   // Weak signal
							|| (( Reg30 & 0xF0 ) == 0x00 ))	
						{
							printf(" ==> Changed Colorsystem to PAL \r\n");
							//MonWriteI2C(0x88, 0x1c, 0x01);	// Go to PAL
							err=write_i2c(pInstance,delay,dev,0x1c,0x01);
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <14>\n");
								return err;
							}

							//delay(15);
							usleep(15);
							//Reg30 = ReadTW99(0x30);
							err = read_i2c(pInstance, delay, dev, 0x30, &Reg30); 
							if (RMFAILED(err)) {
								fprintf(stderr, "setManualColorSystem() Error <10>\n");
								return err;
							}
							
							if( ( Reg30 & 0xF0 ) == 0x50 ) { 
								printf(" ==> Changed Colorsystem to SECAM \r\n");
								//MonWriteI2C(0x88, 0x1c, 0x02);	// Go to SECAM
								err=write_i2c(pInstance,delay,dev,0x1c,0x02);
								if (RMFAILED(err)) {
									fprintf(stderr, "setManualColorSystem() Error <15>\n");