288_drv.c

STV0299 Minituner driver, for ST chipset

**				Counter		=>	Counter to use
**PARAMS OUT::	NONE
**RETURN	::	number of errors
*****************************************************/
U32 FE_288_GetErrorCount(STCHIP_Handle_t hChip,FE_288_ERRORCOUNTER_t Counter)
{
	U32 lsb,msb;
	
	if(Counter == COUNTER1)
	{
		/*
		ChipGetRegisters(hChip,R288_ECNTM,2);   
		lsb = ChipGetFieldImage(hChip,F288_ERROR_COUNT_LSB);
		msb = ChipGetFieldImage(hChip,F288_ERROR_COUNT_MSB);
		*/
		lsb = ChipGetField(hChip,F288_ERROR_COUNT_LSB);
		msb = ChipGetField(hChip,F288_ERROR_COUNT_MSB);
	}
	else
	{
		/*
		ChipGetRegisters(hChip,R288_ECNTM2,2);
		msb = ChipGetFieldImage(hChip,F288_ERROR_COUNT2_MSB);	  
		lsb = ChipGetFieldImage(hChip,F288_ERROR_COUNT2_LSB);
		*/
		lsb = ChipGetField(hChip,F288_ERROR_COUNT2_LSB);
		msb = ChipGetField(hChip,F288_ERROR_COUNT2_MSB);	  
		
	}
	
	return (BYTES2WORD(msb,lsb));
}


/*****************************************************
--FUNCTION	::	FE_288_TimingTimeConstant
--ACTION	::	Compute the amount of time needed by the timing loop to lock
--PARAMS IN	::	SymbolRate	->	symbol rate value
--PARAMS OUT::	NONE
--RETURN	::	Timing loop time constant (ms)
--***************************************************/
long FE_288_TimingTimeConstant(long SymbolRate)
{
	if(SymbolRate > 0)
		return (100000/(SymbolRate/1000));
	else
		return 0;
}

/*****************************************************
--FUNCTION	::	FE_288_DerotTimeConstant
--ACTION	::	Compute the amount of time needed by the Derotator to lock
--PARAMS IN	::	SymbolRate	->	symbol rate value
--PARAMS OUT::	NONE
--RETURN	::	Derotator time constant (ms)
--***************************************************/
long FE_288_DerotTimeConstant(long SymbolRate)
{
	if(SymbolRate > 0)  
		return (10000/(SymbolRate/1000));
	else
		return 0;
}

/*****************************************************
--FUNCTION	::	FE_288_DataTimeConstant
--ACTION	::	Compute the amount of time needed to capture data 
--PARAMS IN	::	Er		->	Viterbi rror rate	
--				Sn		->  viterbi averaging period
--				To		->  viterbi time out
--				Hy		->	viterbi hysteresis
--				SymbolRate	->	symbol rate value
--PARAMS OUT::	NONE
--RETURN	::	Data time constant
--***************************************************/
long FE_288_DataTimeConstant(STCHIP_Handle_t hDemod,long SymbolRate)
{
	U32	Tviterbi = 0,
		TimeOut	= 0,
		THysteresis	= 0,
		Tdata = 0,
		PhaseNumber[6] = {2,6,4,6,14,8},
		averaging[4] = {1024,4096,16384,65536},
		InnerCode = 1000,
		HigherRate = 1000;
		 	
	U32 	i;
	U8 Pr,Sn,To,Hy;
		 	
	/*=======================================================================
	-- Data capture time (in ms)
    -- -------------------------
	-- This time is due to the Viterbi synchronisation.
	--
	--	For each authorized inner code, the Viterbi search time is calculated,
	--	and the results are cumulated in ViterbiSearch.	
	--  InnerCode is multiplied by 1000 in order to obtain timings in ms 
	=======================================================================*/
	Pr=ChipGetOneRegister(hDemod,R288_PR);
	ChipGetOneRegister(hDemod,R288_VAVSRCH);
	Sn=ChipGetFieldImage(hDemod,F288_SN);
	To=ChipGetFieldImage(hDemod,F288_TO); 
	Hy=ChipGetFieldImage(hDemod,F288_H);
	
	
	for(i=0;i<6;i++)
	{
		if (((Pr >> i)& 0x01) == 0x01)
		{
			switch(i)
			{
				case 0:					/*	inner code 1/2	*/	
					InnerCode = 2000;	/* 2.0 */
				break;
				
				case 1:					/*	inner code 2/3	*/ 
					InnerCode = 1500; 	/* 1.5 */
				break;
				
				case 2:					/*	inner code 3/4  */ 
					InnerCode = 1333;	/* 1.333 */
				break;
				
				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 += (2*PhaseNumber[i]*averaging[Sn]*InnerCode);
			
			if(HigherRate < InnerCode) 
				HigherRate = InnerCode;
		}
	}
	
	/*	  Time out calculation (TimeOut)
	--    ------------------------------
	--    This value indicates the maximum duration of the synchro word research.	*/
	TimeOut   = (U32)(HigherRate * 16384L * (1L<<To));  /* 16384= 16x1024 bits */
	
	/*    Hysteresis duration (Hysteresis)
	--    ------------------------------	*/
	THysteresis = (U32)(HigherRate * 26112L * (1L<<Hy));	/*	26112= 16x204x8 bits  */ 
	
	Tdata =((Tviterbi + TimeOut + THysteresis) / (2*(U32)SymbolRate));
	
	/* a guard time of 1 mS is added */
	return (1L + (long)Tdata);
}

/****************************************************
**FUNCTION	::	FE_288_GetRollOff
**ACTION	::	Read the rolloff value
**PARAMS IN	::	hChip	==>	Handle for the chip
**PARAMS OUT::	NONE
**RETURN	::	rolloff
*****************************************************/
int  FE_288_GetRollOff(STCHIP_Handle_t hChip)
{
	if (ChipGetField(hChip,F288_MODE_COEF) == 1)
		return 20;
	else
		return 35;
}

/*****************************************************
**FUNCTION	::	FE_288_CalcDerotFreq
**ACTION	::	Compute Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
S32 FE_288_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_288_GetDerotFreq
**ACTION	::	Read current Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
S32 FE_288_GetDerotFreq(STCHIP_Handle_t hChip,U32 MasterClock)
{
	/*	Read registers	*/
	ChipGetRegisters(hChip,R288_CFRM,2);   
	
	return FE_288_CalcDerotFreq(ChipGetFieldImage(hChip,F288_CARRIER_FREQUENCY_MSB),
								ChipGetFieldImage(hChip,F288_CARRIER_FREQUENCY_LSB), 
								MasterClock);  	
}

/*****************************************************
**FUNCTION	::	FE_288_SetDerotFreq
**ACTION	::	Set current Derotator frequency 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	NONE
*****************************************************/
void FE_288_SetDerotFreq(STCHIP_Handle_t hChip,U32 MasterClock_Hz,S32 DerotFreq_Hz)
{
	S16 s16;
	
	s16=(S16)(DerotFreq_Hz/(S32)(MasterClock_Hz/65536L));
	
	ChipSetFieldImage(hChip,F288_CARRIER_FREQUENCY_MSB,MSB(s16));
	ChipSetFieldImage(hChip,F288_CARRIER_FREQUENCY_LSB,MSB(s16));
	/*	write registers	*/
	ChipSetRegisters(hChip,R288_CFRM,2);   
}

/*****************************************************
**FUNCTION	::	BinaryFloatDiv
**ACTION	::	float division (with integer) 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	Derotator frequency (KHz)
*****************************************************/
long 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<<=1;      
			n1<<=1;
		}
		else
		{
			result=(result<<1)+1;
			n1=(n1-n2)<<1;
		}
		i++;
	}
	
	return result;
}

/*****************************************************
**FUNCTION	::	FE_288_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_288_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_288_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_288_SetSymbolRate(STCHIP_Handle_t hChip,U32 MasterClock,U32 SymbolRate)
{
	U32	U32Tmp;
	
	/*
	** 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 b