drv399e.c

st7710的tuner标准驱动

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

Description: 399E driver LLA

Copyright (C) 2003-2004 STMicroelectronics

author: SD

History:

15-07-2004
Comments: First time Integrated in STTUNER STAPI
Revision 1.0.0
---------------------------------------------------------------------------- */


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

/*	generic includes	*/
#include "gen_macros.h"
#include "sysdbase.h"
#include "tunsdrv.h"

#ifdef HOST_PC
	#include <utility.h>
	#include <stdio.h>
	#include "math.h"
	#include "stdlib.h"
	#ifndef NO_GUI
		#include "Appl.h"
		#include "UserPar.h"
		#include "Pnl_report.h"
		#include "399_Report_Msg.h"
		#define REPORTMSG(a,b,c) Report399(a,b,c);
	#else
		#define REPORTMSG(a,b,c)
	#endif
#else
	#define REPORTMSG(a,b,c) 
#endif

/* common includes */ 
#include"sttuner.h"
#include "399_drv.h"
#include"399_util.h"
#include "util399E.h"


#define MINIMUM_GAP 18000 /* Minimum gap size between master clock harmonic and tuner frequency (KHz) */
#define MINIMUM_GAP_low 10000
#define MINIMUM_GAP_2 33000

#ifndef STTUNER_MINIDRIVER
/* Current LLA revision	*/
static const ST_Revision_t Revision399  = "STV0399-LLA_REL_2.2.0";
#endif

 
static FE_399_LOOKUP_t FE_399_RF_LookUp =	{
												16,
												{
													-100,	-200,
													-150,	-190,
													-200,	-140,
													-250,	-90,
													-300,	-40,
													-350,	10,
													-400,	60,
													-450,	110,
													-500,	140,
													-550,	190,
													-600,	235,
													-650,	285,
													-700,	340,
													-750,	390,
													-800,	435,
													-840,	475
												}
											};

											
static FE_399_LOOKUP_t FE_399_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
												}
											};







/* structures -------------------------------------------------------------- */ 




#ifdef STTUNER_MINIDRIVER
		extern D0399_InstanceData_t *DEMODInstance;
#endif
	
#ifndef STTUNER_MINIDRIVER
/***********************************************************
**FUNCTION	::	Drv0399_GetLLARevision
**ACTION	::	Returns the 399 LLA driver revision
**RETURN	::	Revision399
***********************************************************/
ST_Revision_t Drv0399_GetLLARevision(void)
{
	return (Revision399);
}

#endif
/*****************************************************
**FUNCTION	::	XtoPowerY
**ACTION	::	Compute  x^y (where x and y are integers) 
**PARAMS IN	::	Number -> x
**				Power -> y
**PARAMS OUT::	NONE
**RETURN	::	2^n
*****************************************************/
#ifndef STTUNER_MINIDRIVER
U32 XtoPowerY(U32 Number, U32 Power)
{
	int i;
	long result = 1;
	
	for(i=0;i<Power;i++)
		result *= Number;
		
	return (U32)result;
}
#endif
S32 InRange(S32 x,S32 y,S32 z) 
{
	return ((x<=y && y<=z) || (z<=y && y<=x))?1:0;
}

#ifndef STTUNER_MINIDRIVER
S32 RoundToNextHighestInteger(S32 Number,U32 Digits)
{
	S32 result = 0,
		highest = 0;
	
	highest = XtoPowerY(10,Digits);
	result = Number / highest;
	
	if((Number - (Number/highest)*highest) > 0)
		result += 1;
	
	return result;
}
#endif
/*****************************************************
**FUNCTION	::	FE_399E_PowOf2
**ACTION	::	Compute  2^n (where n is an integer) 
**PARAMS IN	::	number -> n
**PARAMS OUT::	NONE
**RETURN	::	2^n
*****************************************************/

long FE_399E_PowOf2(int number)
{
	int i;
	long result=1;
	
	for(i=0;i<number;i++)
		result*=2;
		
	return result;
}

#ifndef STTUNER_MINIDRIVER
/*****************************************************
**FUNCTION	::	FE_399E_GetPowOf2
**ACTION	::	Compute  x according to y with y=2^x 
**PARAMS IN	::	number -> y
**PARAMS OUT::	NONE
**RETURN	::	x
*****************************************************/
long FE_399E_GetPowOf2(int number)
{
	int i=0;
	
	while(FE_399E_PowOf2(i)<number) i++;
		
	return i;
}
#endif
#ifndef STTUNER_MINIDRIVER
BOOL FE_399_Harmonic(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,U32 MasterClock,U32 RfFrequency,U32 OFFSET)
{
	S32 gap;
	
	gap = RfFrequency % (MasterClock / 1000);
	
	/*if((gap <= MINIMUM_GAP) || (gap >= (MasterClock / 1000)-MINIMUM_GAP))*/
	if((gap <= OFFSET) || (gap >= (MasterClock / 1000)-OFFSET))
		return TRUE;
	else
		return FALSE;
}
#endif
#ifdef STTUNER_MINIDRIVER
BOOL FE_399_Harmonic(U32 MasterClock,U32 RfFrequency,U32 OFFSET)
{
	S32 gap;
	
	gap = RfFrequency % (MasterClock / 1000);
	
	/*if((gap <= MINIMUM_GAP) || (gap >= (MasterClock / 1000)-MINIMUM_GAP))*/
	if((gap <= OFFSET) || (gap >= (MasterClock / 1000)-OFFSET))
		return TRUE;
	else
		return FALSE;
}
#endif
BOOL FE_399_Triple(S32 MasterClock,S32 SymbolRate) 
{
	S32 ratio;
	
	ratio = MasterClock/(SymbolRate/1000);
	
	if((ratio >= 2990) && (ratio <= 3010))
		return TRUE;
	else
		return FALSE;
}


U32 FE_399_SelectOffset(S32 SymbolRate)
{

U32 OFFSET;
if(SymbolRate <= 10000000)
   {
    OFFSET = MINIMUM_GAP_low;
   }
   
else
  {
   OFFSET =MINIMUM_GAP; 
  }
  
return OFFSET;
}

#ifdef STTUNER_MINIDRIVER
S32 FE_399_SelectMclk(U32 RfFrequency,S32 SymbolRate,S32 ExtClk)
{
	BOOL harmonic,triple;
	U32 pll_div;
	U32 coef_div;
	/*S32 clock[2][2]={{65571428,13},{70615384,14}};*/
	S32 clock[2][2];
	S32 index = 0;
	S32 ratio;
	
	
	pll_div = FE_399_Get_PLL_mult_coeff( );
	
	if((pll_div == 34)&&(SymbolRate <= 10000000))
	{
	 coef_div=12;
	}
	
	else if((pll_div == 34)&&(SymbolRate > 10000000)&&(SymbolRate <= 20000000))
	{
	 coef_div=9;
	}
	
	else if((pll_div == 34)&&(SymbolRate > 20000000))
	{
	 coef_div=6;
	}
	
	else if((pll_div == 32)&&(SymbolRate <= 10000000))
	{
	 coef_div=12;
	}
	
	else if((pll_div == 32)&&(SymbolRate > 10000000)&&(SymbolRate <= 20000000))
	{
	 coef_div=9;
	}
	
	else if((pll_div == 32)&&(SymbolRate > 20000000))
	{
	 coef_div=6;
	}
	clock[0][0]=pll_div*27000000/coef_div;
	clock[0][1]=coef_div; 
	clock[1][0]=pll_div*27000000/(coef_div+1); 
	clock[1][1]=coef_div+1; 
	
	ratio = FE_399_GetDivRatio( );
	if((ratio>=6) && (ratio<=13))
	{
		do
		{
			harmonic = FE_399_Harmonic(clock[index][0],RfFrequency,FE_399_SelectOffset(SymbolRate));
			triple = FE_399_Triple(clock[index][0],SymbolRate);
			index++;
		}
		while((harmonic || triple) && (index<2));
	
		if(harmonic || triple)
			FE_399_SetDivRatio(coef_div);
		else
			FE_399_SetDivRatio(clock[index-1][1]);
	}
	
	return FE_399_GetMclkFreq(ExtClk);
	
}
#endif

#ifndef STTUNER_MINIDRIVER
S32 FE_399_SelectMclk(STTUNER_IOREG_DeviceMap_t *DeviceMap, IOARCH_Handle_t IOHandle,U32 RfFrequency,S32 SymbolRate,S32 ExtClk)
{
	BOOL harmonic,triple;
	U32 pll_div;
	U32 coef_div;
	/*S32 clock[2][2]={{65571428,13},{70615384,14}};*/
	S32 clock[2][2];
	S32 index = 0;
	S32 ratio;
	
		
	pll_div = FE_399_Get_PLL_mult_coeff(DeviceMap, IOHandle);
	
	if((pll_div == 34)&&(SymbolRate <= 10000000))
	{
	 coef_div=12;
	}
	
	else if((pll_div == 34)&&(SymbolRate > 10000000)&&(SymbolRate <= 20000000))
	{
	 coef_div=9;
	}
	
	else if((pll_div == 34)&&(SymbolRate > 20000000))
	{
	 coef_div=6;
	}
	
	else if((pll_div == 32)&&(SymbolRate <= 10000000))
	{
	 coef_div=12;
	}
	
	else if((pll_div == 32)&&(SymbolRate > 10000000)&&(SymbolRate <= 20000000))
	{
	 coef_div=9;
	}
	
	else if((pll_div == 32)&&(SymbolRate > 20000000))
	{
	 coef_div=6;
	}
	
	
	
	clock[0][0]=pll_div*27000000/coef_div;
	clock[0][1]=coef_div; 
	clock[1][0]=pll_div*27000000/(coef_div+1); 
	clock[1][1]=coef_div+1; 
	
	ratio = FE_399_GetDivRatio(DeviceMap, IOHandle);
	if((ratio>=6) && (ratio<=13))
	{
		do
		{

		
			
			harmonic = FE_399_Harmonic(DeviceMap, IOHandle,clock[index][0],RfFrequency,FE_399_SelectOffset(SymbolRate));
			triple = FE_399_Triple(clock[index][0],SymbolRate);
			index++;
		}
		while((harmonic || triple) && (index<2));
	
		if(harmonic || triple)
			FE_399_SetDivRatio(DeviceMap, IOHandle,coef_div);
		else
			FE_399_SetDivRatio(DeviceMap, IOHandle,clock[index-1][1]);
	}
	
	return FE_399_GetMclkFreq(DeviceMap, IOHandle,ExtClk);
	
}

#endif
/*****************************************************
**FUNCTION	::	FE_399_CalcAGC1Gain
**ACTION	::	Compute the AGC1 gain
**PARAMS IN	::  regvalue	==>	register value
**PARAMS OUT::	NONE
**RETURN	::	AGC1 gain multiplied by two
*****************************************************/
S32 FE_399_CalcAGC1Gain(U8 regvalue)
{
	S32 gain = 0;
	
	gain = (S32)((regvalue >> 2) & 0x1F);
	
	if(!(regvalue & 0x80))
		gain += 16;
		
	return gain;
}

/*****************************************************
**FUNCTION	::	FE_399_CalcAGC1Integrator
**ACTION	::	Compute the AGC1 gain
**PARAMS IN	::  gain	==>	gain multiplied by two
**PARAMS OUT::	NONE
**RETURN	::	AGC1 integrator value
*****************************************************/
U8 FE_399_CalcAGC1Integrator(S32 gain)
{
	U8 integrator = 0x00;
	
	if(gain > 31)