drv399e.c

st7710的tuner标准驱动

**FUNCTION	::	FE_399_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_399_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_399_SetSymbolRate
**ACTION	::	Set symbol frequency
**PARAMS IN	::	DeviceMap, IOHandle
**				MasterClock	->	Masterclock frequency (Hz)
**				SymbolRate	->	symbol rate (bauds)
**PARAMS OUT::	NONE
**RETURN	::	Symbol frequency
*****************************************************/
#ifndef STTUNER_MINIDRIVER
U32 FE_399_SetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,U32 MasterClock,U32 SymbolRate)
{
	U32 U32Tmp;
	U8 temp[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 )
	*/
	U32Tmp = (U32)FE_399_BinaryFloatDiv(SymbolRate,MasterClock,20);       
		
	temp[0]=(U32Tmp>>12)&0xFF;
	temp[1]=(U32Tmp>>4)&0xFF;
	
	temp[2]=U32Tmp&0x0F;
	STTUNER_IOREG_SetContigousRegisters(DeviceMap,IOHandle, R399_SFRH, temp, 3);     
	
	return(SymbolRate) ;
}
#endif
#ifdef STTUNER_MINIDRIVER
U32 FE_399_SetSymbolRate(U32 MasterClock,U32 SymbolRate)
{
	U32 U32Tmp;
	U8 nsbuffer[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 )
	*/
	U32Tmp = (U32)FE_399_BinaryFloatDiv(SymbolRate,MasterClock,20);       
	
	nsbuffer[0] = (U8)((U32Tmp>>12)&0xFF);
	nsbuffer[1] = (U8)((U32Tmp>>4)&0xFF);
	nsbuffer[2] = (U8)((U32Tmp&0x0F)<<4);
	
	STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R399_SFRH, 0, 0, nsbuffer, 3, FALSE);
	return(SymbolRate) ;
}
#endif
/*****************************************************
**FUNCTION	::	FE_399_IncSymbolRate
**ACTION	::	Increment symbol frequency
**PARAMS IN	::	hChip		->	handle to the chip
**				MasterClock	->	Masterclock frequency (Hz)
**				Increment	->	positive or negative increment
**PARAMS OUT::	NONE
**RETURN	::	Symbol frequency
*****************************************************/
#ifndef STTUNER_MINIDRIVER
void FE_399_IncSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,S32 Increment)
{
	U32  U32Tmp;
	U8 temp[2];
	
	STTUNER_IOREG_GetContigousRegisters(DeviceMap,IOHandle,R399_SFRH,3,temp);     
	
	U32Tmp = (temp[0] & 0xFF)<<12;
	U32Tmp += (temp[1] & 0xFF)<<4;  
	U32Tmp += (temp[2] & 0x0F);  
	
	U32Tmp += Increment;
	
	temp[0]=(U32Tmp>>12)&0xFF;
	temp[1]=(U32Tmp>>4)&0xFF;
	temp[2]=(U32Tmp&0x0F);
	
	STTUNER_IOREG_SetContigousRegisters(DeviceMap,IOHandle, R399_SFRH, temp, 3);     
}


void FE_399_OffsetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,U32 MasterClock,S32 Offset)
{
	U32  U32Tmp;
	S32 tst;
	U8 temp[2];
	STTUNER_IOREG_GetContigousRegisters(DeviceMap,IOHandle,R399_SFRH,3,temp);     
	temp[2]=(temp[2]>>4)&0x0F;
	U32Tmp = (temp[0] & 0xFF)<<12;
	U32Tmp += (temp[1] & 0xFF)<<4;  
	U32Tmp += (temp[2] & 0x0F);  
	
	
	tst = (Offset*(S32)U32Tmp)>>19; 
	U32Tmp += tst;   
	
	temp[0]=(U32Tmp>>12)&0xFF;
	temp[1]=(U32Tmp>>4)&0xFF;
	temp[3]=U32Tmp&0x0F;

	
	STTUNER_IOREG_SetContigousRegisters(DeviceMap,IOHandle, R399_SFRH, temp, 3);     
}
#endif
/*****************************************************
**FUNCTION	::	FE_399_GetSymbolRate
**ACTION	::	Get the current symbol rate
**PARAMS IN	::	hChip		->	handle to the chip
**				MasterClock	->	Masterclock frequency (Hz)
**PARAMS OUT::	NONE
**RETURN	::	Symbol rate
*****************************************************/
#ifndef STTUNER_MINIDRIVER
U32 FE_399_GetSymbolRate(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,U32 MasterClock)
{
	U8 temp[2];
	STTUNER_IOREG_GetContigousRegisters(DeviceMap,IOHandle,R399_SFRH,3,temp);
	temp[2]=(temp[2]&0x0F)>>4;
	return FE_399_CalcSymbolRate(MasterClock,temp[0],temp[1],temp[2]);
									
    
}
#endif
#ifdef STTUNER_MINIDRIVER
U32 FE_399_GetSymbolRate(U32 MasterClock)
{
	U8 nsbuffer[3];
	STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_READ, R399_SFRH, 0, 0, nsbuffer, 3, FALSE);
	
	return FE_399_CalcSymbolRate(	MasterClock,
									nsbuffer[0]/*HSB*/,
									nsbuffer[1]/*MSB*/,
									nsbuffer[2]/*LSB*/);
									
    
}
#endif
/*****************************************************
--FUNCTION	::	FE_399_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_399_CarrierWidth(long SymbolRate, long RollOff)
{
	return (SymbolRate  + (SymbolRate*RollOff)/100);
}


/*****************************************************
--FUNCTION	::	FE_399_InitialCalculations
--ACTION	::	Set Params fields that are never changed during search algorithm   
--PARAMS IN	::	NONE
--PARAMS OUT::	NONE
--RETURN	::	NONE
--***************************************************/
void FE_399_InitialCalculations(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,FE_399_InternalParams_t *pParams)
{
	U8 temp[1];
	
	#ifndef STTUNER_MINIDRIVER
	int		stdby,
			m1,betaagc1,
			agc2coef;	
	/*	Read registers (in burst mode)	*/
	STTUNER_IOREG_GetRegister(DeviceMap,IOHandle,R399_AGC1C);
	STTUNER_IOREG_GetContigousRegisters(DeviceMap,IOHandle,R399_AGC1R,2,temp);		/*	Read AGC1R and AGC2O registers */
	
	/*	Get fields values	*/
	stdby=STTUNER_IOREG_GetField(DeviceMap,IOHandle,F399_STANDBY);
	m1=STTUNER_IOREG_GetField(DeviceMap,IOHandle,F399_AGC1R_REF);
	betaagc1=STTUNER_IOREG_GetField(DeviceMap,IOHandle,F399_AGC1C_BETA1);   
	agc2coef=STTUNER_IOREG_GetField(DeviceMap,IOHandle,F399_AGC2COEFF);
	
	/*	Initial calculations	*/ 
	pParams->Tagc1 = 1;
	pParams->Tagc2 = 1;
	pParams->RollOff = FE_399_GetRollOff(DeviceMap,IOHandle);
	#endif
	#ifdef STTUNER_MINIDRIVER	
	/*	Initial calculations	*/ 
	pParams->Tagc1 = 1;
	pParams->Tagc2 = 1;
	
	#endif
}


/*****************************************************
--FUNCTION	::	FE_399_SearchTiming
--ACTION	::	Perform an Fs/2 zig zag to found timing
--PARAMS IN	::	NONE
--PARAMS OUT::	NONE
--RETURN	::	NOTIMING_399E if no valid timing had been found, TIMINGOK_399E otherwise
--***************************************************/
FE_399_SIGNALTYPE_t FE_399_SearchTiming(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,FE_399_InternalParams_t *pParams)
{
	S16	DerotStep,
		DerotFreq = 0,
		DerotMin,DerotMax,
		NextLoop = 2;
		
	S32 index = 0;
	U8 temp[2];
			
	#ifndef STTUNER_MINIDRIVER
	pParams->State = NOTIMING_399E;
	
	REPORTMSG(SEARCHTIMINGMSG,pParams->Frequency,DerotFreq*pParams->Mclk)
	
	/* timing loop computation & symbol rate optimisation	*/
	DerotMin =  (short int)  (((-(long)(pParams->SubRange))/ 2L + pParams->FreqOffset) / pParams->Mclk); /* introduce 14 MHz derotator offset */
    	DerotMax =  (short int)  ((pParams->SubRange/2L + pParams->FreqOffset)/pParams->Mclk);  /* introduce 14 MHz derotator offset */
	DerotStep = (S16)((pParams->SymbolRate/2L)/pParams->Mclk);    
	while((FE_399_CheckTiming(DeviceMap,IOHandle,pParams)!=TIMINGOK_399E) && NextLoop)
	{
		REPORTMSG(SEARCHOFFSET,pParams->Frequency,DerotFreq*pParams->Mclk)
		
		index++;
		DerotFreq += index*pParams->Direction*DerotStep;	/*	Compute the next derotator position for the zig zag	*/    
		
		if((DerotFreq < DerotMin) || (DerotFreq > DerotMax))
			NextLoop--;
			
		if(NextLoop)
		{
			temp[0]=MSB(DerotFreq);
			temp[1]=LSB(DerotFreq);
			
			STTUNER_IOREG_SetContigousRegisters(DeviceMap,IOHandle,R399_CFRM,temp,2); 							/*	Set the derotator frequency	*/
		}
		
		pParams->Direction = -pParams->Direction;			/*	Change the zigzag direction	*/    
	}
	
	
	if(pParams->State == TIMINGOK_399E)
	{
		pParams->Results.SymbolRate = pParams->SymbolRate; 
		STTUNER_IOREG_GetContigousRegisters(DeviceMap,IOHandle,R399_CFRM,2,temp); 								/*	Get the derotator frequency	*/ 
		pParams->DerotFreq = (short int) MAKEWORD(temp[0], temp[1]);
	}
	#endif
	/************************MINIDRIVER***********************/
	#ifdef STTUNER_MINIDRIVER
	U8 nsbuffer[2];
	pParams->State = NOTIMING_399E;
	REPORTMSG(SEARCHTIMINGMSG,pParams->Frequency,DerotFreq*pParams->Mclk)
	/* timing loop computation & symbol rate optimisation	*/
	DerotMin =  (short int)  (((-(long)(pParams->SubRange))/ 2L + pParams->FreqOffset) / pParams->Mclk); /* introduce 14 MHz derotator offset */
    	DerotMax =  (short int)  ((pParams->SubRange/2L + pParams->FreqOffset)/pParams->Mclk);  /* introduce 14 MHz derotator offset */
	DerotStep = (S16)((pParams->SymbolRate/2L)/pParams->Mclk);    
	while((FE_399_CheckTiming(pParams)!=TIMINGOK_399E) && NextLoop)
	{
		index++;
		DerotFreq += index*pParams->Direction*DerotStep;
		if((DerotFreq < DerotMin) || (DerotFreq > DerotMax))
			NextLoop--;
			
		if(NextLoop)
		{
			nsbuffer[0] = MSB(DerotFreq);
    	        	nsbuffer[1] = LSB(DerotFreq);
    	        	STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R399_CFRM, 0, 0, nsbuffer,2, FALSE);
		}		
		pParams->Direction = -pParams->Direction;
	}	
	if(pParams->State == TIMINGOK_399E)
	{
		pParams->Results.SymbolRate = pParams->SymbolRate; 
		STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_READ, R399_CFRM, 0, 0, nsbuffer,2, FALSE);
		pParams->DerotFreq = (short int) MAKEWORD(nsbuffer[0],nsbuffer[1]);
	}
	#endif
	return pParams->State;
}

/****************************************************
--FUNCTION	::	FE_399_SearchLock
--ACTION	::	Search for Lock 
--PARAMS IN	::	pParams->Tdata	=>	Time to wait for data
--PARAMS OUT::	pParams->State	=>	Result of the search
--RETURN	::	NODATA_399E if data not founded, DATAOK_399E otherwise 
--**************************************************/
FE_399_SIGNALTYPE_t FE_399_SearchLock(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,FE_399_InternalParams_t *pParams)
{
	#ifndef STTUNER_MINIDRIVER
	switch(pParams->DemodIQMode)
	{
		case 0:
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F399_SYM,0);
		FE_399_CheckData(DeviceMap,IOHandle,pParams);
		break;
		case 1:
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F399_SYM,1);
		FE_399_CheckData(DeviceMap,IOHandle,pParams);
		break;
		case 2:
		if(FE_399_CheckData(DeviceMap,IOHandle,pParams) != DATAOK_399E)		/*	Check for data	*/
		{
			FE_399_IQInvertion(DeviceMap,IOHandle,pParams);			/*	Invert I and Q	*/
	
			if(FE_399_CheckData(DeviceMap,IOHandle,pParams) != DATAOK_399E) /*	Check for data	*/
			{
				FE_399_IQInvertion(DeviceMap,IOHandle,pParams);		/*	Invert I and Q	*/
			}
			else
			{
				REPORTMSG(SEARCHIQSWAP,0,0)
			}
		 }
		 break;
		 
		 default:
		 break;
        }
	#endif
	/***************************************MINIDRIVER***************************
	*******************************************************************************/
	#ifdef STTUNER_MINIDRIVER
	U8 Data;
	switch(pParams->DemodIQMode)
	{
		case 0:
		Data = 0;
		STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R399_FECM, F399_SYM, F399_SYM_L, &Data, 1, FALSE);
		FE_399_CheckData(pParams);
		break;
		case 1:
		Data = 1;
		STTUNER_IODIRECT_ReadWrite(STTUNER_IO_SA_WRITE, R399_FECM, F399_SYM, F399_SYM_L, &Data, 1, FALSE);
		FE_399_CheckData(pParams);
		break;
		case 2:
		if(FE_399_CheckData(pParams) != DATAOK_399E)		/*	Check for data	*/
		{
			FE_399_IQInvertion(pParams);			/*	Invert I and Q	*/
	
			if(FE_399_CheckData(pParams) != DATAOK_399E) /*	Check for data	*/
			{
				FE_399_IQInvertion(pParams);		/*	Invert I and Q	*/
			}
			else
			{
				REPORTMSG(SEARCHIQSWAP,0,0)
			}
		 }
		 break;
		 
		 default:
		 break;
        }
	#endif
	return pParams->State;
}


/*****************************************************
--FUNCTION	::	FE_399_SearchCarrier
--ACTION	::	Search a QPSK carrier with the derotator
--PARAMS IN	::	
--PARAMS OUT::	NONE
--RETURN	::	NOCARRIER_399E if no carrier had been found, CARRIEROK_399E otherwise 
--***************************************************/
FE_399_SIGNALTYPE_t FE_399_SearchCarrier(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,FE_399_InternalParams_t *pParams)
{
	short int	DerotFreq = 0,
		LastDerotFreq = 0, 
		DerotMin,DerotMax,
		NextLoop = 2;
	int 	index = 0;
	U8 temp[2];

	#ifndef STTUNER_MINIDRIVER
	pParams->State = NOCARRIER_399E;
	
	REPORTMSG(SEARCHCARRIERMSG,0,0)   
	
	DerotMin =  (short int)  (((-(long)(pParams->SubRange))/ 2L + pParams->FreqOffset) / pParams->Mclk); /* introduce 14 MHz derotator offset */
    	DerotMax =  (short int)  ((pParams->SubRange/2L + pParams->FreqOffset)/pParams->Mclk);  /* introduce 14 MHz derotator offset */
	DerotFreq = pParams->DerotFreq;
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F399_CFD_ON,1);
	
	do
	{
		REPORTMSG(SEARCHOFFSET,pParams->Frequency,DerotFreq*pParams->Mclk)  
		
		if(FE_399_CheckCarrier(DeviceMap,IOHandle,pParams) != CARRIEROK_399E)
		{
			index++;
			LastDerotFreq = DerotFreq;
			DerotFreq += index*pParams->Direction*pParams->DerotStep;	/*	Compute the next derotator position for the zig zag	*/    
		
			if((DerotFreq < DerotMin) || (DerotFreq > DerotMax))
				NextLoop--;
				
			if(NextLoop)
			{
				temp[0]=MSB(DerotFreq);
				temp[1]=LSB(DerotFreq);   
				STTUNER_IOREG_SetContigousRegisters(DeviceMap,IOHandle,R399_CFRM,temp,2);
				STTUNER_IOREG_SetField(DeviceMap,IOHandle,F399_CFD_ON,1); 							/*	Set the derotator frequency	*/
			}
		}
		else
		{
			pParams->Results.SymbolRate = pParams->SymbolRate;
		}
		
		pParams->Direction = -pParams->Direction;			/*	Change the zigzag direction	*/    
	}
	while(	(pParams->State!=CARRIEROK_399E) && NextLoop);
	
	
	if(pParams->State == CARRIEROK_399E)
	{
		STTUNER_IOREG_GetContigousRegisters(DeviceMap,IOHandle,R399_CFRM,2,temp);