ll_tun0360.c

st7710的tuner标准驱动

		frequency+=Tuner->IF; 
		
		nbsteps = (int) ( (frequency * 1000 + Tuner->StepSize/2)/Tuner->StepSize);
	       
		LL_TunerSetNbSteps(Tuner,nbsteps);

		
	}
	 /******* ATC Implementation*****/
	 #ifdef STTUNER_BASIC
		 #ifdef STTUNER_ATCBIT_TUNER_ENABLE
		 
		 if (Tuner->TunerType == STTUNER_TUNER_DTT7592 )
				{
			        /*** Wait for 50 msec before checking whether PLL locks or not ***/		
				WAIT_IN_MS(50);		
				loop = 20;
					
				while ((FL==0) && (loop>0))
					{
					   WAIT_IN_MS(1);	
					   loop-=1;
					   /***Reading for checking PLL lock*****/
					   TunerReadWrite((TUNER_Handle_t)Tuner,READ);
					   FL=Tuner->RdBuffer[0];
					   FL=(FL && 0x40); 
					}
				
				if (FL)
					{
					   Tuner->WrBuffer[3]    = (unsigned char) 0x20;/** Making AGC current low***/
					   TunerReadWrite((TUNER_Handle_t)Tuner,WRITE);  
					}
					else
					{
					   Tuner->Error = TNR_PLL_ERR ;
					  
					}
					
				}
		#endif
	
	#endif
	/********************************************/
	
	*returned_freq=LL_TunerGetFrequency(Tuner);	
	return Tuner->Error;

}



#endif /***** #ifndef STTUNER_MINIDRIVER *******/

#ifdef STTUNER_MINIDRIVER
#include	"chip.h"
#include "stcommon.h"   
#include 	"string.h"
#include 	"tuntdrv.h"
#include	"ll_tun0360.h"
#include        "sttbx.h"
#define 	WRITE 1
#define 	READ  0

#ifdef ST_OS21
#define WAIT_IN_MS(X)     task_delay( (signed int)(X * (ST_GetClocksPerSecond() / 1000)) )   /*task_delay(X)*/
#else
#define WAIT_IN_MS(X)     task_delay( (unsigned int)(X * (ST_GetClocksPerSecond() / 1000)) )   /*task_delay(X)*/
#endif


/*****************************************************
**FUNCTION	::	LL_TunerInit
**ACTION	::	Initialize the tuner according to its type
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void LL_TunerInit(TUNTDRV_InstanceData_t* Tuner)
{
#ifdef HOST_PC
int step;
double If;
#endif
	
		Tuner->SelectBW = 0;
		Tuner->BandWidth[TUN_MAX_BW] = 0;	/* To avoid list without end	*/ 
/* dcdc		Tuner->Repeator=0x0;*/ /* no repeator by defaults */
		switch(Tuner->TunerType)
		{
			
#ifdef STTUNER_BASIC			
			#if defined(STTUNER_DRV_TER_TUN_DTT7578)||defined(STTUNER_DRV_TER_TUN_DTT7592) 				 
			case STTUNER_TUNER_DTT7578:
			case STTUNER_TUNER_DTT7592:
				
				if(Tuner->TunerType == STTUNER_TUNER_DTT7578)
				{
				   Tuner->PLLType	=	TUNER_PLL_DTT7578;/* need to be verified */
				}
				else
				{
				   Tuner->PLLType	=	TUNER_PLL_DTT7592;/* need to be verified */
				}
				Tuner->SubAddress=0xC0;
				Tuner->WrSubSize=4;		
				Tuner->I_Q = 1;
				Tuner->FreqFactor = 1;
				Tuner->StepSize = (int)166667L;
				Tuner->IF = (int)36000L;
				Tuner->BandWidth[0] = (int)7600L;
				Tuner->BandWidth[1] = (int)0L;
		/*dcdc		Tuner->Repeator = 0;*/
			
				Tuner->WrSize = 4;
				Tuner->WrBuffer[0] = 0x2;
				Tuner->WrBuffer[1] = 0x34;
				Tuner->WrBuffer[2] = 0x93;
				Tuner->WrBuffer[3] = 0x05;
				
				Tuner->WrSubBuffer[0] = 0x2;
				Tuner->WrSubBuffer[1] = 0x34;
				Tuner->WrSubBuffer[2] = 0x93;
				Tuner->WrSubBuffer[3] = 0x05;
			
				Tuner->RdSize = 1;
				Tuner->RdBuffer[0] = 0x00; 
			break;
			#endif
			
#endif			
			default:
				Tuner->Error = TNR_TYPE_ERR;
			break;
		}
}

/*****************************************************
**FUNCTION	::	LL_tuner_tuntdrv_Select
**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 LL_TunerSelect(TUNTDRV_InstanceData_t* Tuner,STTUNER_TunerType_t type,unsigned char address)

{
	Tuner->Error=TNR_NO_ERR;
	Tuner->TunerType = type;
	Tuner->Address = address;
	
}

/*****************************************************
**FUNCTION	::	LL_TunerGetNbSteps
**ACTION	::	Get the number of steps of the tuner
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE  
**RETURN	::	Number of steps, 0 if an error occur
*****************************************************/
int LL_TunerGetNbSteps(TUNTDRV_InstanceData_t* Tuner)
{
	int nbsteps = 0;
		
	        switch (Tuner->PLLType)
		{
#ifdef STTUNER_BASIC			
			case TUNER_PLL_DTT7578:
			case TUNER_PLL_DTT7592:
				nbsteps	 = ((int)Tuner->WrBuffer[0] & 0x0000007F)<<8L;
				nbsteps	|= ((int)Tuner->WrBuffer[1] & 0x000000FF);
				
			break;
#endif			
			default:
				Tuner->Error = TNR_PLL_ERR;
			break;
		}
	
	
		
	return nbsteps;
}

/*****************************************************
**FUNCTION	::	LL_TunerGetFrequency
**ACTION	::	Get the frequency of the tuner
**PARAMS IN	::	NONE  
**PARAMS OUT::	NONE  
**RETURN	::	frequency of the tuner (KHz), 0 if an error occur 
*****************************************************/
int LL_TunerGetFrequency(TUNTDRV_InstanceData_t* Tuner)
{
	int frequency = 0;
	
	if(Tuner->StepSize>0)
	{
				 
		  frequency = ((LL_TunerGetNbSteps(Tuner)*(Tuner->StepSize/2)) - 500*Tuner->IF)/500	;
		  frequency *= Tuner->FreqFactor;
		
	}
	else
		Tuner->Error = TNR_STEP_ERR;
	
	return frequency; 
}

/*****************************************************
**FUNCTION	::	LL_TunerSetNbSteps
**ACTION	::	Set the number of steps of the tuner
**PARAMS IN	::	nbsteps ==> number of steps of the tuner
**PARAMS OUT::	NONE  
**RETURN	::	NONE
*****************************************************/
void LL_TunerSetNbSteps(TUNTDRV_InstanceData_t* Tuner,int nbsteps)
{
	
		switch(Tuner->PLLType)
		{

			
#ifdef STTUNER_BASIC		
			case TUNER_PLL_DTT7578:
			case TUNER_PLL_DTT7592:
				Tuner->WrBuffer[0] = (unsigned char) ( (nbsteps >> 8) & 0x7f );
				Tuner->WrBuffer[1] = (unsigned char) ( (nbsteps >> 0) & 0xff );
				Tuner->WrSubBuffer[0] = (unsigned char) ( (nbsteps >> 8) & 0x7f );
				Tuner->WrSubBuffer[1] = (unsigned char) ( (nbsteps >> 0) & 0xff );
  			break;
#endif  			
                        default:
				Tuner->Error = TNR_PLL_ERR;
			break ;
		}
		
		TunerReadWrite(WRITE); 
		
		
	
}


/*****************************************************
**FUNCTION	::	LL_TunerSetFrequency
**ACTION	::	Set the frequency of the tuner
**PARAMS IN	::	frequency ==> the frequency of the tuner (KHz) 
**PARAMS OUT::	NONE  
**RETURN	::	real tuner frequency, 0 if an error occur 
*****************************************************/

/*ST_ErrorCode_t	tuner_tuntdrv_SetFrequency(TUNER_Handle_t  Handle,U32 frequency,(U32*)&returned_freq); */
 ST_ErrorCode_t LL_TunerSetFrequency(TUNTDRV_InstanceData_t* Tuner,U32 frequency,U32* returned_freq)  

{
	int nbsteps = 0,     
		chargepump = 0,
		channel_size,
		Atc;
	
	
	#ifdef STTUNER_ATCBIT_TUNER_ENABLE
	int loop = 0;
	int FL = 0;
	#endif
	/*Code added for MT2060*/
	Tuner->Error=TNR_NO_ERR;
	
	if(Tuner->StepSize > 0)
	{
		
		switch(Tuner->TunerType)
		{
	
	#ifdef STTUNER_BASIC
			case STTUNER_TUNER_DTT7578:
			case STTUNER_TUNER_DTT7592:
				if 		(frequency <= 230000) chargepump=(unsigned char)0xB4;/* modifs of the spec */
				else if (frequency <= 699000) chargepump=(unsigned char)0xBC;
				else if (frequency <= 799000) chargepump=(unsigned char)0xF4;
				else if (frequency <= 860000) chargepump=(unsigned char)0xFC;
				else  chargepump=(unsigned char)0xFC;
				switch(Tuner->StepSize)
					{
					case 50000:
		
					chargepump=(chargepump&0xC9);	
					
					break;
					case 31250:
					chargepump=(chargepump&0xC9);
					chargepump=chargepump|((0x1)<<1);
					break;
					
					case 166667:
					chargepump=(chargepump&0xF9);
					chargepump=chargepump|(2<<1);
					break;

					case 62500:
					chargepump=(chargepump&0xF9);
					chargepump=chargepump|(3<<1);					
					break;

					case 125000:
					chargepump=(chargepump&0xC9);
					chargepump=chargepump|(0x3<<4);					
					break;

					case 142860:
					chargepump=(chargepump&0xC9);
					chargepump=chargepump|(0x3<<4);					
					chargepump=chargepump|(0x1<<1);/* RSA RSB */
					break;
					}
				Tuner->WrBuffer[2] = (unsigned char) chargepump;  
	
				channel_size=Tuner->ChannelBW;
				#ifdef HOST_PC
				UsrRdInt("CHANNEL_WIDTH",&channel_size); 			
				#endif
				
				if (frequency<=68000) 	   Tuner->WrBuffer[3] = (unsigned char) 0x01; /* VHF   I */ 
				else if (frequency<=228000) Tuner->WrBuffer[3] = (unsigned char) 0x02; /* VHF III */
				else 					   Tuner->WrBuffer[3] = (unsigned char) 0x08; /*   UHF   */
  						
  				if (channel_size==7) Tuner->WrBuffer[3]= ( (Tuner->WrBuffer[3]) | (0x10));
  					
				/* Tuner->WrBuffer[4] = (unsigned char) Tuner->Address; */
				Tuner->WrSubBuffer[2]= 	((chargepump & 0xC7)|(3<<3));
				Atc=1;
				#ifdef HOST_PC
				UsrRdInt("Atc",&Atc); 			
				#endif
				Tuner->WrSubBuffer[3] = (unsigned char) (0x20 | (Atc<<7));
				
				/******* ATC Implementation*****/
				
				#ifdef STTUNER_ATCBIT_TUNER_ENABLE
				TunerReadWrite(WRITE); /* Write the initial tuner*/
				/*** Now making ATC bit = 1 ******/
				if (frequency < 735000)
				{
				   Tuner->WrBuffer[2]= 0x9C;/*** Enabling Auxillary Byte to
				                                 be written over BandSwitch
				                                 byte*****/
				}
				else
				{
				   Tuner->WrBuffer[2]= 0xDC;/*** Enabling Auxillary Byte to
				                                 be written over BandSwitch
				                                 byte*****/   
				}
				 
				Tuner->WrBuffer[3]= 0xA0;/*** Making ATC bit 1 to make AGC
				                              current high . This is recommendable
				                              during channel select and search
				                              mode *****/
			        #endif
			/*******************************************************/
				
			break;
			
#endif			
			default:
			break;
		}
		
		frequency+=Tuner->IF; 
		nbsteps = (int) ( (frequency * 1000 + (Tuner->StepSize/2))/Tuner->StepSize);
		LL_TunerSetNbSteps(Tuner,nbsteps);
		
	}
	 /******* ATC Implementation*****/
#ifdef STTUNER_BASIC
	 #ifdef STTUNER_ATCBIT_TUNER_ENABLE
	 if (Tuner->TunerType == STTUNER_TUNER_DTT7592 )
			{
		        /*** Wait for 50 msec before checking whether PLL locks or not ***/		
			WAIT_IN_MS(50);		
			loop = 20;
				
			while ((FL==0) && (loop>0))
				{
				   WAIT_IN_MS(1);	
				   loop-=1;
				   /***Reading for checking PLL lock*****/
				   TunerReadWrite(READ);
				   FL=Tuner->RdBuffer[0];
				   FL=(FL && 0x40); 
				}
			
			if (FL)
				{
				   Tuner->WrBuffer[3]    = (unsigned char) 0x20;/** Making AGC current low***/
				   TunerReadWrite(WRITE);  
				}
				else
				{
				   Tuner->Error = TNR_PLL_ERR ;
				  
				}
				
			}
	#endif
	
#endif
	/********************************************/
	
	*returned_freq=LL_TunerGetFrequency(Tuner);	
	return Tuner->Error;

}
#endif /****************#ifdef STTUNER_MINIDRIVER******************/