stb0899_drv.c~

DVB-S STB0899 source code

/* -------------------------------------------------------------------------
File Name: STB0899_drv.c

Description: STB0899 driver LLA	V3.4 December/05/2005 


author: BJ
---------------------------------------------------------------------------- */


/* includes ---------------------------------------------------------------- */

#include <linux/dvb/frontend.h>
#include "stb0899_drv.h"

 FE_STB0899_LOOKUP_t FE_STB0899_CN_LookUp = {
	20,{
	{15,9600},
	{20,9450},
	{30,9000},
	{40,8250},
	{50,7970},
	{60,7360},
	{70,6770},
	{80,6200},
	{90,5670},
	{100,5190},
	{110,4740},
	{120,4360},
	{130,4010},
	{140,3710},
	{150,3440},
	{160,3210},
	{170,3020},
	{180,2860},
	{190,2700},
	{200,2600}
	}
};
	
 FE_STB0899_LOOKUP_t FE_STB0899_RF_LookUp = {
	20,{
	{-5,79},
	{-10,73},
	{-15,67},
	{-20,62},
	{-25,56},
	{-30,49},
	{-33,44},
	{-35,40},
	{-37,36},
	{-38,33},
	{-40,27},
	{-45,4},
	{-47,-11},
	{-48,-19},
	{-50,-29},
	{-55,-43},
	{-60,-52},
	{-65,-61},
	{-67,-65},
	{-70,-128},
	}
};

 FE_STB0899_LOOKUP_t FE_STB0899_DVBS2RF_LookUp = {
	15,{
	{-5,2899},
	{-10, 3330},
	{-15, 3123},
	{-20, 3577},
	{-25, 4004},
	{-30, 4417},
	{-35, 4841},
	{-40, 5300},
	{-45, 5822},
	{-50, 6491},
	{-55, 7516},
	{-60, 9235},
	{-65, 11374},
	{-70, 12364},
	{-75, 13063},
	}
};

/*****************************************************
**FUNCTION	::	FE_STB0899_SetInternalError
**ACTION		::	Set the internal error value and location 
**PARAMS IN	::	Type	==> Type of the error
**			Location==> Location of the error
**PARAMS OUT	::	pError
**RETURN	::	NONE
*****************************************************/
static void FE_STB0899_SetInternalError(FE_STB0899_ErrorType_t Type,FE_STB0899_Location_t Location,FE_STB0899_InternalError_t *pError)
{
	if(pError != NULL)
	{
		pError->Type = Type;
		pError->Location = Location;
	}
}

/*****************************************************
**FUNCTION	::	WaitTuner
**ACTION	::	Wait for tuner locked
**PARAMS IN	::	TimeOut	->Maximum waiting time (in ms) 
**PARAMS OUT::	NONE
**RETURN	::	NONE
*****************************************************/
static void WaitTuner(TUNER_Handle_t hTuner,int TimeOut)
{
	int Time=0;
	int TunerLocked = FALSE;
	
	while(!TunerLocked && (Time<TimeOut))
	{
		WAIT_N_MS(1);
		TunerLocked = TunerGetStatus(hTuner);
		
		Time++;
	}
	Time--;
}

/*****************************************************
--FUNCTION	::	FE_STB0899_CheckTiming
--ACTION	::	Check for timing locked
--PARAMS IN	::	pParams->Ttiming=>Time to wait for timing loop locked
--PARAMS OUT	::	pParams->State	=>result of the check
--RETURN	::	NOTIMING if timing not locked, TIMINGOK otherwise
--***************************************************/
static FE_STB0899_SIGNALTYPE_t FE_STB0899_CheckTiming(FE_STB0899_InternalParams_t *pParams)
{
	int locked,timing;
	
	WAIT_N_MS(pParams->Ttiming);
	ChipSetField(pParams->hDemod,FSTB0899_TIMING_LOOP_FREQ,0xf2);
	locked=ChipGetField(pParams->hDemod,FSTB0899_TMG_LOCK_IND);
	timing=ABS(ChipGetField(pParams->hDemod,FSTB0899_TIMING_LOOP_FREQ));
	if(locked >= 42)
	{
		if((locked > 48) && (timing >= 110))
			pParams->State = ANALOGCARRIER;
		else 
			pParams->State = TIMINGOK;
	}
	else
		pParams->State = NOTIMING;

	return pParams->State;
}

/*****************************************************
--FUNCTION	::	FE_STB0899_CheckCarrier
--ACTION	::	Check for carrier founded
--PARAMS IN	::	pParams	=>Pointer to FE_STB0899_InternalParams_t structure
--PARAMS OUT	::	pParams->State	=> Result of the check
--RETURN	::	NOCARRIER carrier not founded, CARRIEROK otherwise
--***************************************************/
static FE_STB0899_SIGNALTYPE_t FE_STB0899_CheckCarrier(FE_STB0899_InternalParams_t *pParams)
{
	WAIT_N_MS(pParams->Tderot); /*wait for derotator ok*/
	ChipSetField(pParams->hDemod,FSTB0899_CFD_ON,0);
	
	if (ChipGetField(pParams->hDemod,FSTB0899_CARRIER_FOUND/*FSTB0899_FDCT*/))
		pParams->State = CARRIEROK;
	else
		pParams->State = NOCARRIER;
	
	return pParams->State;
}

static u32 FE_STB0899_GetErrorCount(STCHIP_Handle_t hChip,ERRORCOUNTER Counter)
{
	u32 lsb=0,msb=0;
	
	/*Do not modified the read order (lsb first)*/
	switch(Counter)
	{
		case COUNTER1:
			lsb = ChipGetField(hChip,FSTB0899_ERROR_COUNT_LSB);
			msb = ChipGetField(hChip,FSTB0899_ERROR_COUNT_MSB);
		break;
	
		case COUNTER2:
			lsb = ChipGetField(hChip,FSTB0899_ERROR_COUNT2_LSB);
			msb = ChipGetField(hChip,FSTB0899_ERROR_COUNT2_MSB);
		break;
		
		case COUNTER3:
			lsb = ChipGetField(hChip,FSTB0899_ERROR_COUNT3_LSB);
			msb = ChipGetField(hChip,FSTB0899_ERROR_COUNT3_MSB);
		break;
	}

	return (MAKEWORD(msb,lsb));
}

/*****************************************************
--FUNCTION	::	FE_STB0899_CheckData
--ACTION	::	Check for data founded
--PARAMS IN	::	pParams	=>Pointer to FE_STB0899_InternalParams_t structure
--PARAMS OUT	::	pParams->State	=> Result of the check
--RETURN	::	NODATA data not founded, DATAOK otherwise
--***************************************************/
static FE_STB0899_SIGNALTYPE_t FE_STB0899_CheckData(FE_STB0899_InternalParams_t *pParams)
{
	int lock = 0, index=0, dataTime=500;
	pParams->State = NODATA;
	
	/* reset du FEC */
	ChipSetField(pParams->hDemod,FSTB0899_FRESACS,1);
	WAIT_N_MS(1);
	ChipSetField(pParams->hDemod,FSTB0899_FRESACS,0);

	if(pParams->SymbolRate <= 2000000)
		dataTime=2000;
	else if(pParams->SymbolRate <= 5000000)
		dataTime=1500;
	else if(pParams->SymbolRate <= 15000000)
		dataTime=1000;
	else
		dataTime=500;

	/* force search loop */
	ChipSetOneRegister(pParams->hDemod,RSTB0899_DSTATUS2,0x00);
	
	/* warning : vit locked has to be tested before end_loop */
	while(!(lock = ChipGetField(pParams->hDemod,FSTB0899_LOCKEDVIT)) &&	
		!ChipGetField(pParams->hDemod,FSTB0899_END_LOOPVIT) && index<dataTime)
		index++;   /* wait for viterbi end loop */
	
	/*DVB Mode*/
	if (lock)/*Test DATA LOCK indicator*/
		pParams->State = DATAOK;

	return pParams->State;
}

/*****************************************************
--FUNCTION	::	FE_STB0899_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)
--***************************************************/
static long FE_STB0899_TimingTimeConstant(long SymbolRate)
{
	if(SymbolRate > 0)
		return (100000/(SymbolRate/1000));
	else
		return 0;
}

/*****************************************************
--FUNCTION	::	FE_STB0899_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)
--***************************************************/
static long FE_STB0899_DerotTimeConstant(long SymbolRate)
{
	if(SymbolRate > 0)
		return (100000/(SymbolRate/1000));
	else
		return 0;
}

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

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

/*****************************************************
**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
*****************************************************/
static u32 FE_STB0899_SetSymbolRate(STCHIP_Handle_t hChip, u32 MasterClock, u32 SymbolRate)
{
	u32 U32Tmp, U32TmpUp, SymbolRateUp = SymbolRate;
	
	/*
	** 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 = BinaryFloatDiv(SymbolRate, MasterClock, 20);
	U32TmpUp = BinaryFloatDiv(SymbolRateUp, MasterClock, 20);
	
	ChipSetFieldImage(hChip, FSTB0899_SYMB_FREQ_UP_HSB, (U32TmpUp >> 12) & 0xFF);
	ChipSetFieldImage(hChip, FSTB0899_SYMB_FREQ_UP_MSB, (U32TmpUp >> 4)& 0xFF);
	ChipSetFieldImage(hChip, FSTB0899_SYMB_FREQ_UP_LSB, U32TmpUp & 0x0F);

	ChipSetFieldImage(hChip, FSTB0899_SYMB_FREQ_HSB, (U32Tmp >> 12) & 0xFF);
	ChipSetFieldImage(hChip, FSTB0899_SYMB_FREQ_MSB, (U32Tmp >> 4) & 0xFF);
	ChipSetFieldImage(hChip, FSTB0899_SYMB_FREQ_LSB, U32Tmp & 0x0F);
	

	ChipSetRegisters(hChip,RSTB0899_SFRUPH,3);
	ChipSetRegisters(hChip,RSTB0899_SFRH,3);
	
	/*ChipSetOneRegister(hChip,RSTB0899_TMGCFG,0x40);*/
	
	return(SymbolRate) ;
}

/*****************************************************
--FUNCTION	::	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) 
--***************************************************/
static long 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