reg0299.c

这是DVB tuner驱动部分和其它相关的源码和一些技术资料文档.

/*****************************************************************************
File Name   : reg0299.c

Description : STV0299 register access routines.

Copyright (C) 2000 STMicroelectronics

Revision History    :

    04/02/00        Code based on original implementation by CBB.

    21/03/00        Received code modifications that eliminate compiler
                    warnings.

Reference           :

*****************************************************************************/

#include <stdlib.h>
#include <string.h>

#include "stv299.h"
#include "reg0299.h"

#include "i2c.h"                        /* I2C communcations */

/* Timeout for all I2C operations */
#define I2C_TIMEOUT     10

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

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

/******** AddReg  ************************************************************/
/*	Add a new register to the register map									 */
/*****************************************************************************/
void AddReg(STV0299_ControlBlock_t *Dev_p, int Id,char * Name,char Address,char Reset)
{
    REGISTER *pReg;

    pReg=&Dev_p->RegMap[Id];

    pReg->Addr	= Address;
    pReg->Reset	= Reset;
    pReg->Value	= 0x00;
    strcpy(pReg->Name,Name);
}

/******** FieldCreateMask ****************************************************/
/*	Create the mask of the field according the informations store in the  	 */
/*	FIELD structure															 */
/*****************************************************************************/
unsigned char FieldCreateMask(STV0299_ControlBlock_t *Dev_p, int field)
{
    int i;
    unsigned char mask=0;

    /*	Create mask	*/
    for (i = 0; i < Dev_p->FieldMap[field].Bits; i++)
    {
        mask <<= 1 ;
        mask +=  1 ;
    }

    mask = mask << Dev_p->FieldMap[field].Pos;

    return mask;
}

/******** AddField  **********************************************************/
/*	Add a field to the field map											 */
/*****************************************************************************/
void AddField(STV0299_ControlBlock_t *Dev_p, int RegId, int FieldId,char * Name, char Pos, char NbBits, char Type)
{
    FIELD *pField;

    pField=&Dev_p->FieldMap[FieldId];

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

/******** RegSetOneRegister **************************************************/
/*	Set Register value													  	 */
/*	INPUT :  data, register id												 */
/*****************************************************************************/
ST_ErrorCode_t RegSetOneRegister(STV0299_ControlBlock_t *Dev_p, int reg_id, unsigned char Data)
{
    unsigned char data[2];
    ST_ErrorCode_t Error;

    data[0]=Dev_p->RegMap[reg_id].Addr;
    data[1]=Data;

    Error = I2C_Transfer(Dev_p->I2CHandle,
                         I2C_WRITE,
                         0,
                         data,
                         2,
                         I2C_TIMEOUT);

    Dev_p->RegNbI2cAccess += 1;
    Dev_p->RegMap[reg_id].Value=Data;

    return Error;
}

/******** RegGetOneRegister **************************************************/
/*	Get Register value													  	 */
/*	INPUT :  register id													 */
/*	RETURN :  data															 */
/*****************************************************************************/
int RegGetOneRegister(STV0299_ControlBlock_t *Dev_p, int reg_id)
{
    /*	I2C access	*/
    I2C_Transfer(Dev_p->I2CHandle,
                 I2C_SUBADDR_READ,
                 Dev_p->RegMap[reg_id].Addr,
                 &Dev_p->RegMap[reg_id].Value,
                 1,
                 I2C_TIMEOUT);
    Dev_p->RegNbI2cAccess += 1;
    return Dev_p->RegMap[reg_id].Value;
}

/******** RegSetRegisters *****************************************************/
/*	Set Registers values in burst mode 									  	 */
/*	INPUT : a buffer for data, first register address, last register address */
/*****************************************************************************/
void RegSetRegisters(STV0299_ControlBlock_t *Dev_p, int FirstReg, int NbRegs)
{
    int i;
    unsigned char Data[10];

    Data[0]=Dev_p->RegMap[FirstReg].Addr;

    /*	Read RegMap structure	*/
    for(i=0;i<NbRegs;i++)
        Data[i+1]=Dev_p->RegMap[FirstReg+i].Value;

#if 1   /* !!! TEMP !!! */

    I2C_Transfer(Dev_p->I2CHandle,
                 I2C_WRITE,
                 0,
                 Data,
                 NbRegs+1,
                 I2C_TIMEOUT);

    Dev_p->RegNbI2cAccess += NbRegs;

#else

    {
        int i;
        for (i = FirstReg; i < (FirstReg + NbRegs); i++)
            RegSetOneRegister(Dev_p, i, Dev_p->RegMap[i].Value);
    }
#endif
}

/******** RegGetRegisters ***************************************************/
/*	Get Registers values in burst mode 									  	*/
/*	INPUT : first register address, last register address 					*/
/****************************************************************************/
void RegGetRegisters(STV0299_ControlBlock_t *Dev_p, int FirstReg, int NbRegs)
{
    unsigned char Data[10];
    int i;

#if 1   /* !!! TEMP !!! */
        /*	I2C access	*/

    I2C_Transfer(Dev_p->I2CHandle,
                 I2C_SUBADDR_READ,
                 Dev_p->RegMap[FirstReg].Addr,
                 Data,
                 NbRegs,
                 I2C_TIMEOUT);
    Dev_p->RegNbI2cAccess += NbRegs;
#else
    {
        int i;
        for (i = FirstReg; i < (FirstReg + NbRegs); i++)
            RegGetOneRegister(Dev_p, i);
    }
#endif

    /*	Update RegMap structure	*/
    for(i=0;i<NbRegs;i++)
        Dev_p->RegMap[FirstReg+i].Value=Data[i];

}

/******** RegReset ***********************************************************/
/*	Set Chip register values according Default Values stored in ValRegReset	 */
/*																			 */
/*****************************************************************************/
ST_ErrorCode_t RegReset(STV0299_ControlBlock_t *Dev_p)
{
    int reg;
    ST_ErrorCode_t Error = ST_NO_ERROR;

    for ( reg = 0 ; Error == ST_NO_ERROR && reg < NBREG ; reg++ )
        Error = RegSetOneRegister(Dev_p, reg,Dev_p->RegMap[reg].Reset);

    return Error;
}

/******** 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(STV0299_ControlBlock_t *Dev_p, int field, int fieldval)
{
    FIELD *pfield;

    pfield=&(Dev_p->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	*/
    Dev_p->RegMap[pfield->Reg].Value = (Dev_p->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(STV0299_ControlBlock_t *Dev_p, int field,int value)
{
    FIELD *pfield;

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

    RegGetOneRegister(Dev_p, pfield->Reg);					/*	Read the register	*/
    FieldSetVal(Dev_p, field,value);						/*	Compute new RegMap value */
    RegSetOneRegister(Dev_p, pfield->Reg,Dev_p->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(STV0299_ControlBlock_t *Dev_p, int field)
{
    int value;
    FIELD *pfield;

    pfield=&(Dev_p->FieldMap[field]);						/*	Just for code simplification	*/
    value=(Dev_p->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(STV0299_ControlBlock_t *Dev_p, int field)
{
    FIELD *pfield;

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

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

    return FieldGetVal(Dev_p, field);
}

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

    for(Index = 0; ((Index < NBFIELD)&&(strcmp(Dev_p->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(STV0299_ControlBlock_t *Dev_p, char * _VariableName)
{
    int Index=-1;

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

    return (Index);
}

/********* 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		  */
/**********************************************************************************/
ST_ErrorCode_t RegInit(STV0299_ControlBlock_t *Dev_p)
{
    /*
     **   REGISTER CONFIGURATION
     **     ----------------------
     */
    Dev_p->RegNbI2cAccess  =  0 ;
    Dev_p->lastAGC2Coef    =  1 ;
#if defined(STV0199_4MHZ)
    Dev_p->RegExtClk         =	 4000000L; /*	External Clock in Hz. */
#elif defined(STV0199_27MHZ)
    Dev_p->RegExtClk         =	27000000L; /*	External Clock in Hz. */
#else
#error Must define STV0199_4MHZ or STV0199_27MHZ in makefile
#endif

    /*	REGISTER INITIALISATION	*/
    /*	ID	*/
    AddReg(Dev_p, R_ID,"ID",0x00,0xA1);
    AddField(Dev_p, R_ID,ID,"ID",0,8,UNSIGNED);

    /*	RCR	*/
    AddReg(Dev_p, R_RCR,"RCR",0x01,0x15);
    AddField(Dev_p, R_RCR,K,"K",6,2,UNSIGNED);
    AddField(Dev_p, R_RCR,DIRCLK,"DIRCLK",5,1,UNSIGNED);
    AddField(Dev_p, R_RCR,M,"M",0,5,UNSIGNED);

    /*	MCR	*/
    AddReg(Dev_p, R_MCR,"MCR",0x02,0x0);
    AddField(Dev_p, R_MCR,STDBY,"STDBY",7,1,UNSIGNED);
    AddField(Dev_p, R_MCR,VCO,"VCO",6,1,UNSIGNED);
    AddField(Dev_p, R_MCR,SERCLK,"SERCLK",3,1,UNSIGNED);
    AddField(Dev_p, R_MCR,P,"P",0,3,UNSIGNED);

    /*	ACR	*/
    AddReg(Dev_p, R_ACR,"ACR",0x03,0x0);
    AddField(Dev_p, R_ACR,ACR,"ACR",0,8,UNSIGNED);

    /*	F22RR	*/
 /*   AddReg(Dev_p, R_F22FR,"F22RR",0x04,0x2a);    */
#if defined(mb5518)
    AddReg(Dev_p, R_F22FR,"F22RR",0x04,0x7D);  /* FORCE */
#else
    AddReg(Dev_p, R_F22FR,"F22RR",0x04,0x2a);
#endif

    AddField(Dev_p, R_F22FR,F22FR,"F22RR",0,8,UNSIGNED);

    /*	I2CRPT	*/