drv0370qam.c

st7710的tuner标准驱动

	/*	AcqLoopsTime (In ms): It Is The Time Required For The Lock
		Of The Carrier And Timing Loops */
	switch (QAMSize)
	{
		case 16:
			Log2QAMSize = 4;
			break;
		case 32:
			Log2QAMSize = 5;
			break;
		case 64:
			Log2QAMSize = 6;
			break;
		case 128:
			Log2QAMSize = 7;
			break;
		case 256:
			Log2QAMSize = 8;
			break;
	}
	NbSymbols = 100000;	/* 100000 Symbols Needed At Least To Lock The STL */
	AcqLoopsTime = (int) (NbSymbols/(SymbolRate/1000));	/* In ms */

	/*	SweepRate = 1000*(Sweep Rate/Symbol Rate)
		CarrierOffset = 10000 * (Offset/Symbol Rate)
		Then:
		LMS2TimeOut = 100 * (CarrierOffset/SweepRate)
		In Order To Scan [-Offset, +Offset], We Must Double LMS2TimeOut
		And To Be Safer, 25% Margin Is Added */
	if(SweepRate != 0)	/* TimeOut When Sweep Function Is Used */
	{
		LMS2TimeOut  = 250*CarrierOffset;
		LMS2TimeOut /= SweepRate;	/* In ms */
		if (LMS2TimeOut < 0)	LMS2TimeOut = - LMS2TimeOut;
		/*	Even In Low Carrier Offset Cases, LMS2TimeOut Must Not Be Lower Than A Minimum
			Value Which Is Linked To The QAM Size. */
		switch (QAMSize)
		{
			case 16:
				if( LMS2TimeOut < 50)
					LMS2TimeOut = 100;
				break;
			case 32:
				if( LMS2TimeOut < 50)
					LMS2TimeOut = 150;
				break;
			case 64:
				if( LMS2TimeOut < 50)
					LMS2TimeOut = 100;
				break;
			case 128:
				if( LMS2TimeOut < 100)
					LMS2TimeOut = 200;
				break;
			case 256:
				if( LMS2TimeOut < 100)
					LMS2TimeOut = 150;
				break;
		}
	}
	else						/* TimeOut When Estimator Is Used */
		LMS2TimeOut = 200;	/* Actual TimeOuts Will Be Used In Following Releases */

	/*	The Equalizer Timeout Must Be Greater Than The Carrier And Timing Lock Time */
	LMS2TimeOut += AcqLoopsTime;
	
	/******************************/
	/*	Chip Initialization			*/
	/******************************/
	
	LoadRegisters(DeviceMap,IOHandle,QAMSize,TunerInstance_p->Driver->ID);

	
	/******************************/
	/*	Derotator Initialization	*/
	/******************************/
	
	Clk50_QAM = STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_CLK50_QAM);
	multiply_factor_times_quartz =((-2*Clk50_QAM* pParams->Quartz)/3)+((8*pParams->Quartz)/3);
	
	/* The Initial Demodulator Frequency Is Set If enabled */
	if (STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_IN_DEMOD_EN) ==1)
		Driv0370QAMDemodSetting(DeviceMap,IOHandle,pParams->InitDemodOffset,multiply_factor_times_quartz,pParams->IF);
	/**/
	/******************************/
	/*	Delayed AGC Initialization	*/
	/******************************/
	/* Wide Band AGC Loop Freeze, Wide Band AGC Clear And
	 Wide Band AGC Status Forced To Unlock Position */
	
	STTUNER_IOREG_SetRegister(DeviceMap, IOHandle,R0370QAM_WBAGC_3,0x40);
	/* Wide Band AGC AGC2SD Initialisation To 25% Range */
	AGC2SD = 256;
	Reg0370QAM_SetAGC(DeviceMap, IOHandle,AGC2SD);
	/* AGC RollOff Set To 384 And Acquisition Threshold To 512
	 In Order To Speed-up The WBAGC Lock. Old values are saved*/
	AGCLoop = Reg0370QAM_GetWBAGCloop(DeviceMap,IOHandle);
	ACQThreshold = STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_ACQ_TH);
	Reg0370QAM_SetWBAGCloop(DeviceMap,IOHandle,384);
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_ACQ_TH,9);
	/**/
	

	/******************************/
	/*	STL Initialization			*/
	/******************************/
	/* Symbol Timing Loop Reset And Release
	 Both Integral And Direct Paths Are Cleared */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_STL_RESET,1);
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_STL_RESET,0);
	/* Integral Path Enabled Only After The WBAGC Lock */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_ERR_EN,0);
	/* Direct Path Enabled Immediatly */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_PHASE_EN,1);
	/******************************/
	/*	CRL Initialization			*/
	/******************************/
	/* Carrier Recovery Loop Reset And Release
	 Frequency And Phase Offset Cleared As Well As All Internal Signals */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_CRL_RESET,1);
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_CRL_RESET,0);
	/* Integral Path Enabled Only After The PMFAGC Lock */
	/* Direct Path Enabled Only After The PMFAGC Lock */
	/* Sweep OFF */
	STTUNER_IOREG_SetRegister(DeviceMap, IOHandle,R0370QAM_CRL_2,0x02);
	/* Corner Detector OFF */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_LOCK_DETECT_ENA,0);
	/* PN Loop Bypass */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_BYP_SEC_LOOP,1);
	/* Fading Detector OFF */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_EN_FADDET,0);
	/* Frequency Estimator Reset */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_RESET,0); /* was 1 before*/
	
	/**/
	/******************************/
	/*	PMF AGC Initialization		*/
	/******************************/
	/* PMF AGC Status Forced To Unlock Position. Accumulator Is Also Reset */
	STTUNER_IOREG_SetRegister(DeviceMap, IOHandle,R0370QAM_PMFAGC_2,0x08);
	/**/
	/******************************/
	/*	Equalizer Initialization	*/
	/******************************/
	/* Equalizer Values Capture */
	Freq19	=	STTUNER_IOREG_GetRegister(DeviceMap, IOHandle,R0370QAM_FREQ_19)	;
	Freq23	=	STTUNER_IOREG_GetRegister(DeviceMap, IOHandle,R0370QAM_FREQ_23)	;
	Freq24	=	STTUNER_IOREG_GetRegister(DeviceMap, IOHandle,R0370QAM_FREQ_24)	;
	/* Equalizer Reset And Release */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_EQ_RESET,1);
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_EQ_RESET,0);
	/* Equalizer Values Reload */
	STTUNER_IOREG_SetRegister(DeviceMap,IOHandle,R0370QAM_FREQ_19,Freq19);
	STTUNER_IOREG_SetRegister(DeviceMap,IOHandle,R0370QAM_FREQ_23,Freq23);
	STTUNER_IOREG_SetRegister(DeviceMap,IOHandle,R0370QAM_FREQ_24,Freq24);
	/**/
	/******************************/
	/*	Signal Parameters Setting	*/
	/******************************/
	Reg0370QAM_SetQAMSize(DeviceMap,IOHandle,QAMSize);
	/* STL Freeze (Avoiding STV0297J Symbol Rate Update) */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_PHASE_CLR,1);
	Reg0370QAM_SetSymbolRate(DeviceMap,IOHandle,SymbolRate,multiply_factor_times_quartz);
	Reg0370QAM_SetSpectrumInversion(DeviceMap,IOHandle,SpectrumInversion);
	/**/
	
	/******************************/
	/*	FEC Initialization			*/
	/******************************/
	Driv0370QAMFecInit(DeviceMap,IOHandle);
	/**/
	
	
	/**/
	/******************************/
	/*	AGC Lock Part					*/
	/******************************/
	/* WBAGC Loop Enable */
	STTUNER_IOREG_SetRegister(DeviceMap,IOHandle,R0370QAM_WBAGC_3,0x10);
	/* Wide Band AGC Lock Check */
	EndOfSearch = NO;
	TimeOut = DataSearchTime + 30;	/* 30 ms Timeout */
	while(EndOfSearch == NO)
	{
		STB0370QAM_DelayInMilliSec(5);/*SystemWaitFor(5); to be checked whether this 
						replacement is correct or not ????*/
		DataSearchTime += 5;
		WBAGCLock = STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_WAGC_ACQ);
		if((WBAGCLock == 1)||(DataSearchTime > TimeOut))
			EndOfSearch = YES;			
		
	}
	if(WBAGCLock == 0)	/* The WBAGC Has Not Converged */
	{
		return (DataFound);
	}
	/* The Code Commented Below Can Be Used To Avoid Locking On Very Low Signals */
	
	/* AGC Roll And Acquisition Threshold Set To the formerly chosen values
	 In Order To Switch To Tracking Mode */
	Reg0370QAM_SetWBAGCloop(DeviceMap,IOHandle,AGCLoop);
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_ACQ_TH,ACQThreshold);
	
	/******************************/
	/*	Post WBAGC Blocks Lock		*/
	/******************************/
	/* STL Release */
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_PHASE_CLR,0x00);
	/* Different Settings According To Whether The Estimator Is Used Or Not */
	if ((STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_CORR_BLIND) || STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_CORR_LMS1) || STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_CORR_LMS1)) != 1)
	{
		Reg0370QAM_SetFrequencyOffset(DeviceMap,IOHandle,CarrierOffset);
		Reg0370QAM_SetSweepRate(DeviceMap,IOHandle,SweepRate,multiply_factor_times_quartz)				;
		STTUNER_IOREG_SetRegister(DeviceMap,IOHandle,R0370QAM_CRL_2,0x03)			;	/* Enable Sweep, Estimator Reset Above */
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_LOCK_DETECT_ENA,0x01)		;	/* Corner Detector On */
		
	}
	else	/* Estimator Used */
	{
		/* Corner Detector Is Not Used Because There Is A Similar Detector In The Frequency Estimator */
		Reg0370QAM_SetFrequencyOffset(DeviceMap,IOHandle,0)		;	/* Offset Zeroed */
		Reg0370QAM_SetSweepRate(DeviceMap,IOHandle,0,multiply_factor_times_quartz)				;	/* Sweep Rate Zeroed, Sweep Is Disabled Above */
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_RESET,1)	;	/* Release Of Estimator Reset */	
		
	}	 
	/* PMF AGC Unlock Forcing Is Disabled, The CRL Can Act Now */	
	STTUNER_IOREG_SetRegister(DeviceMap,IOHandle,R0370QAM_PMFAGC_2,0x02);
	
	/* Waiting For A LMS2 Lock Indication Or A Timeout; Several Successive
	 Lock Indications Are Requested To Decide Equalizer Convergence */
	EndOfSearch    = NO;
	TimeOut = DataSearchTime + LMS2TimeOut;
	LMS2TrackingLock = 0;
	while (EndOfSearch == NO)
	{
		STB0370QAM_DelayInMilliSec(5);
		DataSearchTime += 5;
		int_tmp =  STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_LMS_STEP2);
		if(int_tmp == 1)
		{
			LMS2TrackingLock += 1;
		}
		else
		{
			LMS2TrackingLock = 0;
		}
		if((LMS2TrackingLock >= 5)||(DataSearchTime > TimeOut))
		{		
			EndOfSearch = YES;
		}
		
			
			
	}
	if(int_tmp == 0)	/* The Equalizer Has Not Converged */
	{		
			return (DataFound);
	}
	if ((STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_CORR_BLIND) || STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_CORR_LMS1) || STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_FREQ_EST_CORR_LMS2)) != 1)
	{
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_SW_EN,0);		/* LMS2 Is Locked: Sweep Is Disabled */
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_LOCK_DETECT_ENA,0);	/* Corner Detector Disabled */
		
	}
	STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_EN_FADDET,1);		/* Fading Detector Enabled */
	if (SymbolRate <= 2000000)	/* Phase-Noise Loop Activated For Low Symbol Rate Signals */
		STTUNER_IOREG_SetField(DeviceMap,IOHandle,F0370QAM_BYP_SEC_LOOP,0);
	/**/
	/******************************/
	/*	FEC Lock Check					*/
	/******************************/
	EndOfSearch = NO;
	
	 
	DataFound = Driv0370QAMFECLockCheck(DeviceMap,IOHandle,pParams,EndOfSearch, TimeOut, DataSearchTime);
	/**/
	/******************************/
	/*	Signal Parameters Update	*/
	/******************************/
	pParams->SymbolRate			= (S32)Reg0370QAM_GetSymbolRate(DeviceMap,IOHandle,multiply_factor_times_quartz)		;	/* Symbol Rate Update In Baud/s .... 
																		check this typecasting */
	pParams->Frequency			-=(S32) pParams->InitDemodOffset;  /* Carrier Offset Update ... check this typecasting */
	/* Signal Structure Update */
	pParams->Results.Modulation= pParams->Modulation		;
	pParams->Results.SymbolRate	= pParams->SymbolRate	;
	pParams->Results.Frequency	= pParams->Frequency	;
	
	
	return (DataFound);
}

/*----------------------------------------------------
 FUNCTION      FE_370QAM_Search
 ACTION
                This routine is the ENTRY POINT of the STB0370QAM driver.
                ======================================================

                This routine performs the carrier search following the user indications.
                This routine is the entry point of the STB0370QAM driver.

                The returned value is a flag (TRUE, FALSE) which indicates if the trial is
                successful or not. In case of lock, _pSignal->Frequency and _pSignal->SymbolRate
                are modifyed accordingly with the found carrier parameters.
 PARAMS IN     NONE
 PARAMS OUT    NONE
 RETURN        NONE
------------------------------------------------------*/
BOOL FE_370QAM_Search(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,D0370QAM_StateBlock_t *pSearch, STTUNER_Handle_t  TopLevelHandle)
{
	FLAG_370QAM	DataFound = NO	;
	int	CarrierOffset	;
	int	RangeOffset;
	int	SweepRate;
	int	int_tmp	;
	int	InitDemodOffset	;
	ST_ErrorCode_t              Error = ST_NO_ERROR;
	STTUNER_tuner_instance_t *TunerInstance; 
	STTUNER_InstanceDbase_t     *Inst;
	FE_370QAM_InternalParams_t pParams; 
	FLAG_370QAM Driv0370QAMInitDemodOk;
	/* top level public instance data */ 
        Inst = STTUNER_GetDrvInst();
        
        /* get the tuner instance for this driver from the top level handle */
        TunerInstance = &Inst[TopLevelHandle].Cable.Tuner;
	
			
		
			Driv0370QAMSignalStatus.Status	=	_370QAM_NO_LOCKED				;	/* disable the signal monitoring */ 
			Driv0370QAMSignalStatus.NbLockLoss=	0;	
			/* results init */
			pSearch->Result.Lock.Status	    = _370QAM_NO_LOCKED				;	/* disable the signal monitoring */
			pSearch->Result.Lock.NbLockLoss	= 0						;	
			pParams.Quartz = pSearch->Quartz;
			pParams.Modulation			= pSearch->QAMSize;	/* QAM Size =  64, 256 */
			pParams.SymbolRate		    = (S32)pSearch->Params.SymbolRate;	/* in Baud/s ...check this typecasting*/
			pParams.Frequency		    = (S32)pSearch->Params.Frequency	;	/* in kHz */
			pParams.SpecInv	        = pSearch->SpectrumInversion;	/* YES or NO */
			pParams.SweepRate			= pSearch->SweepRate;	/* = 1000* (SweepRate (in MHz/s) / Symbol Rate (in MBaud/s)) */
			pParams.CarrierOffset		= pSearch->CarrierOffset;	/* = 10000 * (Carrier Offset (in KHz) / Symbol Rate (in KBaud)) */
                        pParams.IF                     = (U32) pSearch->Params.TunerIF;
			if (((pParams.SweepRate > 0)&&(pParams.CarrierOffset > 0)) ||
				((pParams.SweepRate < 0)&&(pParams.CarrierOffset < 0)))
				return(DataFound);
			if (pParams.SweepRate < 0)
			{
				SweepRate     = -pParams.SweepRate;
				CarrierOffset = -pParams.CarrierOffset;
			}
			else
			{
				SweepRate     = pParams.SweepRate;
				CarrierOffset = pParams.CarrierOffset;
			}


			Error = (TunerInstance->Driver->tuner_SetFrequency)(TunerInstance->DrvHandle,(U32)pParams.Frequency,(U32 *)&pParams.Frequency);	/*	Move the tuner	*/   			


			DataFound = NO;
			RangeOffset = CarrierOffset;

			/* Initial Derotator Enabled ? */
			int_tmp = STTUNER_IOREG_GetField(DeviceMap,IOHandle,F0370QAM_IN_DEMOD_EN);
			if ((int_tmp == 1)&&(RangeOffset < -400))
			{
				Driv0370QAMInitDemodOk = YES;
				RangeOffset = -400;				
			}
			else 
			{
				Driv0370QAMInitDemodOk = NO;
				
			}

			/* [- RangeOffset, + RangeOffset] range is scanned */
			pParams.InitDemodOffset = 0;
			pParams.CarrierOffset= (110*RangeOffset)/100;
			pParams.SweepRate= SweepRate;
			DataFound = Driv0370QAMDataSearch(DeviceMap,IOHandle,&pParams,TunerInstance);

			if (Driv0370QAMInitDemodOk == YES)
			{
				/* Initial Demodulation Is Required */
				InitDemodOffset = 0 ;
				while ((DataFound == NO)&&((InitDemodOffset + RangeOffset) >= CarrierOffset))
				{
					/* The subranges are scanned in a zig-zag mode around the initial subrange */
					SweepRate = -SweepRate;
					RangeOffset = -RangeOffset;
					if (RangeOffset > 0)
						InitDemodOffset = -InitDemodOffset + RangeOffset;
					else
						InitDemodOffset = -InitDemodOffset;

					/* [InitDemod - RangeOffset, InitDemod + RangeOffset] range is scanned */
					pParams.InitDemodOffset =  (int)((InitDemodOffset*(pParams.SymbolRate/1000))/10000);
					pParams.CarrierOffset= (110*RangeOffset)/100;
					pParams.SweepRate= SweepRate;
					
					DataFound = Driv0370QAMDataSearch(DeviceMap,IOHandle,&pParams,TunerInstance);
				}
			}

			if (DataFound)	
			{
				
				pSearch->Result.Lock.Status = _370QAM_LOCKED;
				Driv0370QAMSignalStatus.Status = _370QAM_LOCKED;
				
				/* Signal Structure Update */
	                    pSearch->Result.QAMSize= pParams.Modulation		;
	                    pSearch->Result.SymbolRate	= pParams.SymbolRate	;
	                    pSearch->Result.Frequency	= pParams.Frequency	;
			}

	return (DataFound);
}


/* End of drv370qam.c */