tun0299.c

stv0299资料

#include "st_tuner.h"

static TUNER_PROP Tuner;	/*	Current tuner	*/

/*****************************************************
**FUNCTION	::	TunerSetProperties
**ACTION	::	Set the properties of the tuner
**PARAMS IN	::	tnr	==> tuner properties
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerSetProperties(TUNER_PROP tnr)
{
	int i;
	
	Tuner.Error = tnr.Error; 
	strcpy(Tuner.Name,tnr.Name);
	Tuner.Address =	tnr.Address;
	
	Tuner.Type = tnr.Type;
	Tuner.PLL =	tnr.PLL; 
	Tuner.I_Q = tnr.I_Q;
	Tuner.FreqFactor = tnr.FreqFactor;
	Tuner.StepSize = tnr.StepSize;
	Tuner.IF = tnr.IF;
	Tuner.Repeator = tnr.Repeator;
	
	Tuner.SelectBW = tnr.SelectBW;
	i=0;
	while(i<(TUN_MAX_BW+1))
	{
		Tuner.BandWidth[i] = tnr.BandWidth[i];
		i++;
	}
	
	Tuner.WrSize = tnr.WrSize;
	
	for(i=0;i<tnr.WrSize;i++)
		Tuner.WrBuffer[i] = tnr.WrBuffer[i];

	Tuner.RdSize = tnr.RdSize;
		
	TunerReadWrite(WRITE);   
}

/*****************************************************
**FUNCTION	::	TunerGetProperties
**ACTION	::	Get the properties of the tuner
**PARAMS IN	::	NONE
**PARAMS OUT::	tnr	==> tuner properties   
**RETURN	::	NONE
*****************************************************/
void TunerGetProperties(TUNER_PROP *tnr)
{
	int i;
	
	if(tnr != NULL)
	{
		TunerReadWrite(READ);
	
		tnr->Type = Tuner.Type;
		strcpy(tnr->Name,Tuner.Name);
		tnr->Address =	Tuner.Address;
		tnr->PLL =	Tuner.PLL; 
		tnr->Error = Tuner.Error;

		tnr->I_Q = Tuner.I_Q;
		tnr->FreqFactor = Tuner.FreqFactor;
		tnr->StepSize = Tuner.StepSize;
		tnr->IF = Tuner.IF;
		tnr->Repeator = Tuner.Repeator;
	
		tnr->SelectBW = Tuner.SelectBW; 
		i=0;
		while(i<(TUN_MAX_BW+1))
		{
			tnr->BandWidth[i] = Tuner.BandWidth[i];
			i++;
		}
	
		tnr->WrSize = Tuner.WrSize;
	
		for(i=0;i<Tuner.WrSize;i++)
			tnr->WrBuffer[i] = Tuner.WrBuffer[i];

		tnr->RdSize = Tuner.RdSize;
	
		for(i=0;i<Tuner.RdSize;i++)
			tnr->RdBuffer[i] = Tuner.RdBuffer[i];
	}
}

/*****************************************************
**FUNCTION	::	TunerResetError
**ACTION	::	reset the error state of the tuner 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerResetError(void)
{
	Tuner.Error = TNR_NO_ERR;
}

/*****************************************************
**FUNCTION	::	TunerGetError
**ACTION	::	return the error state of the tuner 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	error
*****************************************************/
TUNER_ERROR TunerGetError(void)
{
	return Tuner.Error;
}

/*****************************************************
**FUNCTION	::	TunerInit
**ACTION	::	Initialize the tuner according to its type
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerInit(void)
{
	if(!Tuner.Error)
	{
		Tuner.SelectBW = 0;
		Tuner.BandWidth[TUN_MAX_BW] = 0L;	/* To avoid list without end	*/ 
	
		switch(Tuner.Type)
		{
			case TNR_VG6821:
				strcpy(Tuner.Name,"SHARP VG6821");
				Tuner.PLL	=	PLL_5522; 
			
				Tuner.I_Q = -1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 125000L;
				Tuner.IF = 479500L;
				Tuner.BandWidth[0] = 36000L;
				Tuner.BandWidth[1] = 0L;
				Tuner.Repeator = 0;
			
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x0B;
				Tuner.WrBuffer[1] = 0x00;
				Tuner.WrBuffer[2] = 0xCE;
				Tuner.WrBuffer[3] = 0xA1;
			
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
			break;
		
			case TNR_VZ1011:
			case TNR_VG1011:

            if ( Tuner.Type == TNR_VZ1011 )
            {
   				strcpy ( Tuner . Name, "SHARP VZ1011" );
	   			Tuner . IF = 0L;
            }
            else
            {
   				strcpy ( Tuner . Name, "SHARP VG1011" );
	   			Tuner . IF = 479500L;
            }

            /* VICKY - 010300 - corrected the PLL configuration setup */
#if   0
				Tuner.PLL	=	PLL_5655; 
#else
				Tuner.PLL	=	PLL_5659; 
#endif

			   Tuner . StepSize        = 125000L;
				Tuner . I_Q             = 1;
				Tuner . FreqFactor      = 1;
				Tuner . BandWidth [ 0 ] = 36000L;
				Tuner . BandWidth [ 1 ] = 0L;
				Tuner . Repeator        = 0;
			
				Tuner . WrSize          = 4;
				Tuner . WrBuffer [ 0 ]  = 0x34;
				Tuner . WrBuffer [ 1 ]  = 0x7C;
				Tuner . WrBuffer [ 2 ]  = 0x95;
				Tuner . WrBuffer [ 3 ]  = 0x80;
			
				Tuner . RdSize          = 1;
				Tuner . RdBuffer [ 0 ]  = 0x00; 
			   break;
		
      	case TNR_SU1200:
				strcpy(Tuner.Name,"PHILIPS SU1200");
				Tuner.IF = 0L;
				Tuner.PLL	=	PLL_5655; 

				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
 				Tuner.StepSize = 500000L;
                Tuner.BandWidth[0] = 30000L;
				Tuner.BandWidth[1] =8000L;
				#ifdef USE_I2C_REPEATER
                                Tuner.Repeator = 1;
                #else
                                Tuner.Repeator = 0;
				#endif
                                Tuner.WrSize = 4;
                                Tuner.WrBuffer[0] = 0x08;
                                Tuner.WrBuffer[1] = 0xFD;
                                Tuner.WrBuffer[2] = 0x82;
                                Tuner.WrBuffer[3] = 0x60;
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00;
				break;
		
			case TNR_DST7900:
  				strcpy ( Tuner . Name, "THOMSON DST7900" );

                                Tuner.IF = 0L;
				Tuner.PLL	=	PLL_5655; 

				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
                                #ifdef USE_PHILIPS_ZIF
                                Tuner.StepSize = 500000L;
                                Tuner.BandWidth[0] = 30000L;
								Tuner.BandWidth[1] =8000L;
                                #else
                                Tuner.StepSize = 125000L;
                                Tuner.BandWidth[0] = 36000L;
								Tuner.BandWidth[1] = 0L;
                                #endif
                                
				#ifdef USE_I2C_REPEATER
                                Tuner.Repeator = 1;
                #else
                                Tuner.Repeator = 0;
				#endif
                                Tuner.WrSize = 4;
                                #ifdef USE_PHILIPS_ZIF
                                Tuner.WrBuffer[0] = 0x08;
                                Tuner.WrBuffer[1] = 0xFD;
                                Tuner.WrBuffer[2] = 0x82;
                                Tuner.WrBuffer[3] = 0x60;
                                #else
                                Tuner.WrBuffer[0] = 0x34;
								Tuner.WrBuffer[1] = 0x7C;
								Tuner.WrBuffer[2] = 0xCE;
								Tuner.WrBuffer[3] = 0x80;
                                #endif
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
			   break;
		
			case TNR_EVALMAX:
				strcpy(Tuner.Name,"MAXIM EVALMAX");
				Tuner.PLL	=	PLL_5655; 
			
				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 500000L;
				Tuner.IF = 0L;
				Tuner.BandWidth[0] = 16000L;
				Tuner.BandWidth[1] = 60000L;
				Tuner.BandWidth[2] = 0L;
				Tuner.Repeator = 0;
			
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x08;
				Tuner.WrBuffer[1] = 0xC2;
				Tuner.WrBuffer[2] = 0x82;
				Tuner.WrBuffer[3] = 0x41;
			
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
			break;
		
			case TNR_TUA6100:	
				strcpy(Tuner.Name,"INFINEON TUA6100");
				Tuner.PLL	=	PLL_TUA6100; 
			
				Tuner.I_Q = 1;
				Tuner.FreqFactor = 1;
				Tuner.StepSize = 125000L;
				Tuner.IF = 0L;
				Tuner.BandWidth[0] = 60000L;
				Tuner.BandWidth[1] = 0L;
				Tuner.Repeator = 1;
				
				Tuner.WrSize = 2;
				Tuner.WrBuffer[0] = 0x00;	/* init register 0 */
				Tuner.WrBuffer[1] = 0x0B;   
				TunerReadWrite(WRITE);
				
				Tuner.WrSize = 3;
				Tuner.WrBuffer[0] = 0x02;	/* init register 2 */
				Tuner.WrBuffer[1] = 0x1C;    
				Tuner.WrBuffer[2] = 0x20; 
				TunerReadWrite(WRITE);
				
				Tuner.WrSize = 4;
				Tuner.WrBuffer[0] = 0x01;	/* default settings register 1 */
				Tuner.WrBuffer[1] = 0x2C;   
				Tuner.WrBuffer[2] = 0x96;
				Tuner.WrBuffer[3] = 0x00;
				
				Tuner.RdSize = 1;
				Tuner.RdBuffer[0] = 0x00; 
			break;
		
			default:
				Tuner.Error = TNR_TYPE_ERR;
			break;
		}
	
		TunerReadWrite(WRITE);
		TunerReadWrite(READ);
	}
}


/*****************************************************
**FUNCTION	::	TunerSelect
**ACTION	::	Select the type of tuner used
**PARAMS IN	::	type	==> type of the tuner
**				address	==> I2C address of the tuner
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void TunerSelect(TUNER_TYPE iTunerType,unsigned char address)
{
	TunerResetError();

   /* VICKY - 010300 - added the error checking */
   if ( iTunerType < TNR_VG6821 || iTunerType > TNR_TUA6100 )
      iTunerType = DEFAULT_TUNER_TYPE;
	Tuner.Type = iTunerType;
	Tuner.Address = address;
	TunerInit();
}


/*****************************************************
**FUNCTION	::	TunerSelectBandwidth
**ACTION	::	Select the bandwidth of the tuner (if this one not exist,
**				closest value bigger than bandwidth will be selected)
**PARAMS IN	::	bandwidth	==> bandwidth of the tuner 
**PARAMS OUT::	NONE  
**RETURN	::	Selected bandwidth, 0 if error
*****************************************************/
int TunerSelectBandwidth(int bandwidth)
{
	int band;
	
	Tuner.SelectBW = 0;
	
	if(!Tuner.Error)
	{
	   #ifdef USE_PHILIPS_ZIF
	   /* Tuner.BandWidth[0] corresponds to the higher bandwith 30MHZ
	      whereas Tuner.BandWidth[1] to the smaller (8MHz) for SCPC*/

	   if(bandwidth < Tuner.BandWidth[Tuner.SelectBW])
		{
			#if 1
			Tuner.SelectBW++;		  
			#else					  
	    	Tuner.SelectBW=0;
	    	#endif
	    }
	  #else
		while(	(Tuner.BandWidth[Tuner.SelectBW + 1] != 0) && 
				(bandwidth > Tuner.BandWidth[Tuner.SelectBW]))
		{
			Tuner.SelectBW++;
		}
	  #endif
		switch(Tuner.Type)
		{
			case TNR_EVALMAX:
				switch(Tuner.SelectBW)
				{
					case 0:
						band = 0x00;	/* Wide bandwidth 16MHz */
					break;
					
					case 1:
						band = 0x01;	/* Narrow bandwidth 60MHz */   
					break;
				}
				Tuner.WrBuffer[3] =  (Tuner.WrBuffer[3] & 0xFE) | band; 
			break;
		
		  case TNR_SU1200:
				switch(Tuner.SelectBW)
				{
					case 0:
						band = 0x00;	/* Wide bandwidth 30MHz */
					break;
					
					case 1:
						band = 0x01; 	/* Narrow bandwidth 8MHz */   
					break;
				}
				Tuner.WrBuffer[3] =  (Tuner.WrBuffer[3] & 0xFE) | band; 
				
				/* LP debug 131000 */
          /*printf ("Select bandwith [%d] => Reg =0x%02X\n",Tuner.SelectBW,Tuner.WrBuffer[3]); */
				break;

			default:
				break;
		}