reg0299.c

stv0299资料

#define  ENABLE_DEBUG_PRINT

#include "st_tuner.h"

#include REGFILE

#if(HOST > 1000)
	#include <userint.h>
	#include "trace.h"
	#include "panel_u.h"
	#include "drivmain.h"
	#include "userpar.h"
#endif

#ifdef   ENABLE_DEBUG_PRINT
   #define  DEBUG_PRINT( __X__ )    printf __X__
#else
   #define  DEBUG_PRINT( __X__ )
#endif

REGISTER RegMap [NBREG];
FIELD	   FieldMap[NBFIELD];
/* LP 260600 - declared as global and initialised in qpsk0299.c */
/* static */  semaphore_t  semSTv0299RegAccess;
static int  RegExtClk, 
			RegNbI2cAccess; 
			
static FLAG RegTrigger;

/*{{{ I2cGetSTVAddress ()*/
unsigned char  I2cGetSTVAddress ( void )
{
   return   ( unsigned char ) I2C_SLAVE_ADDR_FOR_STV0299;
}
/*}}}*/

/*****************************************************
**FUNCTION	::	RegSetNbI2cAccess
**ACTION	::	Set the number of I2C access 
**PARAMS IN	::	_Value	->	number of I2C access
**PARAMS OUT::	NONE
**RETURN	::	NONE
*****************************************************/
void  RegSetNbI2cAccess(int _Value)
{
   RegNbI2cAccess = _Value;
}

/*****************************************************
**FUNCTION	::	RegGetNbI2cAccess
**ACTION	::	Get the number of I2C access 
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	NONE
*****************************************************/
int  RegGetNbI2cAccess(void)
{
   return (RegNbI2cAccess);
}

/******** AddReg  ************************************************************/
/*	Add a new register to the register map									 */
/*****************************************************************************/
void AddReg(int Id,char * Name,char Address,char Reset)
{
	REGISTER *pReg;
	
	pReg=&RegMap[Id];
	
	pReg->Addr	= Address;
	pReg->Reset	= Reset;
	pReg->Value	= 0x00;
   if ( strlen ( Name ) < REG_NAME_LENGTH )
   {
      strcpy ( pReg -> Name, Name );
   }
#if   0
   else
   {
      do_report ( severity_info, "%s %d> Reg_%d Name[%s] Size(%d)\n",
            __FILE__,
            __LINE__,
            Id,
            Name,
            strlen ( Name ) );
   }
#endif
}

/******** FieldCreateMask ****************************************************/
/*	Create the mask of the field according the informations store in the  	 */
/*	FIELD structure															 */
/*****************************************************************************/
unsigned char FieldCreateMask(int field)
{
	int i;
	unsigned char mask=0;
	
	/*	Create mask	*/
	for (i = 0; i < FieldMap[field].Bits; i++)
	{
		mask <<= 1 ;
		mask +=  1 ;
	}
	  
	mask = mask << FieldMap[field].Pos;
	
	return mask;
}

/******** AddField  **********************************************************/
/*	Add a field to the field map											 */
/*****************************************************************************/
void AddField(int RegId, int FieldId,char * Name, char Pos, char NbBits, char Type)
{
	FIELD *pField; 
	
	pField=&FieldMap[FieldId];
	
   if ( strlen ( Name ) < REG_NAME_LENGTH )
   {
      strcpy(pField->Name,Name);	
   }
#if   0
   else
   {
      do_report ( severity_info, "%s %d> Reg_%d.Fld_%d => Name[%s] Size(%d)\n",
            __FILE__,
            __LINE__,
            RegId,
            FieldId,
            Name,
            strlen ( Name ) );
   }
#endif

	pField->Reg=	RegId;
	pField->Pos=	Pos;
	pField->Bits=	NbBits;
	pField->Type=	Type;
	pField->Mask=	FieldCreateMask(FieldId);
}

/******** RegSetOneRegister **************************************************/
/*	Set Register value													  	 */
/*	INPUT :  data, register id												 */
/*****************************************************************************/
void RegSetOneRegister(int reg_id, unsigned char Data)   
{
	#if (HOST > 1000)
		char Tstat,Dstat;
	#endif

	unsigned char data[2];
	int ChipAddress;
	
	#if (HOST > 1000)
		Tstat=TraceGetState();
		Dstat=DriverMainGetStandBy();
	   UsrRdInt("I2cSTVAddress",&ChipAddress);
   #else
    /* VICKY - 060200 - read the I2C slave address */
    ChipAddress=I2cGetSTVAddress();
	#endif
	
	data[0]=RegMap[reg_id].Addr;
	data[1]=Data; 
	
	#if (HOST > 1000)
		if(Tstat&&Dstat)
			TraceWriteFile(OUT,ChipAddress,data,2);
	
		if(!(Tstat&&TraceGetMode()&&Dstat))
		{
	#endif
		I2cReadWrite(WRITE,ChipAddress,data,2);
		RegNbI2cAccess += 1;  
	#if (HOST > 1000)
		}	
	#endif
	
	RegMap[reg_id].Value=Data;  
}

/******** RegGetOneRegister **************************************************/
/*	Get Register value													  	 */
/*	INPUT :  register id													 */
/*	RETURN :  data															 */     
/*****************************************************************************/
int RegGetOneRegister(int reg_id)         
{
#if (HOST > 1000)
	char Tstat,Tmode,Dstat;
	int error;
#endif
	int ChipAddress;

   semaphore_wait ( &semSTv0299RegAccess );
	
#if (HOST > 1000)
	UsrRdInt("I2cSTVAddress",&ChipAddress);
#else
    /* VICKY - 060200 - read the I2C slave address */
    ChipAddress=I2cGetSTVAddress();
#endif

#if (HOST > 1000)
	Tstat=TraceGetState();
	Tmode=!TraceGetMode();
	Dstat=DriverMainGetStandBy();
	
	if(!(Tstat&&Tmode&&Dstat))
	{
#endif
	/*	I2C access	*/
	I2cReadWrite(WRITE,ChipAddress,&RegMap[reg_id].Addr,1);  
	I2cReadWrite(READ,ChipAddress,&RegMap[reg_id].Value,1); 
	RegNbI2cAccess += 1;    
#if (HOST > 1000)
	}

	if(Tstat&&Dstat)
	{		
		/*	Trace ON and Driver RUNNING	*/
		if(Tmode)
			/*	Playback mode	*/
			error=TraceReadFile(IN,ChipAddress,&RegMap[reg_id].Value,1);
		else 
			/*	Record mode   */
			TraceWriteFile(IN,ChipAddress,&RegMap[reg_id].Value,1);  
		error=2;
	}
#endif
	
   semaphore_signal ( &semSTv0299RegAccess );

	return RegMap[reg_id].Value;
}

/******** RegSetRegisters *****************************************************/
/*	Set Registers values in burst mode 									  	 */
/*	INPUT : a buffer for data, first register address, last register address */
/*****************************************************************************/
void  RegSetRegisters(int FirstReg, int NbRegs)
{
#if (HOST > 1000)
	char Tstat,Dstat;   
#endif                                                                                                                                                                        
	unsigned char *Data;
	int i,ChipAddress;
	
#if (HOST > 1000)
	Tstat=TraceGetState();
	Dstat=DriverMainGetStandBy();
#endif
	
#if (HOST > 1000)
	UsrRdInt("I2cSTVAddress",&ChipAddress);
#else
    /* VICKY - 060200 - read the I2C slave address */
    ChipAddress=I2cGetSTVAddress();
#endif

#if   0
   if ( FirstReg == R_CFRM )
   {
		i = (short int) MAKEWORD(FieldGetVal(DEROTATORFREQUENCYMSB),FieldGetVal(DEROTATORFREQUENCYLSB));
      printf ( "CFRM=> %02X%02X V[%04X] (%d)\n",
            RegMap [ FirstReg ] . Value,
            RegMap [ FirstReg + 1 ] . Value,
            i,
            i );
   }
#endif

	Data=(unsigned char *) malloc(NbRegs+1);	
	Data[0]=RegMap[FirstReg].Addr;
	
	/*	Read RegMap structure	*/
	for(i=0;i<NbRegs;i++)
		Data[i+1]=RegMap[FirstReg+i].Value;

#if (HOST > 1000)
	if(Tstat&&Dstat)
		TraceWriteFile(OUT,ChipAddress,Data,NbRegs+1);
	
	if(!(Tstat&&TraceGetMode()&&Dstat))
	{
#endif
		I2cReadWrite(WRITE,ChipAddress,Data,NbRegs+1);
		RegNbI2cAccess += NbRegs;   
#if (HOST > 1000)
	}
#endif
	
	free(Data);
}

/******** RegGetRegisters ***************************************************/
/*	Get Registers values in burst mode 									  	*/
/*	INPUT : first register address, last register address 					*/
/****************************************************************************/
void RegGetRegisters(int FirstReg, int NbRegs)
{
#if (HOST > 1000)
	char Tstat,Tmode,Dstat;
	int nbdata;
#endif
	unsigned char *Data;
	int i,ChipAddress;
	
	Data=(unsigned char *) malloc(NbRegs);	

   semaphore_wait ( &semSTv0299RegAccess );

#if (HOST > 1000)
	UsrRdInt("I2cSTVAddress",&ChipAddress);
#else
    /* VICKY - 060200 - read the I2C slave address */
    ChipAddress=I2cGetSTVAddress();
#endif

#if (HOST > 1000)
	Tstat=TraceGetState();
	Tmode=TraceGetMode();
	Dstat=DriverMainGetStandBy();
	
	if(!(Tstat&&Tmode&&Dstat))
	{
#endif
		/*	I2C access	*/
		I2cReadWrite(WRITE,ChipAddress,&RegMap[FirstReg].Addr,1);   
		I2cReadWrite(READ,ChipAddress,Data,NbRegs); 
		RegNbI2cAccess += NbRegs;   
#if (HOST > 1000)
	}
	
	if(Tstat&&Dstat)
	{		
		/*	Trace ON and Driver RUNNING	*/
		if(Tmode)
			/*	Playback mode	*/
			TraceReadFile(IN,ChipAddress,Data,nbdata);
		else 
			/*	Record mode	*/
			TraceWriteFile(IN,ChipAddress,Data,NbRegs);  
	}
#endif
	
	/*	Update RegMap structure	*/
	for(i=0;i<NbRegs;i++)
		RegMap[FirstReg+i].Value=Data[i];
		
   semaphore_signal ( &semSTv0299RegAccess );

	free(Data);
}

/******** RegReset ***********************************************************/
/*	Set Chip register values according Default Values stored in ValRegReset	 */
/*																			 */
/*****************************************************************************/
void RegReset(void)
{
	int reg ;

	for ( reg = 0 ; reg < NBREG ; reg++ )
		RegSetOneRegister(reg,RegMap[reg].Reset);

}
  
/******** FieldSetVal ***************************************************************/
/*	Compute the new value of the register with the value of the field				*/
/*	Input : index of the field, value of the field			        				*/
/*	Output: NONE								  				      				*/
/************************************************************************************/
void FieldSetVal(int field, int fieldval)
{
	FIELD *pfield;
	
	pfield=&(FieldMap[field]);						/*	Just for code simplification	*/
	
	if(pfield->Type == SIGNED)
		fieldval = (fieldval > 0 ) ? fieldval : fieldval + (1<<pfield->Bits);	/*	compute signed fieldval	*/
  
	fieldval = pfield->Mask & (fieldval << pfield->Pos);	/*	Shift and mask value	*/
	RegMap[pfield->Reg].Value = (RegMap[pfield->Reg].Value & (~pfield->Mask)) + fieldval;	/*	Concat register value and fieldval	*/
}

/******** RegSetField ***********************************************************/
/*	Set Chip register bits of the field "field" to the value "value"			*/
/*	Input : index of the field and value to write						    	*/
/********************************************************************************/
void	 RegSetField(int field,int value)
{
	FIELD *pfield;


#if   1
   /* VICKY - 030300 - forced no update on CFD_ALGO */
   if ( field == CFD_ALGO )
      return;
#endif
	
	pfield=&(FieldMap[field]);						/*	Just for code simplification   */
	
	RegGetOneRegister(pfield->Reg);					/*	Read the register	*/
	FieldSetVal(field,value);						/*	Compute new RegMap value */
	RegSetOneRegister(pfield->Reg,RegMap[pfield->Reg].Value);      	/*	Write the register */
}

/******** FieldGetVal ***************************************************************/
/*	Compute the value of the field with the register value store in  REGMAP			*/
/*	Input : index of the field								        				*/
/*	Output: value of the field								        				*/
/************************************************************************************/
int FieldGetVal(int field)
{
	int value;
	FIELD *pfield;
	
	pfield=&(FieldMap[field]);						/*	Just for code simplification	*/
	value=(RegMap[pfield->Reg].Value & pfield->Mask) >> pfield->Pos;	/*	Extract field	*/
	
	if((pfield->Type == SIGNED)&&(value & (1<<(pfield->Bits-1))))
		value = value - (1<<pfield->Bits);			/*	Compute signed value	*/
	
	return value;
}

/******** RegGetField ***************************************************************/
/*	Get Chip register Value (bitwise) then store Value in structure REGMAP			*/
/*	Input : index of the field								        				*/
/*	Output: value of the field								        				*/
/************************************************************************************/
int	 RegGetField(int field)
{
	FIELD *pfield;

	pfield=&(FieldMap[field]);						/*	Just for code simplification	*/

	/* I2C Read : register address set-up */
	RegGetOneRegister(pfield->Reg);					/*	Read the register	*/     

	return FieldGetVal(field);
}

/******** FieldSearchName ***********************/
/*	Function : search the index of the      	*/
/*  field which name is _VariableName    		*/
/*  input  parameter : _VariableName  			*/
/*	output parameter : Index     				*/
/************************************************/
int  FieldSearchName(char * _VariableName)
{
	int Index=-1;

	for(Index = 0; ((Index < NBFIELD)&&(strcmp(FieldMap[Index].Name,_VariableName)!= 0)); Index++) ;
	if(Index>= NBFIELD)
		Index = -1 ;
 
	return (Index);
}

/********** RegSearchName ***********************/
/*	Function : search the index of the      	*/
/*  field which name is _VariableName    		*/
/*  input  parameter : _VariableName  			*/
/*	output parameter : Index     				*/
/************************************************/
int  RegSearchName(char * _VariableName)
{
	int Index=-1;

	for(Index = 0; ((Index < NBREG)&&(strcmp(RegMap[Index].Name,_VariableName)!= 0)); Index++) ;
	if(Index>= NBREG)
		Index = -1 ;
 
	return (Index);
}

#if   0
/* VICKY - 010300 - ACK/ NOACK is redefined here */
#ifdef  ACK
   #undef   ACK
#endif

#ifdef  NOACK
   #undef   NOACK
#endif

#define  ACK         0
#define  NOACK       -1

int RegChipAck(void)
{
	int ChipAddress,test;
	
#if (HOST > 1000)
	UsrRdInt("I2cSTVAddress",&ChipAddress);
#else
    /* VICKY - 060200 - read the I2C slave address */
    ChipAddress=I2cGetSTVAddress();
#endif

	test = (I2cReadWrite(WRITE,ChipAddress,NULL,0) == ACK);
	test = test && (I2cReadWrite(WRITE,ChipAddress+2,NULL,0) == NOACK);
	
	return (test ? ACK : NOACK);  
}
#endif

/********* RegInit ****************************************************************/
/*	This function initializes in memory the STV0197 registers					  */
/*	configure & initialize the REGISTERS : 8bit registers						  */
/*	configure & initialize the FIELD : subset of 8 bit registers				  */
/*  FIELD is for example a bit status, or a coefficient, etc ...				  */
/*	initialize in memory the default registers values of the STV0197			  */ 
/*  STV0197 Default values are stored in ValRegReset array						  */
/*  Define Which Registers to display in the register Map with MemReg array		  */		
/**********************************************************************************/
void	 RegInit(void)
{
	/*
	**   REGISTER CONFIGURATION
	**     ----------------------
	*/
#if 0  /* LP -260600  Put into DVBTunerInit()*/
   semaphore_init_fifo ( &semSTv0299RegAccess, 1 );
#endif
	RegNbI2cAccess  =  0 ;
#if defined(STV0199_4MHZ)