reg0297.c

stv0297 寄存器 tuner 驱动 5105 方案

/*Demodulator, dtvia-Thomson, 1.0 1/8/2001 15:35:15*/  
/*----------------------------------------------------------------------*
*									*
*	       Copyright , DTVIA TechLabs Co.,Ltd.			*
*			ALL RIGHTS RESERVED				*
*									*
*   Permission	is hereby granted to licensees of DTVIA TechLabs Co.,   *
*   Ltd. products to use or abstract this computer program for	the	*
*   sole purpose of implementing a product based on DTVIA TechLabs 	*
*   Co.,Ltd. products.   No other	rights to reproduce, use,	*
*   or	disseminate this computer program, whether in part or in	*
*   whole, are	granted.						*
*									*
*   DTVIA TechLabs Co.,Ltd. makes no representation or warranties	*
*   with respect to the performance of	this computer program, and	*
*   specifically disclaims any	responsibility for any damages,		*
*   special or	consequential, connected with the use of this program.	*
*									*
************************************************************************/
/*----------------------------------------------------------------------+
| DTVIA HARDWARE_LIB							|
| Author: chaiyong							|
| Component:REG0297.c							|
| File: QAM_demodulate							|
| Purpose: Implement demodulate device application functions.		|
| Changes:                                      			|
| Date:		             Comment:                           Auther  | 
| -----                      --------                           --------|
| 11-11-2002                 Created                           chaiyong |
+----------------------------------------------------------------------*/
#define SOURCE REG0297
#include "appldef.h"
#include "def.h"
#include "reg0297.h"
#include "REGMap0297.h"


#define 	ST0297_ADDR 0x38

extern 		REGISTER RegMap [NBREG];
extern 		FIELD	FieldMap[NBFIELD];
int    		_ExtClk=28900;
unsigned 	long RegSymbolRate;  	/*_SymbolRate is in Bd*/
FLAG            RegTrigger ;
extern BOOLEAN link_write( BYTE reg, BYTE value );
extern BOOLEAN link_read ( BYTE reg, BYTE *value_p );
/*---------------------+
NOTE:Set Registers value													  
+----------------------*/
void RegSetRegisters(int FirstReg, int NbRegs)
{  
int i;
	for(i=0;i<NbRegs;i++)
	{
		link_write( RegMap[FirstReg+i].Addr, RegMap[FirstReg+i].Value);
	}
}
/*---------------------+
NOTE:Get Registers value													  
+----------------------*/
void RegGetRegisters(int FirstReg, int NbRegs)
{
	unsigned char  *Data;
	int err,i;
	
	Data=(unsigned char *) malloc(NbRegs);	
		
	for(i=0;i<NbRegs;i++)
	{
		link_read (RegMap[FirstReg+i].Addr, (Data+i));
		RegMap[FirstReg+i].Value=Data[i];
	}			
	free(Data);
}
void RegSetOneRegister(int reg_id, unsigned char Data)   
{	
	link_write( RegMap[reg_id].Addr, Data);
	RegMap[reg_id].Value=Data;  
	return ;
}
/*-----------------------------+
NOTE:RegGet One Register value													  
+------------------------------*/
int RegGetOneRegister(int reg_id)         
{
	link_read( RegMap[reg_id].Addr,&RegMap[reg_id].Value);
  return(RegMap[reg_id].Value)  ;
}



/*--------------------------------------------------------------------------+
NOTE: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);

}

/*-----------------------------------------+
NOTE:Store the current chip register values                  
+------------------------------------------*/
void RegStoreValue(void)
{
	int reg ;

	for ( reg = 0 ; reg < NBREG ; reg++ )
		RegMap[reg].Store = RegMap[reg].Value ;
	return;

 } 
/*--------------------------------------------+
NOTE:Reload the chip register stored values 
+----------------------------------------------*/
void RegReloadValue(void)
   {
	int reg ;
	for ( reg = 0 ; reg < NBREG ; reg++ )
	{
	   	RegMap[reg].Value = RegMap[reg].Store ;
	   	RegSetOneRegister(reg,RegMap[reg].Value);
	}
	return;
   }  
/*-------------------------------------------------------------------+
NOTE:Compute the new value of the register with the value of the field				
+--------------------------------------------------------------------*/
void FieldSetVal(int field, int fieldval)
{
	int value;
	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
}

/*------------------------------------------------------------------+
NOTE:Set Chip register bits of the field "field" to the value "value"			
+-------------------------------------------------------------------*/
void RegSetField(int field,int value)
{
	int valread;
	FIELD *pfield;
	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 
}
/*-----------------------------------------------------------------------+
NOTE:Compute the value of the field with the register value store in  REGMAP			
-------------------------------------------------------------------------*/
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;
}

/*------------------------------------------------------------------------+
NOTE:Get Chip register Value (bitwise) then store Value in structure REGMAP
+-------------------------------------------------------------------------*/
int RegGetField(int field)
{
	int	  Value;
	FIELD *pfield;
	pfield=&(FieldMap[field]);	//Just for code simplification
	RegGetOneRegister(pfield->Reg);	//Read the register     
	Value = FieldGetVal(field) ;
	return Value;
}

/********* RegInit *******************************************************/
/*This function initializes in memory the STV0297 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 STV0297	 */ 
/*STV0297 Default values are stored in ValRegReset array		 */
/*Define Which Registers to display in the register Map with MemReg array*/		
/*************************************************************************/
void RegInit(void)
{
	RegTrigger=M_NO;
	RegMapInit() ;
        RegSTV0297reset() ;      
        RegResetAfterDI() ;
        RegReset()        ; 
        RegSetSymbolRate(6875000);
	return;
}

/*-------------------------------------------------------+
NOTE:STV0297 Software reset, Set bit 0 @reg0x80 to 1 then 0												  
+--------------------------------------------------------*/
void RegSTV0297reset(void)
  {
	RegSetField(SOFT_RESET,1);
	RegSetField(SOFT_RESET,0);
  }


/*---------------------+
NOTE:ResetAfterDI 
+----------------------*/
void RegResetAfterDI(void)
  {
	RegSetField(RESET_DI,1);
	RegSetField(RESET_DI,0);
   return ;
  } 
 
/*--------------+
NOYE: SetQamSize
----------------*/
void RegSetQAMSize(int _QAMSize)
  {
	int QAMSize ;
	switch (_QAMSize)
	{
	   	case 16:
			QAMSize = QAM16 ;
		break;
	   	case 32:
			QAMSize = QAM32 ;
		break;
	   	case 64:
			QAMSize = QAM64 ;
		break;
	   	case 128:
			QAMSize = QAM128 ;
		break;
	   	case 256:
			QAMSize = QAM256 ;
		break;
	   	default:
	   	break;
	}	
	RegSetField(MODE_SELECT, QAMSize);
	return;	
  } 

/*--------------+
NOYE: RegGetQAMSize
----------------*/
int  RegGetQAMSize(void)
  {
    	int Value ,RegQAMSize;

	Value = RegGetField(MODE_SELECT);
	switch (Value)
	{
	   case 0:
			RegQAMSize = 16 ;
		   break;
	   case 1:
			RegQAMSize = 32 ;
		   break;
	   case 4:
			RegQAMSize = 64 ;
		   break;
	   case 2:
			RegQAMSize = 128 ;
		   break;
	   case 3:
			RegQAMSize = 256 ;
		   break;
	   default:
	   	   break;
	}
	return(RegQAMSize);
  }



/*------------------------------+
NOTE:GetSymbolRate 
+-------------------------------*/
unsigned long RegGetSymbolRate(void)
  {
	unsigned long regsym;
	regsym  = RegGetField(SYMB_RATE_0);
	regsym += RegGetField(SYMB_RATE_1)<<8;
	regsym += RegGetField(SYMB_RATE_2)<<16;
	regsym += RegGetField(SYMB_RATE_3)<<24;
	if(regsym > 1073741824L) /* 1073741824L = 2**30 */
	                         /* # 7.4 MBd (clock = 28.92 MHz) */
	{
	   	regsym = regsym/16384L;/* 65536L = 2**14 */
	   	regsym = _ExtClk * regsym; /* _ExtClk in KHz */
	   	RegSymbolRate = regsym/128L;/* 128 = 2**7 */
	}
	else if(regsym > 536870912L) /* 536870912L = 2**29 */
	                         /*             # 3.6 MBd (clock = 28.92 MHz) */
	{
	   	regsym = regsym/8192L;/* 8192L = 2**13 */