drv0899.c

st7710的tuner标准驱动

				case 3:					/*	inner code 5/6	*/  
					InnerCode = 1200;	/* 1.2 */
				break;
				
				case 4:					/*	inner code 6/7	*/  
					InnerCode = 1167;	/* 1.667 */
				break;
				
				case 5:					/*	inner code 7/8	*/
					InnerCode = 1143;	/* 1.143 */
				break;
			}
			
			Tviterbi +=(int)((PhaseNumber[i]*averaging[Sn]*InnerCode)/SymbolRate);
			
			if(HigherRate < InnerCode) 
				HigherRate = InnerCode;
		}
	}
	
	/*	  time out calculation (TimeOut)
	--    ------------------------------
	--    This value indicates the maximum duration of the synchro word research.	*/
	TimeOut   = (long)((HigherRate * 16384L * (To + 1L))/(2*SymbolRate));
	
	/*    Hysteresis duration (Hysteresis)
	--    ------------------------------	*/
	THysteresis = (long)((HigherRate * 26112L * (Hy +1L))/(2*SymbolRate));	/*	26112= 16*204*8 bits  */ 
	
	/* a guard time of 1 mS is added */
	return (1 + Tviterbi + TimeOut + THysteresis);
}

/****************************************************
**FUNCTION	::	FE_STB0899_GetAlpha
**ACTION	::	Read the rolloff value
**PARAMS IN	::	hChip	==>	Handle for the chip
**PARAMS OUT::	NONE
**RETURN	::	rolloff
*****************************************************/
int  FE_STB0899_GetAlpha(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle)
{
	if (STTUNER_IOREG_GetField_SizeU32(DeviceMap, IOHandle, FSTB0899_MODE_COEF,FSTB0899_MODE_COEF_INFO) == 1)
		return 20;
	else
		return 35;

}
/*****************************************************
**FUNCTION	::	FE_STB0899_CalcDerotFreq
**ACTION	::	Compute Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
S32 FE_STB0899_CalcDerotFreq(U8 derotmsb,U8 derotlsb,U32 fm)
{
	S32	dfreq;
	S32 Itmp;
		
	Itmp = (S16)(derotmsb<<8)+derotlsb;
	dfreq =(S32)(Itmp*( fm /10000L));
	dfreq =(S32)(dfreq/65536L);
	dfreq *= 10;
	
	return dfreq; 
}
/*****************************************************
**FUNCTION	::	FE_STB0899_GetDerotFreq
**ACTION	::	Read current Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
S32 FE_STB0899_GetDerotFreq(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, U32 MasterClock)
{
	U32 CarrierFreq[2];
	/*	Read registers	*/
	STTUNER_IOREG_GetContigousRegisters_SizeU32(DeviceMap,IOHandle,RSTB0899_CFRM,2,CarrierFreq); 
	CarrierFreq[0]&=0xff;
	CarrierFreq[1]&=0xff;
	
	return FE_STB0899_CalcDerotFreq(CarrierFreq[0],CarrierFreq[1],MasterClock);

}

/*****************************************************
**FUNCTION	::	FE_899_BinaryFloatDiv
**ACTION	::	float division (with integer) 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
long FE_899_BinaryFloatDiv(long n1, long n2, int precision)
{
	int i=0;
	long result=0;
	
	/*	division de N1 par N2 avec N1<N2	*/
	while(i<=precision) /*	n1>0	*/
	{
		if(n1<n2)
		{
			result*=2;      
			n1*=2;
		}
		else
		{
			result=result*2+1;
			n1=(n1-n2)*2;
		}
		i++;
	}
	
	return result;
}



/*****************************************************
**FUNCTION	::	FE_STB0899_CalcSymbolRate
**ACTION	::	Compute symbol frequency
**PARAMS IN	::	Hbyte	->	High order byte
**				Mbyte	->	Mid byte
**				Lbyte	->	Low order byte
**PARAMS OUT::	NONE
**RETURN	::	Symbol frequency
*****************************************************/
U32 FE_STB0899_CalcSymbolRate(U32 MasterClock,U8 Hbyte,U8 Mbyte,U8 Lbyte)
{
	U32 Ltmp,
		Ltmp2,
		Mclk;

	Mclk =  (U32) (MasterClock / 4096L);	/* MasterClock*10/2^20 */
	Ltmp = (((U32)Hbyte<<12)+((U32)Mbyte<<4))/16;
	Ltmp *= Mclk;
	Ltmp /=16;
	Ltmp2=((U32)Lbyte*Mclk)/256;     
	Ltmp+=Ltmp2;
	
	return Ltmp;
}

/*****************************************************
**FUNCTION	::	FE_STB0899_SetSymbolRate
**ACTION	::	Set symbol frequency
**PARAMS IN	::	hChip		->	handle to the chip
**				MasterClock	->	Masterclock frequency (Hz)
**				SymbolRate	->	symbol rate (bauds)
**PARAMS OUT::	NONE
**RETURN	::	Symbol frequency
*****************************************************/
U32 FE_STB0899_SetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, U32 MasterClock,U32 SymbolRate)
{
	U32 U32Tmp,
	    U32TmpUp,
	    SymbolRateUp=SymbolRate;
	U32  TMP[3];
	U32   TMPUP[3];
	
	/*
	** in order to have the maximum precision, the symbol rate entered into
	** the chip is computed as the closest value of the "true value".
	** In this purpose, the symbol rate value is rounded (1 is added on the bit
	** below the LSB )
	*/
	
	SymbolRateUp+=((SymbolRateUp*3)/100);
	
	U32Tmp = (U32)(FE_899_BinaryFloatDiv(SymbolRate,MasterClock,20));       
	U32TmpUp=(U32)(FE_899_BinaryFloatDiv(SymbolRateUp,MasterClock,20));  
	
	
	
	/*STTUNER_IOREG_SetRegister(DeviceMap, IOHandle, RSTB0899_TMGCFG,0x40);*//* to activate auto search for timing offset*/
	
	TMP[0] = (U32TmpUp>>12)&0xFF;
	TMP[1] = (U32TmpUp>>4)&0xFF;
	TMP[2] = (U32TmpUp&0x0F);
	
	
	TMPUP[0] = (U32Tmp>>12)&0xFF; 
	TMPUP[1] = (U32Tmp>>4)&0xFF;
	TMPUP[2] = (U32Tmp&0x0F);
	
	STTUNER_IOREG_SetContigousRegisters_SizeU32(DeviceMap, IOHandle,RSTB0899_SFRUPH,TMP,3);
	STTUNER_IOREG_SetContigousRegisters_SizeU32(DeviceMap, IOHandle,RSTB0899_SFRH,TMPUP,3);
		
	
	return(SymbolRate) ;
}

/*****************************************************
**FUNCTION	::	FE_STB0899_GetSymbolRate
**ACTION	::	Get the current symbol rate
**PARAMS IN	::	hChip		->	handle to the chip
**				MasterClock	->	Masterclock frequency (Hz)
**PARAMS OUT::	NONE
**RETURN	::	Symbol rate
*****************************************************/
U32 FE_STB0899_GetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,U32 MasterClock)
{
	U32 sfrh[3];
	
	STTUNER_IOREG_GetContigousRegisters_SizeU32(DeviceMap, IOHandle, RSTB0899_SFRH,3,sfrh);
	sfrh[0]&=0xff;
	sfrh[1]&=0xff;
	sfrh[2]&=0xff;
	return FE_STB0899_CalcSymbolRate(	MasterClock,sfrh[0],
						sfrh[1],
						sfrh[2]);

}

/*****************************************************
--FUNCTION	::	FE_899_CarrierWidth
--ACTION	::	Compute the width of the carrier
--PARAMS IN	::	SymbolRate	->	Symbol rate of the carrier (Kbauds or Mbauds)
--				RollOff		->	Rolloff * 100
--PARAMS OUT::	NONE
--RETURN	::	Width of the carrier (KHz or MHz) 
--***************************************************/
long FE_899_CarrierWidth(long SymbolRate, long RollOff)
{
	return (SymbolRate  + (SymbolRate*RollOff)/100);
}
/*****************************************************
--FUNCTION	::	FE_STB0899_InitialCalculations
--ACTION	::	Set Params fields that are never changed during search algorithm   
--PARAMS IN	::	NONE
--PARAMS OUT::	NONE
--RETURN	::	NONE
--***************************************************/
void FE_STB0899_InitialCalculations(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, FE_STB0899_InternalParams_t *Params)
{
	int  MasterClock;
	
	
	/*	Initial calculations	*/   
	MasterClock = FE_STB0899_GetMclkFreq(DeviceMap, IOHandle,Params->Quartz);
	Params->Tagc1 = 0;
	Params->Tagc2 = 0;
	Params->MasterClock = MasterClock;
	Params->Mclk = (U32)(MasterClock/65536L);
	Params->RollOff = FE_STB0899_GetAlpha(DeviceMap, IOHandle);
	
	/*DVBS2 Initial Calculation from Validation Code*/
	/*Set AGC init value to to the midle*/ 
	Params->AgcGain = 8154;
	
	STTUNER_IOREG_SetField_SizeU32(DeviceMap, IOHandle,FSTB0899_IF_GAININIT,FSTB0899_IF_GAININIT_INFO,Params->AgcGain);


	Params->RrcAlpha = STTUNER_IOREG_GetField_SizeU32(DeviceMap, IOHandle,FSTB0899_RRC_ALPHA,FSTB0899_RRC_ALPHA_INFO);

	Params->CenterFreq=0;	
	Params->AveFrameCoarse=10;
	Params->AveFramefine=20;	
	Params->StepSize=2;
	
	if((Params->SpectralInv==STTUNER_IQ_MODE_NORMAL)||(Params->SpectralInv==STTUNER_IQ_MODE_AUTO))
		Params->IQLocked=0;
	else
		Params->IQLocked=1;

}


/*****************************************************
--FUNCTION	::	FE_STB0899_SearchTiming
--ACTION	::	Perform an Fs/2 zig zag to found timing
--PARAMS IN	::	NONE
--PARAMS OUT::	NONE
--RETURN	::	NOTIMING if no valid timing had been found, TIMINGOK otherwise
--***************************************************/
FE_STB0899_SIGNALTYPE_t FE_STB0899_SearchTiming(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, FE_STB0899_InternalParams_t *Params)
{
	short int	DerotStep,
				DerotFreq = 0,
				DerotLimit,
				NextLoop = 3;
	int 	index = 0;
	U32   cfrm[2];
			
	Params->State = NOTIMING_899;
		
	/* timing loop computation & symbol rate optimisation	*/
	DerotLimit = (Params->SubRange/2)/Params->Mclk;
	DerotStep = (Params->SymbolRate/2)/Params->Mclk;
	
	while((FE_STB0899_CheckTiming(DeviceMap, IOHandle, Params)!=TIMINGOK_899) && NextLoop)
	{
		
		index++;
		DerotFreq += (short int)Params->TunerIQSense*index*(Params->Direction)*DerotStep;	/*	Compute the next derotator position for the zig zag	*/    
		
		if(ABS(DerotFreq) > DerotLimit)
			NextLoop--;
		
		if(NextLoop)
		{
			cfrm[0] = MSB((short int)DerotFreq);
			cfrm[1] = LSB((short int)DerotFreq);
			
			STTUNER_IOREG_SetContigousRegisters_SizeU32(DeviceMap, IOHandle,RSTB0899_CFRM,cfrm,2); 							/*	Set the derotator frequency	*/			
		
		}
		
		Params->Direction = -Params->Direction;			/*	Change the zigzag direction	*/    
	}
	
	
	if(Params->State == TIMINGOK_899)
	{
		Params->Results.SymbolRate = Params->SymbolRate; 
		
		STTUNER_IOREG_GetContigousRegisters_SizeU32(DeviceMap, IOHandle,RSTB0899_CFRM,2,cfrm);								/*	Get the derotator frequency	*/ 
		cfrm[0]&=0xff;
		cfrm[1]&=0xff;
		Params->DerotFreq =(short int)Params->TunerIQSense*((short int) MAKEWORD(cfrm[0],cfrm[1]));
	
	}
	
	return Params->State;
}

/*****************************************************
--FUNCTION	::	FE_STB0899_SearchCarrier
--ACTION	::	Search a QPSK carrier with the derotator
--PARAMS IN	::	
--PARAMS OUT::	NONE
--RETURN	::	NOCARRIER_899 if no carrier had been found, CARRIEROK_899 otherwise 
--***************************************************/
FE_STB0899_SIGNALTYPE_t FE_STB0899_SearchCarrier(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle, FE_STB0899_InternalParams_t *Params)
{
	short int	DerotFreq = 0,
				LastDerotFreq = 0, 
				DerotLimit,
				NextLoop = 3;
	int 	index = 0;
	U32   cfrm[2];
			
	Params->State = NOCARRIER_899;
	
	DerotLimit = (Params->SubRange/2)/Params->Mclk;
	DerotFreq = Params->DerotFreq;
	
	STTUNER_IOREG_SetField_SizeU32(DeviceMap, IOHandle, FSTB0899_CFD_ON,FSTB0899_CFD_ON_INFO, 1);
	
	do
	{		
		if(FE_STB0899_CheckCarrier(DeviceMap, IOHandle, Params)==NOCARRIER_899)
		{
			index++;
			LastDerotFreq = DerotFreq;
			DerotFreq += (short int)Params->TunerIQSense * index * Params->Direction * Params->DerotStep;	/*	Compute the next derotator position for the zig zag	*/    
		
			if(ABS(DerotFreq) > DerotLimit)
				NextLoop--;
				
			if(NextLoop)
			{
					
				STTUNER_IOREG_SetField_SizeU32(DeviceMap, IOHandle,FSTB0899_CFD_ON,FSTB0899_CFD_ON_INFO,1);
				cfrm[0] = MSB((short int)DerotFreq);
				cfrm[1] = LSB((short int)DerotFreq);
				
				STTUNER_IOREG_SetContigousRegisters_SizeU32(DeviceMap, IOHandle,RSTB0899_CFRM,cfrm,2); 							/*	Set the derotator frequency	*/