362_drv.c

STV0299 Minituner driver, for ST chipset

/*	standard ansi includes	*/
/*#include "math.h"*/
#include  <stdlib.h>
#include "chip.h"
#ifdef HOST_PC
#include "I2C.h"
#else
#include "sti2c.h"
#endif

#ifdef HOST_PC
/*	362 includes	*/
#ifndef NO_GUI
	#include "362_GUI.h"
	#include "Appl.h"  
#endif
//

#include "Tuner.h" 

//FILE *fp;


#else

#include "stlite.h"                     /* Standard includes */ 
#include "stddefs.h"

/* STAPI */
#include "sttuner.h"
#include "sti2c.h"
#include "stcommon.h"
#include "sttbx.h"
#include "stevt.h"

/* local to sttuner */
#include "util.h"       /* generic utility functions for sttuner */ 
#include "dbtypes.h"    /* data types for databases */
#include "sysdbase.h"   /* functions to accesss system data */ 


#include "ioarch.h"     /* I/O for this driver */ 
#include "ioreg.h"      /* I/O for this driver */

#include "d0362.h"      /* top level header for this driver */
#include "tuntdrv.h"






#define UTIL_Delay(micro_sec) task_delay((unsigned int)(((micro_sec) + 999) / 1000) * ST_GetClocksPerSecond() / 1000)
#define SystemWaitFor(x) UTIL_Delay((x*1000))
#define Delay(x) task_delay((unsigned int)(ST_GetClocksPerSecond()*x));
TUNTDRV_InstanceData_t *TUNTDRV_GetInstFromHandle(TUNER_Handle_t Handle);

#endif


#ifdef HOST_PC
/*	generic includes	*/
//#include <utility.h>
//#include <ansi_c.h>
#include "gen_macros.h"
//#include "gen_types.h"
//#include "gen_csts.h" 
#endif

#include "362_init.h"
#include "362_echo.h"
#include "362_drv.h"

#define M6_F_GAIN_SRC_HI        0xA
#define M6_F_GAIN_SRC_LO        0xF0 
#define M6_F_TRL_NOMRATE0       0x0
#define M6_F_TRL_NOMRATE8_1     0x01 
#define M6_F_TRL_NOMRATE16_9    0x41

#define M7_GAIN_SRC_HI        	0xC
#define M7_GAIN_SRC_LO        	0xE4    /*For normal IF Mode*/

#define M7_E_GAIN_SRC_HI        0x7
#define M7_E_GAIN_SRC_LO        0x6C    /* For long path IF / IQ modes */ 

#define M7_F_TRL_NOMRATE0       0x0	   	/* ok */
#define M7_F_TRL_NOMRATE8_1     0xD6   	/* ok */
#define M7_F_TRL_NOMRATE16_9    0x4B   	/* ok */

#define M8_GAIN_SRC_HI        	0x0E
#define M8_GAIN_SRC_LO        	0xD8 	/*For normal IF Mode*/ 

#define M8_E_GAIN_SRC_HI		0x08
#define M8_E_GAIN_SRC_LO		0x86	/* For long path IF / IQ modes */ 

#define M8_F_TRL_NOMRATE0       0x1	   	/* ok */
#define M8_F_TRL_NOMRATE8_1     0xAB   	/* ok */
#define M8_F_TRL_NOMRATE16_9    0x56   	/* ok */





#define DELTA 666

#define DELTA_T 10

/* dcdc #define CPQ_LIMIT 23*/
#define CPQ_LIMIT 23

extern dbg_num_trials;

const ST_Revision_t Revision362  = "STV0362-LLA_REL_1.1";
extern 	unsigned int dbg_num_trial;  
unsigned short int cum_cpq[8];

U16 CellsCoeffs_8MHz[6][5]={ 
						{0x10EF,0xE205,0x10EF,0xCE49,0x6DA7},  /* CELL 1 COEFFS */
						{0x2151,0xc557,0x2151,0xc705,0x6f93},  /* CELL 2 COEFFS */ 
						{0x2503,0xc000,0x2503,0xc375,0x7194},  /* CELL 3 COEFFS */ 
						{0x20E9,0xca94,0x20e9,0xc153,0x7194},  /* CELL 4 COEFFS */ 
						{0x06EF,0xF852,0x06EF,0xC057,0x7207},  /* CELL 5 COEFFS */ 
						{0x0000,0x0ECC,0x0ECC,0x0000,0x3647}   /* CELL 6 COEFFS */ 
					  } ;


U16 CellsCoeffs_7MHz[6][5]={ 
						{0x12CA,0xDDAF,0x12CA,0xCCEB,0x6FB1},  /* CELL 1 COEFFS */
						{0x2329,0xC000,0x2329,0xC6B0,0x725F},  /* CELL 2 COEFFS */ 
						{0x2394,0xC000,0x2394,0xC2C7,0x7410},  /* CELL 3 COEFFS */ 
						{0x251C,0xC000,0x251C,0xC103,0x74D9},  /* CELL 4 COEFFS */ 
						{0x0804,0xF546,0x0804,0xC040,0x7544},  /* CELL 5 COEFFS */ 
						{0x0000,0x0CD9,0x0CD9,0x0000,0x370A}   /* CELL 6 COEFFS */ 
					  } ;

U16 CellsCoeffs_6MHz[6][5]={ 
						{0x12CA,0xDDAF,0x12CA,0xCCEB,0x6FB1},  /* CELL 1 COEFFS */
						{0x2329,0xC000,0x2329,0xC6B0,0x725F},  /* CELL 2 COEFFS */ 
						{0x2394,0xC000,0x2394,0xC2C7,0x7410},  /* CELL 3 COEFFS */ 
						{0x251C,0xC000,0x251C,0xC103,0x74D9},  /* CELL 4 COEFFS */ 
						{0x0804,0xF546,0x0804,0xC040,0x7544},  /* CELL 5 COEFFS */ 
						{0x0000,0x0CD9,0x0CD9,0x0000,0x370A}   /* CELL 6 COEFFS */ 
					  } ;


/***************************************************** 
**FUNCTION  ::  PowOf4
**ACTION    ::  Compute  4^n (where n is an integer) 
**PARAMS IN ::  number -> n
**PARAMS OUT::  NONE
**RETURN    ::  4^n
*****************************************************/ 
int PowOf4(int number)
{
int i;
int result=1;

for(i=0;i<number;i++)
result*=4;

return result;
}


/*****************************************************
**FUNCTION	::	PowOf2
**ACTION	::	Compute  2^n (where n is an integer) 
**PARAMS IN	::	number -> n
**PARAMS OUT::	NONE
**RETURN	::	2^n
*****************************************************/
int PowOf2(int number)
{
	int i;
	int result=1;
	
	for(i=0;i<number;i++)
		result*=2;
		
	return result;
}

/*****************************************************
**FUNCTION	::	GetPowOf2
**ACTION	::	Compute  x according to y with y=2^x 
**PARAMS IN	::	number -> y
**PARAMS OUT::	NONE
**RETURN	::	x
*****************************************************/
long GetPowOf2(int number)
{
	int i=0;
	
	while(PowOf2(i)<number) i++;
		
	return i;
}



/****************************************************
**FUNCTION	::	BinaryFloatDiv
**ACTION	::	
**PARAMS IN	::	n1,n2 operands for division n1/n2
**			::	n1<n2
**				
**PARAMS OUT::	result=pow(2,precision)*n1/n2;
*****************************************************/

U32 BinaryFloatDiv(U32 n1, U32 n2, int precision)
{
	int i=0;
	U32 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	::	FilterCoeffInit
--ACTION	::	Apply filter coeffs values
				
--PARAMS IN	::	Handle to the Chip
				
--PARAMS OUT::	NONE
--********************************************************/
void FilterCoeffInit(STCHIP_Handle_t hChip,U16 CellsCoeffs[6][5])		
{			

	int i,j;
		
		for(i=1;i<=6;i++)
		{
			ChipSetField(hChip,IIR_CELL_NB,i-1);   
				
			for(j=1;j<=5;j++)
			{
				ChipSetField(hChip,(IIR_CX_COEFF1_MSB+2*(j-1)), MSB(CellsCoeffs[i-1][j-1]));
				ChipSetField(hChip,(IIR_CX_COEFF1_LSB+2*(j-1)), LSB(CellsCoeffs[i-1][j-1])); 
		
			}
		
		}

}


/**********************************************************/
/*********************************************************
--FUNCTION	::	SpeedInit
--ACTION	::	calculate I2C speed (for SystemWait ...)
				
--PARAMS IN	::	Handle to the Chip
--PARAMS OUT::	NONE
--RETURN	::	#ms for an I2C reading access ..
--********************************************************/
int SpeedInit(STCHIP_Handle_t hChip)
{									
#if (0)	//#ifdef HOST_PC
unsigned int i;
int tempo;

tempo= clock();
for (i=0;i<16;i++) ChipGetField(hChip,PPM_CPC);

tempo=clock()-tempo;
tempo=(tempo*1000)/CLOCKS_PER_SEC;
tempo=(tempo+4)>>4;	/* 4 not 8 to avoid too rough rounding */

return tempo;
#else
unsigned int i,tempo;
clock_t     time1,time2,time_diff;

time1 = time_now();
for (i=0;i<16;i++) ChipGetField(hChip,PPM_CPC); time2 = time_now();
time_diff = time_minus(time2,time1);
tempo = (time_diff * 1000 ) / ST_GetClocksPerSecond() + 4; /* Duration in milliseconds, + 4 for rounded value */
tempo = tempo << 4;
return tempo;
#endif

}


/***** SET TRLNOMRATE REGISTERS *******************************/

void SET_TRLNOMRATE_REGS(STCHIP_Handle_t hChip,short unsigned int value)
{
div_t divi;   

divi=div(value,512); 
ChipSetField(hChip,TRL_NOMRATE_HI,divi.quot);
ChipSetField(hChip,TRL_NOMRATE_LO,(divi.rem/2));
ChipSetField(hChip,TRL_NOMRATE_LSB,(divi.rem%2));						

}
/*************************************************************/
short unsigned int GET_TRLNOMRATE_VALUE(STCHIP_Handle_t hChip)
{
short unsigned int value;   
value=  ChipGetField(hChip,TRL_NOMRATE_HI)*512+ChipGetField(hChip,TRL_NOMRATE_LO)*2+ChipGetField(hChip,TRL_NOMRATE_LSB);	

return value;
}
/**************************************************************/
signed int GET_TRL_OFFSET(STCHIP_Handle_t hChip)
{
	unsigned int  u_var;
    signed int    s_var;
	signed int i_int;
 
	ChipSetField(hChip,FREEZE,1);								  
	ChipGetRegisters(hChip,R_TRL_NOMRATE1,4);
	ChipSetField(hChip,FREEZE,0);
	
	s_var= 256* ChipGetFieldImage(hChip,TRL_TOFFSET_HI)+ChipGetFieldImage(hChip,TRL_TOFFSET_LO);
	if (s_var > 32768 ) s_var = s_var - 65536;
	
	u_var=  (512*ChipGetFieldImage(hChip,TRL_NOMRATE_HI)+ChipGetFieldImage(hChip,TRL_NOMRATE_LO)*2 + ChipGetFieldImage(hChip,TRL_NOMRATE_LSB));
	i_int=((signed)(1000000/u_var)*s_var)/2048;


	return i_int;
}


/*****************************************************
--FUNCTION		::	FE_362_AGC_IIR_LOCK_DETECTOR_SET
--ACTION		::	Sets Good values for AGC IIR lock detector
--PARAMS IN		::	Handle to the Chip 
--PARAMS OUT	::	None 
--***************************************************/
void  FE_362_AGC_IIR_LOCK_DETECTOR_SET(STCHIP_Handle_t hChip)

{
	
	ChipSetField(hChip,LOCK_DETECT_LSB,0x00);
	
	/* Lock detect 1 */
	ChipSetField(hChip,LOCK_DETECT_CHOICE,0x00);
	ChipSetField(hChip,LOCK_DETECT_MSB,0x06);
	ChipSetField(hChip,AUT_AGC_TARGET_LSB,0x04);

	/* Lock detect 2 */
	ChipSetField(hChip,LOCK_DETECT_CHOICE,0x01);
	ChipSetField(hChip,LOCK_DETECT_MSB,0x06);
	ChipSetField(hChip,AUT_AGC_TARGET_LSB,0x04);
	
	/* Lock detect 3 */
	ChipSetField(hChip,LOCK_DETECT_CHOICE,0x02);
	ChipSetField(hChip,LOCK_DETECT_MSB,0x01);
	ChipSetField(hChip,AUT_AGC_TARGET_LSB,0x00);
	
	/* Lock detect 4 */
	ChipSetField(hChip,LOCK_DETECT_CHOICE,0x03);
	ChipSetField(hChip,LOCK_DETECT_MSB,0x01);
	ChipSetField(hChip,AUT_AGC_TARGET_LSB,0x00);

}


/*****************************************************
--FUNCTION		::	FE_362_IIR_FILTER_INIT
--ACTION		::	Sets Good IIR Filters coefficients
--PARAMS IN		::	Handle to the Chip 
					selected bandwidth
--PARAMS OUT	::	None 
--***************************************************/
void  FE_362_IIR_FILTER_INIT(STCHIP_Handle_t hChip,U8 Bandwidth)

{


	ChipSetField(hChip,NRST_IIR,0);


	switch (Bandwidth)
	{
	
		case 6:
			FilterCoeffInit(hChip,CellsCoeffs_6MHz);
		break;
		
		case 7:
			FilterCoeffInit(hChip,CellsCoeffs_7MHz);
		break;
		
		case 8:
			FilterCoeffInit(hChip,CellsCoeffs_8MHz);
		break;
	
	
	}


	ChipSetField(hChip,NRST_IIR,1);   

}


/*****************************************************
--FUNCTION		::	FE_362_AGC_IIR_RESET
--ACTION		::	AGC reset procedure
--PARAMS IN		::	Handle to the Chip 
--PARAMS OUT	::	None 
--***************************************************/
void FE_362_AGC_IIR_RESET(STCHIP_Handle_t hChip) 
{

	U8 com_n;

	com_n=ChipGetField(hChip,COM_N);
	
	ChipSetField(hChip,COM_N,0x07);
	
	ChipSetField(hChip,COM_SOFT_RSTN,0x00);  
	ChipSetField(hChip,COM_AGC_ON,0x00); 
	
	ChipSetField(hChip,COM_SOFT_RSTN,0x01);  
	ChipSetField(hChip,COM_AGC_ON,0x01);  
	
	ChipSetField(hChip,COM_N,com_n);

}

U8 FE_362_GET_LOCK(STCHIP_Handle_t hChip)
{

	U8 lock;
	
	lock = ChipGetField(hChip,AGC_LOCK);
	lock|= ChipGetField(hChip,SYR_LOCK); 
	lock|= ChipGetField(hChip,TPS_LOCK);  
	lock|= ChipGetField(hChip,PRF);
	lock|= ChipGetField(hChip,LK);
	
	return lock;  
}

/*********************************************************
--FUNCTION	::	CheckAGC
--ACTION	::	Get AGC status
--PARAMS IN	::	Handle to the Chip, AGC Lock Timeout
--PARAMS OUT::	AGC Lock status
--********************************************************/
FE_362_SignalStatus_t CheckAGC(STCHIP_Handle_t hChip,U32 Tempo)
{
	
	S32 AGCLock,Time=0;
	
	do
	{
	
	 WAIT_N_MS(1);
	 AGCLock=ChipGetField(hChip,AGC_LOCK);
	 Time++; 
	}while((AGCLock==0)&&(Time<Tempo)); 
	
	if (ChipGetField(hChip,AGC_LOCK))
		AGCLock = AGCOK;
	else
		AGCLock = NOAGC;
		
	return AGCLock;
}





/*********************************************************
--FUNCTION	::	CheckSYR
--ACTION	::	Get SYR status
--PARAMS IN	::	Handle to the Chip, SYR Lock Timeout
--PARAMS OUT::	SYR Lock status
--********************************************************/
FE_362_SignalStatus_t CheckSYR(STCHIP_Handle_t hChip,U32 Tempo)
{
	
	S32 SYRLock,Time=0;
	
	do
	{
	
	 WAIT_N_MS(1);
	 SYRLock=ChipGetField(hChip,SYR_LOCK);
	 Time++; 
	}while((SYRLock==0)&&(Time<Tempo)); 
	
	if (ChipGetField(hChip,SYR_LOCK))
		SYRLock = SYMBOLOK;
	else
		SYRLock = NOSYMBOL;
		
	return SYRLock;
}


/*********************************************************
--FUNCTION	::	CheckCPAMP
--ACTION	::	Get CPAMP status
--PARAMS IN	::	Handle to the Chip
--PARAMS OUT::	CPAMP status
--********************************************************/
FE_362_SignalStatus_t CheckCPAMP(STCHIP_Handle_t hChip)
{
	
	S32 mode, CPAMPvalue, CPAMPStatus, CPAMPMin,tempo,idx;
	
	mode= ChipGetField(hChip,SYR_MODE);
	
	switch(mode)
	{
		case 0: /*2k mode*/
			 CPAMPMin=20;
			 tempo=30;
		break;
		
		case 1: /*8k mode*/
			 CPAMPMin=80; 
		break;
		
		case 2: /*4k mode*/